use super::dense::{add, identity, inf_norm, mul, scale, sub};
use crate::domain::real::RealScalar;
use leto::{Array2, ArrayView2, LetoError, Result};
const PADE_Q: usize = 6;
const _: () = assert!(PADE_Q == 6, "even/odd Padé split is unrolled for q = 6");
const SCALE_THRESHOLD: f64 = 0.5;
const MAX_SCALE: u32 = 1023;
pub fn matexp<T: RealScalar>(matrix: &ArrayView2<'_, T>) -> Result<Array2<T>> {
let [rows, cols] = matrix.shape();
if rows != cols {
return Err(LetoError::ShapeMismatch {
lhs: vec![rows, cols],
rhs: vec![rows, rows],
});
}
let is_finite = if let Some(slice) = matrix.as_slice() {
slice.iter().all(|x| x.is_finite())
} else {
matrix.iter().all(|x| x.is_finite())
};
if !is_finite {
return Err(LetoError::StorageError {
reason: "matrix exponential requires finite entries".to_string(),
});
}
if rows == 0 {
return Ok(Array2::from_shape_vec([0, 0], vec![]).expect("empty shape matches empty vec"));
}
let half = T::from_f64(SCALE_THRESHOLD);
let two = T::from_f64(2.0);
let mut scaled_norm = inf_norm(matrix);
let mut s: u32 = 0;
while scaled_norm > half {
scaled_norm = scaled_norm.div(two);
s += 1;
if s > MAX_SCALE {
return Err(LetoError::StorageError {
reason: "matrix exponential scaling exponent overflow".to_string(),
});
}
}
let b = scale(matrix, T::from_f64(2f64.powi(-(s as i32))));
let c = pade_coefficients::<T>();
let id = identity::<T>(rows);
let b2 = mul(&b.view(), &b.view())?;
let b4 = mul(&b2.view(), &b2.view())?;
let b6 = mul(&b2.view(), &b4.view())?;
let u_even = add(
&add(
&add(
&scale(&id.view(), c[0]).view(),
&scale(&b2.view(), c[2]).view(),
)
.view(),
&scale(&b4.view(), c[4]).view(),
)
.view(),
&scale(&b6.view(), c[6]).view(),
);
let v_odd = add(
&add(
&scale(&id.view(), c[1]).view(),
&scale(&b2.view(), c[3]).view(),
)
.view(),
&scale(&b4.view(), c[5]).view(),
);
let bv = mul(&b.view(), &v_odd.view())?;
let numerator = add(&u_even.view(), &bv.view());
let denominator = sub(&u_even.view(), &bv.view());
let inv_denominator = crate::application::linalg::lu::inv(&denominator.view())?;
let mut result = mul(&inv_denominator.view(), &numerator.view())?;
for _ in 0..s {
result = mul(&result.view(), &result.view())?;
}
Ok(result)
}
fn pade_coefficients<T: RealScalar>() -> [T; PADE_Q + 1] {
let q = PADE_Q as f64;
let mut c = [0.0f64; PADE_Q + 1];
c[0] = 1.0;
for k in 1..=PADE_Q {
let kf = k as f64;
c[k] = c[k - 1] * (q - kf + 1.0) / (kf * (2.0 * q - kf + 1.0));
}
let mut out = [T::ZERO; PADE_Q + 1];
for (slot, &value) in out.iter_mut().zip(c.iter()) {
*slot = T::from_f64(value);
}
out
}