Struct Dendrogram 

pub struct Dendrogram {
    pub num_vertices: usize,
    pub merges: Vec<(i64, i64)>,
    pub modularity: Vec<f64>,
    pub membership: Vec<i64>,
}

A hierarchical clustering (dendrogram) together with the modularity of each of its levels and the best cut.

Returned by Graph::community_fastgreedy, Graph::community_walktrap and Graph::community_eb_get_merges.

Fields

num_vertices: usize

Number of leaves, i.e. vertices of the clustered graph.

merges: Vec<(i64, i64)>

The merges: the i-th pair (a, b) joins clusters a and b into cluster num_vertices + i; ids below num_vertices are single vertices.

modularity: Vec<f64>

Modularity before the first merge and after each merge (merges.len() + 1 values), empty if not computed.

membership: Vec<i64>

Membership vector of the cut with the highest modularity.

Implementations

impl Dendrogram

pub fn num_communities(&self) -> usize

Number of communities in membership.

pub fn sizes(&self) -> Vec<usize>

Size of each community, indexed by community id.

pub fn communities(&self) -> Vec<Vec<VertexId>>

The vertices of each community, indexed by community id.

impl Dendrogram

pub fn max_modularity(&self) -> f64

The highest modularity along the dendrogram (NaN if unknown).

pub fn cut(&self, num_communities: usize) -> Result<Vec<i64>>

Cuts the dendrogram into num_communities clusters, returning the membership vector (see community_to_membership).

This is how to get a clustering with a prescribed number of communities instead of the modularity-maximizing membership.

Errors

ErrorKind::InvalidValue if num_communities is zero (for a non-empty graph), exceeds the number of vertices, or the dendrogram has not enough merges to reach it.

Examples

use igraph::prelude::*;
// Three triangles in a row, joined by single edges.
let g = Graph::from_edges(&[(0, 1), (1, 2), (2, 0), (3, 4), (4, 5), (5, 3),
                            (6, 7), (7, 8), (8, 6), (2, 3), (5, 6)], 9, false).unwrap();
let d = g.community_walktrap(None, 4).unwrap();
assert_eq!(d.cut(3).unwrap(), d.membership); // the best cut has 3 clusters
let two = d.cut(2).unwrap();
assert_eq!(two.iter().filter(|&&c| c == two[0]).count() % 3, 0);
assert_eq!(d.cut(1).unwrap(), vec![0; 9]);
assert!(d.cut(10).is_err());

Trait Implementations

impl Clone for Dendrogram

fn clone(&self) -> Dendrogram

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Dendrogram

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

Formats the value using the given formatter.

impl PartialEq for Dendrogram

fn eq(&self, other: &Dendrogram) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Dendrogram