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

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 Square;

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

        theta = theta.rem_euclid(&tau);
        if theta < pi {-one} else {one}
    }
    fn waveform_with_dtc(&self, mut theta: F, mut duty_cycle: F) -> F
    {
        let zero = F::zero();
        let one = F::one();
        let tau = F::TAU();

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

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

        let frac_two_pi = F::FRAC_2_PI();

        Some(Wavetable::from_fn(zero, |m| {
            let n = F::from(m + 1).unwrap();
            let g = frac_two_pi/n;

            let dn = pi*n;
            let (s, c) = dn.sin_cos();
            (
                -g*s,
                g*c - g
            )
        }))
    }

    fn wavetable_with_dtc<const N: usize>(&self, duty_cycle: F) -> Option<Wavetable<F, N>>
    {
        let zero = F::zero();
        let one = F::one();
        let pi = F::PI();
        let tau = F::TAU();

        let frac_two_pi = F::FRAC_2_PI();

        let d = tau*duty_cycle.clamp(zero, one);

        Some(Wavetable::from_fn(-(d - pi)/pi, |m| {
            let n = F::from(m + 1).unwrap();
            let g = frac_two_pi/n;

            let dn = d*n;
            let (s, c) = dn.sin_cos();
            (
                -g*s,
                g*c - g
            )
        }))
    }
}

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

    use super::Square;

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