use crate::newton::exact;
use crate::prec::{max_abs, parts};
use crate::{Jvp, ResidualJet};
use multidouble::dd::DD;
use multidouble::precision::Precision;
use multidouble::simd::Native;
#[derive(Clone, Debug)]
pub struct Branch<P: Precision<Native>> {
pub z: Vec<Vec<P::Scalar>>,
pub residual: Vec<f64>,
}
fn to_parts<P: Precision<Native>>(v: &[P::Scalar]) -> Vec<Vec<f64>> {
(0..P::PARTS)
.map(|q| v.iter().map(|&x| P::part(x, q)).collect())
.collect()
}
pub fn series<P: Precision<Native>, Pr: ResidualJet<P> + Jvp<P> + ?Sized>(
pr: &Pr,
z0: &[&[f64]],
order: usize,
refine: usize,
par: bool,
) -> Result<Branch<P>, String> {
let lu = exact::<P, Pr>(pr, z0, par)?.0;
let mut orders = pr.jet_orders(order)?;
let mut last: Vec<Vec<f64>> = z0.iter().map(|p| p.to_vec()).collect();
let mut br = Branch {
z: vec![(0..pr.len())
.map(|i| P::from_raw(&z0.iter().map(|p| p[i]).collect::<Vec<_>>()))
.collect()],
residual: Vec::new(),
};
for _ in 1..=order {
let f = orders.next(&parts(&last), par)?;
let b: Vec<P::Scalar> = f.iter().map(|&v| -v).collect();
let mut x = b.clone();
P::lu_solve(&lu, &mut x);
let resid = |x: &[P::Scalar]| -> Result<Vec<P::Scalar>, String> {
let jx = pr.jvp(z0, &parts(&to_parts::<P>(x)), par)?;
Ok(b.iter().zip(&jx).map(|(&bi, &ji)| bi - ji).collect())
};
for _ in 0..refine {
let mut r = resid(&x)?;
P::lu_solve(&lu, &mut r);
x.iter_mut().zip(&r).for_each(|(xi, &ri)| *xi = *xi + ri);
}
let nb = max_abs::<P>(&b);
br.residual.push(if refine > 0 {
max_abs::<P>(&resid(&x)?) / if nb.is_nan() { nb } else { nb.max(f64::MIN_POSITIVE) }
} else {
f64::NAN
});
last = to_parts::<P>(&x);
br.z.push(x);
}
Ok(br)
}
impl<P: Precision<Native>> Branch<P> {
pub fn order(&self) -> usize {
self.z.len() - 1
}
pub fn eval(&self, a: f64) -> Vec<P::Scalar> {
let a = P::from_dd(DD::from_f64(a));
let mut out = self.z[self.order()].clone();
for zk in self.z.iter().rev().skip(1) {
out.iter_mut().zip(zk).for_each(|(o, &c)| *o = *o * a + c);
}
out
}
pub fn eval_parts(&self, a: f64) -> Vec<Vec<f64>> {
to_parts::<P>(&self.eval(a))
}
pub fn radius(&self, delta: f64) -> f64 {
let n = self.order();
assert!(n >= 2, "radius: the series needs order 2 or more, not {n}");
let last = max_abs::<P>(&self.z[n]);
if last == 0.0 {
return f64::INFINITY;
}
(delta * max_abs::<P>(&self.z[1]) / last).powf(1.0 / (n - 1) as f64)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::Double;
#[test]
fn radius_and_eval_of_a_geometric_series() {
let r = 0.25f64;
let z: Vec<Vec<DD>> = (0..=6).map(|k| vec![DD::from_f64(r.powi(-k))]).collect();
let br = Branch::<Double> { z, residual: vec![] };
let want = 1e-8f64.powf(1.0 / 5.0) * r;
let radius_ok = |b: &Branch<Double>| (b.radius(1e-8) / want - 1.0).abs() < 1e-14;
let a = 0.1;
let sum: f64 = (0..=6).map(|k| (a / r).powi(k)).sum();
let eval_ok = |b: &Branch<Double>| (b.eval(a)[0].hi / sum - 1.0).abs() < 1e-15;
assert!(radius_ok(&br) && eval_ok(&br), "{}", br.radius(1e-8));
let short = Branch::<Double> {
z: br.z[..6].to_vec(),
residual: vec![],
};
assert!(!radius_ok(&short), "radius control did not fire");
assert!(!eval_ok(&short), "eval control did not fire");
}
#[test]
fn radius_of_a_constant_branch() {
let br = |z1: f64, z2: f64| Branch::<Double> {
z: vec![vec![DD::ONE], vec![DD::from_f64(z1)], vec![DD::from_f64(z2)]],
residual: vec![],
};
assert_eq!(br(0.0, 0.0).radius(1e-8), f64::INFINITY);
assert!(br(f64::NAN, 1.0).radius(1e-8).is_nan());
assert!(br(0.0, 1e-300).radius(1e-8).is_finite(), "control did not fire");
}
}