use ndarray::{s, Array1, Array2};
use solow_core::error::{Error, Result};
use solow_distributions::norm_sf;
use solow_linalg::{cholesky, inv};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Trend {
N,
C,
}
impl Trend {
fn order(self) -> usize {
match self {
Trend::N => 0,
Trend::C => 1,
}
}
}
#[derive(Debug, Clone)]
pub struct Var {
endog: Array2<f64>,
trend: Trend,
}
#[derive(Debug, Clone)]
pub struct VarResults {
pub k_ar: usize,
pub neqs: usize,
pub nobs: usize,
pub df_model: usize,
pub df_resid: usize,
pub k_trend: usize,
pub params: Array2<f64>,
pub intercept: Array1<f64>,
pub coefs: Vec<Array2<f64>>,
pub resid: Array2<f64>,
pub fittedvalues: Array2<f64>,
pub sigma_u: Array2<f64>,
pub sigma_u_mle: Array2<f64>,
pub llf: f64,
pub aic: f64,
pub bic: f64,
pub hqic: f64,
pub fpe: f64,
pub bse: Array1Of2,
pub tvalues: Array2<f64>,
pub pvalues: Array2<f64>,
}
type Array1Of2 = Array2<f64>;
impl Var {
pub fn new(endog: Array2<f64>) -> Result<Self> {
Self::with_trend(endog, Trend::C)
}
pub fn with_trend(endog: Array2<f64>, trend: Trend) -> Result<Self> {
let (n, k) = endog.dim();
if k == 0 || n == 0 {
return Err(Error::Value("endog must be non-empty".into()));
}
Ok(Self { endog, trend })
}
fn build(&self, p: usize) -> (Array2<f64>, Array2<f64>) {
let (n, k) = self.endog.dim();
let t = n - p;
let ktrend = self.trend.order();
let df_model = k * p + ktrend;
let mut z = Array2::<f64>::zeros((t, df_model));
let mut y = Array2::<f64>::zeros((t, k));
for i in 0..t {
let row = p + i; for c in 0..k {
y[[i, c]] = self.endog[[row, c]];
}
let mut col = 0;
if ktrend == 1 {
z[[i, col]] = 1.0;
col += 1;
}
for lag in 1..=p {
let src = row - lag;
for c in 0..k {
z[[i, col]] = self.endog[[src, c]];
col += 1;
}
}
}
(z, y)
}
pub fn fit(&self, p: usize) -> Result<VarResults> {
let (n, k) = self.endog.dim();
if p == 0 {
return Err(Error::Value("lag order p must be >= 1".into()));
}
if p >= n {
return Err(Error::Value("lag order p must be smaller than nobs".into()));
}
let ktrend = self.trend.order();
let (z, y) = self.build(p);
let (t, df_model) = z.dim();
if t <= df_model {
return Err(Error::Value(
"not enough observations for the requested lag order".into(),
));
}
let df_resid = t - df_model;
let ztz = z.t().dot(&z);
let ztz_inv = inv(&ztz)?;
let zty = z.t().dot(&y);
let params = ztz_inv.dot(&zty);
let fitted = z.dot(¶ms); let resid = &y - &fitted;
let sse = resid.t().dot(&resid); let tf = t as f64;
let dfr = df_resid as f64;
let sigma_u = sse.mapv(|v| v / dfr);
let sigma_u_mle = sse.mapv(|v| v / tf);
let logdet_mle = logdet_symm(&sigma_u_mle)?;
let kf = k as f64;
let llf =
-(tf * kf / 2.0) * (2.0 * std::f64::consts::PI).ln() - (tf / 2.0) * (logdet_mle + kf);
let free_params = (p * k * k + k * ktrend) as f64;
let aic = logdet_mle + (2.0 / tf) * free_params;
let bic = logdet_mle + (tf.ln() / tf) * free_params;
let hqic = logdet_mle + (2.0 * tf.ln().ln() / tf) * free_params;
let fpe = ((tf + df_model as f64) / dfr).powf(kf) * logdet_mle.exp();
let mut bse = Array2::<f64>::zeros((df_model, k));
for r in 0..df_model {
for c in 0..k {
bse[[r, c]] = (ztz_inv[[r, r]] * sigma_u[[c, c]]).sqrt();
}
}
let tvalues = ¶ms / &bse;
let pvalues = tvalues.mapv(|tv| 2.0 * norm_sf(tv.abs()));
let intercept = if ktrend == 1 {
params.slice(s![0, ..]).to_owned()
} else {
Array1::<f64>::zeros(0)
};
let mut coefs = Vec::with_capacity(p);
for lag in 0..p {
let start = ktrend + lag * k;
let block = params.slice(s![start..start + k, ..]); let mut a = Array2::<f64>::zeros((k, k));
for r in 0..k {
for c in 0..k {
a[[r, c]] = block[[c, r]];
}
}
coefs.push(a);
}
Ok(VarResults {
k_ar: p,
neqs: k,
nobs: t,
df_model,
df_resid,
k_trend: ktrend,
params,
intercept,
coefs,
resid,
fittedvalues: fitted,
sigma_u,
sigma_u_mle,
llf,
aic,
bic,
hqic,
fpe,
bse,
tvalues,
pvalues,
})
}
}
fn logdet_symm(m: &Array2<f64>) -> Result<f64> {
let l = cholesky(m)?;
let n = m.dim().0;
let mut s = 0.0;
for i in 0..n {
s += l[[i, i]].ln();
}
Ok(2.0 * s)
}
#[cfg(test)]
mod tests {
use super::*;
use ndarray::array;
fn small_series() -> Array2<f64> {
array![
[0.5, 1.0],
[0.7, 0.8],
[0.4, 1.2],
[0.9, 0.6],
[0.6, 1.1],
[1.0, 0.5],
[0.7, 0.9],
[1.1, 0.4],
[0.8, 1.0],
[1.2, 0.3],
[0.9, 0.8],
[1.3, 0.5],
]
}
#[test]
fn shapes_and_residual_orthogonality() {
let m = Var::new(small_series()).unwrap();
let res = m.fit(2).unwrap();
assert_eq!(res.neqs, 2);
assert_eq!(res.k_ar, 2);
assert_eq!(res.nobs, 10);
assert_eq!(res.df_model, 5); assert_eq!(res.df_resid, 5);
assert_eq!(res.params.dim(), (5, 2));
assert_eq!(res.coefs.len(), 2);
assert_eq!(res.coefs[0].dim(), (2, 2));
let col_sums = res.resid.sum_axis(ndarray::Axis(0));
for v in col_sums.iter() {
assert!(v.abs() < 1e-10, "residual sum not zero: {v}");
}
}
#[test]
fn sigma_u_scaling_consistent() {
let m = Var::new(small_series()).unwrap();
let res = m.fit(1).unwrap();
let ratio = res.df_resid as f64 / res.nobs as f64;
for i in 0..res.neqs {
for j in 0..res.neqs {
let expect = res.sigma_u[[i, j]] * ratio;
assert!((res.sigma_u_mle[[i, j]] - expect).abs() < 1e-12);
}
}
}
#[test]
fn n_trend_rejects_zero_lag() {
let m = Var::with_trend(small_series(), Trend::N).unwrap();
assert!(m.fit(0).is_err());
let res = m.fit(1).unwrap();
assert_eq!(res.k_trend, 0);
assert_eq!(res.intercept.len(), 0);
}
}