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
//! Missing-value fill and interpolation.

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

impl<T> Vec1<T>
where
    T: Copy + PartialEq + Default,
{
    /// Forward fill missing values (`T::default()`).
    ///
    /// ```rust
    /// use one_indexed_vec::vec1;
    /// let v = vec1![1, 0, 0, 2, 0, 3];
    /// assert_eq!(v.forward_fill().as_slice(), &[1, 1, 1, 2, 2, 3]);
    /// ```
    #[inline]
    pub fn forward_fill(&self) -> Vec1<T> {
        let mut out = Vec1::with_capacity(self.len());
        let mut last = T::default();
        let mut found = false;
        for i in 1..=self.len() {
            if self[i] != T::default() {
                last = self[i];
                found = true;
            }
            out.push(if found { last } else { self[i] });
        }
        out
    }

    /// Backward fill missing values (`T::default()`).
    ///
    /// ```rust
    /// use one_indexed_vec::vec1;
    /// let v = vec1![1, 0, 0, 2, 0, 3];
    /// assert_eq!(v.backward_fill().as_slice(), &[1, 2, 2, 2, 3, 3]);
    /// ```
    #[inline]
    pub fn backward_fill(&self) -> Vec1<T> {
        if self.is_empty() {
            return Vec1::new();
        }
        let mut out = Vec1::with_capacity(self.len());
        let mut next = T::default();
        let mut found = false;
        for i in (1..=self.len()).rev() {
            if self[i] != T::default() {
                next = self[i];
                found = true;
            }
            out.push(if found { next } else { self[i] });
        }
        out.reverse();
        out
    }
}

impl<T> Vec1<T>
where
    T: Copy + PartialEq + Default + Into<f64>,
{
    /// Linear interpolation of missing values (`T::default()`), returns `f64`.
    ///
    /// ```rust
    /// use one_indexed_vec::vec1;
    /// let v = vec1![1.0f64, 0.0, 0.0, 4.0];
    /// let r = v.linear_interpolate();
    /// assert!((r[1] - 1.0).abs() < 1e-10);
    /// assert!((r[2] - 2.0).abs() < 1e-10);
    /// assert!((r[3] - 3.0).abs() < 1e-10);
    /// assert!((r[4] - 4.0).abs() < 1e-10);
    /// ```
    #[inline]
    pub fn linear_interpolate(&self) -> Vec1<f64> {
        if self.is_empty() {
            return Vec1::new();
        }
        let mut known: Vec<(usize, f64)> = Vec::new();
        for i in 1..=self.len() {
            if self[i] != T::default() {
                known.push((i, self[i].into()));
            }
        }
        let mut out = Vec1::with_capacity(self.len());
        for _ in 1..=self.len() {
            out.push(0.0);
        }
        if known.is_empty() {
            return out;
        }
        if known.len() == 1 {
            let v = known[0].1;
            for i in 1..=self.len() {
                out[i] = v;
            }
            return out;
        }
        let (fi, fv) = known[0];
        for i in 1..fi {
            out[i] = fv;
        }
        out[fi] = fv;
        for w in known.windows(2) {
            let (i1, v1) = w[0];
            let (i2, v2) = w[1];
            for i in i1..=i2 {
                let frac = (i - i1) as f64 / (i2 - i1) as f64;
                out[i] = v1 + frac * (v2 - v1);
            }
        }
        let (li, lv) = known[known.len() - 1];
        for i in li..=self.len() {
            out[i] = lv;
        }
        out
    }
}

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

    #[test]
    fn forward_fill_basic() {
        let v = vec1![1, 0, 0, 2, 0, 3];
        assert_eq!(v.forward_fill().as_slice(), &[1, 1, 1, 2, 2, 3]);
    }

    #[test]
    fn backward_fill_basic() {
        let v = vec1![1, 0, 0, 2, 0, 3];
        assert_eq!(v.backward_fill().as_slice(), &[1, 2, 2, 2, 3, 3]);
    }

    #[test]
    fn linear_interpolate_basic() {
        let v = vec1![1.0, 0.0, 0.0, 4.0];
        let r = v.linear_interpolate();
        assert!((r[1] - 1.0).abs() < 1e-10);
        assert!((r[2] - 2.0).abs() < 1e-10);
        assert!((r[3] - 3.0).abs() < 1e-10);
        assert!((r[4] - 4.0).abs() < 1e-10);
    }

    #[test]
    fn forward_fill_all_missing() {
        let v = vec1![0, 0, 0];
        assert_eq!(v.forward_fill().as_slice(), &[0, 0, 0]);
    }
}