use ndarray::{Array1, Array2};
use solow_core::error::{Error, Result};
use solow_linalg::solve as linsolve;
use crate::linear::{LinearModel, LinearResults};
#[derive(Clone, Debug)]
pub struct Glsar {
endog: Array1<f64>,
exog: Array2<f64>,
order: usize,
}
#[derive(Clone, Debug)]
pub struct GlsarResults {
pub ols: LinearResults,
pub params: Array1<f64>,
pub bse: Array1<f64>,
pub rho: Array1<f64>,
pub iterations: usize,
pub converged: bool,
}
impl Glsar {
pub fn new(endog: Array1<f64>, exog: Array2<f64>, order: usize) -> Result<Self> {
if endog.len() != exog.nrows() {
return Err(Error::Shape(format!(
"endog length {} != exog rows {}",
endog.len(),
exog.nrows()
)));
}
if order == 0 {
return Err(Error::Value("AR order must be >= 1".into()));
}
if endog.len() <= order {
return Err(Error::Value(
"nobs must exceed the AR order (whitening drops the first `order` rows)".into(),
));
}
Ok(Glsar { endog, exog, order })
}
pub fn order(&self) -> usize {
self.order
}
fn whiten_vec(&self, x: &Array1<f64>, rho: &Array1<f64>) -> Array1<f64> {
let n = x.len();
let mut out = x.clone();
for (i, &r) in rho.iter().enumerate() {
for t in (i + 1)..n {
out[t] -= r * x[t - (i + 1)];
}
}
out.slice(ndarray::s![self.order..]).to_owned()
}
fn whiten_mat(&self, x: &Array2<f64>, rho: &Array1<f64>) -> Array2<f64> {
let n = x.nrows();
let k = x.ncols();
let mut out = x.clone();
for (i, &r) in rho.iter().enumerate() {
for t in (i + 1)..n {
for j in 0..k {
out[[t, j]] -= r * x[[t - (i + 1), j]];
}
}
}
out.slice(ndarray::s![self.order.., ..]).to_owned()
}
fn fit_rho(&self, rho: &Array1<f64>) -> Result<LinearResults> {
let wendog = self.whiten_vec(&self.endog, rho);
let wexog = self.whiten_mat(&self.exog, rho);
LinearModel::ols(wendog, wexog)?.fit()
}
fn yule_walker(&self, resid: &Array1<f64>) -> Result<Array1<f64>> {
let p = self.order;
let n = resid.len() as f64;
let mean = resid.sum() / n;
let x: Vec<f64> = resid.iter().map(|&v| v - mean).collect();
let m = x.len();
let mut r = vec![0.0_f64; p + 1];
r[0] = x.iter().map(|v| v * v).sum::<f64>() / n;
for k in 1..=p {
let mut s = 0.0;
for t in 0..(m - k) {
s += x[t] * x[t + k];
}
r[k] = s / (n - k as f64);
}
let mut rmat = Array2::<f64>::zeros((p, p));
for i in 0..p {
for j in 0..p {
rmat[[i, j]] = r[i.abs_diff(j)];
}
}
let rhs = Array1::from_vec(r[1..].to_vec());
let rho = linsolve(&rmat, &rhs)?;
Ok(rho)
}
pub fn iterative_fit(&self, maxiter: usize, rtol: f64) -> Result<GlsarResults> {
let mut rho = Array1::<f64>::zeros(self.order);
let mut last: Option<Array1<f64>> = None;
let mut converged = false;
let mut last_i: isize = -1;
if maxiter >= 1 {
for i in 0..(maxiter - 1) {
last_i = i as isize;
let res = self.fit_rho(&rho)?;
let params = res.params.clone();
if i == 0 {
last = Some(params.clone());
} else {
let last_p = last.as_ref().unwrap();
let diff = params
.iter()
.zip(last_p.iter())
.map(|(&c, &l)| (l - c).abs() / l.abs())
.fold(0.0_f64, f64::max);
if diff < rtol {
converged = true;
break;
}
last = Some(params.clone());
}
let fitted = self.exog.dot(¶ms);
let resid_full = &self.endog - &fitted;
rho = self.yule_walker(&resid_full)?;
}
}
let final_res = self.fit_rho(&rho)?;
let mut iter_count = (last_i + 1).max(0) as usize;
if !converged {
iter_count += 1;
}
let params = final_res.params.clone();
let bse = final_res.bse.clone();
Ok(GlsarResults {
ols: final_res,
params,
bse,
rho,
iterations: iter_count,
converged,
})
}
}
#[cfg(test)]
mod tests {
use super::*;
use ndarray::array;
#[test]
fn glsar_docstring_example() {
let x = array![
[1.0, 1.0],
[1.0, 2.0],
[1.0, 3.0],
[1.0, 4.0],
[1.0, 5.0],
[1.0, 6.0],
[1.0, 7.0],
];
let y = array![1.0, 3.0, 4.0, 5.0, 8.0, 10.0, 9.0];
let res = Glsar::new(y, x, 2).unwrap().iterative_fit(6, 1e-4).unwrap();
assert!((res.rho[0] - (-0.60479146)).abs() < 1e-6);
assert!((res.rho[1] - (-0.85841922)).abs() < 1e-6);
assert!((res.params[0] - (-0.66661205)).abs() < 1e-6);
assert!((res.params[1] - 1.60850853).abs() < 1e-6);
assert!((res.bse[0] - 0.31697526).abs() < 1e-6);
assert!((res.bse[1] - 0.0737688).abs() < 1e-6);
assert_eq!(res.ols.nobs, 5.0);
}
#[test]
fn rejects_bad_order() {
let x = array![[1.0], [1.0], [1.0]];
let y = array![1.0, 2.0, 3.0];
assert!(Glsar::new(y.clone(), x.clone(), 0).is_err());
assert!(Glsar::new(y, x, 3).is_err());
}
}