ear-algae 0.5.0

Linear algebra featuring Vectors, Normal Vectors, Matrices, Rotors (Unit Quaternions) and Rigid Transforms (Rotation + Translation)
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

#[cfg(feature = "serde")]
use serde::{Deserialize, Serialize};

use crate::{
    Mat, Vect,
    ops::{Apl, BefAft},
    rotor::*,
    traits::*,
};

#[derive(Copy, Clone, Default)]
#[cfg_attr(
    feature = "serde",
    derive(Serialize, Deserialize),
    serde(bound(
        serialize = "
            [S; N]: Serialize,
            Bivector<N, S>: Serialize,
        ",
        deserialize = " 
            [S; N]: Deserialize<'de>,
            Bivector<N, S>: Deserialize<'de>,
        ",
    ))
)]
pub struct Rig<const N: usize, S: Field>
where
    (): RotDim<N>,
{
    pub trans: Vect<N, S>,
    pub rot: Rot<N, S>,
}

impl<const N: usize, S: Field> Rig<N, S>
where
    (): RotDim<N>,
{
    pub const IDENT: Self = Self {
        trans: Vect::ZERO,
        rot: Rot::IDENT,
    };

    pub fn new(trans: Vect<N, S>, rot: Rot<N, S>) -> Self {
        Self { trans, rot }
    }

    pub fn rot(rot: Rot<N, S>) -> Self {
        Self { rot, ..Self::IDENT }
    }

    pub fn trans(trans: Vect<N, S>) -> Self {
        Self {
            trans,
            ..Self::IDENT
        }
    }

    pub fn inv(self) -> Self {
        let rot = self.rot.inv();
        Self {
            rot,
            trans: rot.apl(-self.trans),
        }
    }
}

impl<const N: usize, S: Field> From<Rot<N, S>> for Rig<N, S>
where
    (): RotDim<N>,
{
    fn from(value: Rot<N, S>) -> Self {
        Self::rot(value)
    }
}

impl<const N: usize, S: Field> Apl<Vect<N, S>> for Rig<N, S>
where
    (): RotDim<N>,
{
    type Output = Vect<N, S>;

    fn apl(self, other: Vect<N, S>) -> Vect<N, S> {
        self.rot.apl(other) + self.trans
    }
}

impl<const N: usize, S: Field> BefAft for Rig<N, S>
where
    (): RotDim<N>,
{
    fn aft(self, other: Self) -> Self {
        Self {
            rot: self.rot.aft(other.rot),
            trans: self.rot.apl(other.trans) + self.trans,
        }
    }
}

impl<S: Field> Rig<3, S> {
    pub fn to_hmat(self) -> Mat<4, 4, S> {
        Mat::affine(self.rot.mat(), self.trans)
    }
}