Struct kodama::Dendrogram

pub struct Dendrogram<T> { /* private fields */ }

A step-wise dendrogram that represents a hierarchical clustering as a binary tree.

A dendrogram consists of a series of N - 1 steps, where N is the number of observations that were clustered. Each step corresponds to a merge between two other clusters (where a cluster might consist of one or more observations). Each step includes the labels for the pair of clusters that were merged, the number of total observations in the new merged cluster and the dissimilarity between the two merged clusters.

The labels of clusters are assigned as follows:

1. A cluster that corresponds to a single observation is assigned a label that corresponds to the given observation’s index in the pairwise dissimilarity matrix.
2. A cluster with more than one observation has the label N + i, where N is the total number of observations and i corresponds to the the ith step in which the cluster was created. So for example, the very first step in a dendrogram creates a cluster with the label N and the last step in a dendrogram creates a cluster with the label (N + N - 1) - 1 (since there are always N - 1 steps in a dendrogram).

This labeling scheme corresponds to the same labeling scheme used by SciPy.

The type parameter T refers to the type of dissimilarity used in the steps. In practice, T is a floating point type.

Implementations

impl<T> Dendrogram<T>

pub fn new(observations: usize) -> Dendrogram<T>

Return a new dendrogram with space for the given number of observations.

pub fn reset(&mut self, observations: usize)

Clear this dendrogram and ensure there is space for the given number of observations.

This method is useful for reusing a dendrogram’s allocation.

Note that this method does not need to be called before passing it to one of the clustering functions. The clustering functions will reset the dendrogram for you.

pub fn push(&mut self, step: Step<T>)

Push a new step on to this dendrogram.

Panics

This method panics if the dendrogram has N - 1 steps, where N is the number of observations supported by this dendrogram.

pub fn steps(&self) -> &[Step<T>]

Returns the steps in the dendrogram.

pub fn steps_mut(&mut self) -> &mut [Step<T>]

Return a mutable slice of the steps in this dendrogram.

pub fn len(&self) -> usize

Return the number of steps in this dendrogram.

pub fn is_empty(&self) -> bool

Return true if and only if this dendrogram has no steps.

pub fn observations(&self) -> usize

Return the number of observations that this dendrogram supports.

pub fn cluster_size(&self, label: usize) -> usize

Returns the total number of observations in the cluster identified by the following label.

The label may be any value in the half-open interval [0, N + N - 1), where N is the total number of observations.

impl<T: Float> Dendrogram<T>

pub fn eq_with_epsilon(&self, other: &Dendrogram<T>, epsilon: T) -> bool

Compare two dendrograms for approximate equality.

Approximate equality in this case refers to the dissimilarities in each step. In particular, two dissimilarities are considered equal if and only if the absolute value of their difference is less than or equal to the given epsilon value.

Trait Implementations

impl<T: Debug> Debug for Dendrogram<T>

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

Formats the value using the given formatter.

impl<T: Hash> Hash for Dendrogram<T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where
    H: Hasher,
    Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> Index<usize> for Dendrogram<T>

type Output = Step<T>

The returned type after indexing.

fn index(&self, i: usize) -> &Step<T>

Performs the indexing (container[index]) operation.

impl<T> IndexMut<usize> for Dendrogram<T>

fn index_mut(&mut self, i: usize) -> &mut Step<T>

Performs the mutable indexing (container[index]) operation.

impl<T: PartialEq> PartialEq<Dendrogram<T>> for Dendrogram<T>

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T: Eq> Eq for Dendrogram<T>

impl<T> StructuralEq for Dendrogram<T>

impl<T> StructuralPartialEq for Dendrogram<T>