ear-algae 0.5.1

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
104
105
106
107
108
109
110
111
112
113
114
115
116

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

use crate::traits::{Field, Ring};

macro_rules! scs {
    ($($s:tt),* $(,)?) => {$(
        let $s = $crate::op_wrapper::Sc($s);
    )*}
}
pub(crate) use scs;

#[derive(Copy, Clone, PartialEq, PartialOrd)]
pub struct Sc<S>(pub S);

impl<S: Ring> Add for Sc<S> {
    type Output = Self;

    fn add(self, rhs: Self) -> Self::Output {
        Self(self.0.add(rhs.0))
    }
}

impl<S: Ring> Sub for Sc<S> {
    type Output = Self;

    fn sub(self, rhs: Self) -> Self::Output {
        Self(self.0.sub(rhs.0))
    }
}

impl<S: Ring> Mul for Sc<S> {
    type Output = Self;

    fn mul(self, rhs: Self) -> Self::Output {
        Self(self.0.mul(rhs.0))
    }
}

impl<S: Ring> Div for Sc<S> {
    type Output = Self;

    fn div(self, rhs: Self) -> Self::Output {
        Self(self.0.div(rhs.0))
    }
}

impl<S: Ring> Neg for Sc<S> {
    type Output = Self;

    fn neg(self) -> Self::Output {
        Self(self.0.neg())
    }
}

impl<S: Ring> Sc<S> {
    pub fn pow(self, other: u32) -> Self {
        Self(self.0.pow(other))
    }

    pub fn max(self, other: Self) -> Self {
        Self(self.0.max(other.0))
    }
    pub fn min(self, other: Self) -> Self {
        Self(self.0.min(other.0))
    }

    pub fn clamp(self, min: Self, max: Self) -> Self {
        Self(self.0.clamp(min.0, max.0))
    }
}

impl<S: Field> Sc<S> {
    pub const SQRT_2: Self = Self(S::SQRT_2);
    pub const PI: Self = Self(S::PI);

    pub fn sqrt(self) -> Self {
        Self(self.0.sqrt())
    }

    pub fn exp(self) -> Self {
        Self(self.0.exp())
    }

    pub fn sin(self) -> Self {
        Self(self.0.sin())
    }
    pub fn cos(self) -> Self {
        Self(self.0.cos())
    }
    pub fn tan(self) -> Self {
        Self(self.0.tan())
    }

    pub fn sin_cos(self) -> (Self, Self) {
        let (sin, cos) = self.0.sin_cos();
        (Self(sin), Self(cos))
    }

    pub fn ln(self) -> Self {
        Self(self.0.ln())
    }

    pub fn asin(self) -> Self {
        Self(self.0.asin())
    }
    pub fn acos(self) -> Self {
        Self(self.0.acos())
    }
    pub fn atan(self) -> Self {
        Self(self.0.atan())
    }

    pub fn atan2(y: Self, x: Self) -> Self {
        Self(S::atan2(y.0, x.0))
    }
}