Struct net_ensembles::sw::SwEnsemble

pub struct SwEnsemble<T: Node, R: Rng> { /* fields omitted */ }

Implements small-world graph ensemble

• for more details look at documentation of module sw
• for topology functions look at GenericGraph

Sampling

Simple sampling and/or monte carlo steps?

• look at Ensemble trait

Access or manipulate RNG?

• look at EnsembleRng trait

Minimal example

use net_ensembles::{SwEnsemble, EmptyNode};
use net_ensembles::traits::*; // I recommend always using this
use rand_pcg::Pcg64; //or whatever you want to use as rng
use rand::SeedableRng; // I use this to seed my rng, but you can use whatever

let rng = Pcg64::seed_from_u64(12);

// now create small-world ensemble with 200 nodes
// and a rewiring probability of 0.3 for each edge
let sw_ensemble = SwEnsemble::<EmptyNode, Pcg64>::new(200, 0.3, rng);

Simple sampling example

use net_ensembles::{SwEnsemble, EmptyNode};
use net_ensembles::traits::*; // I recommend always using this
use rand_pcg::Pcg64; //or whatever you want to use as rng
use rand::SeedableRng; // I use this to seed my rng, but you can use whatever
use std::fs::File;
use std::io::{BufWriter, Write};

let rng = Pcg64::seed_from_u64(122);

// now create small-world ensemble with 100 nodes
// and a rewiring probability of 0.3 for each edge
let mut sw_ensemble = SwEnsemble::<EmptyNode, Pcg64>::new(100, 0.3, rng);

// setup file for writing
let f = File::create("simple_sample_sw_example.dat")
    .expect("Unable to create file");
let mut f = BufWriter::new(f);
f.write_all(b"#diameter bi_connect_max average_degree\n")
    .unwrap();

// simple sample for 10 steps
sw_ensemble.simple_sample(10,
    |ensemble|
    {
        let diameter = ensemble.graph()
            .diameter()
            .unwrap();

        let bi_connect_max = ensemble.graph()
            .clone()
            .vertex_biconnected_components(false)[0];

        let average_degree = ensemble.graph()
            .average_degree();

        write!(f, "{} {} {}\n", diameter, bi_connect_max, average_degree)
            .unwrap();
    }
);

// or just collect this into a vector to print or do whatever
let vec = sw_ensemble.simple_sample_vec(10,
    |ensemble|
    {
        let diameter = ensemble.graph()
            .diameter()
            .unwrap();

        let transitivity = ensemble.graph()
            .transitivity();
        (diameter, transitivity)
    }
);
println!("{:?}", vec);

Methods

impl<T, R> SwEnsemble<T, R> where
    T: Node,
    R: Rng, 

pub fn new(n: u32, r_prob: f64, rng: R) -> Self

Initialize

• create new SwEnsemble graph with n vertices
• r_prob is probability of rewiring for each edge
• rng is consumed and used as random number generator in the following
• internally uses SwGraph<T>::new(n)

pub fn draw_edge(&mut self) -> (u32, u32)

• draws random edge (i0, i1)
• edge rooted at i0
• uniform probability
• result dependent on order of adjecency lists
• mut because it uses the rng

pub fn sort_adj(&mut self)

Sort adjecency lists

If you depend on the order of the adjecency lists, you can sort them

Performance

• internally uses pattern-defeating quicksort as long as that is the standard
• sorts an adjecency list with length d in worst-case: O(d log(d))
• is called for each adjecency list, i.e., self.vertex_count() times

pub fn graph(&self) -> &SwGraph<T>

• returns reference to the underlying topology aka, the SwGraph<T>
• use this to call functions regarding the topology

pub fn at(&self, index: usize) -> &T

• access additional information at

pub fn at_mut(&mut self, index: usize) -> &mut T

• mutable access of additional information at index

pub fn r_prob(&self) -> f64

• returns rewiring probability

pub fn set_r_prob(&mut self, r_prob: f64)

• set new value for rewiring probability

Note

• will only set the value, which will be used from now on
• if you also want to create a new sample, call randomize afterwards

Trait Implementations

impl<T: Clone + Node, R: Clone + Rng> Clone for SwEnsemble<T, R>

fn clone(&self) -> SwEnsemble<T, R>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug + Node, R: Debug + Rng> Debug for SwEnsemble<T, R>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.