irox-geometry 0.1.0

2D and 3D Geometry Primitives
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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

// SPDX-License-Identifier: MIT
// Copyright 2025 IROX Contributors
//

use crate::{Point, Point2D};
use core::ops::DivAssign;
use core::ops::{Add, AddAssign, Mul, MulAssign, Sub, SubAssign};
use irox_tools::math::Matrix;
use irox_tools::FloatIsh;
use irox_units::units::angle::Angle;

pub trait Vector2D<T: FloatIsh>: Default + Copy + Clone + PartialEq + PartialOrd {
    fn vx(&self) -> T;
    fn vy(&self) -> T;
    fn magnitude(&self) -> T;
    #[must_use]
    fn normalize(&self) -> Self;
    fn dot(&self, other: &Self) -> T;

    fn angle(&self, other: &Self) -> Angle;
    #[must_use]
    fn perpendicular(&self) -> Self;
    #[must_use]
    fn rotate(&self, angle: Angle) -> Self;
    #[must_use]
    fn abs(&self) -> Self;
    fn to_point(&self) -> Point<T>;
}

#[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Default)]
pub struct Vector<T: FloatIsh> {
    pub vx: T,
    pub vy: T,
}
impl<T: FloatIsh> Vector<T> {
    pub fn new(vx: T, vy: T) -> Self {
        Self { vx, vy }
    }
    pub fn splat(v: T) -> Self {
        Self::new(v, v)
    }
    pub fn to_matrix(&self) -> Matrix<2, 1, f64> {
        Matrix::new([[self.vy.to_f64()], [self.vy.to_f64()]])
    }
}

impl<T: FloatIsh> Vector2D<T> for Vector<T> {
    fn vx(&self) -> T {
        self.vx
    }

    fn vy(&self) -> T {
        self.vy
    }

    fn magnitude(&self) -> T {
        (self.vx * self.vx + self.vy * self.vy).sqrt()
    }

    fn normalize(&self) -> Self {
        let mag = self.magnitude();
        Self {
            vx: self.vx / mag,
            vy: self.vy / mag,
        }
    }

    fn dot(&self, other: &Self) -> T {
        self.vx * other.vx + self.vy * other.vy
    }

    fn angle(&self, other: &Self) -> Angle {
        let rad = self.vy.atan2(self.vx) - other.vy.atan2(other.vx);
        Angle::new_radians(rad.to_f64())
    }

    fn perpendicular(&self) -> Self {
        self.rotate(Angle::new_degrees(90.))
    }

    fn rotate(&self, angle: Angle) -> Self {
        let Matrix {
            values: [[vx], [vy]],
        } = Matrix::<2, 2, _>::rotation_counterclockwise(angle.as_radians().value())
            .mul(self.to_matrix());
        Self {
            vx: T::from_f64(vx),
            vy: T::from_f64(vy),
        }
    }

    fn abs(&self) -> Self {
        Self {
            vx: self.vx.abs(),
            vy: self.vy.abs(),
        }
    }
    fn to_point(&self) -> Point<T> {
        Point::new_point(self.vx, self.vy)
    }
}

impl<T: FloatIsh> Add for Vector<T> {
    type Output = Self;

    fn add(self, rhs: Self) -> Self::Output {
        Self {
            vx: self.vx + rhs.vx,
            vy: self.vy + rhs.vy,
        }
    }
}
impl<T: FloatIsh> AddAssign for Vector<T> {
    fn add_assign(&mut self, rhs: Self) {
        self.vx += rhs.vx;
        self.vy += rhs.vy;
    }
}
impl<T: FloatIsh> Mul<T> for Vector<T> {
    type Output = Self;

    fn mul(self, rhs: T) -> Self::Output {
        Self {
            vx: self.vx * rhs,
            vy: self.vy * rhs,
        }
    }
}
impl<T: FloatIsh> MulAssign<T> for Vector<T> {
    fn mul_assign(&mut self, rhs: T) {
        self.vx *= rhs;
        self.vy *= rhs;
    }
}
impl<T: FloatIsh> Sub for Vector<T> {
    type Output = Self;

    fn sub(self, rhs: Self) -> Self::Output {
        Self {
            vx: self.vx - rhs.vx,
            vy: self.vy - rhs.vy,
        }
    }
}
impl<T: FloatIsh> SubAssign for Vector<T> {
    fn sub_assign(&mut self, rhs: Self) {
        self.vx -= rhs.vx;
        self.vy -= rhs.vy;
    }
}
impl<T: FloatIsh> DivAssign<T> for Vector<T> {
    fn div_assign(&mut self, rhs: T) {
        self.vx /= rhs;
        self.vy /= rhs;
    }
}