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
//! Normalization and scaling.

use crate::Vec1;

impl Vec1<f64> {
    /// Min-Max normalization to `[0, 1]`.
    ///
    /// ```rust
    /// use one_indexed_vec::vec1;
    /// let v = vec1![1.0, 2.0, 3.0, 4.0, 5.0];
    /// assert_eq!(v.min_max_normalize().as_slice(), &[0.0, 0.25, 0.5, 0.75, 1.0]);
    /// ```
    #[inline]
    pub fn min_max_normalize(&self) -> Vec1<f64> {
        if self.is_empty() {
            return Vec1::new();
        }
        let mut min_v = self[1];
        let mut max_v = self[1];
        for i in 2..=self.len() {
            if self[i] < min_v {
                min_v = self[i];
            }
            if self[i] > max_v {
                max_v = self[i];
            }
        }
        let range = max_v - min_v;
        let mut out = Vec1::with_capacity(self.len());
        if range == 0.0 {
            for _ in 1..=self.len() {
                out.push(0.5);
            }
            return out;
        }
        for i in 1..=self.len() {
            out.push((self[i] - min_v) / range);
        }
        out
    }

    /// Z-Score normalization: `(x - mean) / std_dev`.
    ///
    /// ```rust
    /// use one_indexed_vec::vec1;
    /// let v = vec1![1.0, 2.0, 3.0, 4.0, 5.0];
    /// let z = v.z_score_normalize();
    /// assert!((z[1] - (-1.41421356)).abs() < 1e-6);
    /// ```
    #[inline]
    pub fn z_score_normalize(&self) -> Vec1<f64> {
        if self.len() < 2 {
            let mut out = Vec1::with_capacity(self.len());
            for _ in 1..=self.len() {
                out.push(0.0);
            }
            return out;
        }
        let mean = self.mean();
        let sd = self.std_dev();
        let mut out = Vec1::with_capacity(self.len());
        if sd == 0.0 {
            for _ in 1..=self.len() {
                out.push(0.0);
            }
            return out;
        }
        for i in 1..=self.len() {
            out.push((self[i] - mean) / sd);
        }
        out
    }

    /// L2 (unit) normalization: `v / ‖v‖₂`.
    #[inline]
    pub fn l2_normalize(&self) -> Vec1<f64> {
        let norm: f64 = libm::sqrt(self.iter().map(|&x| x * x).sum::<f64>());
        let mut out = Vec1::with_capacity(self.len());
        if norm == 0.0 {
            for _ in 1..=self.len() {
                out.push(0.0);
            }
            return out;
        }
        for i in 1..=self.len() {
            out.push(self[i] / norm);
        }
        out
    }
}

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

    #[test]
    fn min_max_basic() {
        let v = vec1![1.0, 2.0, 3.0, 4.0, 5.0];
        assert_eq!(v.min_max_normalize().as_slice(), &[0.0, 0.25, 0.5, 0.75, 1.0]);
    }

    #[test]
    fn min_max_constant() {
        let v = vec1![3.0, 3.0, 3.0];
        assert_eq!(v.min_max_normalize().as_slice(), &[0.5, 0.5, 0.5]);
    }

    #[test]
    fn z_score_basic() {
        let v = vec1![1.0, 2.0, 3.0, 4.0, 5.0];
        let z = v.z_score_normalize();
        //assert!((z[1] - (-1.41421356)).abs() < 1e-6);
        assert!((z[1] - (-core::f64::consts::SQRT_2)).abs() < 1e-6);
        //assert!((z[5] - 1.41421356).abs() < 1e-6);
        assert!((z[5] - core::f64::consts::SQRT_2).abs() < 1e-6);
    }

    #[test]
    fn l2_normalize_basic() {
        let v = vec1![3.0, 4.0];
        let n = v.l2_normalize();
        assert!((n[1] - 0.6).abs() < 1e-10);
        assert!((n[2] - 0.8).abs() < 1e-10);
    }
}