culsynth 0.2.0

Culsynth DSP Library
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

#[cfg(not(feature = "libm"))]
use num_traits::float::FloatCore as NumTraitsFloat;
#[cfg(feature = "libm")]
use num_traits::Float as NumTraitsFloat;

/// Types must implement this trait to instantiate any of the generic devices
/// in this module.  Implementations are provided for `f32` and `f64`.
pub trait Float: NumTraitsFloat + From<u16> + Default + Copy {
    /// 0
    const ZERO: Self;
    /// 1
    const ONE: Self;
    /// 2
    const TWO: Self;
    /// 3
    const THREE: Self;
    /// 1/2
    const ONE_HALF: Self;
    /// 0.1
    const POINT_ONE: Self;
    /// 0.98
    const POINT_NINE_EIGHT: Self;
    /// 0xF000 / 0xFFFF
    const RES_MAX: Self;
    /// 127 * (0xFFFF / 0x10000)
    const NOTE_MAX: Self;
    /// 0.9375
    const SHAPE_CLIP: Self;
    /// 2 / pi
    const FRAC_2_PI: Self;
    /// pi / 2
    const FRAC_PI_2: Self;
    /// pi
    const PI: Self;
    /// 2*pi
    const TAU: Self;
    /// Creates a value of this type from a u16.  Functionality provided by
    /// the trait (uses the `From<u16>` implementation)
    fn from_u16(x: u16) -> Self {
        <Self as From<u16>>::from(x)
    }
    /// Returns the sine of self
    fn fsin(self) -> Self;
    /// Returns the cosine of self
    fn fcos(self) -> Self;
    /// Returns the tangent of self
    fn ftan(self) -> Self;
    /// Convert a MIDI note number to a frequency
    fn midi_to_freq(self) -> Self;
    /// Convert to a f32
    fn as_f32(self) -> f32;
}

impl Float for f32 {
    const ZERO: f32 = 0.0f32;
    const ONE: f32 = 1.0f32;
    const TWO: f32 = 2.0f32;
    const THREE: f32 = 3.0f32;
    const ONE_HALF: f32 = 0.5f32;
    const POINT_ONE: f32 = 0.1f32;
    const POINT_NINE_EIGHT: f32 = 0.98f32;
    const FRAC_PI_2: f32 = core::f32::consts::FRAC_PI_2;
    const FRAC_2_PI: f32 = core::f32::consts::FRAC_2_PI;
    const PI: f32 = core::f32::consts::PI;
    const TAU: f32 = core::f32::consts::TAU;
    const RES_MAX: f32 = 0xF000 as f32 / 0xFFFF as f32;
    const NOTE_MAX: f32 = 127.0f32 * (0xFFFF as f32 / 0x10000 as f32);
    const SHAPE_CLIP: f32 = 0.9375f32;
    fn fsin(self) -> Self {
        #[cfg(not(feature = "libm"))]
        let ret = crate::float_approx::sin_approx(self);
        #[cfg(feature = "libm")]
        let ret = <Self as NumTraitsFloat>::sin(self);
        ret
    }
    fn fcos(self) -> Self {
        #[cfg(not(feature = "libm"))]
        let ret = crate::float_approx::cos_approx(self);
        #[cfg(feature = "libm")]
        let ret = <Self as NumTraitsFloat>::cos(self);
        ret
    }
    fn ftan(self) -> Self {
        #[cfg(not(feature = "libm"))]
        let ret = crate::float_approx::tan_approx(self);
        #[cfg(feature = "libm")]
        let ret = <Self as NumTraitsFloat>::tan(self);
        ret
    }
    fn midi_to_freq(self) -> Self {
        #[cfg(not(feature = "libm"))]
        let ret = crate::float_approx::midi_note_to_frequency(self);
        #[cfg(feature = "libm")]
        let ret = 440f32 * ((self - 69f32) / 12f32).exp2();
        ret
    }
    fn as_f32(self) -> f32 {
        self
    }
}

impl Float for f64 {
    const ZERO: f64 = 0.0f64;
    const ONE: f64 = 1.0f64;
    const TWO: f64 = 2.0f64;
    const THREE: f64 = 3.0f64;
    const ONE_HALF: f64 = 0.5f64;
    const POINT_ONE: f64 = 0.1f64;
    const POINT_NINE_EIGHT: f64 = 0.98f64;
    const RES_MAX: f64 = 0xF000 as f64 / 0xFFFF as f64;
    const FRAC_PI_2: f64 = core::f64::consts::FRAC_PI_2;
    const FRAC_2_PI: f64 = core::f64::consts::FRAC_2_PI;
    const PI: f64 = core::f64::consts::PI;
    const TAU: f64 = core::f64::consts::TAU;
    const NOTE_MAX: f64 = 127.0f64 * (0xFFFF as f64 / 0x10000 as f64);
    const SHAPE_CLIP: f64 = 0.9375f64;
    fn fsin(self) -> Self {
        #[cfg(not(feature = "libm"))]
        let ret = crate::float_approx::sin_approx(self);
        #[cfg(feature = "libm")]
        let ret = <Self as NumTraitsFloat>::sin(self);
        ret
    }
    fn fcos(self) -> Self {
        #[cfg(not(feature = "libm"))]
        let ret = crate::float_approx::cos_approx(self);
        #[cfg(feature = "libm")]
        let ret = <Self as NumTraitsFloat>::cos(self);
        ret
    }
    fn ftan(self) -> Self {
        #[cfg(not(feature = "libm"))]
        let ret = crate::float_approx::tan_approx(self);
        #[cfg(feature = "libm")]
        let ret = <Self as NumTraitsFloat>::tan(self);
        ret
    }
    fn midi_to_freq(self) -> Self {
        #[cfg(not(feature = "libm"))]
        let ret = crate::float_approx::midi_note_to_frequency(self);
        #[cfg(feature = "libm")]
        let ret = 440f64 * ((self - 69f64) / 12f64).exp2();
        ret
    }
    fn as_f32(self) -> f32 {
        self as f32
    }
}