use ndarray::{Array1, Array2};
use solow_core::error::{Error, Result};
use solow_linalg::solve;
pub fn arma_impulse_response(ar: &[f64], ma: &[f64], leads: usize) -> Array1<f64> {
let a0 = ar[0];
let mut psi = Array1::<f64>::zeros(leads);
for n in 0..leads {
let mut acc = if n < ma.len() { ma[n] } else { 0.0 };
for k in 1..ar.len() {
if n >= k {
acc -= ar[k] * psi[n - k];
}
}
psi[n] = acc / a0;
}
psi
}
pub fn arma_acovf(ar: &[f64], ma: &[f64], nobs: usize, sigma2: f64) -> Result<Array1<f64>> {
if sigma2 < 0.0 {
return Err(Error::Value(
"Must have positive innovation variance.".into(),
));
}
let p = ar.len() - 1;
let q = ma.len() - 1;
let m = p.max(q) + 1;
if p == 0 && q == 0 {
let mut out = Array1::<f64>::zeros(nobs);
if nobs > 0 {
out[0] = sigma2;
}
return Ok(out);
}
let ma_coeffs = arma_impulse_response(ar, ma, m);
let mut a = Array2::<f64>::zeros((m, m));
let mut b = Array1::<f64>::zeros(m);
let mut tmp_ar = vec![0.0; m];
for (i, &v) in ar.iter().enumerate().take((p + 1).min(m)) {
tmp_ar[i] = v;
}
for k in 0..m {
for j in 0..=k {
a[[k, j]] = tmp_ar[k - j];
}
let upper = m - k;
for (off, j) in (1..upper).enumerate() {
a[[k, j]] += tmp_ar[k + 1 + off];
}
let count = (q + 1).saturating_sub(k);
let mut dotv = 0.0;
for j in 0..count {
dotv += ma[k + j] * ma_coeffs[j];
}
b[k] = sigma2 * dotv;
}
let solved = solve(&a, &b).map_err(|_| {
Error::Value("The provided ar polynomial does not give a stationary process.".into())
})?;
let total = nobs.max(m);
let mut acovf = Array1::<f64>::zeros(total);
for k in 0..m {
acovf[k] = solved[k];
}
if total > m {
for k in m..total {
let mut acc = 0.0;
for j in 1..=p {
acc -= ar[j] * acovf[k - j];
}
acovf[k] = acc / ar[0];
}
}
Ok(acovf.slice(ndarray::s![..nobs]).to_owned())
}
pub fn arma_acf(ar: &[f64], ma: &[f64], lags: usize) -> Result<Array1<f64>> {
let acovf = arma_acovf(ar, ma, lags, 1.0)?;
let g0 = acovf[0];
Ok(acovf.mapv(|v| v / g0))
}
pub fn arma_pacf(ar: &[f64], ma: &[f64], lags: usize) -> Result<Array1<f64>> {
let mut apacf = Array1::<f64>::zeros(lags);
let acov = arma_acf(ar, ma, lags + 1)?;
if lags == 0 {
return Ok(apacf);
}
apacf[0] = 1.0;
for k in 2..=lags {
let r = acov.slice(ndarray::s![..k]);
let order = k - 1;
let mut t = Array2::<f64>::zeros((order, order));
for i in 0..order {
for j in 0..order {
t[[i, j]] = r[(i as isize - j as isize).unsigned_abs()];
}
}
let rhs = r.slice(ndarray::s![1..]).to_owned();
let phi = solve(&t, &rhs)?;
apacf[k - 1] = phi[order - 1];
}
Ok(apacf)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn ar1_impulse_response_is_geometric() {
let psi = arma_impulse_response(&[1.0, -0.8], &[1.0], 6);
for k in 0..6 {
assert!((psi[k] - 0.8_f64.powi(k as i32)).abs() < 1e-12);
}
}
#[test]
fn white_noise_acf_is_delta() {
let acf = arma_acf(&[1.0], &[1.0], 5).unwrap();
assert!((acf[0] - 1.0).abs() < 1e-12);
for k in 1..5 {
assert!(acf[k].abs() < 1e-12);
}
}
#[test]
fn ar1_acf_is_geometric() {
let acf = arma_acf(&[1.0, -0.5], &[1.0], 6).unwrap();
for k in 0..6 {
assert!((acf[k] - 0.5_f64.powi(k as i32)).abs() < 1e-10);
}
}
#[test]
fn ar1_pacf_cuts_off_after_lag1() {
let pacf = arma_pacf(&[1.0, -0.5], &[1.0], 5).unwrap();
assert!((pacf[0] - 1.0).abs() < 1e-12);
assert!((pacf[1] - 0.5).abs() < 1e-10);
for k in 2..5 {
assert!(pacf[k].abs() < 1e-10);
}
}
}