use ndarray::{Array1, Array2};
use solow_core::error::{Error, Result};
use solow_linalg::{cholesky, eigh, solve_matrix};
#[derive(Clone, Debug)]
pub struct SlicedInverseReg {
endog: Array1<f64>,
exog: Array2<f64>,
}
#[derive(Clone, Debug)]
pub struct SirResults {
pub params: Array2<f64>,
pub eigenvalues: Array1<f64>,
}
impl SlicedInverseReg {
pub fn new(endog: Array1<f64>, exog: Array2<f64>) -> Result<Self> {
if endog.len() != exog.nrows() {
return Err(Error::Shape(format!(
"endog length {} != exog rows {}",
endog.len(),
exog.nrows()
)));
}
if exog.nrows() == 0 {
return Err(Error::Value("empty design matrix".into()));
}
Ok(SlicedInverseReg { endog, exog })
}
pub fn fit(&self, slice_n: usize) -> Result<SirResults> {
let n = self.exog.nrows();
let p = self.exog.ncols();
if slice_n == 0 {
return Err(Error::Value("slice_n must be >= 1".into()));
}
let n_slice = n / slice_n;
if n_slice < 1 {
return Err(Error::Value(
"too few observations for even a single slice".into(),
));
}
let mut idx: Vec<usize> = (0..n).collect();
idx.sort_by(|&a, &b| {
self.endog[a]
.partial_cmp(&self.endog[b])
.unwrap_or(std::cmp::Ordering::Equal)
.then(a.cmp(&b))
});
let mut x = Array2::<f64>::zeros((n, p));
for (newi, &oldi) in idx.iter().enumerate() {
for j in 0..p {
x[[newi, j]] = self.exog[[oldi, j]];
}
}
let nf = n as f64;
let mut means = Array1::<f64>::zeros(p);
for j in 0..p {
means[j] = x.column(j).sum() / nf;
}
for i in 0..n {
for j in 0..p {
x[[i, j]] -= means[j];
}
}
let covx = x.t().dot(&x) / nf;
let covxr = cholesky(&covx)?;
let xt = x.t().to_owned();
let zt = solve_matrix(&covxr, &xt)?; let z = zt.t().to_owned();
let base = n / n_slice;
let rem = n % n_slice;
let mut start = 0usize;
let mut slice_means = Array2::<f64>::zeros((n_slice, p));
let mut slice_counts = Array1::<f64>::zeros(n_slice);
for s in 0..n_slice {
let len = base + if s < rem { 1 } else { 0 };
let end = start + len;
for j in 0..p {
let mut acc = 0.0;
for i in start..end {
acc += z[[i, j]];
}
slice_means[[s, j]] = acc / len as f64;
}
slice_counts[s] = len as f64;
start = end;
}
let total: f64 = slice_counts.sum();
let mut weighted = slice_means.clone();
for s in 0..n_slice {
for j in 0..p {
weighted[[s, j]] *= slice_counts[s];
}
}
let mnc = slice_means.t().dot(&weighted) / total;
let (evals_asc, evecs_asc) = eigh(&mnc)?;
let mut order: Vec<usize> = (0..p).collect();
order.sort_by(|&a, &b| {
evals_asc[b]
.partial_cmp(&evals_asc[a])
.unwrap_or(std::cmp::Ordering::Equal)
});
let mut eigenvalues = Array1::<f64>::zeros(p);
let mut b = Array2::<f64>::zeros((p, p));
for (newj, &oldj) in order.iter().enumerate() {
eigenvalues[newj] = evals_asc[oldj];
for i in 0..p {
b[[i, newj]] = evecs_asc[[i, oldj]];
}
}
let covxr_t = covxr.t().to_owned();
let params = solve_matrix(&covxr_t, &b)?;
Ok(SirResults {
params,
eigenvalues,
})
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn sir_runs_and_orders_eigenvalues() {
let n = 100;
let p = 3;
let mut exog = Array2::<f64>::zeros((n, p));
let mut endog = Array1::<f64>::zeros(n);
for i in 0..n {
let t = i as f64 / n as f64;
exog[[i, 0]] = (t * 5.5).sin();
exog[[i, 1]] = (t * 2.5).cos();
exog[[i, 2]] = t - 0.5;
endog[i] = 2.0 * exog[[i, 0]] + 0.01 * exog[[i, 2]];
}
let res = SlicedInverseReg::new(endog, exog).unwrap().fit(20).unwrap();
for w in res.eigenvalues.windows(2) {
assert!(w[0] >= w[1] - 1e-12);
}
assert_eq!(res.params.dim(), (p, p));
assert!(res.eigenvalues[0] > res.eigenvalues[1]);
}
}