Struct net_ensembles::spacial::SpacialEnsemble

pub struct SpacialEnsemble<T, R> { /* fields omitted */ }

Implements a special Ensemble

• You can generate a dot file which includes special information.
• NOTE You should use neato for that to work
• see module for literature

Implementations

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

pub fn new(n: usize, rng: R, f: f64, alpha: f64) -> Self

Generate a new Spacial ensemble with

• n nodes
• rng as random number generator
• f - see paper
• alpha - see paper

The specific model I implemented is described in

Timo Dewenter and Alexander K. Hartmann, “Large-deviation properties of resilience of power grids” New J. Phys. 17 (2015), DOI: 10.1088/1367-2630/17/1/015005

pub fn distance(&self, i: usize, j: usize) -> Option<f64>

Euclidean distance between two vertices

• Calculates the distance between the vertices corresponding to the indices i and j
• None if any of the indices is out of bounds

pub fn edge_probability(&self, i: usize, j: usize) -> Option<f64>

Calculates probability

• calculates the probability for an edge between the vertices corresponding to the indices i and j

Of cause you can check if there is currently an edge, but this probability is the probability used when determining, if there should be an edge

Trait Implementations

impl<T, R> AsRef<GenericGraph<T, SpacialNodeContainer<T>>> for SpacialEnsemble<T, R>

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

Performs the conversion.

impl<T: Clone, R: Clone> Clone for SpacialEnsemble<T, R>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug, R: Debug> Debug for SpacialEnsemble<T, R>

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

Formats the value using the given formatter.

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

You should use neato if you want the correct spacial placement of nodes

fn dot_from_indices<F, W, S1, S2>(
    &self,
    writer: W,
    dot_options: S1,
    f: F
) -> Result<(), Error> where
    S1: AsRef<str>,
    S2: AsRef<str>,
    W: Write,
    F: FnMut(usize) -> S2, 

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

fn dot_string_from_indices<F, S1, S2>(&self, dot_options: S1, f: F) -> String where
    S1: AsRef<str>,
    S2: AsRef<str>,
    F: FnMut(usize) -> S2, 

same as self.dot_from_indices but returns String instead

fn dot_with_indices<S, W>(&self, writer: W, dot_options: S) -> Result<(), Error> where
    S: AsRef<str>,
    W: Write, 

use index as labels for the nodes

default implementation uses dot_from_indices

fn dot_string_with_indices<S>(&self, dot_options: S) -> String where
    S: AsRef<str>, 

same as self.dot_with_indices but returns String instead

fn dot<S, W>(&self, writer: W, dot_options: S) -> Result<(), Error> where
    S: AsRef<str>,
    W: Write, 

create dot file with empty labels

default implementation uses dot_from_indices

fn dot_string<S>(&self, dot_options: S) -> String where
    S: AsRef<str>, 

same as self.dot(), but returns a String instead

impl<T, R> MarkovChain<SpacialStep, SpacialStep> for SpacialEnsemble<T, R> where
    T: Node,
    R: Rng, 

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

• panics if step is error, or cannot be undone The latter means, you are undoing the steps in the wrong order

fn m_step(&mut self) -> SpacialStep

Markov step

fn m_steps_quiet(&mut self, count: usize)

Markov steps without return

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

undo a markov step, return result-state

if you want to undo more than one step see undo_steps

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

Markov steps

fn m_step_acc<Acc, AccFn>(&mut self, acc: &mut Acc, acc_fn: AccFn) -> S where
    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

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

fn randomize(&mut self)

Randomizes the edges according to Er probabilities

• this is used by ErEnsembleC::new to create the initial topology
• you can use this for sampling the ensemble
• runs in O(vertices * vertices)

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: