scirs2-spatial 0.4.0

Spatial algorithms module for SciRS2 (scirs2-spatial)
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

//! # MinkowskiDistance - Trait Implementations
//!
//! This module contains trait implementations for `MinkowskiDistance`.
//!
//! ## Implemented Traits
//!
//! - `Distance`
//!
//! 🤖 Generated with [SplitRS](https://github.com/cool-japan/splitrs)

use scirs2_core::numeric::Float;

use super::functions::prefetch_read;
use super::functions::Distance;
use super::types::MinkowskiDistance;

impl<T: Float + Send + Sync> Distance<T> for MinkowskiDistance<T> {
    fn distance(&self, a: &[T], b: &[T]) -> T {
        if a.len() != b.len() {
            return T::nan();
        }
        if self.p == T::one() {
            let mut sum = T::zero();
            for i in 0..a.len() {
                sum = sum + (a[i] - b[i]).abs();
            }
            sum
        } else if self.p == T::from(2.0).expect("Operation failed") {
            let mut sum = T::zero();
            for i in 0..a.len() {
                let diff = a[i] - b[i];
                sum = sum + diff * diff;
            }
            sum.sqrt()
        } else if self.p == T::infinity() {
            let mut max_diff = T::zero();
            for i in 0..a.len() {
                let diff = (a[i] - b[i]).abs();
                if diff > max_diff {
                    max_diff = diff;
                }
            }
            max_diff
        } else {
            let mut sum = T::zero();
            for i in 0..a.len() {
                sum = sum + (a[i] - b[i]).abs().powf(self.p);
            }
            sum.powf(T::one() / self.p)
        }
    }
    fn min_distance_point_rectangle(&self, point: &[T], mins: &[T], maxes: &[T]) -> T {
        if self.p == T::one() {
            let mut sum = T::zero();
            for i in 0..point.len() {
                if point[i] < mins[i] {
                    sum = sum + (mins[i] - point[i]);
                } else if point[i] > maxes[i] {
                    sum = sum + (point[i] - maxes[i]);
                }
            }
            sum
        } else if self.p == T::from(2.0).expect("Operation failed") {
            let mut sum = T::zero();
            for i in 0..point.len() {
                if point[i] < mins[i] {
                    let diff = mins[i] - point[i];
                    sum = sum + diff * diff;
                } else if point[i] > maxes[i] {
                    let diff = point[i] - maxes[i];
                    sum = sum + diff * diff;
                }
            }
            sum.sqrt()
        } else if self.p == T::infinity() {
            let mut max_diff = T::zero();
            for i in 0..point.len() {
                let diff = if point[i] < mins[i] {
                    mins[i] - point[i]
                } else if point[i] > maxes[i] {
                    point[i] - maxes[i]
                } else {
                    T::zero()
                };
                if diff > max_diff {
                    max_diff = diff;
                }
            }
            max_diff
        } else {
            let mut sum = T::zero();
            for i in 0..point.len() {
                let diff = if point[i] < mins[i] {
                    mins[i] - point[i]
                } else if point[i] > maxes[i] {
                    point[i] - maxes[i]
                } else {
                    T::zero()
                };
                sum = sum + diff.powf(self.p);
            }
            sum.powf(T::one() / self.p)
        }
    }
}