smartcore 0.6.5

Machine Learning in Rust.
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
137
138
139
140
141
142
143

//! # Euclidian Metric Distance
//!
//! The Euclidean distance (L2) between two points \\( x \\) and \\( y \\) in n-space is defined as
//!
//! \\[ d(x, y) = \sqrt{\sum_{i=1}^n (x-y)^2} \\]
//!
//! Example:
//!
//! ```
//! use smartcore::metrics::distance::Distance;
//! use smartcore::metrics::distance::euclidian::Euclidian;
//!
//! let x = vec![1., 1.];
//! let y = vec![2., 2.];
//!
//! let l2: f64 = Euclidian::new().distance(&x, &y);
//! ```
//!
//! <script src="https://polyfill.io/v3/polyfill.min.js?features=es6"></script>
//! <script id="MathJax-script" async src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js"></script>
#[cfg(feature = "serde")]
use serde::{Deserialize, Serialize};
use std::marker::PhantomData;

use crate::linalg::basic::arrays::ArrayView1;
use crate::numbers::basenum::Number;

use super::Distance;

/// Euclidean distance is a measure of the true straight line distance between two points in Euclidean n-space.
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[derive(Debug, Clone)]
pub struct Euclidian<T> {
    _t: PhantomData<T>,
}

impl<T: Number> Default for Euclidian<T> {
    fn default() -> Self {
        Self::new()
    }
}

impl<T: Number> Euclidian<T> {
    /// instatiate the initial structure
    pub fn new() -> Euclidian<T> {
        Euclidian { _t: PhantomData }
    }

    /// return sum of squared distances
    #[inline]
    pub(crate) fn squared_distance<A: ArrayView1<T>>(x: &A, y: &A) -> f64 {
        if x.shape() != y.shape() {
            panic!("Input vector sizes are different.");
        }

        let sum: f64 = x
            .iterator(0)
            .zip(y.iterator(0))
            .map(|(&a, &b)| {
                let r = a - b;
                (r * r).to_f64().unwrap()
            })
            .sum();

        sum
    }
}

impl<T: Number, A: ArrayView1<T>> Distance<A> for Euclidian<T> {
    fn distance(&self, x: &A, y: &A) -> f64 {
        Euclidian::squared_distance(x, y).sqrt()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[cfg_attr(
        all(target_arch = "wasm32", not(target_os = "wasi")),
        wasm_bindgen_test::wasm_bindgen_test
    )]
    #[test]
    fn squared_distance() {
        let a = vec![1, 2, 3];
        let b = vec![4, 5, 6];

        let l2: f64 = Euclidian::new().distance(&a, &b);

        assert!((l2 - 5.19615242).abs() < 1e-8);
    }

    #[cfg(not(target_arch = "wasm32"))]
    #[test]
    fn euclidean_distance_zero_for_identical_points() {
        use proptest::prelude::*;

        proptest!(
            |(a in proptest::collection::vec(-100.0f64..100.0, 1..=10))|
            {
                let dist: f64 = Euclidian::new().distance(&a, &a);
                prop_assert!(dist.abs() < 1e-10, "d(a,a)={dist}");
            }
        );
    }

    #[cfg(not(target_arch = "wasm32"))]
    #[test]
    fn euclidean_distance_symmetric() {
        use proptest::prelude::*;

        proptest!( |(len in 1usize..=10,
                   a_vals in proptest::collection::vec(-100.0f64..100.0, 10),
                   b_vals in proptest::collection::vec(-100.0f64..100.0, 10))| {
            let a: Vec<f64> = a_vals[..len].to_vec();
            let b: Vec<f64> = b_vals[..len].to_vec();
            let d_ab: f64 = Euclidian::new().distance(&a, &b);
            let d_ba: f64 = Euclidian::new().distance(&b, &a);
            prop_assert!((d_ab - d_ba).abs() < 1e-10, "d(a,b)={}, d(b,a)={}", d_ab, d_ba);
        });
    }

    #[cfg(not(target_arch = "wasm32"))]
    #[test]
    fn euclidean_distance_triangle_inequality() {
        use proptest::prelude::*;

        proptest!( |(len in 1usize..=8,
                   a_vals in proptest::collection::vec(-50.0f64..50.0, 8),
                   b_vals in proptest::collection::vec(-50.0f64..50.0, 8),
                   c_vals in proptest::collection::vec(-50.0f64..50.0, 8))| {
            let a: Vec<f64> = a_vals[..len].to_vec();
            let b: Vec<f64> = b_vals[..len].to_vec();
            let c: Vec<f64> = c_vals[..len].to_vec();
            let d_ab: f64 = Euclidian::new().distance(&a, &b);
            let d_bc: f64 = Euclidian::new().distance(&b, &c);
            let d_ac: f64 = Euclidian::new().distance(&a, &c);
            prop_assert!(d_ac <= d_ab + d_bc + 1e-9,
                "triangle inequality violated: d(a,c)={}, d(a,b)+d(b,c)={}",
                d_ac, d_ab + d_bc);
        });
    }
}