This crate provides different representations for graphs, some of which are efficient to use, and others that are efficient to construct.
The crate supports conversion between the different representations while preserving node ids.
Creating an adjacency array.
```rust use graphrepresentations::simplegraph::SimpleGraph; use graphrepresentations::graph::{MutableGraph, Node, Edge, Graph}; use graphrepresentations::adjacencyarray::AdjacencyArray;
let mut simplegraph = SimpleGraph::new(); let n1 = simplegraph.addnode(Node::new(5)); let n2 = simplegraph.addnode(Node::new(7)); let e1 = simplegraph.addedge(Edge::new(n1, n2, 'c')).unwraporelse(|error| panic!("The edge refers nonexistent nodes: {:?}", error)); let adjacencyarray = AdjacencyArray::from(&simple_graph);
let mut nodeiter = adjacencyarray.nodeiditer(); let mut edgeiter = adjacencyarray.edgeiditer(); asserteq!(simplegraph.nodedata(nodeiter.next().expect("Node got lost")), adjacencyarray.nodedata(n1)); // The order of the nodes is guaranteed to stay the same asserteq!(simplegraph.nodedata(nodeiter.next().expect("Node got lost")), adjacencyarray.nodedata(n2)); asserteq!(nodeiter.next(), None); asserteq!(adjacencyarray.edge(edgeiter.next().expect("Edge was not converted correctly")), simplegraph.edge(e1)); asserteq!(edgeiter.next(), None); ```
Navigating that same adjacency array.
rust
// The same adjacency array as above
let mut neighbors = adjacency_array.out_edges(n1);
assert_eq!(adjacency_array.edge(neighbors.next().expect("Edge was not converted correctly")), simple_graph.edge(e1));
assert_eq!(neighbors.next(), None);
Graph The basic trait for graphs.
It cannot do much more than acting as an unmodifiable container.
Supported are iteration of node and edge ids and lookup of node and edge data by id.MutableGraph A trait for mutable graphs.
Graphs implementing this trait are supposed to allow efficient mutations.
At the moment, the trait only requires add-methods.ForwardNavigableGraph A graph that can be navigated forward.
It requires the method out_edges that returns an iterator over all out-edges of a node.IterableGraph A graph that supports efficient iteration of complete node and edge data.
This is not implemented and blocked by #29661.At the moment, this crate supports only two graph representations. One dynamic, and one static.
SimpleGraph: Graph + MutableGraph A dynamic graph representation, that allows efficient modification, but is not very useful to implement any algorithms.AdjacencyArray: Graph + ForwardNavigableGraph A static graph representation that is efficient to use in graph algorithms, but inefficient to modify.
At the moment, modification needs to be done by rebuilding it from a SimpleGraph. This crate uses ids to refer to nodes and edges. This comes natural when implementing adjacency arrays or edge lists. It is a fast and easy solution to pass around node and edge data in client code without having to worry about borrowing. Ids are 32 bit (or maybe also 64 bit in the future), so passing them around is basically zero-cost.
Keep in mind that ids are not bound in any way to the graph instance that created them. There is no protection against using an id for one graph in another, resulting in unpredictable behavior. But using the node ids of one graph instance with a converted version of that same graph is guaranteed to work consistently, if none of the graphs were modified after conversion.
If you are missing a feature or found a bug, please open an issue on github.