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
//! Correlation and covariance.

use crate::Vec1;

impl Vec1<f64> {
    /// Covariance (sample, divisor `n-1`).
    ///
    /// ```rust
    /// use one_indexed_vec::vec1;
    /// let x = vec1![1.0, 2.0, 3.0, 4.0, 5.0];
    /// let y = vec1![2.0, 4.0, 6.0, 8.0, 10.0];
    /// assert!((x.covariance(&y) - 5.0).abs() < 1e-10);
    /// ```
    pub fn covariance(&self, other: &Vec1<f64>) -> f64 {
        assert_eq!(self.len(), other.len(), "covariance: length mismatch");
        if self.len() < 2 {
            return 0.0;
        }
        let mx = self.mean();
        let my = other.mean();
        let mut acc = 0.0;
        for i in 1..=self.len() {
            acc += (self[i] - mx) * (other[i] - my);
        }
        acc / (self.len() - 1) as f64
    }

    /// Pearson correlation coefficient.
    ///
    /// ```rust
    /// use one_indexed_vec::vec1;
    /// let x = vec1![1.0, 2.0, 3.0, 4.0, 5.0];
    /// let y = vec1![2.0, 4.0, 6.0, 8.0, 10.0];
    /// assert!((x.pearson(&y) - 1.0).abs() < 1e-10);
    /// ```
    pub fn pearson(&self, other: &Vec1<f64>) -> f64 {
        assert_eq!(self.len(), other.len(), "pearson: length mismatch");
        if self.len() < 2 {
            return 0.0;
        }
        let cov = self.covariance(other);
        let sx = self.sample_std_dev();
        let sy = other.sample_std_dev();
        if sx == 0.0 || sy == 0.0 {
            return 0.0;
        }
        cov / (sx * sy)
    }

    /// Spearman rank correlation coefficient.
    ///
    /// ```rust
    /// use one_indexed_vec::vec1;
    /// let x = vec1![1.0, 2.0, 3.0, 4.0, 5.0];
    /// let y = vec1![2.0, 4.0, 6.0, 8.0, 10.0];
    /// assert!((x.spearman(&y) - 1.0).abs() < 1e-10);
    /// ```
    pub fn spearman(&self, other: &Vec1<f64>) -> f64 {
        assert_eq!(self.len(), other.len(), "spearman: length mismatch");
        let rx = ranks(self);
        let ry = ranks(other);
        rx.pearson(&ry)
    }
}

/// Computes ranks with ties broken by average rank.
fn ranks(v: &Vec1<f64>) -> Vec1<f64> {
    let n = v.len();
    let mut idx: Vec<usize> = (0..n).collect();
    idx.sort_by(|&a, &b| v[a + 1].partial_cmp(&v[b + 1]).unwrap_or(core::cmp::Ordering::Equal));

    let mut r = vec![0.0; n];
    let mut i = 0;
    while i < n {
        let mut j = i;
        while j + 1 < n && v[idx[j + 1] + 1] == v[idx[i] + 1] {
            j += 1;
        }
        let avg = (i + j) as f64 / 2.0 + 1.0;
        for k in i..=j {
            r[idx[k]] = avg;
        }
        i = j + 1;
    }

    let mut out = Vec1::with_capacity(n);
    for x in r {
        out.push(x);
    }
    out
}

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

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

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

    #[test]
    fn covariance_basic() {
        let x = vec1![1.0, 2.0, 3.0, 4.0, 5.0];
        let y = vec1![2.0, 4.0, 6.0, 8.0, 10.0];
        assert!((x.covariance(&y) - 5.0).abs() < 1e-10);
    }

    #[test]
    fn pearson_perfect_positive() {
        let x = vec1![1.0, 2.0, 3.0, 4.0, 5.0];
        let y = vec1![2.0, 4.0, 6.0, 8.0, 10.0];
        assert!((x.pearson(&y) - 1.0).abs() < 1e-10);
    }

    #[test]
    fn pearson_perfect_negative() {
        let x = vec1![1.0, 2.0, 3.0, 4.0, 5.0];
        let y = vec1![10.0, 8.0, 6.0, 4.0, 2.0];
        assert!((x.pearson(&y) - (-1.0)).abs() < 1e-10);
    }

    #[test]
    fn spearman_basic() {
        let x = vec1![1.0, 2.0, 3.0, 4.0, 5.0];
        let y = vec1![2.0, 4.0, 6.0, 8.0, 10.0];
        assert!((x.spearman(&y) - 1.0).abs() < 1e-10);
    }
}