Struct net_ensembles::ConfigurationModel

pub struct ConfigurationModel<T, R>where
    T: Node,{ /* private fields */ }

Generate networks with a given degree distribution

• the degree of each vertex is fixed (see self.degree_vec), while the actual edges will be drawn randomly
• No self loops allowed

Implementations

impl<T, R> ConfigurationModel<T, R>where
    T: Node,

pub fn degree_vec(&self) -> &Vec<usize>

Get reference to the degree vector of the vertices, faster than self.graph().degree_vec(), since the former has to construct the vector, while the latter just returns a reference to an existing vector

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

pub fn from_const(constant: usize, size: usize, rng: R) -> Option<Self>

create configuration model from a constant degree

• drawn graphs will consist of degree_vec.len() vertices, where a vertex i will have degree degree_vec[i]
• size: number of nodes in the resulting graphs
• returns None if resulting degree vector is invalid

pub fn from_generic_graph<T1, A1>(
    generic_graph: &GenericGraph<T1, A1>,
    rng: R
) -> Selfwhere
    T1: Node,
    A1: AdjContainer<T1>,

create ConfigurationModel from a generic graph

• same as from_vec_unchecked, but creates degree vector from a generic graph

pub fn clone_from_generic_graph<A>(
    generic_graph: &GenericGraph<T, A>,
    rng: R
) -> Selfwhere
    T: Clone,
    A: AdjContainer<T>,

create ConfigurationModel from a generic graph and clones underlying Data

• degree_vec will be extracted from generic_graph
• Data will be cloned from the generic_graph
• returns ConfigurationModel model
• model.graph() will have the same topology as generic_graph after this creation. This will of cause change, if you call randomize or do markov steps

pub fn from_vec(degree_vec: Vec<usize>, rng: R) -> Option<Self>

create configuration model from a degree vector

• drawn graphs will consist of degree_vec.len() vertices, where a vertex i will have degree degree_vec[i]
• returns None if degree vector is invalid

pub fn from_vec_unchecked(degree_vec: Vec<usize>, rng: R) -> Self

create configuration model from a degree vector

• same as from_vec, but it does not check if the degree_vec is valid - that is on you now

pub fn degree_vec_is_valid(degree_vec: &[usize]) -> bool

check if a vector (slice) is a vaild degree distribution

• sum of degree_vec needs to be even
• degree_vec.len() has to be greater than 1
• no entry can request a degree larger than degree_vec.len()-2

pub fn assert_degree_vec_valid(degree_vec: &[usize])

asserts, that a vector is a vaild degree distribution

• similar to degree_vec_is_valid, but asserts instead
• intended for debugging: see why the degree_vec is invalid

pub fn swap_degree_vec(&mut self, new_degree_vec: Vec<usize>) -> Vec<usize>

Swaps the degree vector for a new one and draws a new network accordingly

Note new_degree_vec.len() has to be of the same length as self.degree_vec.len() will panic otherwise

• panics if new_degree_vec is invalid
• returns previous degree_vec

pub fn swap_degree_vec_unchecked(
    &mut self,
    new_degree_vec: Vec<usize>
) -> Vec<usize>

Swaps the degree_vec for a new one and draws a new network accordingly

• same as swap_degree_vec but does not assert, that the degree vector is valid
• panics if self.degree_vec.len() != new_degree_vec.len() (the only thing still checked for, as that check is really really cheap)

pub fn degree_vec_from_generic_graph<T1, A1>(
    &mut self,
    generic_graph: &GenericGraph<T1, A1>
)where
    T1: Node,
    A1: AdjContainer<T1>,

Use the degree vector of a generic graph

• asserts, that generic_graph and self.graph() have the same number of vertices
• similar to self.swap_degree_vec_unchecked(generic_graph.degree_vec()) but does not create new vector and as such does not return old degree vector. If you need the old degree vector, you can use self.degree_vec().clone() before calling this method

Trait Implementations

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

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

Converts this type into a shared reference of the (usually inferred) input type.

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

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

Immutably borrows from an owned value.

impl<T: Clone, R: Clone> Clone for ConfigurationModel<T, R>where
    T: Node,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, R> Contained<T> for ConfigurationModel<T, R>where
    T: Node,

fn get_contained(&self, index: usize) -> Option<&T>

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

fn get_contained_mut(&mut self, index: usize) -> Option<&mut T>

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

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

For a save alternative see get_contained

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

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

impl<T: Debug, R: Debug> Debug for ConfigurationModel<T, R>where
    T: Node,

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

Formats the value using the given formatter.

impl<'de, T, R> Deserialize<'de> for ConfigurationModel<T, R>where
    T: Node,
    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 ConfigurationModel<T, R>where
    T: Node,

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

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

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

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

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

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)

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

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

Access RNG

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

If you need to exchange the internal rng

impl<T, R> MarkovChain<ConfigurationModelStep, Result<(), UndoStepErrorCM>> for ConfigurationModel<T, R>where
    T: Node + SerdeStateConform,
    R: Rng,

fn m_step(&mut self) -> ConfigurationModelStep

Markov step

• use this to perform a markov step, e.g., to create a markov chain
• result ConfigurationModelStep can be used to undo the step with self.undo_step(result)

How it works

• it draws two distinct vertices, weighted with the Vertex degree
• then for each vertex a random edge is drawn from the respective adjacency list. let these edges be edge1 = (n, j) and edge2 = (k, l). These edges are removed and the edges (n, k) and (j, l) are added.
• If the above would result in an invalid topology, nothing is added or removed and ConfigurationModelStep::Error is returned

fn undo_step(
    &mut self,
    step: &ConfigurationModelStep
) -> Result<(), UndoStepErrorCM>

Undo a markcov step

• adds removed edge and removes added edge, or does nothing

Important:

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

Error

If an error is encountered, this will revert the graph to the state, before trying to undo the step. The returned Error gives a hint for why this did not succeed.

fn undo_step_quiet(&mut self, step: &ConfigurationModelStep)

Undo a markcov step

• adds removed edge and removes added edge, or does nothing
• as long as you know, that you undo the steps in the correct order, this is the prefered method as this more efficent
• panics if an Error is encountered

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

Markov steps

fn m_steps_quiet(&mut self, count: usize)

Markov steps without return

fn m_step_acc<Acc, AccFn>(&mut self, acc: &mut Acc, acc_fn: AccFn) -> Swhere
    AccFn: FnMut(&Self, &S, &mut Acc),

Accumulating markov step

fn m_steps_acc<Acc, AccFn>(
    &mut self,
    count: usize,
    steps: &mut Vec<S, Global>,
    acc: &mut Acc,
    acc_fn: AccFn
)where
    AccFn: FnMut(&Self, &S, &mut Acc),

Accumulating markov steps

fn m_steps_acc_quiet<Acc, AccFn>(
    &mut self,
    count: usize,
    acc: &mut Acc,
    acc_fn: AccFn
)where
    AccFn: FnMut(&Self, &S, &mut Acc),

Accumulating markov steps

fn undo_steps(&mut self, steps: &[S], res: &mut Vec<Res, Global>)

Undo markov steps

fn undo_steps_quiet(&mut self, steps: &[S])

Undo markov steps

fn steps_accepted(&mut self, _steps: &[S])

Function called whenever the steps are accepted.

fn steps_rejected(&mut self, _steps: &[S])

Function called whenever the steps are rejected.

impl<T, R> Serialize for ConfigurationModel<T, R>where
    T: Node,
    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 ConfigurationModel<T, R>where
    T: Node,
    R: Rng,

fn randomize(&mut self)

Randomizes the edges according to the configuration Model

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

do the following times times:

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

do the following times times:

impl<T, R> WithGraph<T, GenericGraph<T, NodeContainer<T>>> for ConfigurationModel<T, R>where
    T: Node,

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

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

access additional information at index

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

mutable access to additional information at index

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

returns reference to the underlying topology aka, the GenericGraph

use this to call functions regarding the topology