use crate::OdeError;
use crate::RhsCallable;
use crate::linalg::DMat;
use crate::problem::OdeProblemBuilder;
use crate::solver::Method;
pub struct SensitivityResult {
pub t: Vec<f64>,
pub states: Vec<Vec<f64>>,
pub sensitivities: Vec<Vec<f64>>,
}
#[allow(clippy::too_many_arguments)]
pub fn forward_sensitivities<F>(
f: F,
y0: &[f64],
p: &[f64],
t0: f64,
t_final: f64,
method: Method,
rtol: f64,
atol: f64,
t_eval: Option<&[f64]>,
) -> Result<SensitivityResult, OdeError>
where
F: Fn(f64, &[f64], &[f64], &mut [f64]) + 'static,
{
let n = y0.len();
let np = p.len();
let aug = n + n * np; let p_owned = p.to_vec();
struct AugRhs<F> {
f: F,
p: Vec<f64>,
n: usize,
np: usize,
}
impl<F> RhsCallable for AugRhs<F>
where
F: Fn(f64, &[f64], &[f64], &mut [f64]),
{
fn nstates(&self) -> usize {
0
}
fn call(&self, t: f64, z: &[f64], dydz: &mut [f64]) -> Result<(), OdeError> {
let n = self.n;
let np = self.np;
let y = &z[..n];
let s = &z[n..];
let mut dydt = vec![0.0; n];
(self.f)(t, y, &self.p, &mut dydt);
dydz[..n].copy_from_slice(&dydt);
let sqrt_eps = f64::sqrt(f64::EPSILON);
let mut jac = DMat::new(n, n);
for c in 0..n {
let dy = sqrt_eps * y[c].abs().max(1.0);
let mut yp = y.to_vec();
yp[c] += dy;
let mut fp = vec![0.0; n];
(self.f)(t, &yp, &self.p, &mut fp);
let inv = 1.0 / dy;
for r in 0..n {
jac.set(r, c, (fp[r] - dydt[r]) * inv);
}
}
let mut fp_grad = DMat::new(n, np);
for c in 0..np {
let dp = sqrt_eps * self.p[c].abs().max(1.0);
let mut pp = self.p.clone();
pp[c] += dp;
let mut fp = vec![0.0; n];
(self.f)(t, y, &pp, &mut fp);
let inv = 1.0 / dp;
for r in 0..n {
fp_grad.set(r, c, (fp[r] - dydt[r]) * inv);
}
}
for i in 0..n {
for k in 0..np {
let mut acc = fp_grad.get(i, k);
for j in 0..n {
acc += jac.get(i, j) * s[j * np + k];
}
dydz[n + i * np + k] = acc;
}
}
Ok(())
}
}
let aug_rhs = AugRhs {
f,
p: p_owned,
n,
np,
};
let mut z0 = vec![0.0; aug];
z0[..n].copy_from_slice(y0);
let eval_times: Vec<f64> = match t_eval {
Some(te) => te.to_vec(),
None => vec![t_final],
};
let prob = OdeProblemBuilder::from_rhs(aug_rhs, z0, t0)
.rtol(rtol)
.atol(atol)
.build()?;
let aug_traj = prob.solve_dense(method, &eval_times)?;
let mut t = Vec::new();
let mut states = Vec::new();
let mut sensitivities = Vec::new();
for (idx, z) in aug_traj.iter().enumerate() {
t.push(eval_times[idx]);
states.push(z[..n].to_vec());
sensitivities.push(z[n..].to_vec());
}
Ok(SensitivityResult {
t,
states,
sensitivities,
})
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn sensitivity_of_exponential_decay() {
let res = forward_sensitivities(
|_t, y, p, dydt| {
dydt[0] = -p[0] * y[0];
},
&[1.0],
&[2.0],
0.0,
1.0,
Method::Tsit45,
1e-8,
1e-8,
Some(&[1.0]),
)
.unwrap();
let y = res.states[0][0];
let expected_y = (-2.0_f64).exp();
assert!((y - expected_y).abs() < 1e-5);
let s = res.sensitivities[0][0];
let expected_s = -expected_y; assert!((s - expected_s).abs() < 1e-4);
}
#[test]
fn sensitivity_of_linear_param() {
let res = forward_sensitivities(
|_t, _y, p, dydt| {
dydt[0] = p[0];
},
&[0.0],
&[3.0],
0.0,
2.0,
Method::Tsit45,
1e-8,
1e-8,
Some(&[2.0]),
)
.unwrap();
assert!((res.states[0][0] - 6.0).abs() < 1e-6);
assert!((res.sensitivities[0][0] - 2.0).abs() < 1e-6); }
}