Use rational

DrPeaboss · Oct 15, 2024 · 01070ce · 01070ce
1 parent dc20bdb
commit 01070ce
Show file tree

Hide file tree

Showing 4 changed files with 93 additions and 17 deletions.
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -9,6 +9,9 @@ repository = "https://github.com/DrPeaboss/simple_src"
 keywords = ["audio", "dsp", "sample-rate"]
 exclude = ["*.py"]
 
+[dependencies]
+num-rational = "0.4"
+
 [dev-dependencies]
 divan = "0.1.14"
 hound = "3.5.1"

diff --git a/src/linear.rs b/src/linear.rs
@@ -1,5 +1,7 @@
 //! Linear converter
 
+use num_rational::Rational64;
+
 use super::{Convert, Error, Result};
 
 enum State {
@@ -9,18 +11,29 @@ enum State {
 }
 
 pub struct Converter {
-    step: f64,
-    pos: f64,
+    numer: usize,
+    denom: usize,
+    pos: usize,
+    coefs: Vec<f64>,
     last_in: [f64; 2],
     state: State,
 }
 
 impl Converter {
     #[inline]
     fn new(step: f64) -> Self {
+        let rstep = Rational64::approximate_float(step).unwrap();
+        let numer = *rstep.numer() as usize;
+        let denom = *rstep.denom() as usize;
+        let mut coefs = Vec::with_capacity(denom);
+        for i in 0..denom {
+            coefs.push(i as f64 / denom as f64);
+        }
         Self {
-            step,
-            pos: 0.0,
+            numer,
+            denom,
+            pos: 0,
+            coefs,
             last_in: [0.0; 2],
             state: State::First,
         }
@@ -38,15 +51,15 @@ impl Convert for Converter {
                 State::First => {
                     if let Some(s) = iter.next() {
                         self.last_in[1] = s;
-                        self.pos = 1.0;
+                        self.pos = self.numer;
                         self.state = State::Normal;
                     } else {
                         return None;
                     }
                 }
                 State::Normal => {
-                    while self.pos >= 1.0 {
-                        self.pos -= 1.0;
+                    while self.pos >= self.denom {
+                        self.pos -= self.denom;
                         self.last_in[0] = self.last_in[1];
                         if let Some(s) = iter.next() {
                             self.last_in[1] = s;
@@ -55,8 +68,9 @@ impl Convert for Converter {
                             return None;
                         }
                     }
-                    let interp = self.last_in[0] + (self.last_in[1] - self.last_in[0]) * self.pos;
-                    self.pos += self.step;
+                    let coef = self.coefs[self.pos];
+                    let interp = self.last_in[0] + (self.last_in[1] - self.last_in[0]) * coef;
+                    self.pos += self.numer;
                     return Some(interp);
                 }
                 State::Suspend => {

diff --git a/src/sinc.rs b/src/sinc.rs
@@ -4,6 +4,8 @@ use std::collections::VecDeque;
 use std::f64::consts::PI;
 use std::sync::Arc;
 
+use num_rational::Rational64;
+
 use super::{Convert, Error, Result};
 
 #[inline]
@@ -82,8 +84,10 @@ enum State {
 }
 
 pub struct Converter {
-    step: f64,
-    pos: f64,
+    numer: usize,
+    denom: usize,
+    pos: usize,
+    coefs: Vec<f64>,
     half_order: f64,
     quan: f64,
     filter: Arc<Vec<f64>>,
@@ -94,12 +98,21 @@ pub struct Converter {
 impl Converter {
     #[inline]
     fn new(step: f64, order: u32, quan: u32, filter: Arc<Vec<f64>>) -> Self {
+        let rstep = Rational64::approximate_float(step).unwrap();
+        let numer = *rstep.numer() as usize;
+        let denom = *rstep.denom() as usize;
+        let mut coefs = Vec::with_capacity(denom);
+        for i in 0..denom {
+            coefs.push(i as f64 / denom as f64);
+        }
         let taps = (order + 1) as usize;
         let mut buf = VecDeque::with_capacity(taps);
         buf.extend(std::iter::repeat(0.0).take(taps));
         Self {
-            step,
-            pos: 0.0,
+            numer,
+            denom,
+            pos: 0,
+            coefs,
             half_order: 0.5 * order as f64,
             quan: quan as f64,
             filter,
@@ -110,7 +123,7 @@ impl Converter {
 
     #[inline]
     fn interpolate(&self) -> f64 {
-        let coef = self.pos;
+        let coef = self.coefs[self.pos];
         let mut interp = 0.0;
         let pos_max = self.filter.len() - 1;
         for (i, s) in self.buf.iter().enumerate() {
@@ -137,8 +150,8 @@ impl Convert for Converter {
         loop {
             match self.state {
                 State::Normal => {
-                    while self.pos >= 1.0 {
-                        self.pos -= 1.0;
+                    while self.pos >= self.denom {
+                        self.pos -= self.denom;
                         if let Some(s) = iter.next() {
                             self.buf.pop_front();
                             self.buf.push_back(s);
@@ -147,8 +160,8 @@ impl Convert for Converter {
                             return None;
                         }
                     }
-                    self.pos += self.step;
                     let interp = self.interpolate();
+                    self.pos += self.numer;
                     return Some(interp);
                 }
                 State::Suspend => {