del-geo-core 0.1.38

2D/3D geometry utility codes
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

//! methods for N dimensional vector

pub trait VecN<T, const N: usize> {
    fn add(&self, other: &[T; N]) -> Self;
    fn add_in_place(&mut self, other: &[T; N]);
    fn sub(&self, other: &[T; N]) -> Self;
    fn sub_in_place(&mut self, other: &[T; N]);
    fn scale(&self, scalar: T) -> Self;
    fn scale_in_place(&mut self, scale: T);
    fn norm(&self) -> T;
}

impl<T, const N: usize> VecN<T, N> for [T; N]
where
    T: num_traits::Float,
{
    fn add(&self, other: &[T; N]) -> Self {
        std::array::from_fn(|i| self[i] + other[i])
    }
    fn add_in_place(&mut self, other: &[T; N]) {
        *self = self.add(other);
    }
    fn sub(&self, other: &[T; N]) -> Self {
        std::array::from_fn(|i| self[i] - other[i])
    }
    fn sub_in_place(&mut self, other: &[T; N]) {
        self.iter_mut()
            .zip(other.iter())
            .for_each(|(a, &b)| *a = *a - b);
    }
    fn norm(&self) -> T {
        // self.iter().map(|&v| v * v).sum::<T>().sqrt() // remove because it requires std:iter::Sum
        self.iter()
            .fold(T::zero(), |acc, &elem| acc + elem * elem)
            .sqrt()
    }
    fn scale(&self, scalar: T) -> Self {
        std::array::from_fn(|i| self[i] * scalar)
    }
    fn scale_in_place(&mut self, scale: T) {
        *self = self.scale(scale);
    }
}

#[test]
fn test_add() {
    // Test with different array sizes
    assert_eq!([1., 2.].add(&[2., 3.]), [3., 5.]);
    assert_eq!([1., 2.].sub(&[2., 3.]), [-1., -1.]);
    assert_eq!([4., 3.].norm(), 5.);
    // assert_eq!([1, 2, 3].add(&[2, 3, 4]), [3, 5, 7]);
    // assert_eq!([1, 2, 3, 4].add(&[2, 3, 4, 5]), [3, 5, 7, 9]);
}

pub fn add_three<T, const N: usize>(a: &[T; N], b: &[T; N], c: &[T; N]) -> [T; N]
where
    T: num_traits::Float,
{
    std::array::from_fn(|i| a[i] + b[i] + c[i])
}

pub fn add_four<T, const N: usize>(a: &[T; N], b: &[T; N], c: &[T; N], d: &[T; N]) -> [T; N]
where
    T: num_traits::Float,
{
    std::array::from_fn(|i| a[i] + b[i] + c[i] + d[i])
}

pub fn distance<T, const N: usize>(a: &[T; N], b: &[T; N]) -> T
where
    T: num_traits::Float,
{
    a.iter()
        .zip(b.iter())
        .fold(T::zero(), |sum, (&u, &v)| sum + (u - v) * (u - v))
        .sqrt()
}

pub fn squared_distance<T, const N: usize>(a: &[T; N], b: &[T; N]) -> T
where
    T: num_traits::Float,
{
    a.iter()
        .zip(b.iter())
        .fold(T::zero(), |sum, (&u, &v)| sum + (u - v) * (u - v))
}

pub fn dot<T, const N: usize>(a: &[T; N], b: &[T; N]) -> T
where
    T: num_traits::Float,
{
    a.iter()
        .zip(b.iter())
        .fold(T::zero(), |sum, (&u, &v)| sum + u * v)
}

pub fn scale_in_place<T, const N: usize>(a: &mut [T; N], s: T)
where
    T: num_traits::Float,
{
    a.iter_mut().for_each(|v| *v = (*v) * s);
}

pub fn add_in_place<T, const N: usize>(a: &mut [T; N], s: &[T; N])
where
    T: num_traits::Float,
{
    a.iter_mut()
        .zip(s.iter())
        .for_each(|(b, c)| *b = (*b) + (*c));
}