use ndarray::{Array1, Array2};
use solow_core::error::{Error, Result};
use solow_linalg::lstsq;
use crate::tsatools::Trend;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ArIc {
Aic,
Bic,
Hqic,
}
impl ArIc {
pub fn parse(s: &str) -> Result<Self> {
match s {
"aic" => Ok(ArIc::Aic),
"bic" => Ok(ArIc::Bic),
"hqic" => Ok(ArIc::Hqic),
other => Err(Error::Value(format!("unknown ic '{other}'"))),
}
}
}
#[derive(Debug, Clone)]
pub struct ArSelectResult {
pub ic: ArIc,
pub selected_order: usize,
pub ic_path: Array1<f64>,
}
fn ntrend(trend: Trend) -> usize {
match trend {
Trend::N => 0,
Trend::C | Trend::T => 1,
Trend::Ct => 2,
Trend::Ctt => 3,
}
}
fn trend_powers(trend: Trend) -> Vec<i32> {
match trend {
Trend::N => vec![],
Trend::C => vec![0],
Trend::T => vec![1],
Trend::Ct => vec![0, 1],
Trend::Ctt => vec![0, 1, 2],
}
}
fn has_constant(trend: Trend) -> bool {
matches!(trend, Trend::C | Trend::Ct | Trend::Ctt)
}
pub fn ar_select_order(
y: &Array1<f64>,
maxlag: usize,
ic: ArIc,
trend: Trend,
) -> Result<ArSelectResult> {
let n = y.len();
if maxlag >= n {
return Err(Error::Value("maxlag must be smaller than nobs".into()));
}
let nobs = n - maxlag;
let nt = ntrend(trend);
let powers = trend_powers(trend);
let const_adj = if has_constant(trend) { 1usize } else { 0 };
let nobs_f = nobs as f64;
let ln_n = nobs_f.ln();
let ln_ln_n = ln_n.ln();
let mut ic_path = Array1::<f64>::zeros(maxlag + 1);
for p in 0..=maxlag {
let k = nt + p;
let mut yv = Array1::<f64>::zeros(nobs);
for i in 0..nobs {
yv[i] = y[maxlag + i];
}
let ssr = if k == 0 {
yv.iter().map(|&v| v * v).sum::<f64>()
} else {
let mut x = Array2::<f64>::zeros((nobs, k));
for i in 0..nobs {
let t = maxlag + i; let time = (t + 1) as f64;
for (c, &power) in powers.iter().enumerate() {
x[[i, c]] = time.powi(power);
}
for j in 0..p {
x[[i, nt + j]] = y[t - 1 - j];
}
}
let beta = lstsq(&x, &yv)?;
let fitted = x.dot(&beta);
let resid = &yv - &fitted;
resid.iter().map(|&v| v * v).sum::<f64>()
};
let sigma2 = ssr / nobs_f;
let llf = -nobs_f * ((2.0 * std::f64::consts::PI * sigma2).ln() + 1.0) / 2.0;
let df_modelwc = (k - const_adj) + 1;
let dfw = df_modelwc as f64;
let value = match ic {
ArIc::Aic => -2.0 * llf + 2.0 * dfw,
ArIc::Bic => -2.0 * llf + ln_n * dfw,
ArIc::Hqic => -2.0 * llf + 2.0 * ln_ln_n * dfw,
};
ic_path[p] = value;
}
let mut best = 0usize;
for p in 1..=maxlag {
if ic_path[p] < ic_path[best] {
best = p;
}
}
Ok(ArSelectResult {
ic,
selected_order: best,
ic_path,
})
}
#[cfg(test)]
mod tests {
use super::*;
use ndarray::Array1;
fn ar2_series() -> Array1<f64> {
let n = 120usize;
let mut y = vec![0.0; n + 60];
let mut s = 7.0_f64;
let mut rnd = || {
s = (s * 1103515245.0 + 12345.0) % 2147483648.0;
s / 2147483648.0 - 0.5
};
for t in 2..(n + 60) {
y[t] = 0.6 * y[t - 1] - 0.2 * y[t - 2] + rnd();
}
Array1::from_vec(y[60..].to_vec())
}
#[test]
fn path_has_expected_length() {
let y = ar2_series();
let r = ar_select_order(&y, 5, ArIc::Aic, Trend::C).unwrap();
assert_eq!(r.ic_path.len(), 6);
assert!(r.ic_path.iter().all(|v| v.is_finite()));
assert!(r.selected_order <= 5);
}
#[test]
fn bic_penalises_more_than_aic() {
let y = ar2_series();
let aic = ar_select_order(&y, 5, ArIc::Aic, Trend::C).unwrap();
let bic = ar_select_order(&y, 5, ArIc::Bic, Trend::C).unwrap();
assert!(bic.selected_order <= aic.selected_order + 5);
assert_eq!(aic.ic_path.len(), bic.ic_path.len());
}
#[test]
fn rejects_maxlag_too_large() {
let y = Array1::from_vec(vec![1.0, 2.0, 3.0]);
assert!(ar_select_order(&y, 3, ArIc::Aic, Trend::C).is_err());
}
}