rcgal 0.2.2

Rust Computational Geometry Algorithms Library.
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

use std::ops::{Add, Div, Mul, Sub};

use super::number_type::NumberType;

#[derive(Debug, Clone, Copy)]
pub struct Vector2<T: NumberType> {
    x: T,
    y: T,
}

impl<T: NumberType> Vector2<T> {
    pub fn new(x: T, y: T) -> Self {
        Self { x, y }
    }

    pub fn x(&self) -> T {
        self.x
    }

    pub fn y(&self) -> T {
        self.y
    }

    pub fn length(&self) -> T {
        (self.x * self.x + self.y * self.y).sqrt()
    }

    pub fn normalize(&self) -> Self {
        let length = self.length();
        let eps = T::default_eps();
        if length < eps {
            return *self;
        }
        Self {
            x: self.x / length,
            y: self.y / length,
        }
    }

    pub fn dot(&self, other: &Self) -> T {
        self.x * other.x + self.y * other.y
    }

    pub fn cross(&self, other: &Self) -> T {
        self.x * other.y - self.y * other.x
    }

    pub fn radian_to(&self, other: &Self) -> T {
        let radian_a = self.y().atan2(self.x());
        let radian_b = other.y().atan2(other.x());
        let mut radian = radian_b - radian_a;
        if radian < T::zero() {
            radian = radian + T::from_f64(2.0) * T::pi();
        }
        radian
    }
}

impl<T: NumberType> Add for Vector2<T> {
    type Output = Self;

    fn add(self, other: Self) -> Self::Output {
        Self::new(self.x + other.x, self.y + other.y)
    }
}

impl<T: NumberType> Sub for Vector2<T> {
    type Output = Self;

    fn sub(self, other: Self) -> Self::Output {
        Self::new(self.x - other.x, self.y - other.y)
    }
}

impl<T: NumberType> Mul<T> for Vector2<T> {
    type Output = Self;

    fn mul(self, rhs: T) -> Self::Output {
        Self::new(self.x * rhs, self.y * rhs)
    }
}

impl<T: NumberType> Div<T> for Vector2<T> {
    type Output = Self;

    fn div(self, rhs: T) -> Self::Output {
        Self::new(self.x / rhs, self.y / rhs)
    }
}

impl<T: NumberType> PartialEq for Vector2<T> {
    fn eq(&self, other: &Self) -> bool {
        self.x.equals(other.x) && self.y.equals(other.y)
    }
}

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

    #[test]
    fn test() {
        let v_a = Vector2::new(1.0, 0.0);
        let v_b = Vector2::new(0.0, 1.0);
        assert_eq!(v_a.radian_to(&v_b), std::f64::consts::PI / 2.0);

        let v_b = Vector2::new(-1.0, 0.0);
        assert_eq!(v_a.radian_to(&v_b), std::f64::consts::PI);

        let v_b = Vector2::new(0.0, -4.0);
        assert_eq!(v_a.radian_to(&v_b), std::f64::consts::PI * 3.0 / 2.0);

        let v_a = Vector2::new(0.0, 1.0);
        let v_b = Vector2::new(1.0, 0.0);
        assert_eq!(v_a.radian_to(&v_b), std::f64::consts::PI * 3.0 / 2.0);

        let v_a = Vector2::new(0.0, 1.0);
        let v_b = Vector2::new(1.0, 0.0);
        assert_eq!(v_b.radian_to(&v_a), std::f64::consts::PI / 2.0);
    }
}