violin 0.3.0

decentralized network coordinate system using the vivaldi algorithm
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

//! Defines the `VecD` coordinate vector that does not use any heap allocation

use crate::{
    std::ops::{Add, AddAssign, Div, Mul},
    Vector,
};

/// A `VecD` is a coordinate vector made up of some number of `f64`s stored as
/// an array
///
/// ```rust
/// use violin::heapless::VecD;
///
/// // defines a 3D vector
/// let v3 = VecD::from([1.1, 2.2, 3.3]);
///
/// // defines a 2D vector
/// let v3 = VecD::from([1.1, 2.2]);
///
/// // defines a 8D vector
/// let v3 = VecD::from([1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8]);
/// ```
#[derive(Copy, Clone, PartialEq, Debug)]
pub struct VecD<const N: usize> {
    inner: [f64; N],
}

impl<const N: usize> Default for VecD<N> {
    fn default() -> Self { Self { inner: [0.0f64; N] } }
}

impl<const N: usize> From<[f64; N]> for VecD<N> {
    fn from(arr: [f64; N]) -> Self { Self { inner: arr } }
}

impl_vec!(VecD<N>);

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

    #[test]
    fn distance() {
        let dist = VecD::from([1., 0., 5.]).distance(&VecD::from([0., 2., 4.]));
        #[cfg(feature = "std")]
        assert_eq!(dist, 2.449489742783178);
        #[cfg(not(feature = "std"))]
        assert_eq!(dist, 2.44948974);
    }

    #[test]
    fn magnitude() {
        assert_eq!(VecD::<3>::default().magnitude(), 0.0);
        assert_eq!(VecD::from([-2., 4., -4.]).magnitude(), 6.0f64);

        #[cfg(feature = "std")]
        assert_eq!(VecD::from([1.0, -2.0, 3.0]).magnitude(), 3.7416573867739413);
        #[cfg(not(feature = "std"))]
        assert_eq!(VecD::from([1.0, -2.0, 3.0]).magnitude(), 3.74165739);
    }

    #[cfg_attr(feature = "std", test)]
    #[cfg(feature = "std")]
    fn unit_vector() {
        let (_, uv) = VecD::from([1., 0., 5.]).unit_vector_from(&VecD::from([0., 2., 4.]));
        assert_eq!(
            uv,
            VecD::from([0.4082482904638631, -0.8164965809277261, 0.4082482904638631])
        );

        let a = VecD::from([1.0, 2.0, 3.0]);
        let b = VecD::from([0.5, 0.6, 0.7]);
        let (mag, uv) = a.unit_vector_from(&b);
        assert_eq!(
            uv,
            VecD::from([0.18257418583505536, 0.511207720338155, 0.8398412548412546])
        );
        let uv_mag = uv.magnitude();
        assert!(uv_mag > 0.9999999 && uv_mag <= 1.0);
        assert_eq!(mag, a.difference(&b).magnitude());
    }

    #[cfg_attr(not(feature = "std"), test)]
    #[cfg(not(feature = "std"))]
    fn unit_vector_no_std() {
        let (_, uv) = VecD::from([1., 0., 5.]).unit_vector_from(&VecD::from([0., 2., 4.]));
        assert_eq!(
            uv,
            VecD::from([0.408248290927726, -0.816496581855452, 0.408248290927726])
        );

        let a = VecD::from([1.0, 2.0, 3.0]);
        let b = VecD::from([0.5, 0.6, 0.7]);
        let (mag, uv) = a.unit_vector_from(&b);
        assert_eq!(
            uv,
            VecD::from([0.18257418567011074, 0.5112077198763101, 0.8398412540825093])
        );
        let uv_mag = uv.magnitude();
        assert!(uv_mag > 0.9999999 && uv_mag <= 1.0);
        assert_eq!(mag, a.difference(&b).magnitude());
    }

    #[test]
    fn equal_unit_vectors() {
        // equal coordinates should not get a divide by zero
        let a = VecD::from([1.0, 2.0, 3.0]);
        let (mag, uv) = a.unit_vector_from(&a);
        assert_eq!(uv.magnitude(), 1.0);
        assert_eq!(mag, 0.0);
    }

    #[test]
    fn add() {
        let a = VecD::from([1.0, -3.0, 3.0]);
        let b = VecD::from([-4.0, 5.0, 6.0]);
        assert_eq!(a + b, VecD::from([-3.0, 2.0, 9.0]));
        assert_eq!(a + VecD::default(), a);
    }

    #[test]
    fn difference() {
        let a = VecD::from([1.0, -3.0, 3.0]);
        let b = VecD::from([-4.0, 5.0, 6.0]);
        assert_eq!(a.difference(&b), VecD::from([5.0, -8.0, -3.0]));
        assert_eq!(a.difference(&VecD::default()), a);
    }
}