use ndarray::{Array1, Array2};
use solow_core::error::{Error, Result};
use solow_linalg::{cholesky, eigh, inv, matrix_rank, solve_matrix, svd};
use crate::mvstats::{multivariate_stats, MultivariateStats};
#[derive(Clone, Debug)]
pub struct Manova {
params: Array2<f64>,
df_resid: f64,
inv_cov: Array2<f64>,
sscpr: Array2<f64>,
k_exog: usize,
}
impl Manova {
pub fn new(endog: Array2<f64>, exog: Array2<f64>) -> Result<Self> {
let (nobs, k_endog) = endog.dim();
let (nobs1, k_exog) = exog.dim();
if k_endog < 2 {
return Err(Error::Shape(
"there must be more than one dependent variable to fit MANOVA".into(),
));
}
if nobs != nobs1 {
return Err(Error::Shape(
"endog and exog must have the same number of rows".into(),
));
}
let df_resid = (nobs - k_exog) as f64;
let (u, s, vt) = svd(&exog)?;
let tolerance = 1e-8;
if s.iter().filter(|&&x| x > tolerance).count() < s.len() {
return Err(Error::Singular("covariance of exog singular".into()));
}
let k = s.len();
let invs = s.mapv(|x| 1.0 / x);
let uty = u.t().dot(&endog);
let mut dinv_uty = uty.clone();
for i in 0..k {
for j in 0..k_endog {
dinv_uty[[i, j]] *= invs[i];
}
}
let params = vt.t().dot(&dinv_uty);
let mut vt_scaled = vt.clone();
for i in 0..k {
let w = invs[i] * invs[i];
for j in 0..vt.ncols() {
vt_scaled[[i, j]] *= w;
}
}
let inv_cov = vt.t().dot(&vt_scaled);
let vt_params = vt.dot(¶ms);
let mut t = vt_params.clone();
for i in 0..k {
for j in 0..k_endog {
t[[i, j]] *= s[i];
}
}
let yty = endog.t().dot(&endog);
let sscpr = &yty - &t.t().dot(&t);
Ok(Manova {
params,
df_resid,
inv_cov,
sscpr,
k_exog,
})
}
pub fn k_exog(&self) -> usize {
self.k_exog
}
pub fn mv_test(&self) -> Result<Vec<ManovaTest>> {
let mut out = Vec::with_capacity(self.k_exog);
for i in 0..self.k_exog {
let mut l = Array2::<f64>::zeros((1, self.k_exog));
l[[0, i]] = 1.0;
out.push(self.test_contrast(&l, format!("x{i}"))?);
}
Ok(out)
}
pub fn test_contrast(&self, l: &Array2<f64>, name: String) -> Result<ManovaTest> {
let t1 = l.dot(&self.params);
let t2 = l.dot(&self.inv_cov).dot(&l.t());
let q = matrix_rank(&t2)?;
let inv_t2 = inv(&t2)?;
let h = t1.t().dot(&inv_t2).dot(&t1);
let e = self.sscpr.clone();
let eh = &e + &h;
let p = matrix_rank(&eh)?;
let eigvals = gen_sym_eigvals(&h, &eh)?;
let eigvals_s = eigvals
.as_slice()
.ok_or_else(|| Error::Value("eigvals must be contiguous".into()))?;
let stat = multivariate_stats(eigvals_s, p, q, self.df_resid);
Ok(ManovaTest {
name,
stats: stat,
e,
h,
})
}
}
fn gen_sym_eigvals(a: &Array2<f64>, b: &Array2<f64>) -> Result<Array1<f64>> {
let l = cholesky(b)?; let y = solve_matrix(&l, a)?;
let yt = y.t().to_owned();
let c = solve_matrix(&l, &yt)?;
let mut csym = c.clone();
let n = c.nrows();
for i in 0..n {
for j in 0..n {
csym[[i, j]] = 0.5 * (c[[i, j]] + c[[j, i]]);
}
}
let (w, _v) = eigh(&csym)?;
Ok(w) }
#[derive(Clone, Debug)]
pub struct ManovaTest {
pub name: String,
pub stats: MultivariateStats,
pub e: Array2<f64>,
pub h: Array2<f64>,
}
#[cfg(test)]
mod tests {
use super::*;
use ndarray::array;
#[test]
fn two_group_two_dv_runs() {
let exog = array![
[1.0, 0.0],
[1.0, 0.0],
[1.0, 0.0],
[1.0, 1.0],
[1.0, 1.0],
[1.0, 1.0],
];
let endog = array![
[1.0, 2.0],
[1.2, 1.9],
[0.9, 2.1],
[3.0, 0.5],
[3.1, 0.6],
[2.9, 0.4],
];
let m = Manova::new(endog, exog).unwrap();
let tests = m.mv_test().unwrap();
assert_eq!(tests.len(), 2);
for t in &tests {
assert!(t.stats.wilks_lambda.value > 0.0 && t.stats.wilks_lambda.value <= 1.0 + 1e-9);
assert!(t.stats.pillai_trace.value >= -1e-12);
}
}
#[test]
fn rejects_single_dependent_variable() {
let exog = array![[1.0], [1.0], [1.0]];
let endog = array![[1.0], [2.0], [3.0]];
assert!(Manova::new(endog, exog).is_err());
}
}