Struct Network 

pub struct Network { /* private fields */ }

Undirected weighted graph backing the Leiden / Louvain algorithms.

Node ids are dense usize in 0..nodes(). Each undirected edge is stored twice (once per endpoint) so adjacency iteration is O(deg). Internal adjacency uses u32 neighbour ids for compactness; callers see only usize.

Implementations

impl Network

pub fn new() -> Network

Create a new empty network.

pub fn with_capacity(n_nodes: usize) -> Network

Create a new empty network with capacity for n_nodes nodes.

pub fn with_nodes(node_weights: &[f32], degrees: &[usize]) -> Network

Every node at once, with weight and room for degree neighbours, so the edges that follow never grow an adjacency list.

pub fn add_node(&mut self, weight: f32) -> usize

Append a node with weight. Returns its node id.

pub fn add_edge(&mut self, source: usize, target: usize, weight: f32)

Add an undirected edge between source and target with weight.

Panics

If source or target exceeds u32::MAX, or is out of range.

pub fn nodes(&self) -> usize

Number of nodes.

pub fn edge_count(&self) -> usize

Number of undirected edges (each pair counted once).

pub fn weight(&self, node: usize) -> f64

Get the weight of node as f64.

Panics

If node >= nodes().

pub fn node_weight_mut(&mut self, node: usize) -> &mut f32

Mutable access to a node’s weight.

Panics

If node >= nodes().

pub fn neighbors(&self, node: usize) -> NeighborAndWeightIter<'_>

Iterator over (neighbour_id, edge_weight) for all neighbours of node.

Panics

If node >= nodes().

pub fn edge_references(&self) -> EdgeReferences<'_>

Iterator over each undirected edge once.

pub fn get_total_node_weight(&self) -> f64

Sum of all node weights.

pub fn get_total_edge_weight(&self) -> f64

Sum of all edge weights (each undirected edge counted once).

pub fn get_total_edge_weight_par(&self) -> f64

Parallel total edge weight. Sums the double-counted weights then divides by 2. Chunked + serially reduced for determinism.

pub fn get_total_edge_weight_per_node(&self, result: &mut Vec<f64>)

Tabulate the total edge weight of each node into result.

pub fn create_reduced_network(&self, clustering: &impl Clustering) -> Network

Aggregate network where each cluster becomes a single node.

Node weights are summed within each cluster. Edge weights between distinct clusters are summed. Within-cluster edges are dropped — only the inter-cluster summary is preserved.

Panics

If a cluster id exceeds u32::MAX.

pub fn create_subnetworks(&self, c: &impl Clustering) -> Vec<Network>

One subnetwork per cluster, containing only intra-cluster edges.

Panics

If a node index exceeds u32::MAX.

Trait Implementations

impl Default for Network

fn default() -> Self

Returns the “default value” for a type.

impl WeightedGraph for Network

fn num_nodes(&self) -> usize

fn num_edges(&self) -> usize

fn neighbors_with_weight<'a>( &'a self, node: usize, ) -> Box<dyn Iterator<Item = (usize, f32)> + 'a>

fn degree(&self, node: usize) -> usize

fn weighted_degree(&self, node: usize) -> f32