use ndarray::{Array1, Array2};
use solow_core::error::{Error, Result};
use solow_linalg::solve;
pub fn hpfilter(x: &Array1<f64>, lamb: f64) -> Result<(Array1<f64>, Array1<f64>)> {
let nobs = x.len();
if nobs < 3 {
return Err(Error::Value(
"hpfilter requires at least 3 observations".into(),
));
}
let mut a = Array2::<f64>::zeros((nobs, nobs));
for i in 0..nobs {
a[[i, i]] += 1.0;
}
let kcoef = [1.0_f64, -2.0, 1.0];
for r in 0..(nobs - 2) {
for (di, &ci) in kcoef.iter().enumerate() {
for (dj, &cj) in kcoef.iter().enumerate() {
a[[r + di, r + dj]] += lamb * ci * cj;
}
}
}
let trend = solve(&a, x)?;
let cycle = x - &trend;
Ok((cycle, trend))
}
fn bk_weights(low: f64, high: f64, k: usize) -> Array1<f64> {
let omega_1 = 2.0 * std::f64::consts::PI / high;
let omega_2 = 2.0 * std::f64::consts::PI / low;
let n = 2 * k + 1;
let mut b = Array1::<f64>::zeros(n);
b[k] = (omega_2 - omega_1) / std::f64::consts::PI;
for j in 1..=k {
let jf = j as f64;
let w = 1.0 / (std::f64::consts::PI * jf) * ((omega_2 * jf).sin() - (omega_1 * jf).sin());
b[k + j] = w;
b[k - j] = w; }
let mean = b.sum() / n as f64;
b.mapv_inplace(|v| v - mean);
b
}
pub fn bkfilter(x: &Array1<f64>, low: f64, high: f64, k: usize) -> Result<Array1<f64>> {
let nobs = x.len();
if nobs <= 2 * k {
return Err(Error::Value(
"bkfilter requires nobs > 2K observations".into(),
));
}
let weights = bk_weights(low, high, k);
let m = weights.len(); let out_len = nobs - 2 * k;
let mut y = Array1::<f64>::zeros(out_len);
for i in 0..out_len {
let mut s = 0.0;
for j in 0..m {
s += weights[j] * x[i + j];
}
y[i] = s;
}
Ok(y)
}
pub fn cffilter(
x: &Array1<f64>,
low: f64,
high: f64,
drift: bool,
) -> Result<(Array1<f64>, Array1<f64>)> {
if low < 2.0 {
return Err(Error::Value("low must be >= 2".into()));
}
let nobs = x.len();
if nobs < 2 {
return Err(Error::Value(
"cffilter requires at least 2 observations".into(),
));
}
let a = 2.0 * std::f64::consts::PI / high;
let b = 2.0 * std::f64::consts::PI / low;
let mut xa = x.clone();
if drift {
let slope = (x[nobs - 1] - x[0]) / (nobs as f64 - 1.0);
for t in 0..nobs {
xa[t] = x[t] - (t as f64) * slope;
}
}
let mut bj = Array1::<f64>::zeros(nobs + 1);
bj[0] = (b - a) / std::f64::consts::PI;
for j in 1..=nobs {
let jf = j as f64;
bj[j] = ((b * jf).sin() - (a * jf).sin()) / (std::f64::consts::PI * jf);
}
let mut y = Array1::<f64>::zeros(nobs);
let xv = &xa;
for i in 0..nobs {
let mid_stop_signed = nobs as isize - 1 - i as isize;
let mid_stop = if mid_stop_signed > 1 {
mid_stop_signed as usize
} else {
1
};
let mut sum_mid = 0.0;
for idx in 1..mid_stop {
sum_mid += bj[idx];
}
let bcoef = -0.5 * bj[0] - sum_mid;
let mut sum_low = 0.0;
for idx in 1..i {
sum_low += bj[idx];
}
let acoef = -bj[0] - sum_mid - sum_low - bcoef;
let mut val = bj[0] * xv[i] + bcoef * xv[nobs - 1] + acoef * xv[0];
for (off, idx) in (1..mid_stop).enumerate() {
val += bj[idx] * xv[i + 1 + off];
}
for idx in 1..i {
val += bj[idx] * xv[i - idx];
}
y[i] = val;
}
let trend = xa - &y;
Ok((y, trend))
}
#[cfg(test)]
mod tests {
use super::*;
use ndarray::Array1;
#[test]
fn hp_cycle_plus_trend_reconstructs_input() {
let x = Array1::from_vec(vec![
1.0, 2.0, 1.5, 3.0, 2.5, 4.0, 3.5, 5.0, 4.5, 6.0, 5.5, 7.0,
]);
let (cycle, trend) = hpfilter(&x, 1600.0).unwrap();
for i in 0..x.len() {
assert!((cycle[i] + trend[i] - x[i]).abs() < 1e-12);
}
}
#[test]
fn hp_trend_is_linear_for_linear_input() {
let x: Array1<f64> = Array1::from_iter((0..20).map(|i| 2.0 * i as f64 + 1.0));
let (cycle, trend) = hpfilter(&x, 1600.0).unwrap();
for i in 0..x.len() {
assert!(cycle[i].abs() < 1e-7, "cycle[{i}] = {}", cycle[i]);
assert!((trend[i] - x[i]).abs() < 1e-7);
}
}
#[test]
fn bk_weights_sum_to_zero() {
let w = bk_weights(6.0, 32.0, 12);
assert_eq!(w.len(), 25);
assert!(w.sum().abs() < 1e-12);
for j in 1..=12 {
assert!((w[12 + j] - w[12 - j]).abs() < 1e-15);
}
}
#[test]
fn bk_output_length() {
let x: Array1<f64> = Array1::from_iter((0..40).map(|i| (i as f64 * 0.3).sin()));
let c = bkfilter(&x, 6.0, 32.0, 12).unwrap();
assert_eq!(c.len(), 40 - 24);
}
#[test]
fn cf_cycle_plus_trend_reconstructs_adjusted_input() {
let x = Array1::from_vec(vec![
1.0, 1.4, 0.9, 2.1, 1.7, 2.6, 2.0, 3.1, 2.5, 3.6, 3.0, 4.1,
]);
let (cycle, trend) = cffilter(&x, 6.0, 32.0, true).unwrap();
let slope = (x[x.len() - 1] - x[0]) / (x.len() as f64 - 1.0);
for i in 0..x.len() {
let xa = x[i] - i as f64 * slope;
assert!((cycle[i] + trend[i] - xa).abs() < 1e-12);
}
}
#[test]
fn cf_rejects_low_below_two() {
let x = Array1::from_vec(vec![1.0, 2.0, 3.0, 4.0]);
assert!(cffilter(&x, 1.5, 10.0, true).is_err());
}
}