Struct net_ensembles::sw::SwEnsemble[][src]

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

Implements small-world graph ensemble

Sampling

Other

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 net_ensembles::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 net_ensembles::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);

Save and load example

  • only works if feature "serde_support" is enabled
  • Note: "serde_support" is enabled by default
  • I need the #[cfg(feature = "serde_support")] to ensure the example does compile if you opt out of the default feature
  • you can do not have to use serde_json, look here for more info
use net_ensembles::traits::*; // I recommend always using this
use serde_json;
use rand_pcg::Pcg64;
use net_ensembles::{SwEnsemble, EmptyNode, rand::SeedableRng};
use std::fs::File;

let rng = Pcg64::seed_from_u64(95);
// create small-world ensemble
let sw_ensemble = SwEnsemble::<EmptyNode, Pcg64>::new(200, 0.3, rng);

#[cfg(feature = "serde_support")]
{
    // storing the ensemble in a file:

    let sw_file = File::create("store_SW.dat")
          .expect("Unable to create file");

    // or serde_json::to_writer(sw_file, &sw_ensemble);
    serde_json::to_writer_pretty(sw_file, &sw_ensemble);

    // loading ensemble from file:

    let mut read = File::open("store_SW.dat")
        .expect("Unable to open file");

    let sw: SwEnsemble::<EmptyNode, Pcg64> = serde_json::from_reader(read).unwrap();
}

Implementations

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)
Experimental! Connect the connected components
  • resets edges, to connect the connected components
  • intended as starting point for a markov chain, if you require connected graphs
  • do not use this to independently (simple-) sample connected networks, as this will skew the statistics
  • This is still experimental, this member might change the internal functionallity resulting in different connected networks, without prior notice
  • This member might be removed in braking releases
  • draws random edge (i0, i1)
  • edge rooted at i0
  • uniform probability
  • result dependent on order of adjecency lists
  • mut because it uses the rng
  • returns rewiring probability
  • 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
  • retuns GenericGraph::contained_iter_neighbors_mut
  • otherwise you would not have access to this function, since no mut access to the graph is allowed

Trait Implementations

Performs the conversion.

Immutably borrows from an owned value. Read more

Returns a copy of the value. Read more

Performs copy-assignment from source. Read more

Returns a reference to the element stored in the specified node or None if out of Bounds

Returns a mutable reference to the element stored in the specified node or None if out of Bounds

For a save alternative see get_contained Read more

Returns a mutable reference to the element stored in the specified node Read more

Formats the value using the given formatter. Read more

Deserialize this value from the given Serde deserializer. Read more

  • use function f to create labels depending on the index
  • for valid dot_options use dot_options! macro and take a look at module dot_constants
  • Read more

  • create dot file with empty labels
  • default implementation uses dot_from_indices
  • Read more

  • same as self.dot(), but returns a String instead
  • same as self.dot_from_indices but returns String instead
  • same as self.dot_with_indices but returns String instead
  • use index as labels for the nodes
  • default implementation uses dot_from_indices
  • Read more

  • iterate over mutable additional information of neighbors of vertex index
  • iterator returns &mut T
  • sort_adj will affect the order
  • panics if index out of bounds
  • Read more

  • iterate over mutable additional information of neighbors of vertex index
  • iterator returns (index_neighbor: usize, neighbor: &mut T)
  • sort_adj will affect the order
  • panics if index out of bounds
  • Read more

  • get iterator over mutable additional information stored at each vertex in order of the indices
  • iterator returns a Node (for example EmptyNode or whatever you used)
  • Read more

    Access RNG

    If, for some reason, you want access to the internal random number generator: Here you go

    Swap random number generator
    • returns old internal rng
    Markov step
    • use this to perform a markov step
    • keep in mind, that it is not unlikely for a step to do Nothing as it works by drawing an edge and then reseting it with r_prob, else the edge is rewired
    • result SwChangeState can be used to undo the step with self.undo_step(result)
    • result should never be InvalidAdjecency or GError if used on a valid graph
    Undo a markov step
    • rewires edge to old state
    • Note: cannot undo InvalidAdjecency or GError, will just return InvalidAdjecency or GError respectively
    • returns result of rewire
    Important:

    Restored graph is the same as before the random step except the order of nodes in the adjacency list might be shuffled!

    Undo a Monte Carlo step
    • rewires edge to old state
    • panics if you try to undo InvalidAdjecency or GError
    • panics if rewire result (SwChangeState) is invalid (i.e. !result.is_valid())
    Important:

    Restored graph is the same as before the random step except the order of nodes in the adjacency list might be shuffled!

    Markov steps Read more

    Markov steps without return Read more

    Accumulating markov step Read more

    Accumulating markov steps Read more

    Accumulating markov steps Read more

    Undo markov steps Read more

    Undo markov steps Read more

    Serialize this value into the given Serde serializer. Read more

    Randomizes the edges according to small-world model
    • this is used by SwEnsemble::new to create the initial topology
    • you can use this for sampling the ensemble
    • runs in O(vertices)

    do the following times times: Read more

    do the following times times: Read more

    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

  • access additional information at index
  • mutable access to additional information at index
  • returns reference to the underlying topology aka, the GenericGraph
  • use this to call functions regarding the topology
  • Read more

    Auto Trait Implementations

    Blanket Implementations

    Gets the TypeId of self. Read more

    Immutably borrows from an owned value. Read more

    Mutably borrows from an owned value. Read more

    Cast from Self to T

    Try converting from Self to T

    Cast to integer, truncating Read more

    Cast to the nearest integer Read more

    Cast the floor to an integer Read more

    Cast the ceiling to an integer Read more

    Try converting to integer with truncation Read more

    Try converting to the nearest integer Read more

    Try converting the floor to an integer Read more

    Try convert the ceiling to an integer Read more

    Convert from T to Self

    Try converting from T to Self

    Performs the conversion.

    Performs the conversion.

    The alignment of pointer.

    The type for initializers.

    Initializes a with the given initializer. Read more

    Dereferences the given pointer. Read more

    Mutably dereferences the given pointer. Read more

    Drops the object pointed to by the given pointer. Read more

    The resulting type after obtaining ownership.

    Creates owned data from borrowed data, usually by cloning. Read more

    🔬 This is a nightly-only experimental API. (toowned_clone_into)

    Uses borrowed data to replace owned data, usually by cloning. Read more

    The type returned in the event of a conversion error.

    Performs the conversion.

    The type returned in the event of a conversion error.

    Performs the conversion.