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
//! Finite differences and moving averages.

use core::ops::{Add, Div, Mul, Sub};

use crate::Vec1;

impl<T> Vec1<T>
where
    T: Copy + Add<Output = T> + Sub<Output = T> + Default,
{
    /// Forward finite difference: `diff[i] = v[i+1] - v[i]`.
    ///
    /// ```rust
    /// use one_indexed_vec::vec1;
    /// let v = vec1![1, 3, 6, 10];
    /// assert_eq!(v.finite_difference().as_slice(), &[2, 3, 4]);
    /// ```
    #[inline]
    pub fn finite_difference(&self) -> Vec1<T> {
        if self.len() < 2 {
            return Vec1::new();
        }
        let mut out = Vec1::with_capacity(self.len() - 1);
        for i in 1..self.len() {
            out.push(self[i + 1] - self[i]);
        }
        out
    }

    /// Second finite difference: `v[i+2] - 2·v[i+1] + v[i]`.
    ///
    /// ```rust
    /// use one_indexed_vec::vec1;
    /// let v = vec1![1, 4, 9, 16, 25];
    /// assert_eq!(v.second_finite_difference().as_slice(), &[2, 2, 2]);
    /// ```
    #[inline]
    pub fn second_finite_difference(&self) -> Vec1<T> {
        if self.len() < 3 {
            return Vec1::new();
        }
        let mut out = Vec1::with_capacity(self.len() - 2);
        for i in 1..=self.len() - 2 {
            out.push(self[i + 2] - self[i + 1] - self[i + 1] + self[i]);
        }
        out
    }
}

impl<T> Vec1<T>
where
    T: Copy
        + Add<Output = T>
        + Mul<Output = T>
        + Sub<Output = T>
        + Div<Output = T>
        + Default
        + From<u8>,
{
    /// Central finite difference: `(v[i+1] - v[i-1]) / 2`.
    ///
    /// ```rust
    /// use one_indexed_vec::{vec1, Vec1};
    /// let v: Vec1<f64> = vec1![1.0, 4.0, 9.0, 16.0, 25.0];
    /// assert_eq!(v.central_difference().as_slice(), &[4.0, 6.0, 8.0]);
    /// ```
    #[inline]
    pub fn central_difference(&self) -> Vec1<T> {
        if self.len() < 3 {
            return Vec1::new();
        }
        let two = T::from(2u8);
        let mut out = Vec1::with_capacity(self.len() - 2);
        for i in 2..self.len() {
            out.push((self[i + 1] - self[i - 1]) / two);
        }
        out
    }

    /// Forward difference with a custom step `h`: `(v[i+1] - v[i]) / h`.
    #[inline]
    pub fn finite_difference_step(&self, h: T) -> Vec1<T> {
        if self.len() < 2 {
            return Vec1::new();
        }
        let mut out = Vec1::with_capacity(self.len() - 1);
        for i in 1..self.len() {
            out.push((self[i + 1] - self[i]) / h);
        }
        out
    }
}

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

    #[test]
    fn finite_difference_basic() {
        assert_eq!(vec1![1, 3, 6, 10].finite_difference().as_slice(), &[2, 3, 4]);
    }

    #[test]
    fn second_finite_difference_basic() {
        assert_eq!(vec1![1, 4, 9, 16, 25].second_finite_difference().as_slice(), &[2, 2, 2]);
    }

    #[test]
    fn central_difference_basic() {
        let v = vec1![1.0, 4.0, 9.0, 16.0, 25.0];
        assert_eq!(v.central_difference().as_slice(), &[4.0, 6.0, 8.0]);
    }
}