one-indexed-vec 0.2.0

A one-based (1-indexed) wrapper around Vec<T>: element at position N is accessed via vec[N].
Documentation
//! Digital filters operating on `Vec1`.

use crate::Vec1;

#[cfg(not(feature = "std"))]
use alloc::vec::Vec;

#[cfg(feature = "std")]
use std::vec::Vec;

// ============================================================================
// Moving average / FIR
// ============================================================================

impl<T> Vec1<T>
where
    T: Copy + core::ops::Add<Output = T> + core::ops::Div<Output = T> + Default + From<u8>,
{
    /// Simple moving average with window size `n`.
    ///
    /// Result length = `len - n + 1`, 1-based.
    ///
    /// ```rust
    /// use one_indexed_vec::vec1;
    /// let v = vec1![1.0, 2.0, 3.0, 4.0, 5.0];
    /// assert_eq!(v.moving_average(3).as_slice(), &[2.0, 3.0, 4.0]);
    /// ```
    pub fn moving_average(&self, n: usize) -> Vec1<T> {
        assert!(n > 0, "moving_average: window size must be > 0");
        if self.len() < n {
            return Vec1::new();
        }
        let factor = T::from(n as u8);
        let mut out = Vec1::with_capacity(self.len() - n + 1);
        for start in 1..=self.len() - n + 1 {
            let mut sum = T::default();
            for i in start..start + n {
                sum = sum + self[i];
            }
            out.push(sum / factor);
        }
        out
    }

    /// High-pass filter: `y[i] = x[i] - moving_average(x, n)[i]`.
    ///
    /// Result length = `len - n + 1`, 1-based.
    pub fn high_pass(&self, n: usize) -> Vec1<T>
    where
        T: core::ops::Sub<Output = T>,
    {
        let ma = self.moving_average(n);
        let mut out = Vec1::with_capacity(ma.len());
        for i in 1..=ma.len() {
            out.push(self[i] - ma[i]);
        }
        out
    }

    /// Low-pass filter — alias for [`Self::moving_average`].
    pub fn low_pass(&self, n: usize) -> Vec1<T> {
        self.moving_average(n)
    }
}

// ============================================================================
// FIR filter (general)
// ============================================================================

impl Vec1<f64> {
    /// Applies a FIR filter with the given coefficients.
    ///
    /// The output `y[k] = Σ_j h[j] · x[k + j - 1]` for `k = 1..=(len - m + 1)`
    /// where `m = h.len()`.
    ///
    /// ```rust
    /// use one_indexed_vec::vec1;
    ///
    /// let x = vec1![1.0, 2.0, 3.0, 4.0, 5.0];
    /// let h = vec1![0.5, 0.5];
    /// let y = x.fir(&h);
    /// // y[1] = 0.5*1 + 0.5*2 = 1.5
    /// assert!((y[1] - 1.5).abs() < 1e-10);
    /// ```
    pub fn fir(&self, h: &Vec1<f64>) -> Vec1<f64> {
        assert!(!h.is_empty(), "fir: filter kernel must be non-empty");
        if self.len() < h.len() {
            return Vec1::new();
        }
        let m = h.len();
        let mut out = Vec1::with_capacity(self.len() - m + 1);
        for k in 1..=self.len() - m + 1 {
            let mut acc = 0.0;
            for j in 1..=m {
                acc += h[j] * self[k + j - 1];
            }
            out.push(acc);
        }
        out
    }

    /// Median filter with window size `n` (must be odd).
    ///
    /// Result length = `len - n + 1`.
    pub fn median_filter(&self, n: usize) -> Vec1<f64> {
        assert!(n > 0, "median_filter: window size must be > 0");
        assert!(n % 2 == 1, "median_filter: window size must be odd");
        if self.len() < n {
            return Vec1::new();
        }
        let mut result = Vec1::with_capacity(self.len() - n + 1);
        let mut buf: Vec<f64> = Vec::with_capacity(n);
        for start in 1..=self.len() - n + 1 {
            buf.clear();
            for i in start..start + n {
                buf.push(self[i]);
            }
            buf.sort_by(|a, b| a.partial_cmp(b).unwrap_or(core::cmp::Ordering::Equal));
            result.push(buf[n / 2]);
        }
        result
    }
}

// ============================================================================
// Tests
// ============================================================================

#[cfg(test)]
mod tests {
    use crate::vec1;

    #[test]
    fn moving_average_basic() {
        let v = vec1![1.0f64, 2.0, 3.0, 4.0, 5.0];
        assert_eq!(v.moving_average(3).as_slice(), &[2.0, 3.0, 4.0]);
    }

    #[test]
    fn moving_average_window_one() {
        let v = vec1![1.0f64, 2.0, 3.0];
        assert_eq!(v.moving_average(1).as_slice(), &[1.0, 2.0, 3.0]);
    }

    #[test]
    fn moving_average_too_large() {
        let v = vec1![1.0f64, 2.0];
        assert!(v.moving_average(5).is_empty());
    }

    #[test]
    fn high_pass_basic() {
        let v = vec1![1.0f64, 2.0, 3.0, 4.0, 5.0];
        let hp = v.high_pass(3);
        // hp[1] = v[1] - ma[1] = 1 - 2 = -1
        assert!((hp[1] - (-1.0f64)).abs() < 1e-10);
    }

    #[test]
    fn fir_basic() {
        let x = vec1![1.0f64, 2.0, 3.0, 4.0, 5.0];
        let h = vec1![0.5f64, 0.5];
        let y = x.fir(&h);
        assert_eq!(y.len(), 4);
        assert!((y[1] - 1.5).abs() < 1e-10);
        assert!((y[4] - 4.5).abs() < 1e-10);
    }

    #[test]
    fn fir_moving_average_kernel() {
        let x = vec1![1.0f64, 2.0, 3.0, 4.0, 5.0];
        let h = vec1![1.0f64 / 3.0, 1.0 / 3.0, 1.0 / 3.0];
        let y = x.fir(&h);
        assert_eq!(y.len(), 3);
        assert!((y[1] - 2.0).abs() < 1e-10);
    }

    #[test]
    fn fir_kernel_too_long() {
        let x = vec1![1.0f64, 2.0];
        let h = vec1![0.5f64, 0.5, 0.5, 0.5];
        assert!(x.fir(&h).is_empty());
    }

    #[test]
    fn median_filter_basic() {
        let v = vec1![1.0f64, 2.0, 100.0, 4.0, 5.0];
        let m = v.median_filter(3);
        assert_eq!(m.len(), 3);
        assert!((m[1] - 2.0).abs() < 1e-10);
        assert!((m[2] - 4.0).abs() < 1e-10);
    }

    #[test]
    #[should_panic(expected = "window size must be odd")]
    fn median_filter_even_window_panics() {
        let v = vec1![1.0f64, 2.0, 3.0];
        let _ = v.median_filter(2);
    }

    #[test]
    fn low_pass_alias() {
        let v = vec1![1.0f64, 2.0, 3.0, 4.0, 5.0];
        assert_eq!(v.low_pass(3).as_slice(), v.moving_average(3).as_slice());
    }
}