fructose 0.3.9

Mathematical Traits for the Glucose Library and the Rust programming language.
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
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179

use crate::operators::exp::Exponentiation;

pub trait TrigOps: Exponentiation + Sized {
    const PI: Self;
    const TAU: Self;
    const FRAC_PI_2: Self;
    const FRAC_PI_3: Self;
    const FRAC_PI_4: Self;
    const FRAC_PI_6: Self;
    const FRAC_PI_8: Self;
    const FRAC_1_PI: Self;
    const FRAC_2_PI: Self;
    const FRAC_2_SQRT_PI: Self;

    fn sin(self) -> Self;
    fn cos(self) -> Self;
    fn tan(self) -> Self {
        self.try_tan().unwrap()
    }
    fn sin_cos(self) -> (Self, Self);

    fn try_tan(self) -> Option<Self>;

    fn asin(self) -> Self {
        self.try_asin().unwrap()
    }
    fn acos(self) -> Self {
        self.try_acos().unwrap()
    }
    fn atan(self) -> Self {
        self.try_atan().unwrap()
    }
    fn atan2(self, rhs: Self) -> Self {
        self.try_atan2(rhs).unwrap()
    }

    fn try_asin(self) -> Option<Self>;
    fn try_acos(self) -> Option<Self>;
    fn try_atan(self) -> Option<Self>;
    fn try_atan2(self, rhs: Self) -> Option<Self>;

    fn sinh(self) -> Self;
    fn cosh(self) -> Self;
    fn tanh(self) -> Self;

    fn coth(self) -> Self {
        self.try_coth().unwrap()
    }
    fn csch(self) -> Self {
        self.try_csch().unwrap()
    }

    fn try_coth(self) -> Option<Self>;
    fn try_csch(self) -> Option<Self>;

    fn asinh(self) -> Self;
    fn acosh(self) -> Self {
        self.try_acosh().unwrap()
    }
    fn atanh(self) -> Self {
        self.try_atanh().unwrap()
    }

    fn try_acosh(self) -> Option<Self>;
    fn try_atanh(self) -> Option<Self>;

    fn to_degrees(self) -> Self;
    fn to_radians(self) -> Self;
}

macro_rules! float_to_option {
    ($expr:expr) => {{
        let result = $expr;
        if result.is_infinite() || result.is_nan() {
            None
        } else {
            Some(result)
        }
    }};
}

macro_rules! impl_trig_float {
    ($($set:ty => [$($name: ident = $val:expr);* $(;)?]);* $(;)?) => {
        $(
                impl TrigOps for $set {

                $(
                    const $name: $set = $val;
                )*

                #[inline]
                fn try_tan(self) -> Option<Self> {
                    float_to_option!(self.tan())
                }
                #[inline]
                fn try_asin(self) -> Option<Self> {
                    float_to_option!(self.asin())
                }
                #[inline]
                fn try_acos(self) -> Option<Self> {
                    float_to_option!(self.acos())
                }
                #[inline]
                fn try_atan(self) -> Option<Self> {
                    float_to_option!(self.atan())
                }
                #[inline]
                fn try_atan2(self, rhs: Self) -> Option<Self> {
                    float_to_option!(self.atan2(rhs))
                }
                #[inline]
                fn try_acosh(self) -> Option<Self> {
                    float_to_option!(self.acosh())
                }
                #[inline]
                fn try_atanh(self) -> Option<Self> {
                    float_to_option!(self.atanh())
                }
                #[inline]
                fn try_coth(self) -> Option<Self> {
                    unimplemented!()
                }
                #[inline]
                fn try_csch(self) -> Option<Self> {
                    unimplemented!()
                }
                forward! {
                    fn sin(self) -> Self;
                    fn cos(self) -> Self;
                    fn tan(self) -> Self;
                    fn sin_cos(self) -> (Self, Self);

                    fn asin(self) -> Self;
                    fn acos(self) -> Self;
                    fn atan(self) -> Self;
                    fn atan2(self, rhs: Self) -> Self;

                    fn sinh(self) -> Self;
                    fn cosh(self) -> Self;
                    fn tanh(self) -> Self;

                    fn asinh(self) -> Self;
                    fn acosh(self) -> Self;
                    fn atanh(self) -> Self;

                    fn to_degrees(self) -> Self;
                    fn to_radians(self) -> Self;
                }
            }
        )*
    }
}

impl_trig_float! {
    f32 => [
        PI              = core::f32::consts::PI;
        TAU             = core::f32::consts::TAU;
        FRAC_PI_2       = core::f32::consts::FRAC_PI_2;
        FRAC_PI_3       = core::f32::consts::FRAC_PI_3;
        FRAC_PI_4       = core::f32::consts::FRAC_PI_4;
        FRAC_PI_6       = core::f32::consts::FRAC_PI_6;
        FRAC_PI_8       = core::f32::consts::FRAC_PI_8;
        FRAC_1_PI       = core::f32::consts::FRAC_1_PI;
        FRAC_2_PI       = core::f32::consts::FRAC_2_PI;
        FRAC_2_SQRT_PI  = core::f32::consts::FRAC_2_SQRT_PI;
    ];
    f64 => [
        PI              = core::f64::consts::PI;
        TAU             = core::f64::consts::TAU;
        FRAC_PI_2       = core::f64::consts::FRAC_PI_2;
        FRAC_PI_3       = core::f64::consts::FRAC_PI_3;
        FRAC_PI_4       = core::f64::consts::FRAC_PI_4;
        FRAC_PI_6       = core::f64::consts::FRAC_PI_6;
        FRAC_PI_8       = core::f64::consts::FRAC_PI_8;
        FRAC_1_PI       = core::f64::consts::FRAC_1_PI;
        FRAC_2_PI       = core::f64::consts::FRAC_2_PI;
        FRAC_2_SQRT_PI  = core::f64::consts::FRAC_2_SQRT_PI;
    ];
}