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
//! Linear and polynomial regression.

use crate::Vec1;
use crate::linear::matrix::Matrix;

impl Vec1<f64> {
    /// Simple linear regression `y = a + b·x`.
    ///
    /// Returns `(a, b, r²)`.
    ///
    /// ```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];
    /// let (a, b, r2) = x.linear_regression(&y);
    /// assert!(a.abs() < 1e-10);
    /// assert!((b - 2.0).abs() < 1e-10);
    /// assert!((r2 - 1.0).abs() < 1e-10);
    /// ```
    pub fn linear_regression(&self, y: &Vec1<f64>) -> (f64, f64, f64) {
        assert_eq!(self.len(), y.len(), "linear_regression: length mismatch");
        let n = self.len() as f64;
        if n < 2.0 {
            return (0.0, 0.0, 0.0);
        }

        let sum_x = self.sum();
        let sum_y = y.sum();
        let sum_xy: f64 = (1..=self.len()).map(|i| self[i] * y[i]).sum();
        let sum_x2: f64 = (1..=self.len()).map(|i| self[i] * self[i]).sum();

        let mean_x = sum_x / n;
        let mean_y = sum_y / n;

        let denom = n * sum_x2 - sum_x * sum_x;
        if denom.abs() < 1e-15 {
            return (mean_y, 0.0, 0.0);
        }

        let b = (n * sum_xy - sum_x * sum_y) / denom;
        let a = mean_y - b * mean_x;

        // R²
        let ss_tot: f64 = (1..=y.len()).map(|i| (y[i] - mean_y).powi(2)).sum();
        let ss_res: f64 = (1..=y.len()).map(|i| (y[i] - (a + b * self[i])).powi(2)).sum();
        let r2 = if ss_tot > 0.0 { 1.0 - ss_res / ss_tot } else { 0.0 };

        (a, b, r2)
    }

    /// Polynomial regression of degree `d` via least squares.
    ///
    /// Returns the coefficient vector `[c_0, c_1, ..., c_d]` as a 1-based
    /// `Vec1` where `y ≈ c_0 + c_1 x + ... + c_d x^d`.
    ///
    /// ```rust
    /// use one_indexed_vec::vec1;
    ///
    /// // y = 2 + 3x + x²
    /// let x = vec1![0.0, 1.0, 2.0, 3.0, 4.0];
    /// let y = vec1![2.0, 6.0, 12.0, 20.0, 30.0];
    /// let c = x.polynomial_fit(&y, 2);
    /// assert!((c[1] - 2.0).abs() < 1e-8);
    /// assert!((c[2] - 3.0).abs() < 1e-8);
    /// assert!((c[3] - 1.0).abs() < 1e-8);
    /// ```
    pub fn polynomial_fit(&self, y: &Vec1<f64>, degree: usize) -> Vec1<f64> {
        assert_eq!(self.len(), y.len(), "polynomial_fit: length mismatch");
        let n = self.len();
        let m = degree + 1;

        // Design matrix: A[i][j] = x_i^(j-1)
        let mut a = Matrix::new(n, m, 0.0);
        for i in 1..=n {
            let mut p = 1.0;
            for j in 1..=m {
                a.set(i, j, p);
                p *= self[i];
            }
        }

        // Normal equations: (Aᵀ A) c = Aᵀ y
        let at = a.transpose();
        let ata = at.matmul(&a);
        let aty = at.matvec(y);

        // Solve via Gaussian elimination
        ata.solve(&aty)
    }
}

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

    #[test]
    fn linear_regression_exact() {
        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];
        let (a, b, r2) = x.linear_regression(&y);
        assert!(a.abs() < 1e-10);
        assert!((b - 2.0).abs() < 1e-10);
        assert!((r2 - 1.0).abs() < 1e-10);
    }

    #[test]
    fn linear_regression_with_noise() {
        let x = vec1![1.0, 2.0, 3.0, 4.0, 5.0];
        let y = vec1![2.1, 3.9, 6.2, 7.9, 10.1];
        let (a, b, _r2) = x.linear_regression(&y);
        assert!((b - 2.0).abs() < 0.1);
        assert!(a.abs() < 0.5);
    }

    #[test]
    fn polynomial_fit_quadratic() {
        let x = vec1![0.0, 1.0, 2.0, 3.0, 4.0];
        let y = vec1![2.0, 6.0, 12.0, 20.0, 30.0];
        let c = x.polynomial_fit(&y, 2);
        assert!((c[1] - 2.0).abs() < 1e-8);
        assert!((c[2] - 3.0).abs() < 1e-8);
        assert!((c[3] - 1.0).abs() < 1e-8);
    }
}