vivaldi 0.1.0

Efficient network point-to-point latency estimations for large scale clusters
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

use super::*;
use rand::Rng;
use std::ops::Div;

/// A 2 dimensional Euclidean vector.
#[derive(PartialEq, Debug, Copy, Clone, Default)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Dimension2(pub [f64; 2]);

impl Vector for Dimension2 {
    fn magnitude(&self) -> Magnitude {
        let m = self.0.iter().fold(0.0, |acc, v| acc + (v * v)).sqrt();

        Magnitude(m)
    }

    fn random() -> Self {
        Dimension2([
            rand::thread_rng().gen::<f64>(),
            rand::thread_rng().gen::<f64>(),
        ])
    }
}

impl Add for Dimension2 {
    type Output = Self;

    fn add(self, other: Self) -> Self::Output {
        Self([self.0[0] + other.0[0], self.0[1] + other.0[1]])
    }
}

impl Add<f64> for Dimension2 {
    type Output = Self;

    fn add(self, other: f64) -> Self::Output {
        Self([self.0[0] + other, self.0[1] + other])
    }
}

impl Sub for Dimension2 {
    type Output = Self;

    fn sub(self, other: Self) -> Self::Output {
        Self([self.0[0] - other.0[0], self.0[1] - other.0[1]])
    }
}

/// Divide a vector by a constant amount.
impl Div<f64> for Dimension2 {
    type Output = Self;

    fn div(self, other: f64) -> Self::Output {
        Self([self.0[0] / other, self.0[1] / other])
    }
}

impl Mul<f64> for Dimension2 {
    type Output = Self;

    fn mul(self, other: f64) -> Self::Output {
        Self([self.0[0] * other, self.0[1] * other])
    }
}

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

    #[test]
    fn add() {
        let a = Dimension2([1.0, 2.0]);
        let b = Dimension2([0.1, 0.2]);

        assert_eq!(a + b, Dimension2([1.1, 2.2]));
    }

    #[test]
    fn add_f64_constant() {
        assert_eq!(Dimension2([1.0, 2.0]) + 42.0, Dimension2([43.0, 44.0]));
    }

    #[test]
    fn sub() {
        let a = Dimension2([1.1, 2.2]);
        let b = Dimension2([0.1, 0.2]);

        assert_eq!(a - b, Dimension2([1.0, 2.0]));
    }

    #[test]
    fn mul_f64_constant() {
        let a = Dimension2([1.0, 2.0]);

        assert_eq!(a * 2.0, Dimension2([2.0, 4.0]));
    }

    #[test]
    fn div_f64_constant() {
        assert_eq!(Dimension2([1.0, 2.0]) / 2.0, Dimension2([0.5, 1.0]));
    }

    #[test]
    fn magnitude() {
        assert_eq!(Dimension2([0.0, 0.0]).magnitude(), Magnitude(0.0));

        // Non-zero magnitude
        assert_eq!(
            Dimension2([1.0, 2.0]).magnitude(),
            Magnitude(2.23606797749979)
        );

        // Direction plays no part
        assert_eq!(
            Dimension2([-1.0, -2.0]).magnitude(),
            Magnitude(2.23606797749979)
        );
    }
}