Struct Graph 

pub struct Graph<F> {
    pub n_nodes: usize,
    pub adjacency: Vec<Vec<(usize, F)>>,
    pub node_features: Option<Array2<F>>,
}

Graph representation for clustering algorithms

Fields

n_nodes: usize

Number of nodes in the graph

adjacency: Vec<Vec<(usize, F)>>

Adjacency list representation: node_id -> [(neighbor_id, weight), …]

node_features: Option<Array2<F>>

Optional node labels/features

Implementations

impl<F: Copy + PartialOrd + Zero + 'static> Graph<F>

Basic construction and traversal methods — no Float arithmetic required. Works with any F that is Copy + PartialOrd + Zero + 'static.

pub fn new(_nnodes: usize) -> Self

Create a new empty graph with specified number of nodes

pub fn from_adjacencymatrix(_adjacencymatrix: ArrayView2<'_, F>) -> Result<Self>

Create a graph from an adjacency matrix

pub fn add_edge(&mut self, node1: usize, node2: usize, weight: F) -> Result<()>

Add an edge between two nodes

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

Get the degree of a node (number of neighbor_s)

pub fn neighbor_s(&self, node: usize) -> &[(usize, F)]

Get all neighbor_s of a node

impl<F: Float + FromPrimitive + Debug + ScalarOperand + Sum + 'static> Graph<F>

Float-arithmetic methods — modularity calculations, KNN graph construction, etc.

pub fn from_knngraph(data: ArrayView2<'_, F>, k: usize) -> Result<Self>

Create a k-nearest neighbor_ graph from data points

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

Get the weighted degree of a node (sum of edge weights)

pub fn modularity(&self, communities: &[usize]) -> F

Calculate modularity of a given community assignment

Trait Implementations

impl<F: Clone> Clone for Graph<F>

fn clone(&self) -> Graph<F>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F: Debug> Debug for Graph<F>

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

Formats the value using the given formatter.

impl<'de, F> Deserialize<'de> for Graph<F>

where F: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<F> Serialize for Graph<F>

where F: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.