distances 1.8.0

Fast and generic distance functions for high-dimensional data.
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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

//! Number variants for floats, integers, and unsigned integers.

use core::hash::Hash;

use crate::Number;

/// Sub-trait of `Number` for all integer types.
pub trait Int: Number + Hash + Eq + Ord {}

/// Macro to implement `IntNumber` for all integer types.
macro_rules! impl_int {
    ($($ty:ty),*) => {
        $(
            impl Int for $ty {}
        )*
    }
}

impl_int!(u8, i8, u16, i16, u32, i32, u64, i64, u128, i128, usize, isize);

/// Sub-trait of `Number` for all signed integer types.
pub trait IInt: Number + Hash + Eq + Ord {}

/// Macro to implement `IIntNumber` for all signed integer types.
macro_rules! impl_iint {
    ($($ty:ty),*) => {
        $(
            impl IInt for $ty {}
        )*
    }
}

impl_iint!(i8, i16, i32, i64, i128, isize);

/// Sub-trait of `Number` for all unsigned integer types.
pub trait UInt: Number + Hash + Eq + Ord {
    /// Returns the number as a `i64`.
    fn as_i64(self) -> i64;
}

/// Macro to implement `UIntNumber` for all unsigned integer types.
macro_rules! impl_uint {
    ($($ty:ty),*) => {
        $(
            #[allow(clippy::cast_lossless, clippy::cast_possible_truncation)]
            impl UInt for $ty {
                #[allow(clippy::cast_possible_wrap)]
                fn as_i64(self) -> i64 {
                    self as i64
                }
            }
        )*
    }
}

impl_uint!(u8, u16, u32, u64, u128, usize);

/// Sub-trait of `Number` for all floating point types.
pub trait Float: Number + core::ops::Neg<Output = Self> {
    /// The square-root of 2.
    const SQRT_2: Self;

    /// Returns the square root of a `Float`.
    #[must_use]
    fn sqrt(self) -> Self;

    /// Returns the cube root of a `Float`.
    #[must_use]
    fn cbrt(self) -> Self;

    /// Returns the inverse square root of a `Float`, i.e. `1.0 / self.sqrt()`.
    #[must_use]
    fn inv_sqrt(self) -> Self {
        Self::ONE / self.sqrt()
    }

    /// Returns `self` raised to the power of `exp`.
    #[must_use]
    fn powf(self, exp: Self) -> Self;

    /// The error function.
    #[must_use]
    fn erf(self) -> Self;

    /// Returns the logarithm of `self` with base 2.
    #[must_use]
    fn log2(self) -> Self;
}

impl Float for f32 {
    const SQRT_2: Self = core::f32::consts::SQRT_2;

    fn sqrt(self) -> Self {
        Self::sqrt(self)
    }

    fn cbrt(self) -> Self {
        Self::cbrt(self)
    }

    fn powf(self, exp: Self) -> Self {
        Self::powf(self, exp)
    }

    fn erf(self) -> Self {
        libm::erff(self)
    }

    fn log2(self) -> Self {
        Self::log2(self)
    }
}

impl Float for f64 {
    const SQRT_2: Self = core::f64::consts::SQRT_2;

    fn sqrt(self) -> Self {
        Self::sqrt(self)
    }

    fn cbrt(self) -> Self {
        Self::cbrt(self)
    }

    fn powf(self, exp: Self) -> Self {
        Self::powf(self, exp)
    }

    fn erf(self) -> Self {
        libm::erf(self)
    }

    fn log2(self) -> Self {
        Self::log2(self)
    }
}