Struct net_ensembles::er_c::ErEnsembleC [−][src]
pub struct ErEnsembleC<T, R> where
T: Node, { /* fields omitted */ }
Expand description
Implements Erdős-Rényi graph ensemble
- variable number of edges
- targets a connectivity
Sampling
- 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
Implementations
Initialize
create new ErEnsembleC
with:
n
vertices- target connectivity
c_target
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
Experimental! Connect the connected components
- adds edges, to connect the connected components
- panics if no vertices are in the graph
- 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
returns target connectivity
Explanation
The target connectivity c_target
is used to
calculate the probability p
, that any two vertices i
and j
(where i != j
)
are connected.
p = c_target / (N - 1)
where N
is the number of vertices in the graph
- set new value for target connectivity
Note
- will only set the value (and probability), which will be used from now on
- if you also want to create a new sample, call
randomize
afterwards
Trait Implementations
impl<T, R> AsRef<GenericGraph<T, NodeContainer<T>>> for ErEnsembleC<T, R> where
T: Node,
R: Rng,
impl<T, R> AsRef<GenericGraph<T, NodeContainer<T>>> for ErEnsembleC<T, R> where
T: Node,
R: Rng,
impl<T, R> Borrow<GenericGraph<T, NodeContainer<T>>> for ErEnsembleC<T, R> where
T: Node,
R: Rng,
impl<T, R> Borrow<GenericGraph<T, NodeContainer<T>>> for ErEnsembleC<T, R> where
T: Node,
R: Rng,
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
impl<'de, T, R> Deserialize<'de> for ErEnsembleC<T, R> where
T: Node,
T: Deserialize<'de>,
R: Deserialize<'de>,
impl<'de, T, R> Deserialize<'de> for ErEnsembleC<T, R> where
T: Node,
T: Deserialize<'de>,
R: Deserialize<'de>,
fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
__D: Deserializer<'de>,
fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
__D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer. Read more
f
to create labels depending on the indexdot_options
use dot_options!
macro and take a look at module dot_constants
self.dot()
, but returns a String instead
self.dot_from_indices
but returns String instead
self.dot_with_indices
but returns String insteadimpl<T, R> GraphIteratorsMut<T, GenericGraph<T, NodeContainer<T>>, NodeContainer<T>> for ErEnsembleC<T, R> where
T: Node + SerdeStateConform,
R: Rng,
impl<T, R> GraphIteratorsMut<T, GenericGraph<T, NodeContainer<T>>, NodeContainer<T>> for ErEnsembleC<T, R> where
T: Node + SerdeStateConform,
R: Rng,
fn contained_iter_neighbors_mut(
&mut self,
index: usize
) -> NContainedIterMut<'_, T, NodeContainer<T>>ⓘNotable traits for NContainedIterMut<'a, T, A>impl<'a, T, A> Iterator for NContainedIterMut<'a, T, A> where
T: 'a + Node,
A: AdjContainer<T>, type Item = &'a mut T;
fn contained_iter_neighbors_mut(
&mut self,
index: usize
) -> NContainedIterMut<'_, T, NodeContainer<T>>ⓘNotable traits for NContainedIterMut<'a, T, A>impl<'a, T, A> Iterator for NContainedIterMut<'a, T, A> where
T: 'a + Node,
A: AdjContainer<T>, type Item = &'a mut T;
impl<'a, T, A> Iterator for NContainedIterMut<'a, T, A> where
T: 'a + Node,
A: AdjContainer<T>, type Item = &'a mut T;
index
&mut T
sort_adj
will affect the orderfn contained_iter_neighbors_mut_with_index(
&mut self,
index: usize
) -> INContainedIterMut<'_, T, NodeContainer<T>>ⓘNotable traits for INContainedIterMut<'a, T, A>impl<'a, T, A> Iterator for INContainedIterMut<'a, T, A> where
T: 'a + Node,
A: AdjContainer<T>, type Item = (usize, &'a mut T);
fn contained_iter_neighbors_mut_with_index(
&mut self,
index: usize
) -> INContainedIterMut<'_, T, NodeContainer<T>>ⓘNotable traits for INContainedIterMut<'a, T, A>impl<'a, T, A> Iterator for INContainedIterMut<'a, T, A> where
T: 'a + Node,
A: AdjContainer<T>, type Item = (usize, &'a mut T);
impl<'a, T, A> Iterator for INContainedIterMut<'a, T, A> where
T: 'a + Node,
A: AdjContainer<T>, type Item = (usize, &'a mut T);
index
(index_neighbor: usize, neighbor: &mut T)
sort_adj
will affect the orderfn contained_iter_mut(&mut self) -> ContainedIterMut<'_, T, NodeContainer<T>>ⓘNotable traits for ContainedIterMut<'a, T, A>impl<'a, T, A> Iterator for ContainedIterMut<'a, T, A> where
T: 'a + Node,
A: AdjContainer<T>, type Item = &'a mut T;
fn contained_iter_mut(&mut self) -> ContainedIterMut<'_, T, NodeContainer<T>>ⓘNotable traits for ContainedIterMut<'a, T, A>impl<'a, T, A> Iterator for ContainedIterMut<'a, T, A> where
T: 'a + Node,
A: AdjContainer<T>, type Item = &'a mut T;
impl<'a, T, A> Iterator for ContainedIterMut<'a, T, A> where
T: 'a + Node,
A: AdjContainer<T>, type Item = &'a mut T;
Node
(for example EmptyNode
or whatever you used)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
impl<T, R> MarkovChain<ErStepC, ErStepC> for ErEnsembleC<T, R> where
T: Node + SerdeStateConform,
R: Rng,
impl<T, R> MarkovChain<ErStepC, ErStepC> for ErEnsembleC<T, R> where
T: Node + SerdeStateConform,
R: Rng,
Markov step
- use this to perform a markov step, e.g., to create a markov chain
- result
ErStepC
can be used to undo the step withself.undo_step(result)
Undo a markcov step
- adds removed edge, or removes added edge, or does nothing
- if it returns an Err value, you probably used the function wrong
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 markov step
- adds removed edge, or removes added edge, or does nothing
- if it returns an Err value, you probably used the function wrong
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 without return Read more
Accumulating markov step Read more
Accumulating markov steps Read more
Accumulating markov steps Read more
Undo markov steps Read more
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)
do the following times
times: Read more
impl<T, R> WithGraph<T, GenericGraph<T, NodeContainer<T>>> for ErEnsembleC<T, R> where
T: Node + SerdeStateConform,
R: Rng,
impl<T, R> WithGraph<T, GenericGraph<T, NodeContainer<T>>> for ErEnsembleC<T, R> where
T: Node + SerdeStateConform,
R: Rng,
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
Auto Trait Implementations
impl<T, R> RefUnwindSafe for ErEnsembleC<T, R> where
R: RefUnwindSafe,
T: RefUnwindSafe,
impl<T, R> Send for ErEnsembleC<T, R> where
R: Send,
T: Send,
impl<T, R> Sync for ErEnsembleC<T, R> where
R: Sync,
T: Sync,
impl<T, R> Unpin for ErEnsembleC<T, R> where
R: Unpin,
T: Unpin,
impl<T, R> UnwindSafe for ErEnsembleC<T, R> where
R: UnwindSafe,
T: UnwindSafe,
Blanket Implementations
Mutably borrows from an owned value. Read more
pub fn cast_trunc(self) -> T
pub fn cast_trunc(self) -> T
Cast to integer, truncating Read more
pub fn cast_nearest(self) -> T
pub fn cast_nearest(self) -> T
Cast to the nearest integer Read more
pub fn cast_floor(self) -> T
pub fn cast_floor(self) -> T
Cast the floor to an integer Read more
pub fn try_cast_trunc(self) -> Result<T, Error>
pub fn try_cast_trunc(self) -> Result<T, Error>
Try converting to integer with truncation Read more
pub fn try_cast_nearest(self) -> Result<T, Error>
pub fn try_cast_nearest(self) -> Result<T, Error>
Try converting to the nearest integer Read more
pub fn try_cast_floor(self) -> Result<T, Error>
pub fn try_cast_floor(self) -> Result<T, Error>
Try converting the floor to an integer Read more
pub fn try_cast_ceil(self) -> Result<T, Error>
pub fn try_cast_ceil(self) -> Result<T, Error>
Try convert the ceiling to an integer Read more