use ndarray::{Array1, Array2};
use solow_core::error::{Error, Result};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Trim {
None,
Forward,
Backward,
Both,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Original {
Ex,
Sep,
In,
}
pub fn lagmat(
x: &Array2<f64>,
maxlag: usize,
trim: Trim,
original: Original,
) -> Result<(Array2<f64>, Array2<f64>)> {
let (nobs, nvar) = x.dim();
if maxlag >= nobs {
return Err(Error::Value("maxlag should be < nobs".into()));
}
let ncols = nvar * (maxlag + 1);
let mut lm = Array2::<f64>::zeros((nobs + maxlag, ncols));
for k in 0..=maxlag {
let row0 = maxlag - k;
let col0 = nvar * (maxlag - k);
for i in 0..nobs {
for j in 0..nvar {
lm[[row0 + i, col0 + j]] = x[[i, j]];
}
}
}
let (startobs, stopobs) = match trim {
Trim::None => (0usize, nobs + maxlag),
Trim::Forward => (0usize, nobs),
Trim::Backward => (maxlag, nobs + maxlag),
Trim::Both => (maxlag, nobs),
};
let dropidx = match original {
Original::Ex | Original::Sep => nvar,
Original::In => 0,
};
let nrows = stopobs - startobs;
let lag_ncols = ncols - dropidx;
let mut lags = Array2::<f64>::zeros((nrows, lag_ncols));
for i in 0..nrows {
for j in 0..lag_ncols {
lags[[i, j]] = lm[[startobs + i, dropidx + j]];
}
}
let leads = if original == Original::Sep {
let mut leads = Array2::<f64>::zeros((nrows, nvar));
for i in 0..nrows {
for j in 0..nvar {
leads[[i, j]] = lm[[startobs + i, j]];
}
}
leads
} else {
Array2::<f64>::zeros((nrows, 0))
};
Ok((lags, leads))
}
pub fn lagmat1d(
x: &Array1<f64>,
maxlag: usize,
trim: Trim,
original: Original,
) -> Result<(Array2<f64>, Array2<f64>)> {
let col = x.view().insert_axis(ndarray::Axis(1)).to_owned();
lagmat(&col, maxlag, trim, original)
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Trend {
N,
C,
T,
Ct,
Ctt,
}
impl Trend {
pub fn parse(s: &str) -> Result<Self> {
match s {
"n" => Ok(Trend::N),
"c" => Ok(Trend::C),
"t" => Ok(Trend::T),
"ct" => Ok(Trend::Ct),
"ctt" => Ok(Trend::Ctt),
other => Err(Error::Value(format!("unknown trend '{other}'"))),
}
}
}
fn trend_columns(trend: Trend, nobs: usize) -> Array2<f64> {
let specs: &[u8] = match trend {
Trend::N => &[],
Trend::C => &[0],
Trend::T => &[1],
Trend::Ct => &[0, 1],
Trend::Ctt => &[0, 1, 2],
};
let mut out = Array2::<f64>::zeros((nobs, specs.len()));
for i in 0..nobs {
let t = (i + 1) as f64;
for (c, &power) in specs.iter().enumerate() {
out[[i, c]] = t.powi(power as i32);
}
}
out
}
pub fn add_trend(x: &Array2<f64>, trend: Trend, prepend: bool) -> Array2<f64> {
if trend == Trend::N {
return x.clone();
}
let (nobs, nvar) = x.dim();
let tr = trend_columns(trend, nobs);
let ntr = tr.ncols();
let mut out = Array2::<f64>::zeros((nobs, nvar + ntr));
if prepend {
for i in 0..nobs {
for j in 0..ntr {
out[[i, j]] = tr[[i, j]];
}
for j in 0..nvar {
out[[i, ntr + j]] = x[[i, j]];
}
}
} else {
for i in 0..nobs {
for j in 0..nvar {
out[[i, j]] = x[[i, j]];
}
for j in 0..ntr {
out[[i, nvar + j]] = tr[[i, j]];
}
}
}
out
}
#[cfg(test)]
mod tests {
use super::*;
use ndarray::array;
#[test]
fn lagmat_forward_shifts_columns() {
let x = array![[1.0], [2.0], [3.0], [4.0], [5.0]];
let (lags, leads) = lagmat(&x, 2, Trim::Forward, Original::Ex).unwrap();
assert_eq!(lags.dim(), (5, 2));
assert_eq!(leads.ncols(), 0);
assert_eq!(lags[[0, 0]], 0.0);
assert_eq!(lags[[0, 1]], 0.0);
assert_eq!(lags[[2, 0]], 2.0);
assert_eq!(lags[[2, 1]], 1.0);
}
#[test]
fn lagmat_both_drops_padding() {
let x = array![[1.0], [2.0], [3.0], [4.0], [5.0]];
let (lags, _) = lagmat(&x, 2, Trim::Both, Original::Ex).unwrap();
assert_eq!(lags.dim(), (3, 2));
assert_eq!(lags[[0, 0]], 2.0);
assert_eq!(lags[[0, 1]], 1.0);
}
#[test]
fn add_trend_prepend_orders_columns() {
let x = array![[7.0], [8.0], [9.0]];
let out = add_trend(&x, Trend::Ct, true);
assert_eq!(out.dim(), (3, 3));
assert_eq!(out[[0, 0]], 1.0);
assert_eq!(out[[0, 1]], 1.0);
assert_eq!(out[[2, 1]], 3.0);
assert_eq!(out[[2, 2]], 9.0);
}
#[test]
fn add_trend_none_is_identity() {
let x = array![[1.0, 2.0], [3.0, 4.0]];
let out = add_trend(&x, Trend::N, false);
assert_eq!(out, x);
}
#[test]
fn lagmat_rejects_too_large_maxlag() {
let x = array![[1.0], [2.0]];
assert!(lagmat(&x, 2, Trim::Both, Original::Ex).is_err());
}
}