use ndarray::{Array1, Array2};
use solow_core::error::{Error, Result};
use crate::filter::{hamilton_filter, kim_smoother};
use crate::switching::{
maximize, ols, steady_state, transform_transition, transition_matrix, transition_param_names,
untransform_transition, var_pop, MarkovResults,
};
#[derive(Clone, Debug)]
pub struct MarkovRegression {
endog: Array1<f64>,
exog: Array2<f64>,
k_regimes: usize,
k_exog: usize,
switching_variance: bool,
maxiter: usize,
}
impl MarkovRegression {
pub fn new(endog: Array1<f64>, k_regimes: usize, switching_variance: bool) -> Result<Self> {
let n = endog.len();
let exog = Array2::<f64>::ones((n, 1));
Self::with_exog(endog, exog, k_regimes, switching_variance)
}
pub fn with_exog(
endog: Array1<f64>,
exog: Array2<f64>,
k_regimes: usize,
switching_variance: bool,
) -> Result<Self> {
if k_regimes < 2 {
return Err(Error::Value("k_regimes must be >= 2".into()));
}
if endog.len() != exog.nrows() {
return Err(Error::Shape("endog length != exog rows".into()));
}
let k_exog = exog.ncols();
Ok(MarkovRegression {
endog,
exog,
k_regimes,
k_exog,
switching_variance,
maxiter: 2000,
})
}
fn k_trans(&self) -> usize {
self.k_regimes * (self.k_regimes - 1)
}
fn k_mean(&self) -> usize {
self.k_regimes * self.k_exog
}
fn k_var(&self) -> usize {
if self.switching_variance {
self.k_regimes
} else {
1
}
}
fn k_params(&self) -> usize {
self.k_trans() + self.k_mean() + self.k_var()
}
fn param_names(&self) -> Vec<String> {
let k = self.k_regimes;
let mut names = transition_param_names(k);
let exog_name = |c: usize| {
if c == 0 {
"const".to_string()
} else {
format!("x{c}")
}
};
for i in 0..k {
for c in 0..self.k_exog {
names.push(format!("{}[{i}]", exog_name(c)));
}
}
if self.switching_variance {
for i in 0..k {
names.push(format!("sigma2[{i}]"));
}
} else {
names.push("sigma2".to_string());
}
names
}
fn transform(&self, u: &Array1<f64>) -> Array1<f64> {
let k = self.k_regimes;
let mut c = u.clone();
transform_transition(&mut c, u, k);
let var_start = self.k_trans() + self.k_mean();
for idx in var_start..self.k_params() {
c[idx] = u[idx] * u[idx];
}
c
}
fn untransform(&self, c: &Array1<f64>) -> Array1<f64> {
let k = self.k_regimes;
let mut u = c.clone();
untransform_transition(&mut u, c, k);
let var_start = self.k_trans() + self.k_mean();
for idx in var_start..self.k_params() {
u[idx] = c[idx].sqrt();
}
u
}
fn conditional_loglik(&self, c: &Array1<f64>) -> Array2<f64> {
let k = self.k_regimes;
let n = self.endog.len();
let mean_start = self.k_trans();
let var_start = self.k_trans() + self.k_mean();
let mut cll = Array2::<f64>::zeros((k, n));
let two_pi = std::f64::consts::TAU;
for i in 0..k {
let beta_start = mean_start + i * self.k_exog;
let variance = if self.switching_variance {
c[var_start + i]
} else {
c[var_start]
};
for t in 0..n {
let mut yhat = 0.0;
for ci in 0..self.k_exog {
yhat += self.exog[[t, ci]] * c[beta_start + ci];
}
let resid = self.endog[t] - yhat;
cll[[i, t]] = -0.5 * resid * resid / variance - 0.5 * (two_pi * variance).ln();
}
}
cll
}
fn neg_loglike(&self, u: &Array1<f64>) -> Result<f64> {
let c = self.transform(u);
let c_s = c
.as_slice()
.ok_or_else(|| Error::Value("params must be contiguous".into()))?;
let p = transition_matrix(c_s, self.k_regimes);
let init = steady_state(&p)?;
let cll = self.conditional_loglik(&c);
let out = hamilton_filter(&init, &p, &cll, 0);
Ok(-out.llf)
}
fn start_params(&self) -> Result<Array1<f64>> {
let k = self.k_regimes;
let mut c = Array1::<f64>::zeros(self.k_params());
for j in 0..k {
for i in 0..(k - 1) {
c[j * (k - 1) + i] = 1.0 / k as f64;
}
}
let beta = ols(&self.exog, &self.endog)?;
let yhat = self.exog.dot(&beta);
let resid = &self.endog - &yhat;
let variance = var_pop(&resid);
let mean_start = self.k_trans();
for i in 0..k {
let frac = i as f64 / k as f64;
for ci in 0..self.k_exog {
c[mean_start + i * self.k_exog + ci] = beta[ci] * frac;
}
}
let var_start = self.k_trans() + self.k_mean();
if self.switching_variance {
for i in 0..k {
let t = if k == 1 {
0.0
} else {
i as f64 / (k as f64 - 1.0)
};
c[var_start + i] = variance / 10.0 + t * (variance - variance / 10.0);
}
} else {
c[var_start] = variance;
}
Ok(c)
}
pub fn fit(&self) -> Result<MarkovResults> {
self.fit_from(None)
}
pub fn fit_from(&self, start_constrained: Option<Array1<f64>>) -> Result<MarkovResults> {
let start_c = match start_constrained {
Some(c) => c,
None => self.start_params()?,
};
let start_u = self.untransform(&start_c);
let (xopt, _negll, converged) = maximize(
&start_u,
|u| self.neg_loglike(u).unwrap_or(1e10),
self.maxiter,
);
let c = self.transform(&xopt);
let c_s = c
.as_slice()
.ok_or_else(|| Error::Value("params must be contiguous".into()))?;
let p = transition_matrix(c_s, self.k_regimes);
let init = steady_state(&p)?;
let cll = self.conditional_loglik(&c);
let out = hamilton_filter(&init, &p, &cll, 0);
let smoothed = kim_smoother(&p, &out, self.k_regimes, 0);
Ok(MarkovResults::new(
c,
self.param_names(),
out.llf,
self.endog.len(),
p,
init,
out.filtered_marginal,
smoothed,
converged,
))
}
}