New example: Polysynth

Cargo.toml

@@ -54,6 +54,7 @@ filters = ["saturators", "dep:valib-filters"]
 oscillators = ["dep:valib-oscillators"]
 oversample = ["filters", "dep:valib-oversample"]
 voice = ["dep:valib-voice"]
+voice-upsampled = ["voice", "valib-voice/resampled"]
 wdf = ["filters", "dep:valib-wdf"]
 fundsp = ["dep:valib-fundsp"]
 nih-plug = ["dep:valib-nih-plug"]

Makefile.plugins.toml

@@ -9,8 +9,12 @@ dependencies = ["xtask-build"]
 command = "cargo"
 args = ["xtask", "bundle", "${CARGO_MAKE_CRATE_NAME}", "${@}"]
 
+[tasks.install-target-x86_64-darwin]
+command = "rustup"
+args = ["target", "add", "x86_64-apple-darwin"]
+
 [tasks.bundle-universal]
-dependencies = ["xtask-build"]
+dependencies = ["xtask-build", "install-target-x86_64-darwin"]
 command = "cargo"
 args = ["xtask", "bundle-universal", "${CARGO_MAKE_CRATE_NAME}", "${@}"]
 

crates/valib-core/src/dsp/mod.rs

@@ -87,6 +87,18 @@ impl<P: HasParameters> HasParameters for BlockAdapter<P> {
 
 impl<P: DSPMeta> DSPMeta for BlockAdapter<P> {
     type Sample = P::Sample;
+
+    fn set_samplerate(&mut self, samplerate: f32) {
+        self.0.set_samplerate(samplerate);
+    }
+
+    fn latency(&self) -> usize {
+        self.0.latency()
+    }
+
+    fn reset(&mut self) {
+        self.0.reset();
+    }
 }
 
 impl<P: DSPProcess<I, O>, const I: usize, const O: usize> DSPProcess<I, O> for BlockAdapter<P> {
@@ -123,13 +135,14 @@ pub struct SampleAdapter<P, const I: usize, const O: usize>
 where
     P: DSPProcessBlock<I, O>,
 {
+    /// Inner block processor
+    pub inner: P,
     /// Size of the buffers passed into the inner block processor.
     pub buffer_size: usize,
     input_buffer: AudioBufferBox<P::Sample, I>,
     input_filled: usize,
     output_buffer: AudioBufferBox<P::Sample, O>,
     output_filled: usize,
-    inner: P,
 }
 
 impl<P, const I: usize, const O: usize> std::ops::Deref for SampleAdapter<P, I, O>

crates/valib-core/src/math/fast.rs

@@ -0,0 +1,99 @@
+use crate::Scalar;
+use numeric_literals::replace_float_literals;
+use simba::simd::SimdBool;
+
+/// Rational approximation of tanh(x) which is valid in the range -3..3
+///
+/// This approximation only includes the rational approximation part, and will diverge outside the
+/// bounds. In order to apply the tanh function over a bigger interval, consider clamping either the
+/// input or the output.
+///
+/// You should consider using [`tanh`] for a general-purpose faster tanh function, which uses
+/// branching.
+///
+/// Source: <https://www.musicdsp.org/en/latest/Other/238-rational-tanh-approximation.html>
+///
+/// # Arguments
+///
+/// * `x`: Input value (low-error range: -3..3)
+///
+/// returns: T
+#[replace_float_literals(T::from_f64(literal))]
+pub fn rational_tanh<T: Scalar>(x: T) -> T {
+    x * (27. + x * x) / (27. + 9. * x * x)
+}
+
+/// Fast approximation of tanh(x).
+///
+/// This approximation uses branching to clamp the output to -1..1 in order to be useful as a
+/// general-purpose approximation of tanh.
+///
+/// Source: <https://www.musicdsp.org/en/latest/Other/238-rational-tanh-approximation.html>
+///
+/// # Arguments
+///
+/// * `x`: Input value
+///
+/// returns: T
+pub fn tanh<T: Scalar>(x: T) -> T {
+    rational_tanh(x).simd_clamp(-T::one(), T::one())
+}
+
+/// Fast approximation of exp, with maximum error in -1..1 of 0.59%, and in -3.14..3.14 of 9.8%.
+///
+/// You should consider using [`exp`] for a better approximation which uses this function, but
+/// allows a greater range at the cost of branching.
+///
+/// Source: <https://www.musicdsp.org/en/latest/Other/222-fast-exp-approximations.html>
+///
+/// # Arguments
+///
+/// * `x`: Input value
+///
+/// returns: T
+#[replace_float_literals(T::from_f64(literal))]
+pub fn fast_exp5<T: Scalar>(x: T) -> T {
+    (120. + x * (120. + x * (60. + x * (20. + x * (5. + x))))) * 0.0083333333
+}
+
+/// Fast approximation of exp, using [`fast_exp5`]. Uses branching to get a bigger range.
+///
+/// Maximum error in the 0..10.58 range is 0.45%.
+///
+/// Source: <https://www.musicdsp.org/en/latest/Other/222-fast-exp-approximations.html>
+///
+/// # Arguments
+///
+/// * `x`:
+///
+/// returns: T
+#[replace_float_literals(T::from_f64(literal))]
+pub fn exp<T: Scalar>(x: T) -> T {
+    x.simd_lt(2.5).if_else2(
+        || T::simd_e() * fast_exp5(x - 1.),
+        (|| x.simd_lt(5.), || 33.115452 * fast_exp5(x - 3.5)),
+        || 403.42879 * fast_exp5(x - 6.),
+    )
+}
+
+/// Fast 2^x approximation, using [`exp`].
+///
+/// Maximum error in the 0..15.26 range is 0.45%.
+///
+/// Source: <https://www.musicdsp.org/en/latest/Other/222-fast-exp-approximations.html>
+///
+/// # Arguments
+///
+/// * `x`:
+///
+/// returns: T
+///
+/// # Examples
+///
+/// ```
+///
+/// ```
+pub fn pow2<T: Scalar>(x: T) -> T {
+    let log_two = T::simd_ln_2();
+    exp(log_two * x)
+}

crates/valib-core/src/math/interpolation.rs

@@ -133,9 +133,12 @@ impl<T: Scalar> Interpolate<T, 2> for Linear {
 #[derive(Debug, Copy, Clone)]
 pub struct MappedLinear<F>(pub F);
 
+pub type Sine<T> = MappedLinear<fn(T) -> T>;
+
 /// Returns an interpolator that performs sine interpolation.
-pub fn sine_interpolation<T: Scalar>() -> MappedLinear<impl Fn(T) -> T> {
-    MappedLinear(|t| T::simd_cos(t * T::simd_pi()))
+#[replace_float_literals(T::from_f64(literal))]
+pub fn sine_interpolation<T: Scalar>() -> Sine<T> {
+    MappedLinear(|t| 0.5 - 0.5 * T::simd_cos(t * T::simd_pi()))
 }
 
 impl<T, F: Fn(T) -> T> Interpolate<T, 2> for MappedLinear<F>

crates/valib-core/src/math/mod.rs

@@ -8,10 +8,11 @@
 
 use crate::Scalar;
 
+pub mod fast;
 pub mod interpolation;
 pub mod lut;
 pub mod nr;
 #[cfg(feature = "math-polynom")]
 pub mod polynom;
 
 /// Return the complex number in the z-plane corresponding to the frequency `f` at sample rate
@@ -86,6 +87,7 @@
 #[inline]
 pub fn smooth_min<T: Scalar>(t: T, a: T, b: T) -> T {
     let r = (-a / t).simd_exp2() + (-b / t).simd_exp2();
+    // let r = fast::pow2(-a / t) + fast::pow2(-b / t);
     -t * r.simd_log2()
 }
 

crates/valib-core/src/math/snapshots/valib_core__math__interpolation__tests__valib_core_math_interpolation_MappedLinear_fn(f64) -_ f64_.snap

@@ -0,0 +1,16 @@
+---
+source: crates/valib-core/src/math/interpolation.rs
+expression: "&actual as &[_]"
+---
+0.0
+0.146447
+0.5
+0.853553
+1.0
+1.0
+1.0
+1.0
+1.0
+1.0
+1.0
+1.0

crates/valib-core/src/util.rs

@@ -7,7 +7,8 @@
 };
 use num_traits::{AsPrimitive, Float, Zero};
 use numeric_literals::replace_float_literals;
-use simba::simd::SimdValue;
+use simba::simd::{SimdComplexField, SimdValue};
+use std::collections::VecDeque;
 
 /// Transmutes a slice into a slice of static arrays, putting the remainder of the slice not fitting
 /// as a separate slice.
@@ -202,6 +203,27 @@
     2.0.simd_powf(semi / 12.0)
 }
 
+/// Compute the semitone equivalent change in pitch that would have resulted by multiplying the
+/// input ratio to a frequency value.
+///
+/// # Arguments
+///
+/// * `ratio`: Frequency ratio (unitless)
+///
+/// returns: T
+///
+/// # Examples
+///
+/// ```
+/// use valib_core::util::ratio_to_semitone;
+/// assert_eq!(0., ratio_to_semitone(1.));
+/// assert_eq!(12., ratio_to_semitone(2.));
+/// assert_eq!(-12., ratio_to_semitone(0.5));
+/// ```
+pub fn ratio_to_semitone<T: Scalar>(ratio: T) -> T {
+    T::from_f64(12.) * ratio.simd_log2()
+}
+
 /// Create a new matrix referencing this one as storage. The resulting matrix will have the same
 /// shape and same strides as the input one.
 ///
@@ -264,3 +286,32 @@
 
 #[cfg(feature = "test-utils")]
 pub mod tests;
+
+#[derive(Debug, Clone)]
+pub struct Rms<T> {
+    data: VecDeque<T>,
+    summed_squared: T,
+}
+
+impl<T: Zero> Rms<T> {
+    pub fn new(size: usize) -> Self {
+        Self {
+            data: (0..size).map(|_| T::zero()).collect(),
+            summed_squared: T::zero(),
+        }
+    }
+}
+
+impl<T: Scalar> Rms<T> {
+    pub fn add_element(&mut self, value: T) -> T {
+        let v2 = value.simd_powi(2);
+        self.summed_squared -= self.data.pop_front().unwrap();
+        self.summed_squared += v2;
+        self.data.push_back(v2);
+        self.get_rms()
+    }
+
+    pub fn get_rms(&self) -> T {
+        self.summed_squared.simd_sqrt()
+    }
+}

crates/valib-filters/src/ladder.rs

@@ -153,8 +153,7 @@ impl<T: Scalar, Topo: LadderTopology<T>> Ladder<T, Topo> {
     /// let transistor_ladder = Ladder::<_, Transistor<DiodeClipperModel<_>>>::new(48000.0, 440.0, 1.0);
     /// ```
     #[replace_float_literals(T::from_f64(literal))]
-    pub fn new(samplerate: impl Into<f64>, cutoff: T, resonance: T) -> Self {
-        let samplerate = T::from_f64(samplerate.into());
+    pub fn new(samplerate: T, cutoff: T, resonance: T) -> Self {
         let mut this = Self {
             inv_2fs: T::simd_recip(2.0 * samplerate),
             samplerate,
@@ -369,7 +368,7 @@ mod tests {
             bode: true,
             series: &[Series {
                 label: "Frequency response",
-                samplerate,
+                samplerate: samplerate as f32,
                 series: &responsef32,
                 color: &BLUE,
             }],