kodama 0.3.0

Agglomerative hierarchical clustering.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

use crate::float::Float;

#[inline]
pub fn single<T: Float>(a: T, b: &mut T) {
    if a < *b {
        *b = a;
    }
}

#[inline]
pub fn complete<T: Float>(a: T, b: &mut T) {
    if a > *b {
        *b = a;
    }
}

#[inline]
pub fn average<T: Float>(a: T, b: &mut T, size_a: usize, size_b: usize) {
    let size_a = T::from_usize(size_a);
    let size_b = T::from_usize(size_b);
    *b = (size_a * a + size_b * *b) / (size_a + size_b);
}

#[inline]
pub fn weighted<T: Float>(a: T, b: &mut T) {
    *b = T::from_float(0.5) * (a + *b);
}

#[inline]
pub fn ward<T: Float>(
    a: T,
    b: &mut T,
    merged_dist: T,
    size_a: usize,
    size_b: usize,
    size_x: usize,
) {
    let size_a = T::from_usize(size_a);
    let size_b = T::from_usize(size_b);
    let size_x = T::from_usize(size_x);

    let numerator = ((size_x + size_a) * a) + ((size_x + size_b) * *b)
        - (size_x * merged_dist);
    let denom = size_a + size_b + size_x;
    *b = numerator / denom;
}

#[inline]
pub fn centroid<T: Float>(
    a: T,
    b: &mut T,
    merged_dist: T,
    size_a: usize,
    size_b: usize,
) {
    let size_a = T::from_usize(size_a);
    let size_b = T::from_usize(size_b);
    let size_ab = size_a + size_b;

    *b = (((size_a * a) + (size_b * *b)) / size_ab)
        - ((size_a * size_b * merged_dist) / (size_ab * size_ab));
}

#[inline]
pub fn median<T: Float>(a: T, b: &mut T, merged_dist: T) {
    let half = T::from_float(0.5);
    let quarter = T::from_float(0.25);

    *b = (half * (a + *b)) - (merged_dist * quarter);
}