distantia 0.0.0

Away from
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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

pub trait EuclideanDistance<T, Rhs = Self> {
    fn euclidean_distance(&self, rhs: &Rhs) -> T;
    /// It is especially suitable when only the length needs to be compared
    ///
    /// a square root operation is generally 14 instruction cycles
    ///
    /// and the square root cannot be used in some spaces, like Z^n
    fn euclidean_squared(&self, rhs: &Rhs) -> T;
}

pub trait ManhattanDistance<T, Rhs = Self> {
    // Required method
    fn manhattan_distance(&self, rhs: &Rhs) -> T;
}

pub trait ChebyshevDistance<T, Rhs = Self> {
    // Required method
    fn chebyshev_distance(&self, rhs: &Rhs) -> T;
}

pub trait FrechetDistance<T, Rhs = Self> {
    fn frechet_distance(&self, rhs: &Rhs) -> T;
}

pub trait GeodesicDistance<T, Rhs = Self> {
    // Required method
    fn geodesic_distance(&self, rhs: &Rhs) -> T;
}

pub trait HaversineDistance<T, Rhs = Self> {
    // Required method
    fn haversine_distance(&self, rhs: &Rhs) -> T;
}


pub trait MinkowskiDistance<T, Rhs = Self> {
    // Required method
    fn minkowski_distance(&self, rhs: &Rhs, p: T) -> T;
}

pub trait HammingDistance<T, Rhs = Self> {
    // Required method
    fn hamming_distance(&self, rhs: &Rhs) -> T;
}

pub trait LevenshteinDistance<T, Rhs = Self> {
    // Required method
    fn levenshtein_distance(&self, rhs: &Rhs) -> T;
}

pub trait JaroDistance<T, Rhs = Self> {
    // Required method
    fn jaro_distance(&self, rhs: &Rhs) -> T;
}

pub trait JaroWinklerDistance<T, Rhs = Self> {
    // Required method
    fn jaro_winkler_distance(&self, rhs: &Rhs) -> T;
}

pub trait SorensenDiceDistance<T, Rhs = Self> {
    // Required method
    fn sorensen_dice_distance(&self, rhs: &Rhs) -> T;
}

pub trait CosineDistance<T, Rhs = Self> {
    // Required method
    fn cosine_distance(&self, rhs: &Rhs) -> T;
}

pub trait JaccardDistance<T, Rhs = Self> {
    // Required method
    fn jaccard_distance(&self, rhs: &Rhs) -> T;
}

pub trait OverlapDistance<T, Rhs = Self> {
    // Required method
    fn overlap_distance(&self, rhs: &Rhs) -> T;
}

pub trait RogersTanimotoDistance<T, Rhs = Self> {
    fn rogers_tanimoto_distance(&self, rhs: &Rhs) -> T;
}

pub trait RusselRaoDistance<T, Rhs = Self> {
    fn russel_rao_distance(&self, rhs: &Rhs) -> T;
}

pub trait SokalSneathDistance<T, Rhs = Self> {
    fn sokal_sneath_distance(&self, rhs: &Rhs) -> T;
}

pub trait KulczynskiDistance<T, Rhs = Self> {
    fn kulczynski_distance(&self, rhs: &Rhs) -> T;
}

pub trait TverskyDistance<T, Rhs = Self> {
    fn tversky_distance(&self, rhs: &Rhs, alpha: T, beta: T) -> T;
}

pub trait TanimotoDistance<T, Rhs = Self> {
    fn tanimoto_distance(&self, rhs: &Rhs) -> T;
}

pub trait BrayCurtisDistance<T, Rhs = Self> {
    fn bray_curtis_distance(&self, rhs: &Rhs) -> T;
}

pub trait CanberraDistance<T, Rhs = Self> {
    fn canberra_distance(&self, rhs: &Rhs) -> T;
}

pub trait ChiSquaredDistance<T, Rhs = Self> {
    fn chi_squared_distance(&self, rhs: &Rhs) -> T;
}

pub trait GowerDistance<T, Rhs = Self> {
    fn gower_distance(&self, rhs: &Rhs) -> T;
}