Type Definition net_ensembles::graph::Graph [−][src]
pub type Graph<T> = GenericGraph<T, NodeContainer<T>>;
Expand description
Contains the topology and implements functions for analyzing topology
used for graph ensembles
Example:
A graph, where each node stores a phase
use net_ensembles::{Graph, Node, AdjContainer};
use net_ensembles::traits::DotExtra;
use std::fs::File;
// Note: feature "serde_support" is enabled on default
#[cfg(feature = "serde_support")]
use serde_json;
#[cfg(feature = "serde_support")]
use serde::{Serialize, Deserialize};
// define your own vertices, if you need to store extra information at each vertex
// if you do not use the feature "serde_support", you do not need to derive Serialize and Deserialize
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde_support", derive(Serialize, Deserialize))]
pub struct PhaseNode {phase: f64,}
// implement whatever you need
impl PhaseNode {
pub fn set_phase(&mut self, phase: f64) {
self.phase = phase;
}
pub fn get_phase(&self) -> f64 {
self.phase
}
}
// implement the trait `Node`
impl Node for PhaseNode {
fn new_from_index(index: usize) -> Self {
PhaseNode { phase: index as f64 * 10.0}
}
}
// now you can create an empty graph
let mut graph: Graph<PhaseNode> = Graph::new(4);
for i in 0..4 {
assert_eq!(
graph.at(i).get_phase(),
i as f64 * 10.0
);
}
// and fill it with edges
for i in 0..4 {
graph.add_edge(i, (i + 1) % 4).unwrap();
}
// you can manipulate the extra information stored at each Vertex
for i in 0..4 {
graph.at_mut(i).set_phase(i as f64 * 0.5);
}
// you can, of course, also access the information
for i in 0..4 {
assert_eq!(
graph.at(i).get_phase(),
i as f64 * 0.5
);
}
// if you want to visualize your graph, you can generate a file with graphviz representation
let mut f = File::create("phase_example.dot").expect("Unable to create file");
graph.dot_from_contained_index(
f,
"",
|index, contained|
format!(
"Phase: {} at index {}",
contained.get_phase(),
index
)
).unwrap();
// storing the graph only works, if the feature "serde_support" is enabled (enabled by default)
#[cfg(feature = "serde_support")]
{
let mut graph_file = File::create("store_graph_example.dat")
.expect("Unable to create file");
let s = serde_json::to_writer_pretty(graph_file, &graph).unwrap();
// loading stored graph:
let mut read_in = File::open("store_graph_example.dat")
.expect("Unable to open file");
let graph2: Graph<PhaseNode> = serde_json::from_reader(read_in).unwrap();
// now, to show, that the graphs are equal, here is one of my test functions:
// modified for this example, which is a doc-test, so this example also serves as unit test
fn assert_equal_graphs(g1: &Graph<PhaseNode>, g2: &Graph<PhaseNode>) {
assert_eq!(g1.edge_count(), g2.edge_count());
assert_eq!(g1.vertex_count(), g2.vertex_count());
for (n0, n1) in g2.container_iter().zip(g1.container_iter()) {
assert_eq!(n1.id(), n0.id());
assert_eq!(n0.degree(), n1.degree());
for (i, j) in n1.neighbors().zip(n0.neighbors()) {
assert_eq!(i, j);
}
}
for i in 0..g2.vertex_count() {
assert_eq!(
g1.at(i).get_phase(),
g2.at(i).get_phase()
);
}
}
// lets use it
assert_equal_graphs(&graph, &graph2);
// you can also clone the graph, if you need:
let clone = graph.clone();
assert_equal_graphs(&graph, &clone);
let clone2 = graph2.clone();
assert_equal_graphs(&clone, &clone2);
}
phase_example.dot
will contain
graph G{
0 1 2 3 ;
"0" [label="Phase: 0 at index 0"];
"1" [label="Phase: 0.5 at index 1"];
"2" [label="Phase: 1 at index 2"];
"3" [label="Phase: 1.5 at index 3"];
0 -- 1
0 -- 3
1 -- 2
2 -- 3
}
Now you can use circo
or similar programs to create a pdf from that.
Search for graphviz for more info.
Implementations
Efficiently create a complete graph with n nodes
Trait Implementations
Performs the conversion.