use ndarray::{Array1, Array2};
use solow_core::error::{Error, Result};
use solow_linalg::{pinv, solve};
use solow_optimize::{approx_fprime, approx_hess, minimize_bfgs};
pub(crate) fn logsumexp(x: &[f64]) -> f64 {
let m = x.iter().cloned().fold(f64::NEG_INFINITY, f64::max);
if !m.is_finite() {
return m;
}
let s: f64 = x.iter().map(|&v| (v - m).exp()).sum();
m + s.ln()
}
pub(crate) fn transition_matrix(trans: &[f64], k: usize) -> Array2<f64> {
let mut p = Array2::<f64>::zeros((k, k));
let mut col_sum = vec![0.0f64; k];
for i in 0..(k - 1) {
for j in 0..k {
let v = trans[i * k + j];
p[[i, j]] = v;
col_sum[j] += v;
}
}
for j in 0..k {
p[[k - 1, j]] = 1.0 - col_sum[j];
}
p
}
pub(crate) fn steady_state(p: &Array2<f64>) -> Result<Array1<f64>> {
let k = p.nrows();
let mut a = Array2::<f64>::zeros((k + 1, k));
for i in 0..k {
for j in 0..k {
let id = if i == j { 1.0 } else { 0.0 };
a[[i, j]] = id - p[[i, j]];
}
}
for j in 0..k {
a[[k, j]] = 1.0;
}
let (pinv_a, _sv) = pinv(&a)?;
let mut pi = Array1::<f64>::zeros(k);
for i in 0..k {
pi[i] = pinv_a[[i, k]];
}
for v in pi.iter_mut() {
if *v < 1e-20 {
*v = 1e-20;
}
}
Ok(pi)
}
pub(crate) fn logistic_column(unconstrained: &[f64]) -> Vec<f64> {
let mut padded = Vec::with_capacity(unconstrained.len() + 1);
padded.push(0.0);
padded.extend_from_slice(unconstrained);
let denom = logsumexp(&padded);
unconstrained.iter().map(|&u| (u - denom).exp()).collect()
}
pub(crate) fn inv_logistic_scalar(c: f64) -> f64 {
-((1.0 / c) - 1.0).ln()
}
fn trans_index(i: usize, j: usize, k: usize) -> usize {
i * k + j
}
pub(crate) fn transition_param_names(k: usize) -> Vec<String> {
let mut names = Vec::with_capacity(k * (k - 1));
for i in 0..(k - 1) {
for j in 0..k {
names.push(format!("p[{j}->{i}]"));
}
}
names
}
pub(crate) fn transform_transition(out: &mut Array1<f64>, u: &Array1<f64>, k: usize) {
for j in 0..k {
let col: Vec<f64> = (0..(k - 1)).map(|i| u[trans_index(i, j, k)]).collect();
let probs = logistic_column(&col);
for (i, &p) in probs.iter().enumerate() {
out[trans_index(i, j, k)] = p;
}
}
}
pub(crate) fn untransform_transition(out: &mut Array1<f64>, c: &Array1<f64>, k: usize) {
for j in 0..k {
if k == 2 {
let idx = trans_index(0, j, k);
out[idx] = inv_logistic_scalar(c[idx]);
} else {
let probs: Vec<f64> = (0..(k - 1)).map(|i| c[trans_index(i, j, k)]).collect();
let unc = inv_logistic_general(&probs);
for (i, &v) in unc.iter().enumerate() {
out[trans_index(i, j, k)] = v;
}
}
}
}
fn inv_logistic_general(probs: &[f64]) -> Vec<f64> {
let rem: f64 = 1.0 - probs.iter().sum::<f64>();
let base = rem.max(1e-20).ln();
probs.iter().map(|&c| c.max(1e-20).ln() - base).collect()
}
#[derive(Clone, Debug)]
pub struct MarkovResults {
pub params: Array1<f64>,
pub param_names: Vec<String>,
pub llf: f64,
pub nobs: usize,
pub k_params: usize,
pub aic: f64,
pub bic: f64,
pub converged: bool,
pub transition: Array2<f64>,
pub initial_probabilities: Array1<f64>,
pub filtered_marginal_probabilities: Array2<f64>,
pub smoothed_marginal_probabilities: Array2<f64>,
pub expected_durations: Array1<f64>,
}
impl MarkovResults {
#[allow(clippy::too_many_arguments)]
pub(crate) fn new(
params: Array1<f64>,
param_names: Vec<String>,
llf: f64,
nobs: usize,
transition: Array2<f64>,
initial_probabilities: Array1<f64>,
filtered: Array2<f64>,
smoothed: Array2<f64>,
converged: bool,
) -> Self {
let k_params = params.len();
let aic = 2.0 * k_params as f64 - 2.0 * llf;
let bic = (k_params as f64) * (nobs as f64).ln() - 2.0 * llf;
let k = transition.nrows();
let mut expected_durations = Array1::<f64>::zeros(k);
for i in 0..k {
let stay = transition[[i, i]];
expected_durations[i] = if (1.0 - stay).abs() < 1e-300 {
f64::INFINITY
} else {
1.0 / (1.0 - stay)
};
}
MarkovResults {
params,
param_names,
llf,
nobs,
k_params,
aic,
bic,
converged,
transition,
initial_probabilities,
filtered_marginal_probabilities: filtered,
smoothed_marginal_probabilities: smoothed,
expected_durations,
}
}
}
pub(crate) fn ols(x: &Array2<f64>, y: &Array1<f64>) -> Result<Array1<f64>> {
if x.nrows() != y.len() {
return Err(Error::Shape("ols: rows mismatch".into()));
}
let (pinv_x, _sv) = pinv(x)?;
Ok(pinv_x.dot(y))
}
pub(crate) fn var_pop(r: &Array1<f64>) -> f64 {
let n = r.len() as f64;
let mean = r.sum() / n;
r.iter().map(|&v| (v - mean) * (v - mean)).sum::<f64>() / n
}
pub(crate) fn maximize<F>(
start_u: &Array1<f64>,
neg_loglike: F,
maxiter: usize,
) -> (Array1<f64>, f64, bool)
where
F: Fn(&Array1<f64>) -> f64,
{
let f = |u: &Array1<f64>| {
let v = neg_loglike(u);
if v.is_finite() {
v
} else {
1e10
}
};
let g = |u: &Array1<f64>| approx_fprime(u, |x| f(x));
let mut x = match minimize_bfgs(start_u, |u| f(u), |u| g(u), maxiter, 1e-8) {
Ok(r) => r.x,
Err(_) => start_u.clone(),
};
let mut fval = f(&x);
let mut grad = g(&x);
let mut gnorm = grad.dot(&grad).sqrt();
for _ in 0..100 {
if gnorm < 1e-7 {
break;
}
let h = approx_hess(&x, |u| f(u));
let step = match solve(&h, &grad) {
Ok(s) => s,
Err(_) => break,
};
let mut alpha = 1.0;
let mut improved = false;
for _ in 0..40 {
let cand = &x - &(alpha * &step);
let fc = f(&cand);
if fc < fval - 1e-12 * (1.0 + fval.abs()) {
x = cand;
fval = fc;
improved = true;
break;
}
alpha *= 0.5;
}
if !improved {
break;
}
grad = g(&x);
gnorm = grad.dot(&grad).sqrt();
}
let converged = gnorm < 1e-6;
(x, fval, converged)
}
#[cfg(test)]
mod tests {
use super::*;
use ndarray::array;
#[test]
fn transition_matrix_row_major_k3() {
let trans = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6];
let p = transition_matrix(&trans, 3);
assert_eq!(p[[0, 0]], 0.1);
assert_eq!(p[[0, 1]], 0.2);
assert_eq!(p[[0, 2]], 0.3);
assert_eq!(p[[1, 0]], 0.4);
assert_eq!(p[[1, 1]], 0.5);
assert_eq!(p[[1, 2]], 0.6);
for j in 0..3 {
let s: f64 = (0..3).map(|i| p[[i, j]]).sum();
assert!((s - 1.0).abs() < 1e-15);
}
}
#[test]
fn steady_state_is_stationary() {
let p = array![[0.9, 0.2], [0.1, 0.8]];
let pi = steady_state(&p).unwrap();
let ppi = p.dot(&pi);
for i in 0..2 {
assert!((ppi[i] - pi[i]).abs() < 1e-12);
}
assert!((pi.sum() - 1.0).abs() < 1e-12);
let want0 = 0.2 / (0.1 + 0.2);
assert!((pi[0] - want0).abs() < 1e-9);
}
#[test]
fn logistic_roundtrip_k2() {
let u = array![0.7, -1.3];
let mut c = u.clone();
transform_transition(&mut c, &u, 2);
assert!(c[0] > 0.0 && c[0] < 1.0);
assert!(c[1] > 0.0 && c[1] < 1.0);
let mut back = c.clone();
untransform_transition(&mut back, &c, 2);
assert!((back[0] - u[0]).abs() < 1e-10);
assert!((back[1] - u[1]).abs() < 1e-10);
}
#[test]
fn logistic_roundtrip_k3() {
let u = array![0.3, -0.5, 1.1, -0.2, 0.6, 0.1];
let mut c = u.clone();
transform_transition(&mut c, &u, 3);
for j in 0..3 {
let s = c[j] + c[3 + j];
assert!(s < 1.0 && s > 0.0, "column {j} sum {s}");
}
let mut back = c.clone();
untransform_transition(&mut back, &c, 3);
for i in 0..6 {
assert!(
(back[i] - u[i]).abs() < 1e-9,
"idx {i}: {} vs {}",
back[i],
u[i]
);
}
}
}