Struct net_ensembles::BAensemble

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

Implements a Barabási-Albert Graph ensemble

Implementations

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

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

Initialize

• create simplest form of Barabási-Albert graph
• m = 1
• n: Number of nodes, n > 1 has to be true panics otherwise
• rng: Rng to use

pub fn new_from_graph<B>(n: usize, rng: R, m: usize, source_graph: B) -> Selfwhere
    B: Borrow<Graph<T>>,

Generate a new BA graph ensemble with a specified source graph

• panics if source_graph contains any vertices with degree 0
• m: how many edges should each newly added vertex have originally
• rng: Random number generator
• n: Number of nodes, n > source_graph.vertex_count() has to be true panics otherwise

pub fn new_from_generic_graph<A2, B>(
    n: usize,
    rng: R,
    m: usize,
    generic_source_graph: B
) -> Selfwhere
    A2: AdjContainer<T>,
    B: Borrow<GenericGraph<T, A2>>,

Generate a new BA graph ensemble with a specified generic source graph

• panics if generic_source_graph contains any vertices with degree 0
• m: how many edges should each newly added vertex have originally
• rng: Random number generator
• n: Number of nodes, n > source_graph.vertex_count() has to be true panics otherwise

pub fn source_graph(&self) -> &Graph<T>

get reference to original graph, which is at the core of the BA graph

Trait Implementations

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

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 BAensemble<T, R>where
    T: Node,
    R: Rng,

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

Immutably borrows from an owned value.

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

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

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

Formats the value using the given formatter.

impl<'de, T, R> Deserialize<'de> for BAensemble<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 BAensemble<T, R>where
    T: Node + SerdeStateConform,
    R: Rng,

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

fn randomize(&mut self)

Randomizes the Barabási-Albert (BA) graph

• this essentially deletes the BA graph and creates a new one using the initial graph

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 BAensemble<T, R>where
    T: Node + SerdeStateConform,
    R: Rng,

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

fn sort_adj(&mut self)

sorts Adjecaency List