rs-graph 0.6.3

// Copyright (c) 2015, 2016, 2017 Frank Fischer <frank-fischer@shadow-soft.de>
//
// This program is free software: you can redistribute it and/or
// modify it under the terms of the GNU General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see  <http://www.gnu.org/licenses/>
//

//! A library for basic graph data structures and algorithms.

/// Create a node vector associated with a graph.
///
/// # Example
///
/// Create a vector with all elements set to some value, use `nodevec![g; x]`
///
/// ```
/// # #[macro_use]
/// # extern crate rs_graph as graph;
/// # use graph::{Graph, LinkedListGraph};
/// # use graph::classes::peterson;
/// #
/// # fn main() {
/// let g = peterson::<LinkedListGraph>();
/// let weights = nodevec![&g; 0];
/// assert!(g.nodes().all(|u| weights[u] == 0));
/// # }
/// ```
///
/// Convert an existing vector to a `NodeVec`, use `nodevec![g, v]`.
/// Note that the size of `v` must be exactly `g.num_nodes()`.
///
/// ```
/// # #[macro_use]
/// # extern crate rs_graph as graph;
/// # use graph::{Graph, IndexGraph, LinkedListGraph};
/// # use graph::classes::peterson;
/// #
/// # fn main() {
/// let g = peterson::<LinkedListGraph>();
/// let weights: Vec<_> = (0..g.num_nodes()).collect();
/// let weights = nodevec![&g, weights];
/// assert!(g.nodes().all(|u| weights[u] == g.node_id(u)));
/// # }
/// ```
#[macro_export]
macro_rules! nodevec {
    ( $ g : expr ;  $ elem : expr ) => { $crate::vec::NodeVec::from_vec($g, vec![$elem; $g.num_nodes()]) };
    ( $ g : expr ,  $ vec : expr ) => { $crate::vec::NodeVec::from_vec($g, $vec) };
}

/// Create an edge vector associated with a graph.
///
/// # Example
///
/// Create a vector with all elements set to some value, use `edgevec![g; x]`
///
/// ```
/// # #[macro_use]
/// # extern crate rs_graph as graph;
/// # use graph::{Graph, LinkedListGraph};
/// # use graph::classes::peterson;
/// #
/// # fn main() {
/// let g = peterson::<LinkedListGraph>();
/// let weights = edgevec![&g; 0];
/// assert!(g.edges().all(|e| weights[e] == 0));
/// # }
/// ```
///
/// Convert an existing vector to an `EdgeVec`, use `edgevec![g, v]`.
/// Note that the size of `v` must be exactly `g.num_edges()`.
///
/// ```
/// # #[macro_use]
/// # extern crate rs_graph as graph;
/// # use graph::{Graph, IndexGraph, LinkedListGraph};
/// # use graph::classes::peterson;
/// #
/// # fn main() {
/// let g = peterson::<LinkedListGraph>();
/// let weights: Vec<_> = (0..g.num_edges()).collect();
/// let weights = edgevec![&g, weights];
/// assert!(g.edges().all(|e| weights[e] == g.edge_id(e)));
/// # }
/// ```
#[macro_export]
macro_rules! edgevec {
    ( $ g : expr ;  $ elem : expr ) => { $crate::vec::EdgeVec::from_vec($g, vec![$elem; $g.num_edges()]) };
    ( $ g : expr ,  $ vec : expr ) => { $crate::vec::EdgeVec::from_vec($g, $vec) };
}

/// Create a biedge vector associated with a network.
///
/// # Example
///
/// Create a vector with all elements set to some value, use `biedgevec![g; x]`
///
/// ```
/// # #[macro_use]
/// # extern crate rs_graph as graph;
/// # use graph::{Graph, Network, LinkedListGraph};
/// # use graph::classes::peterson;
/// #
/// # fn main() {
/// let g = peterson::<LinkedListGraph>();
/// let weights = biedgevec![&g; 0];
/// assert!(g.edges().all(|e| weights[e] == 0 && weights[g.reverse(e)] == 0));
/// # }
/// ```
///
/// Convert an existing vector to a `BiEdgeVec`, use `biedgevec![g, v]`.
/// Note that the size of `v` must be exactly `g.num_edges() * 2`.
///
/// ```
/// # #[macro_use]
/// # extern crate rs_graph as graph;
/// # use graph::{Graph, IndexGraph, Network, IndexNetwork, LinkedListGraph};
/// # use graph::classes::peterson;
/// #
/// # fn main() {
/// let g = peterson::<LinkedListGraph>();
/// let weights: Vec<_> = (0..g.num_edges() * 2).collect();
/// let weights = biedgevec![&g, weights];
/// assert!(g.edges().all(|e| {
///     let f = g.reverse(e);
///     weights[e] == g.biedge_id(e) && weights[f] == g.biedge_id(f)
/// }));
/// # }
/// ```
#[macro_export]
macro_rules! biedgevec {
    ( $ g : expr ;  $ elem : expr ) => { $crate::vec::BiEdgeVec::from_vec($g, vec![$elem; $g.num_edges() * 2]) };
    ( $ g : expr ,  $ vec : expr ) => { $crate::vec::BiEdgeVec::from_vec($g, $vec) };
}

mod num {
    pub extern crate num_traits as traits;
    pub extern crate num_iter as iter;
}

#[cfg(feature="quick-error")]
#[macro_use]
extern crate quick_error;

#[cfg(feature="serialize")]
extern crate serde;
#[cfg(feature="serialize")]
#[macro_use]
extern crate serde_derive;

// # Data structures

pub mod graph;
pub use self::graph::{Node, Edge, Graph, Digraph, Network, IndexGraph, IndexDigraph, IndexNetwork};

pub mod builder;
pub use builder::Builder;

pub mod attributed;
pub use self::attributed::{Attributes, NetworkAttributes, Attributed, AttributedGraph, AttributedNetwork, AttributedBuilder};

pub mod wrapped;
pub use self::wrapped::{WrappedGraph, WrappedGraphMut, WrappedBuilder};

pub mod linkedlistgraph;
pub use self::linkedlistgraph::LinkedListGraph;

/// Graph classes
pub mod classes;

/// The default graph type.
///
/// A linked-list graph with up to 2^31 nodes and edges.
pub type Net = self::LinkedListGraph<u32>;

pub mod vec;
pub use self::vec::{NodeSlice, NodeSliceMut, NodeVec};
pub use self::vec::{EdgeSlice, EdgeSliceMut, EdgeVec};
pub use self::vec::{BiEdgeSlice, BiEdgeSliceMut, BiEdgeVec};

// # Algorithms

pub mod algorithms;
pub mod branching;
pub mod maxflow;
pub mod mst;
pub mod shortestpath;

// # Drawing

pub mod draw;

#[cfg(any(feature="dimacs"))]
pub mod dimacs;
#[cfg(any(feature="steinlib"))]
pub mod steinlib;