Merge pull request #2 from wagnerf42/master

removed intermediate vec and indices

Author: alesgenova

src/detector/autocorrelation.rs

@@ -1,34 +1,40 @@
-use crate::float::Float;
-use crate::detector::PitchDetector;
-use crate::detector::internals::DetectorInternals;
-use crate::detector::internals::Pitch;
 use crate::detector::internals::autocorrelation;
 use crate::detector::internals::get_power_level;
 use crate::detector::internals::pitch_from_peaks;
+use crate::detector::internals::DetectorInternals;
+use crate::detector::internals::Pitch;
+use crate::detector::PitchDetector;
+use crate::float::Float;
 use crate::utils::peak::PeakCorrection;
 
-
 pub struct AutocorrelationDetector<T>
-    where T : Float
+where
+    T: Float,
 {
-    internals: DetectorInternals<T>
+    internals: DetectorInternals<T>,
 }
 
 impl<T> AutocorrelationDetector<T>
-    where T: Float
+where
+    T: Float,
 {
     pub fn new(size: usize, padding: usize) -> Self {
         let internals = DetectorInternals::new(1, 2, size, padding);
-        AutocorrelationDetector {
-            internals
-        }
+        AutocorrelationDetector { internals }
     }
 }
 
 impl<T> PitchDetector<T> for AutocorrelationDetector<T>
-    where T : Float
+where
+    T: Float + std::iter::Sum,
 {
-    fn get_pitch(&mut self, signal: &[T], sample_rate: usize, power_threshold: T, clarity_threshold: T) -> Option<Pitch<T>> {
+    fn get_pitch(
+        &mut self,
+        signal: &[T],
+        sample_rate: usize,
+        power_threshold: T,
+        clarity_threshold: T,
+    ) -> Option<Pitch<T>> {
         assert_eq!(signal.len(), self.internals.size);
 
         if get_power_level(signal) < power_threshold {
@@ -42,6 +48,11 @@ impl<T> PitchDetector<T> for AutocorrelationDetector<T>
         autocorrelation(signal, signal_complex, scratch, autocorr);
         let clarity_threshold = clarity_threshold * autocorr[0];
 
-        pitch_from_peaks(autocorr, sample_rate, clarity_threshold, PeakCorrection::None)
+        pitch_from_peaks(
+            autocorr,
+            sample_rate,
+            clarity_threshold,
+            PeakCorrection::None,
+        )
     }
 }

src/detector/internals.rs

@@ -1,37 +1,45 @@
-use rustfft::FFTplanner;
 use num_complex::Complex;
+use rustfft::FFTplanner;
 
 use crate::float::Float;
-use crate::utils::buffer::ComplexComponent;
-use crate::utils::buffer::copy_real_to_complex;
 use crate::utils::buffer::copy_complex_to_real;
-use crate::utils::buffer::new_real_buffer;
+use crate::utils::buffer::copy_real_to_complex;
 use crate::utils::buffer::new_complex_buffer;
-use crate::utils::peak::PeakCorrection;
-use crate::utils::peak::detect_peaks;
+use crate::utils::buffer::new_real_buffer;
+use crate::utils::buffer::ComplexComponent;
 use crate::utils::peak::choose_peak;
 use crate::utils::peak::correct_peak;
+use crate::utils::peak::detect_peaks;
+use crate::utils::peak::PeakCorrection;
 
 pub struct Pitch<T>
-    where T: Float
+where
+    T: Float,
 {
     pub frequency: T,
-    pub clarity: T
+    pub clarity: T,
 }
 
 pub struct DetectorInternals<T>
-    where T: Float
+where
+    T: Float,
 {
     pub size: usize,
     pub padding: usize,
     pub real_buffers: Vec<Vec<T>>,
-    pub complex_buffers: Vec<Vec<Complex<T>>>
+    pub complex_buffers: Vec<Vec<Complex<T>>>,
 }
 
 impl<T> DetectorInternals<T>
-    where T : Float
+where
+    T: Float,
 {
-    pub fn new(n_real_buffers: usize, n_complex_buffers: usize, size: usize, padding: usize) -> Self {
+    pub fn new(
+        n_real_buffers: usize,
+        n_complex_buffers: usize,
+        size: usize,
+        padding: usize,
+    ) -> Self {
         let mut real_buffers: Vec<Vec<T>> = Vec::new();
         let mut complex_buffers: Vec<Vec<Complex<T>>> = Vec::new();
 
@@ -49,98 +57,92 @@ impl<T> DetectorInternals<T>
             size,
             padding,
             real_buffers,
-            complex_buffers
+            complex_buffers,
         }
     }
 }
 
-pub fn autocorrelation<T>(signal: &[T], signal_complex: &mut [Complex<T>], scratch: &mut [Complex<T>], result: &mut [T])
-    where T : Float
+pub fn autocorrelation<T>(
+    signal: &[T],
+    signal_complex: &mut [Complex<T>],
+    scratch: &mut [Complex<T>],
+    result: &mut [T],
+) where
+    T: Float,
 {
     copy_real_to_complex(signal, signal_complex, ComplexComponent::Re);
     let mut planner = FFTplanner::new(false);
     let fft = planner.plan_fft(signal_complex.len());
     fft.process(signal_complex, scratch);
-    for i in 0..scratch.len() {
-        scratch[i].re = scratch[i].re * scratch[i].re + scratch[i].im * scratch[i].im;
-        scratch[i].im = T::zero();
-    }
+    scratch.iter_mut().for_each(|s| {
+        s.re = s.re * s.re + s.im * s.im;
+        s.im = T::zero();
+    });
     let mut planner = FFTplanner::new(true);
     let inv_fft = planner.plan_fft(signal_complex.len());
     inv_fft.process(scratch, signal_complex);
     copy_complex_to_real(signal_complex, result, ComplexComponent::Re);
 }
 
-pub fn pitch_from_peaks<T>(input: &[T], sample_rate: usize, clarity_threshold: T, correction: PeakCorrection) -> Option<Pitch<T>>
-    where T: Float
+pub fn pitch_from_peaks<T>(
+    input: &[T],
+    sample_rate: usize,
+    clarity_threshold: T,
+    correction: PeakCorrection,
+) -> Option<Pitch<T>>
+where
+    T: Float,
 {
     let peaks = detect_peaks(input);
-    let chosen_peak = choose_peak(&peaks, clarity_threshold);
-    let chosen_peak = match chosen_peak {
-        Some(peak) => {
-                Some(correct_peak(peak, input, correction))
-        },
-        None => {
-            None
-        }
-    };
-
-    let pitch = match chosen_peak {
-        Some(peak) => {
+    choose_peak(peaks, clarity_threshold)
+        .map(|peak| correct_peak(peak, input, correction))
+        .map(|peak| {
             let frequency = T::from_usize(sample_rate).unwrap() / peak.0;
             let clarity = peak.1 / input[0];
-            Some(Pitch { frequency, clarity })
-        },
-        None => {
-            None
-        }
-    };
-    pitch
+            Pitch { frequency, clarity }
+        })
 }
 
 pub fn get_power_level<T>(signal: &[T]) -> T
-    where T : Float
+where
+    T: Float + std::iter::Sum,
 {
-    let mut power = T::zero();
-    for i in 0..signal.len() {
-        power = power + signal[i] * signal[i];
-    }
-    power
+    signal.iter().map(|s| *s * *s).sum::<T>()
 }
 
 fn m_of_tau<T>(signal: &[T], signal_square_sum: Option<T>, result: &mut [T])
-    where T : Float
+where
+    T: Float + std::iter::Sum,
 {
     assert!(result.len() >= signal.len());
 
-    let signal_square_sum = match signal_square_sum {
-        Some(val) => val,
-        None => {
-            let mut val = T::zero();
-            for i in 0..signal.len() {
-                val = val + signal[i] * signal[i];
-            }
-            val
-        }
-    };
+    let signal_square_sum =
+        signal_square_sum.unwrap_or_else(|| signal.iter().map(|s| *s * *s).sum::<T>());
 
     result[0] = T::from_usize(2).unwrap() * signal_square_sum;
-    for i in 1..signal.len() {
-        result[i] = result[i - 1] - signal[i - 1] * signal[i - 1];
-    }
-
-    // Signal has no padding, but result does
-    for i in signal.len()..result.len() {
-        result[i] = result[i - 1];
-    }
+    let last = result[1..].iter_mut().zip(signal).fold(
+        T::from_usize(2).unwrap() * signal_square_sum,
+        |old, (r, s)| {
+            *r = old - *s * *s;
+            *r
+        },
+    );
+    result[signal.len()..].iter_mut().for_each(|r| *r = last);
 }
 
-pub fn normalized_square_difference<T>(signal: &[T], scratch0: &mut [Complex<T>], scratch1: &mut [Complex<T>], scratch2: &mut [T], result: &mut [T])
-    where T : Float
+pub fn normalized_square_difference<T>(
+    signal: &[T],
+    scratch0: &mut [Complex<T>],
+    scratch1: &mut [Complex<T>],
+    scratch2: &mut [T],
+    result: &mut [T],
+) where
+    T: Float + std::iter::Sum,
 {
     autocorrelation(signal, scratch0, scratch1, result);
     m_of_tau(signal, Some(result[0]), scratch2);
-    for i in 0..result.len() {
-        result[i] = T::from_usize(2).unwrap() * result[i] / scratch2[i];
-    }
+    result
+        .iter_mut()
+        .zip(scratch2)
+        .for_each(|(r, s)| *r = T::from_usize(2).unwrap() * *r / *s)
 }

src/detector/mcleod.rs

@@ -1,33 +1,40 @@
-use crate::float::Float;
-use crate::detector::PitchDetector;
-use crate::detector::internals::DetectorInternals;
-use crate::detector::internals::Pitch;
-use crate::detector::internals::normalized_square_difference;
 use crate::detector::internals::get_power_level;
+use crate::detector::internals::normalized_square_difference;
 use crate::detector::internals::pitch_from_peaks;
+use crate::detector::internals::DetectorInternals;
+use crate::detector::internals::Pitch;
+use crate::detector::PitchDetector;
+use crate::float::Float;
 use crate::utils::peak::PeakCorrection;
 
 pub struct McLeodDetector<T>
-    where T : Float
+where
+    T: Float + std::iter::Sum,
 {
-    internals: DetectorInternals<T>
+    internals: DetectorInternals<T>,
 }
 
 impl<T> McLeodDetector<T>
-    where T: Float
+where
+    T: Float + std::iter::Sum,
 {
     pub fn new(size: usize, padding: usize) -> Self {
         let internals = DetectorInternals::new(2, 2, size, padding);
-        McLeodDetector {
-            internals
-        }
+        McLeodDetector { internals }
     }
 }
 
 impl<T> PitchDetector<T> for McLeodDetector<T>
-    where T : Float
+where
+    T: Float + std::iter::Sum,
 {
-    fn get_pitch(&mut self, signal: &[T], sample_rate: usize, power_threshold: T, clarity_threshold: T) -> Option<Pitch<T>> {
+    fn get_pitch(
+        &mut self,
+        signal: &[T],
+        sample_rate: usize,
+        power_threshold: T,
+        clarity_threshold: T,
+    ) -> Option<Pitch<T>> {
         assert_eq!(signal.len(), self.internals.size);
 
         if get_power_level(signal) < power_threshold {
@@ -36,11 +43,17 @@ impl<T> PitchDetector<T> for McLeodDetector<T>
 
         let (signal_complex, rest) = self.internals.complex_buffers.split_first_mut().unwrap();
         let (scratch0, _) = rest.split_first_mut().unwrap();
+
         let (scratch1, rest) = self.internals.real_buffers.split_first_mut().unwrap();
         let (nsdf, _) = rest.split_first_mut().unwrap();
 
         normalized_square_difference(signal, signal_complex, scratch0, scratch1, nsdf);
 
-        pitch_from_peaks(nsdf, sample_rate, clarity_threshold, PeakCorrection::Quadratic)
+        pitch_from_peaks(
+            nsdf,
+            sample_rate,
+            clarity_threshold,
+            PeakCorrection::Quadratic,
+        )
     }
 }