Struct cnetworks::Network

pub struct Network { /* fields omitted */ }

Network is the main graph-like data structure.

Implementations

impl Network

pub fn new(size: usize, model: Model, weight: Weight) -> Self

Create a new network of given size and desired model. Use Model::None if you want a network with no connections.

Examples

Creating a network of chosen model and random link weight:

use cnetworks::*;
let net = Network::new(20, Model::ER { p: 0.4, whole: true }, Weight::Uniform);
println!("{:?}", net);

Creating a network with no links and establishing them “by hand”:

use cnetworks::*;
let mut net = Network::new(10, Model::None, Weight::Constant { c: 0.25 });
net.link(1, 2);
net.link(4, 7);
println!("{:?}", net);

impl Network

pub fn size(&self) -> usize

Return the network size, ie. the total number of nodes.

pub fn model(&self) -> &Model

Return the model of the network

pub fn weight(&self) -> &Weight

Return the type of link weight

pub fn rng(&self) -> Result<RefMut<'_, impl RngCore>, BorrowMutError>

Try to borrow the network-local rng thread from it’s RefCell. This is effectively to calling a RefCell::try_borrow_mut().

pub fn indexes(
    &self
) -> impl DoubleEndedIterator<Item = usize> + ExactSizeIterator<Item = usize> + '_

Return iterator containing the node indexes.

Use Network::nodes() to iterate over the nodes themselves and Network::enumerate() to use both indexes and values at once.

Keep in mind that nodes are always ordered by their index, but it’s possible to have a network of nodes with non-sequential indexes, such as (0,2,3) or (100, 101, 150), but not (10, 0 1).

pub fn nodes(
    &self
) -> impl DoubleEndedIterator<Item = &Node> + ExactSizeIterator<Item = &Node>

Return iterator containing the network nodes, ordered by their index.

pub fn enumerate(
    &self
) -> impl DoubleEndedIterator<Item = (usize, &Node)> + ExactSizeIterator<Item = (usize, &Node)> + '_

Return iterator containing the (index, node) pairs. Note that this is not strictly equivalent to Network::nodes().enumerate(), since a node’s index doesn’t always equal it’s position in the iterator, even though nodes are always ordered by their index.

For instance, it’s possible to have a network of nodes with indexes (0, 2, 3) or (100, 101, 150), but not (10, 0, 1).

pub fn get(&self, index: usize) -> Result<&Node, CNErr>

Return immutable reference to a given node if it exists, Err if it does not.

pub fn size_connected(&self) -> usize

Return the number of connected nodes in the network, ie. ones that have at least one link

pub fn edges(&self) -> usize

Return the total number of edges in the network.

pub fn avg_deg(&self) -> f64

Calculate the arithmetical average of vertex degrees (ie. number of closest neighbors) in the network.

pub fn total_deg(&self) -> usize

Get the total degree of the network, ie. sum of degrees over all of the nodes.

pub fn deg_distr(&self) -> HashMap<usize, usize>

Return the degree distribution of the network as a HashMap of (degree, occurrences) pairs.

impl Network

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

Get the weight of the link between nodes i and j.

Returns None if such link does not exist and Err if i and j are the same or do not exist.

pub fn link(&mut self, i: usize, j: usize) -> Result<Option<f64>, CNErr>

Establish a link between nodes i and j using current network’s weight.

Returns the weight if the requested link already exist, None if it does not. Returns Err if i and j are the same or do not exist.

pub fn link_exact(
    &mut self,
    i: usize,
    j: usize,
    weight: f64
) -> Result<Option<f64>, CNErr>

Establish a link between nodes i and j with specified weight.

Updates the link weight and returns the old value if it already exist, None otherwise. Returns Err if i and j are the same or do not exist, or if the weight is not in the range (0, 1].

pub fn unlink(&mut self, i: usize, j: usize) -> Result<Option<f64>, CNErr>

Unsafely remove a link between two nodes. Does not perform a check whether the integrity of the network is preserved.

Returns the weight of the removed connection or None if the connection does not exist and Err if i and j are the same or do not exist.

pub fn unlink_safe(&mut self, i: usize, j: usize) -> Result<Option<f64>, CNErr>

Safely remove a link between two nodes ensuring the network does not split. Performs a BFS search to check whether the integrity of the network is preserved.

Returns the weight of removed link or None if the link does not exist or cannot be safely removed. Returns Err if i and j are the same or do not exist.

pub fn disconnect(&mut self, node: usize) -> Result<HashMap<usize, f64>, CNErr>

Unsafely disconnect a node from the network by removing all of its links. Does not check if the network integrity is perserved.

Returns the removed links as a HashMap of (target, weight) pairsm Err if i and j are the same or do not exist.

pub fn disconnect_safe(
    &mut self,
    node: usize
) -> Result<Option<HashMap<usize, f64>>, CNErr>

Safely disconnect a node from the network by removing all of its links. Performs a bfs search to ensure that the other nodes can stil all reach each other, ie. the integrity of the network is perserved.

Returns removed links as HashMap of (target, weight) pairs or None if node cannot be safely disconnected.

Returns Err if node does not exist.

pub fn disconnect_all(&mut self)

Removes ALL links in the network and sets the model to Model::None such that the initial linking process can be conducted again, eg. using a different model in combination with Network::init_*.

pub fn attach(&mut self, indexes: &[usize]) -> Result<(), CNErr>

Attach new nodes with specified indexes. Note that the nodes must be connected to the rest of the network manually, as no links will be automatically established.

Returns Err if there already exists a node with any of the specified indexes. No nodes will be attached in that case.

pub fn detach(&mut self, index: usize) -> Result<(), CNErr>

Completely remove the node with specified index from the network, disconnecting it first.

Returns Err if node with specified index does not exist.

impl Network

pub fn flag(
    &mut self,
    index: usize,
    name: &str,
    content: FlagContent
) -> Result<Option<FlagContent>, CNErr>

Set a flag with specified name and content. Updates existing flag and returns the old contents, or None if the flag was not set. Returns Err if specified node does not exist.

pub fn unflag(
    &mut self,
    index: usize,
    name: &str
) -> Result<Option<FlagContent>, CNErr>

Remove a flag with specified name. Returns the contents or None if flag was not set. Returns Err if specified node does not exist.

pub fn flagged(&self, name: &str) -> HashMap<usize, FlagContent>

Get all nodes containing a given flag. Returns HashMap of (node index, flag value) pairs.

pub fn not_flagged(&self, name: &str) -> Vec<usize>

Get all nodes not containing a given flag. Returns vector of node indexes.

pub fn clear_flag(&mut self, name: &str)

Clear the flag from all nodes. Returns iterator of the removed (node index, flag value) pairs.

Trait Implementations

impl Clone for Network

fn clone(&self) -> Network

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Network

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Network

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

Deserialize this value from the given Serde deserializer.

impl Index<usize> for Network

Enables easy non-mutable access to the nodes using the indexing operator.

type Output = Node

The returned type after indexing.

fn index(&self, idx: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl Serialize for Network

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

Serialize this value into the given Serde serializer.