Struct net_ensembles::er_m::ErEnsembleM

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

Implements Erdős-Rényi graph ensemble

Constant number of edges

• Note simple sampling of this ensemble is somewhat inefficient right now - I might change it in the future, though that will change the results of the simple sampling (Not on average of cause)
• for simple sampling look at SimpleSample trait
• for markov steps look at MarkovChain trait

Other

• for topology functions look at GenericGraph
• to access underlying topology or manipulate additional data look at WithGraph trait
• to use or swap the random number generator, look at HasRng trait

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 can do not have to use serde_json, look here for more info you opt out of the default feature

use net_ensembles::traits::*; // I recommend always using this
use serde_json;
use rand_pcg::Pcg64;
use net_ensembles::{ErEnsembleM, EmptyNode, rand::SeedableRng};
use std::fs::File;

let rng = Pcg64::seed_from_u64(95);
// create Erdős-Rényi ensemble with 200 vertices and 600 edges
let er_ensemble = ErEnsembleM::<EmptyNode, Pcg64>::new(200, 600, rng);

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

    let er_m_file = File::create("store_ER_m.dat")
          .expect("Unable to create file");

    // or serde_json::to_writer(er_m_file, &er_ensemble);
    serde_json::to_writer_pretty(er_m_file, &er_ensemble);

    // loading ensemble from file:

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

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

Implementations

impl<T, R> ErEnsembleM<T, R> where
    T: Node + SerdeStateConform,
    R: Rng, 

pub fn new(n: u32, m: usize, rng: R) -> Self

Initialize

create new ErEnsembleM graph with:

• n vertices
• m edges
• rng is consumed and used as random number generator in the following
• internally uses Graph<T>::new(n)
• generates random edges according to ER model

pub fn get_m(&self) -> usize

Return total number of edges

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

Trait Implementations

impl<T, R> AsRef<GenericGraph<T, NodeContainer<T>>> for ErEnsembleM<T, R> where
    T: Node,
    R: Rng, 

fn as_ref(&self) -> &Graph<T>

Performs the conversion.

impl<T, R> Borrow<GenericGraph<T, NodeContainer<T>>> for ErEnsembleM<T, R> where
    T: Node,
    R: Rng, 

fn borrow(&self) -> &Graph<T>

Immutably borrows from an owned value.

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

fn clone(&self) -> ErEnsembleM<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 ErEnsembleM<T, R> where
    T: Node,
    R: Rng, 

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

Formats the value using the given formatter.

impl<'de, T: Node, R: Rng> Deserialize<'de> for ErEnsembleM<T, R> where
    T: Node,
    R: Rng,
    T: Deserialize<'de>,
    R: Deserialize<'de>, 

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<T, R> GraphIteratorsMut<T, GenericGraph<T, NodeContainer<T>>, NodeContainer<T>> for ErEnsembleM<T, R> where
    T: Node + SerdeStateConform,
    R: Rng, 

fn contained_iter_neighbors_mut(
    &mut self,
    index: usize
) -> NContainedIterMut<T, NodeContainer<T>>

index``&mut T``sort_adj

fn contained_iter_neighbors_mut_with_index(
    &mut self,
    index: usize
) -> INContainedIterMut<T, NodeContainer<T>>

index``(index_neighbor: usize, neighbor: &mut T)``sort_adj

fn contained_iter_mut(&mut self) -> ContainedIterMut<T, NodeContainer<T>>

Node``EmptyNode

impl<T, R> HasRng<R> for ErEnsembleM<T, R> where
    T: Node,
    R: Rng, 

fn rng(&mut self) -> &mut R

Access RNG

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

fn swap_rng(&mut self, rng: R) -> R

Swap random number generator

• returns old internal rng

impl<T, R> MarkovChain<ErStepM, ErStepM> for ErEnsembleM<T, R> where
    T: Node + SerdeStateConform,
    R: Rng, 

fn undo_step(&mut self, step: ErStepM) -> ErStepM

• undo a markov step, return result-state
• if you want to undo more than one step see undo_steps

fn undo_step_quiet(&mut self, step: ErStepM)

• undo a markov step, panic on invalid result state
• for undoing multiple steps see undo_steps_quiet

fn m_step(&mut self) -> ErStepM

Markov step

• use this to perform a markov step
• for doing multiple mc steps at once, use m_steps

fn m_steps(&mut self, count: usize) -> Vec<S>

Markov steps * use this to perform multiple markov steps at once * result Vec<S> can be used to undo the steps with self.undo_steps(result)

fn undo_steps(&mut self, steps: Vec<S>) -> Vec<Res>

Undo markov steps * Note: uses undo_step in correct order and returns result ## Important: * look at specific implementation of undo_step, every thing mentioned there applies to each step

fn undo_steps_quiet(&mut self, steps: Vec<S>)

Undo markov steps * Note: uses undo_step_quiet in correct order ## Important: * look at specific implementation of undo_step_quiet, every thing mentioned there applies to each step

impl<T: Node, R: Rng> Serialize for ErEnsembleM<T, R> where
    T: Node,
    R: Rng,
    T: Serialize,
    R: Serialize, 

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl<T, R> SimpleSample for ErEnsembleM<T, R> where
    T: Node + SerdeStateConform,
    R: Rng, 

fn randomize(&mut self)

Randomizes self according to model

• this is intended for creation of initial sample
• used in simple_sample and simple_sample_vec

fn simple_sample<F>(&mut self, times: usize, f: F) where
    F: FnMut(&Self), 

do the following times times: 1) f(self) 2) self.randomize()

fn simple_sample_vec<F, G>(&mut self, times: usize, f: F) -> Vec<G> where
    F: FnMut(&Self) -> G, 

do the following times times: 1) res = f(self) 2) self.randomize() ## res is collected into Vector

impl<T, R> WithGraph<T, GenericGraph<T, NodeContainer<T>>> for ErEnsembleM<T, R> where
    T: Node + SerdeStateConform,
    R: Rng, 

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

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

fn graph(&self) -> &Graph<T>

GenericGraph