use ndarray::{s, Array1, Array2};
use solow_core::error::{Error, Result};
use solow_distributions::{chi2_sf, norm_cdf};
use solow_linalg::{inv, lstsq};
use crate::tsatools::{add_trend, lagmat1d, Original, Trend, Trim};
fn mean(x: &Array1<f64>) -> f64 {
x.sum() / x.len() as f64
}
pub fn acovf(x: &Array1<f64>, adjusted: bool, demean: bool, nlag: usize) -> Result<Array1<f64>> {
let n = x.len();
if nlag > n - 1 {
return Err(Error::Value("nlag must be smaller than nobs - 1".into()));
}
let xo: Array1<f64> = if demean {
let m = mean(x);
x.mapv(|v| v - m)
} else {
x.clone()
};
let mut acov = Array1::<f64>::zeros(nlag + 1);
acov[0] = xo.dot(&xo);
for i in 0..nlag {
let a = xo.slice(s![i + 1..]);
let b = xo.slice(s![..n - (i + 1)]);
acov[i + 1] = a.dot(&b);
}
for (k, v) in acov.iter_mut().enumerate() {
let denom = if adjusted { (n - k) as f64 } else { n as f64 };
*v /= denom;
}
Ok(acov)
}
pub fn acf(x: &Array1<f64>, nlags: usize, adjusted: bool) -> Result<Array1<f64>> {
let avf = acovf(x, adjusted, true, nlags)?;
let a0 = avf[0];
Ok(avf.mapv(|v| v / a0))
}
pub fn acf_qstat(
x: &Array1<f64>,
nlags: usize,
adjusted: bool,
) -> Result<(Array1<f64>, Array1<f64>, Array1<f64>)> {
let a = acf(x, nlags, adjusted)?;
let tail = a.slice(s![1..]).to_owned();
let (q, p) = q_stat(&tail, x.len());
Ok((a, q, p))
}
pub fn q_stat(acf_vals: &Array1<f64>, nobs: usize) -> (Array1<f64>, Array1<f64>) {
let m = acf_vals.len();
let n = nobs as f64;
let mut qstat = Array1::<f64>::zeros(m);
let mut pvalues = Array1::<f64>::zeros(m);
let mut acc = 0.0;
for k in 0..m {
let lag = (k + 1) as f64;
acc += acf_vals[k].powi(2) / (n - lag);
qstat[k] = n * (n + 2.0) * acc;
pvalues[k] = chi2_sf(qstat[k], lag);
}
(qstat, pvalues)
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PacfMethod {
YuleWalker,
Ols,
}
pub fn pacf(x: &Array1<f64>, nlags: usize, method: PacfMethod) -> Result<Array1<f64>> {
if nlags > x.len() / 2 {
return Err(Error::Value(
"nlags must be < 50% of the sample size".into(),
));
}
match method {
PacfMethod::YuleWalker => pacf_yw(x, nlags),
PacfMethod::Ols => pacf_ols(x, nlags),
}
}
fn pacf_yw(x: &Array1<f64>, nlags: usize) -> Result<Array1<f64>> {
let mut out = Array1::<f64>::zeros(nlags + 1);
out[0] = 1.0;
for k in 1..=nlags {
let phi = yule_walker_adjusted(x, k)?;
out[k] = phi[k - 1];
}
Ok(out)
}
fn yule_walker_adjusted(x: &Array1<f64>, order: usize) -> Result<Array1<f64>> {
let n = x.len();
let m = mean(x);
let xd = x.mapv(|v| v - m);
let denom = xd.dot(&xd) / n as f64;
let mut r = Array1::<f64>::zeros(order + 1);
for k in 0..=order {
let a = xd.slice(s![k..]);
let b = xd.slice(s![..n - k]);
r[k] = a.dot(&b) / (n - k) as f64 / denom;
}
let mut rmat = Array2::<f64>::zeros((order, order));
for i in 0..order {
for j in 0..order {
rmat[[i, j]] = r[(i as isize - j as isize).unsigned_abs()];
}
}
let rhs = r.slice(s![1..]).to_owned();
let phi = solow_linalg::solve(&rmat, &rhs)?;
Ok(phi)
}
fn pacf_ols(x: &Array1<f64>, nlags: usize) -> Result<Array1<f64>> {
let mut out = Array1::<f64>::zeros(nlags + 1);
out[0] = 1.0;
let (xlags, x0) = lagmat1d(x, nlags, Trim::Forward, Original::Sep)?;
let nrows = xlags.nrows();
let mut design = Array2::<f64>::zeros((nrows, nlags + 1));
for i in 0..nrows {
design[[i, 0]] = 1.0;
for j in 0..nlags {
design[[i, j + 1]] = xlags[[i, j]];
}
}
let x0col = x0.column(0).to_owned();
for k in 1..=nlags {
let sub = design.slice(s![k.., ..k + 1]).to_owned();
let yk = x0col.slice(s![k..]).to_owned();
let params = lstsq(&sub, &yk)?;
out[k] = params[params.len() - 1];
}
Ok(out)
}
pub fn ccf(x: &Array1<f64>, y: &Array1<f64>, adjusted: bool) -> Result<Array1<f64>> {
let n = x.len();
if y.len() != n {
return Err(Error::Shape("x and y must have equal length".into()));
}
let mx = mean(x);
let my = mean(y);
let xo = x.mapv(|v| v - mx);
let yo = y.mapv(|v| v - my);
let mut cvf = Array1::<f64>::zeros(n);
for k in 0..n {
let a = xo.slice(s![k..]);
let b = yo.slice(s![..n - k]);
let denom = if adjusted { (n - k) as f64 } else { n as f64 };
cvf[k] = a.dot(&b) / denom;
}
let varx = xo.dot(&xo) / n as f64;
let vary = yo.dot(&yo) / n as f64;
let scale = varx.sqrt() * vary.sqrt();
Ok(cvf.mapv(|v| v / scale))
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AdfRegression {
N,
C,
Ct,
Ctt,
}
impl AdfRegression {
fn trend(self) -> Trend {
match self {
AdfRegression::N => Trend::N,
AdfRegression::C => Trend::C,
AdfRegression::Ct => Trend::Ct,
AdfRegression::Ctt => Trend::Ctt,
}
}
fn ntrend(self) -> usize {
match self {
AdfRegression::N => 0,
AdfRegression::C => 1,
AdfRegression::Ct => 2,
AdfRegression::Ctt => 3,
}
}
pub fn parse(s: &str) -> Result<Self> {
match s {
"n" => Ok(AdfRegression::N),
"c" => Ok(AdfRegression::C),
"ct" => Ok(AdfRegression::Ct),
"ctt" => Ok(AdfRegression::Ctt),
other => Err(Error::Value(format!("unknown regression '{other}'"))),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AutoLag {
None,
Aic,
Bic,
TStat,
}
#[derive(Debug, Clone)]
pub struct AdfResult {
pub adfstat: f64,
pub pvalue: f64,
pub usedlag: usize,
pub nobs: usize,
pub crit_values: [f64; 3],
pub icbest: Option<f64>,
}
pub fn adfuller(
x: &Array1<f64>,
maxlag: usize,
regression: AdfRegression,
autolag: AutoLag,
) -> Result<AdfResult> {
let nobs_full = x.len();
if x.iter().cloned().fold(f64::INFINITY, f64::min)
== x.iter().cloned().fold(f64::NEG_INFINITY, f64::max)
{
return Err(Error::Value("Invalid input, x is constant".into()));
}
let ntrend = regression.ntrend();
if maxlag > nobs_full / 2 - ntrend - 1 {
return Err(Error::Value(
"maxlag must be less than (nobs/2 - 1 - ntrend)".into(),
));
}
let xdiff: Array1<f64> = Array1::from_iter((1..nobs_full).map(|i| x[i] - x[i - 1]));
let (xdall_full, _) = lagmat1d(&xdiff, maxlag, Trim::Both, Original::In)?;
let nobs = xdall_full.nrows();
let mut xdall = xdall_full.clone();
let start_level = nobs_full - nobs - 1;
for i in 0..nobs {
xdall[[i, 0]] = x[start_level + i];
}
let xdshort = xdiff.slice(s![xdiff.len() - nobs..]).to_owned();
let (usedlag, icbest) = match autolag {
AutoLag::None => (maxlag, None),
_ => select_lag(&xdshort, &xdall, regression, maxlag, autolag)?,
};
let (xdall_b_full, _) = lagmat1d(&xdiff, usedlag, Trim::Both, Original::In)?;
let nobs_b = xdall_b_full.nrows();
let mut xdall_b = xdall_b_full.clone();
let start_level_b = nobs_full - nobs_b - 1;
for i in 0..nobs_b {
xdall_b[[i, 0]] = x[start_level_b + i];
}
let xdshort_b = xdiff.slice(s![xdiff.len() - nobs_b..]).to_owned();
let core = xdall_b.slice(s![.., ..usedlag + 1]).to_owned();
let design = add_trend(&core, regression.trend(), false);
let (beta, _ssr, bse) = ols_fit(&xdshort_b, &design)?;
let adfstat = beta[0] / bse[0];
let pvalue = mackinnonp(adfstat, regression);
let crit_values = mackinnoncrit(regression, nobs_b);
Ok(AdfResult {
adfstat,
pvalue,
usedlag,
nobs: nobs_b,
crit_values,
icbest,
})
}
fn select_lag(
xdshort: &Array1<f64>,
xdall: &Array2<f64>,
regression: AdfRegression,
maxlag: usize,
autolag: AutoLag,
) -> Result<(usize, Option<f64>)> {
let full_rhs = if regression != AdfRegression::N {
add_trend(xdall, regression.trend(), true)
} else {
xdall.clone()
};
let startlag = full_rhs.ncols() - xdall.ncols() + 1;
let nobs = xdshort.len() as f64;
let mut best: Option<(f64, usize, Option<f64>)> = None;
let lags: Vec<usize> = (startlag..=startlag + maxlag).collect();
match autolag {
AutoLag::Aic | AutoLag::Bic => {
for &lag in &lags {
let sub = full_rhs.slice(s![.., ..lag]).to_owned();
let (_, ssr, _) = ols_fit(xdshort, &sub)?;
let llf =
-nobs / 2.0 * ((2.0 * std::f64::consts::PI).ln() + (ssr / nobs).ln() + 1.0);
let k = lag as f64;
let ic = match autolag {
AutoLag::Aic => -2.0 * llf + 2.0 * k,
_ => -2.0 * llf + nobs.ln() * k,
};
let better = match best {
None => true,
Some((bic, _, _)) => ic < bic,
};
if better {
best = Some((ic, lag, Some(ic)));
}
}
}
AutoLag::TStat => {
let stop = 1.6448536269514722_f64;
let df_for = |lag: usize| (xdshort.len() - lag) as f64;
let mut chosen = startlag + maxlag;
let mut icval = 0.0;
for lag in (startlag..=startlag + maxlag).rev() {
let sub = full_rhs.slice(s![.., ..lag]).to_owned();
let (beta, _ssr, bse) = ols_fit(xdshort, &sub)?;
let tval = (beta[beta.len() - 1] / bse[bse.len() - 1]).abs();
let _ = df_for;
icval = tval;
chosen = lag;
if tval >= stop {
break;
}
}
best = Some((icval, chosen, Some(icval)));
}
AutoLag::None => unreachable!(),
}
let (_, bestlag, icbest) = best.expect("at least one candidate");
let usedlag = bestlag - startlag;
Ok((usedlag, icbest))
}
fn ols_fit(y: &Array1<f64>, x: &Array2<f64>) -> Result<(Array1<f64>, f64, Array1<f64>)> {
let (n, k) = x.dim();
let xtx = x.t().dot(x);
let xty = x.t().dot(y);
let beta = solow_linalg::solve(&xtx, &xty)?;
let resid = y - &x.dot(&beta);
let ssr = resid.dot(&resid);
let scale = ssr / (n - k) as f64;
let xtx_inv = inv(&xtx)?;
let mut bse = Array1::<f64>::zeros(k);
for j in 0..k {
bse[j] = (scale * xtx_inv[[j, j]]).sqrt();
}
Ok((beta, ssr, bse))
}
fn mackinnon_tables(reg: AdfRegression) -> (f64, f64, f64, [f64; 3], [f64; 4]) {
match reg {
AdfRegression::C => (
2.74,
-18.83,
-1.61,
[2.1659, 1.4412, 0.038269],
[1.7339, 0.93202, -0.12745, -0.010368],
),
AdfRegression::Ct => (
0.7,
-16.18,
-2.89,
[3.2512, 1.6047, 0.049588],
[2.5261, 0.61654, -0.37956, -0.060285],
),
AdfRegression::Ctt => (
0.54,
-17.17,
-3.21,
[4.0003, 1.658, 0.048288],
[3.0778, 0.49529, -0.41477, -0.059359],
),
AdfRegression::N => (
f64::INFINITY,
-19.04,
-1.04,
[0.6344, 1.2378, 0.032496],
[0.4797, 0.93557, -0.06999, 0.033066],
),
}
}
fn mackinnonp(teststat: f64, reg: AdfRegression) -> f64 {
let (maxstat, minstat, starstat, smallp, largep) = mackinnon_tables(reg);
if teststat > maxstat {
return 1.0;
}
if teststat < minstat {
return 0.0;
}
let val = if teststat <= starstat {
polyval(&smallp, teststat)
} else {
polyval(&largep, teststat)
};
norm_cdf(val)
}
fn polyval(coef: &[f64], x: f64) -> f64 {
coef.iter()
.enumerate()
.map(|(i, &c)| c * x.powi(i as i32))
.sum()
}
fn mackinnoncrit(reg: AdfRegression, nobs: usize) -> [f64; 3] {
let table: [[f64; 4]; 3] = match reg {
AdfRegression::N => [
[-2.56574, -2.2358, -3.627, 0.0],
[-1.94100, -0.2686, -3.365, 31.223],
[-1.61682, 0.2656, -2.714, 25.364],
],
AdfRegression::C => [
[-3.43035, -6.5393, -16.786, -79.433],
[-2.86154, -2.8903, -4.234, -40.040],
[-2.56677, -1.5384, -2.809, 0.0],
],
AdfRegression::Ct => [
[-3.95877, -9.0531, -28.428, -134.155],
[-3.41049, -4.3904, -9.036, -45.374],
[-3.12705, -2.5856, -3.925, -22.380],
],
AdfRegression::Ctt => [
[-4.37113, -11.5882, -35.819, -334.047],
[-3.83239, -5.9057, -12.490, -118.284],
[-3.55326, -3.6596, -5.293, -63.559],
],
};
let t = nobs as f64;
let mut out = [0.0; 3];
for (i, row) in table.iter().enumerate() {
out[i] = row[0] + row[1] / t + row[2] / t.powi(2) + row[3] / t.powi(3);
}
out
}
#[cfg(test)]
mod tests {
use super::*;
use ndarray::array;
#[test]
fn acf_lag0_is_one() {
let x = array![1.0, 2.0, 3.0, 2.0, 1.0, 2.0, 3.0, 2.0, 1.0, 2.0];
let a = acf(&x, 3, false).unwrap();
assert!((a[0] - 1.0).abs() < 1e-12);
for v in a.iter() {
assert!(v.abs() <= 1.0 + 1e-12);
}
}
#[test]
fn q_stat_is_monotone_nondecreasing() {
let acf_vals = array![0.5, -0.3, 0.2, 0.1];
let (q, p) = q_stat(&acf_vals, 50);
for k in 1..q.len() {
assert!(q[k] >= q[k - 1] - 1e-12);
}
for v in p.iter() {
assert!((0.0..=1.0).contains(v));
}
}
#[test]
fn pacf_lag0_is_one_both_methods() {
let x = array![0.1, 0.5, 0.2, 0.6, 0.3, 0.7, 0.35, 0.75, 0.4, 0.8, 0.45, 0.85, 0.5, 0.9];
for m in [PacfMethod::YuleWalker, PacfMethod::Ols] {
let p = pacf(&x, 3, m).unwrap();
assert!((p[0] - 1.0).abs() < 1e-12);
}
}
#[test]
fn adfuller_rejects_constant_series() {
let x = Array1::from_elem(20, 3.0);
assert!(adfuller(&x, 2, AdfRegression::C, AutoLag::None).is_err());
}
#[test]
fn acovf_adjusted_uses_smaller_divisor() {
let x = array![1.0, 2.0, 3.0, 4.0, 5.0, 4.0, 3.0, 2.0];
let biased = acovf(&x, false, true, 3).unwrap();
let adjusted = acovf(&x, true, true, 3).unwrap();
assert!((biased[0] - adjusted[0]).abs() < 1e-12);
assert!(adjusted[1].abs() >= biased[1].abs() - 1e-12);
}
}