oscillation 0.1.1

Oscillators and a collection of waveforms for real-time usage.
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 num_traits::{Euclid, Float, FloatConst};

use crate::Wavetable;

use super::Waveform;

#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, serde::Serialize, serde::Deserialize)]
pub struct Triangle;

impl<F> Waveform<F> for Triangle
where
    F: Float + FloatConst + Euclid
{
    fn waveform(&self, mut theta: F) -> F
    {
        let pi = F::PI();
        let tau = F::TAU();

        theta = theta.rem_euclid(&tau);
        let two_theta = theta + theta;
        (pi - (two_theta - tau).abs())/pi
    }
    fn waveform_with_dtc(&self, mut theta: F, duty_cycle: F) -> F
    {
        let zero = F::zero();
        let one = F::one();
        let tau = F::TAU();

        let d = tau*duty_cycle.clamp(zero, one);
        theta = theta.rem_euclid(&tau);
        let two_theta = theta + theta;
        if theta < d
        {
            (two_theta - d)/d
        }
        else
        {
            (tau + d - two_theta)/(tau - d)
        }
    }

    fn wavetable<const N: usize>(&self) -> Option<Wavetable<F, N>>
    {
        let zero = F::zero();
        let pi = F::PI();

        let pi_half = F::FRAC_2_PI();
        let g0 = pi_half*pi_half;

        Some(Wavetable::from_fn(zero, |m| {
            let n = F::from(m + 1).unwrap();
            let g = g0/n/n;
            let dn = pi*n;
            let (s, c) = dn.sin_cos();
            (
                g*c - g,
                g*s
            )
        }))
    }

    fn wavetable_with_dtc<const N: usize>(&self, duty_cycle: F) -> Option<Wavetable<F, N>>
    {
        let zero = F::zero();
        let one = F::one();
        let two = one + one;
        let four = two + two;
        let eps = F::epsilon();
        let tau = F::TAU();

        let frac_two_pi = F::FRAC_2_PI();

        if duty_cycle <= eps
        {
            return Some(Wavetable::from_fn(zero, |m| {
                let n = F::from(m + 1).unwrap();
                (zero, frac_two_pi/n)
            }))
        }
        if duty_cycle >= one - eps
        {
            return Some(Wavetable::from_fn(zero, |m| {
                let n = F::from(m + 1).unwrap();
                (zero, -frac_two_pi/n)
            }))
        }

        let d = tau*duty_cycle;
        let g0 = four/(tau - d)/d;

        Some(Wavetable::from_fn(zero, |m| {
            let n = F::from(m + 1).unwrap();
            let g = g0/n/n;
            let dn = d*n;
            let (s, c) = dn.sin_cos();
            (
                g*c - g,
                g*s
            )
        }))
    }
}

#[cfg(test)]
mod test
{
    use core::error::Error;

    use super::Triangle;

    #[test]
    fn it_works() -> Result<(), Box<dyn Error>>
    {
        crate::tests::print_waveform(Triangle)
    }
}