newnum 0.13.1

Deprecated: General-purpose number traits
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
157
158
159

/// Trigonometric API (`sin`, `cos`, `tan`).
/// Functions take in `self` and return `Output`.
///
/// * `sin(a) = opposite / hypotenuse`,
/// * `cos(a) = adjacent / hypotenuse`,
/// * `tan(a) = sin(a) / cos(a) = opposite / adjacent`,
pub trait Trig {
    /// The output of trigonometric functions.
    /// Represents the triangle side ratio.
    ///
    /// For abstract numbers `Output` is expected to be `Self`.
    /// For non abstract numbers, `Output` can be whatever makes sense.
    ///
    /// For example `Angle::Output = Ratio`.
    type Output;

    /// Computes the sine (in radians for abstract types).
    ///
    /// The precision of this function might be non-deterministic based on the type.
    fn sin(self) -> Self::Output;

    /// Computes the cosine (in radians for abstract types).
    ///
    /// The precision of this function might be non-deterministic based on the type.
    fn cos(self) -> Self::Output;

    /// Computes the tangent (in radians for abstract types).
    /// `tan(a) = sin(a) / cos(a)`
    ///
    /// The precision of this function might be non-deterministic based on the type.
    fn tan(self) -> Self::Output;
}

/// Inverse trigonometric API (`asin`, `acos`, `atan`).
/// Functions take in `self` and return `Output`.
///
/// `sin(asin(x)) = x`, `tan(atan(x)) = x`...
pub trait ATrig {
    /// The output of inverse trigonometric functions.
    /// Represents the angle.
    ///
    /// For abstract numbers `Output` is expected to be `Self`.
    /// For non abstract numbers, `Output` can be whatever makes sense.
    ///
    /// For example `Ratio::Output = Angle`.
    type Output;

    /// Computes the arcsine (in radians for abstract types).
    /// Return value is in the range [-pi/2, pi/2].
    ///
    /// May panic or return NaN if the number is outside the range [-1, 1].
    ///
    /// The precision of this function might be non-deterministic based on the type.
    fn asin(self) -> Self::Output;

    /// Computes the arccosine (in radians for abstract types).
    /// Return value is in the range [0, pi].
    ///
    /// May panic or return NaN if the number is outside the range [-1, 1].
    ///
    /// The precision of this function might be non-deterministic based on the type.
    fn acos(self) -> Self::Output;

    /// Computes the arctangent (in radians for abstract types).
    /// Return value is in the range [-pi/2, pi/2].
    ///
    /// The precision of this function might be non-deterministic based on the type.
    fn atan(self) -> Self::Output;
}

pub trait Hyper {
    type Output;

    fn sinh(self) -> Self::Output;
    fn cosh(self) -> Self::Output;
    fn tanh(self) -> Self::Output;
}

pub trait AHyper {
    type Output;

    fn asinh(self) -> Self::Output;
    fn acosh(self) -> Self::Output;
    fn atanh(self) -> Self::Output;
}

macro_rules! impl_for_primitive {
    ($type:ty) => {
        impl Trig for $type {
            type Output = Self;

            #[inline(always)]
            fn sin(self) -> Self::Output {
                self.sin()
            }
            #[inline(always)]
            fn cos(self) -> Self::Output {
                self.cos()
            }
            #[inline(always)]
            fn tan(self) -> Self::Output {
                self.tan()
            }
        }

        impl ATrig for $type {
            type Output = Self;

            #[inline(always)]
            fn asin(self) -> Self::Output {
                self.asin()
            }
            #[inline(always)]
            fn acos(self) -> Self::Output {
                self.acos()
            }
            #[inline(always)]
            fn atan(self) -> Self::Output {
                self.atan()
            }
        }

        impl Hyper for $type {
            type Output = Self;

            #[inline(always)]
            fn sinh(self) -> Self::Output {
                self.sinh()
            }
            #[inline(always)]
            fn cosh(self) -> Self::Output {
                self.cosh()
            }
            #[inline(always)]
            fn tanh(self) -> Self::Output {
                self.tanh()
            }
        }

        impl AHyper for $type {
            type Output = Self;

            #[inline(always)]
            fn asinh(self) -> Self::Output {
                self.asinh()
            }
            #[inline(always)]
            fn acosh(self) -> Self::Output {
                self.acosh()
            }
            #[inline(always)]
            fn atanh(self) -> Self::Output {
                self.atanh()
            }
        }
    };
}
impl_for_primitive!(f32);
impl_for_primitive!(f64);