use multisolver::prec::{nan_max, parts};
use multisolver::predict::{hermite, lagrange};
use multisolver::{Double, Native, Precision, Quad, DD};
const N: usize = 6;
fn coef(i: usize, d: usize) -> DD {
let v = ((3 * i + 5 * d) as f64).sin() / (d + 1) as f64;
DD::new(v, v * 1e-17 * (1.0 + i as f64 / 7.0))
}
fn branch<P: Precision<Native>>(deg: usize, p: f64, deriv: bool, scale: f64) -> Vec<Vec<f64>> {
let pp = P::from_dd(DD::from_f64(p));
let v: Vec<P::Scalar> = (0..N)
.map(|i| {
let terms = (0..=deg).rev().filter(|&d| !deriv || d > 0);
let mut s = P::ZERO;
for d in terms {
let c = P::from_dd(coef(i, d))
* if deriv {
P::from_dd(DD::from_f64(d as f64))
} else {
P::ONE
};
s = s * pp + c;
}
s * P::from_dd(DD::new(1.0, scale))
})
.collect();
(0..P::PARTS)
.map(|q| v.iter().map(|&x| P::part(x, q)).collect())
.collect()
}
fn rel<P: Precision<Native>>(a: &[Vec<f64>], b: &[Vec<f64>]) -> f64 {
let sc = |z: &[Vec<f64>], i: usize| P::from_raw(&z.iter().map(|p| p[i]).collect::<Vec<_>>());
let d = (0..N)
.map(|i| P::to_dd(sc(a, i) - sc(b, i)).hi.abs())
.fold(0.0, nan_max);
d / (0..N).map(|i| P::to_dd(sc(b, i)).hi.abs()).fold(0.0, nan_max)
}
#[allow(clippy::type_complexity)]
fn lagrange_at<P: Precision<Native>>(deg: usize) -> (Vec<Vec<f64>>, Vec<Vec<f64>>) {
let ps = [0.1, 0.2, 0.3, 0.4];
let zs: Vec<Vec<Vec<f64>>> = ps.iter().map(|&p| branch::<P>(deg, p, false, 0.0)).collect();
let refs: Vec<Vec<&[f64]>> = zs.iter().map(|z| parts(z)).collect();
let pts: Vec<(f64, &[&[f64]])> = ps.iter().zip(&refs).map(|(&p, r)| (p, &r[..])).collect();
(lagrange::<P>(&pts, 0.55), branch::<P>(deg, 0.55, false, 0.0))
}
fn lagrange_err<P: Precision<Native>>(deg: usize) -> f64 {
let (pred, truth) = lagrange_at::<P>(deg);
rel::<P>(&pred, &truth)
}
#[test]
fn lagrange_is_exact_on_a_cubic_branch() {
let (d, q, c) = (
lagrange_err::<Double>(3),
lagrange_err::<Quad>(3),
lagrange_err::<Double>(4),
);
println!("lagrange: double-double {d:.3e}, quad-double {q:.3e}; control, quartic {c:.3e}");
assert!(d <= 1e-30 && q <= 1e-62);
assert!(c > 1e-8, "control did not fire");
let (mut pred, truth) = lagrange_at::<Quad>(3);
pred[0][2] = f64::NAN;
let e = rel::<Quad>(&pred, &truth);
println!("control, one component NaN: {e:.3e}");
let accurate = |e: f64| e <= 1e-62;
assert!(!accurate(e), "control did not fire");
}
fn hermite_err<P: Precision<Native>>(bump: f64) -> f64 {
let (z0, t0) = (branch::<P>(3, 0.2, false, 0.0), branch::<P>(3, 0.2, true, 0.0));
let (z1, t1) = (branch::<P>(3, 0.5, false, 0.0), branch::<P>(3, 0.5, true, bump));
let h = hermite::<P>((0.2, &parts(&z0), &parts(&t0)), (0.5, &parts(&z1), &parts(&t1)), 0.7);
rel::<P>(&h, &branch::<P>(3, 0.7, false, 0.0))
}
#[test]
fn hermite_is_exact_on_a_cubic_branch() {
let (d, q, c) = (
hermite_err::<Double>(0.0),
hermite_err::<Quad>(0.0),
hermite_err::<Double>(1e-10),
);
println!("hermite: double-double {d:.3e}, quad-double {q:.3e}; control, tangent off by 1e-10 {c:.3e}");
assert!(d <= 1e-30 && q <= 1e-62);
assert!(c > 1e-14, "control did not fire");
}