use trading_data_expr::{Expr, Vars, abs, absent, constant, lt, max, present, square};
fn kernel() -> impl Expr {
let v = Vars;
let (x0, x1) = (v.get::<0>(), v.get::<1>());
square(x0 + x1) + abs(x0 - constant(1.0))
}
fn central_fd(e: &impl Expr, env: &[f64], i: usize) -> f64 {
let h = 1e-6;
let (mut ep, mut em) = (env.to_vec(), env.to_vec());
ep[i] += h;
em[i] -= h;
(e.eval(&ep) - e.eval(&em)) / (2.0 * h)
}
#[test]
fn eval_matches_hand_computation() {
let e = kernel();
assert_eq!(e.eval(&[3.0, 5.0]), 66.0);
assert_eq!(e.eval(&[0.0, 0.0]), 1.0);
}
#[test]
fn grad_matches_central_difference() {
let e = kernel();
let env = [3.0, 5.0];
let mut g = [0.0; 2];
let val = e.grad(&env, 1.0, &mut g);
assert_eq!(val, 66.0);
assert!((g[0] - 17.0).abs() < 1e-9, "{g:?}");
assert!((g[1] - 16.0).abs() < 1e-9, "{g:?}");
for i in 0..2 {
assert!((g[i] - central_fd(&e, &env, i)).abs() < 1e-4, "grad {i} vs FD: {g:?}");
}
}
#[test]
fn symbolic_derivative_matches_grad_on_random_envs() {
let e = kernel();
let ast = e.lower();
let mut s: u64 = 0x9e37_79b9_7f4a_7c15;
let mut rng = || {
s = s.wrapping_mul(6364136223846793005).wrapping_add(1442695040888963407);
(s >> 33) as f64 / (1u64 << 31) as f64
};
for _ in 0..64 {
let env = [2.0 + rng() * 5.0, rng() * 6.0 - 3.0];
let mut g = [0.0; 2];
e.grad(&env, 1.0, &mut g);
for i in 0..2 {
let d = ast.diff(i).simplify();
assert!((d.eval(&env) - g[i]).abs() < 1e-9, "∂{i} {d} at {env:?}: {} vs {}", d.eval(&env), g[i]);
}
}
}
#[test]
fn latex_and_infix_render() {
let ast = kernel().lower();
assert_eq!(ast.to_string(), "((x0 + x1)^2 + |(x0 - 1)|)");
assert_eq!(ast.latex(&["x", "y"]), "\\left(\\left(x + y\\right)^{2} + \\left|\\left(x - 1\\right)\\right|\\right)");
}
#[test]
fn trace_renders_intermediate_values() {
let trace = kernel().lower().trace(&[3.0, 5.0]);
let expected = "\
◉ +: 66
├──◉ sq: 64
│ └──◉ +: 8
│ ├──◉ var: 3
│ └──◉ var: 5
└──◉ abs: 2
└──◉ -: 2
├──◉ var: 3
└──◉ const: 1";
assert_eq!(trace.to_string(), expected);
}
#[test]
fn simplify_clears_derivative_litter() {
let d = kernel().lower().diff(1).simplify();
assert_eq!(d.to_string(), "(2 * (x0 + x1))");
}
#[test]
fn every_operator_agrees_with_a_numeric_difference() {
use trading_data_expr::{exp, gt, lt, max, min, or, powi_of, select, sqrt, sum};
macro_rules! check {
($($label:literal: |$v:ident| $body:expr, at $env:expr;)+) => {$({
let $v = Vars;
let e = $body;
let env: [f64; 2] = $env;
let mut g = [0.0; 2];
let val = e.grad(&env, 1.0, &mut g);
assert!((val - e.eval(&env)).abs() < 1e-12, "{}: grad's value disagrees with eval", $label);
for i in 0..2 {
let fd = central_fd(&e, &env, i);
assert!((g[i] - fd).abs() < 1e-4 * fd.abs().max(1.0), "{} ∂{i}: grad {} vs central difference {fd}", $label, g[i]);
}
let ast = e.lower();
for i in 0..2 {
let d = ast.diff(i).simplify();
assert!((d.eval(&env) - g[i]).abs() < 1e-9, "{} ∂{i}: `diff` {} vs `grad` {}", $label, d.eval(&env), g[i]);
}
})+};
}
check! {
"add": |v| v.get::<0>() + v.get::<1>(), at [1.5, 2.5];
"sub": |v| v.get::<0>() - v.get::<1>(), at [1.5, 2.5];
"mul": |v| v.get::<0>() * v.get::<1>(), at [1.5, 2.5];
"div": |v| v.get::<0>() / v.get::<1>(), at [1.5, 2.5];
"neg": |v| -(v.get::<0>() * v.get::<1>()), at [1.5, 2.5];
"square": |v| square(v.get::<0>() + v.get::<1>()), at [1.5, 2.5];
"abs": |v| abs(v.get::<0>() - v.get::<1>()), at [1.5, 2.5];
"sum": |v| sum([v.get::<0>(), v.get::<0>()]) + v.get::<1>(), at [1.5, 2.5];
"sqrt": |v| sqrt(v.get::<0>() * v.get::<1>()), at [1.5, 2.5];
"exp": |v| exp(v.get::<0>() - v.get::<1>()), at [1.5, 2.5];
"powi": |v| powi_of::<_, 3>(v.get::<0>() + v.get::<1>()), at [1.5, 2.5];
"powi-": |v| powi_of::<_, -2>(v.get::<0>() + v.get::<1>()), at [1.5, 2.5];
"min": |v| min(v.get::<0>(), v.get::<1>()) * constant(2.0), at [1.5, 2.5];
"max": |v| max(v.get::<0>(), v.get::<1>()) * constant(2.0), at [1.5, 2.5];
"cmp": |v| lt(v.get::<0>(), v.get::<1>()), at [1.5, 2.5];
"cmp-gt": |v| gt(v.get::<0>(), v.get::<1>()), at [1.5, 2.5];
"select": |v| select(lt(v.get::<0>(), v.get::<1>()), square(v.get::<0>()), v.get::<1>()), at [1.5, 2.5];
"present":|v| present(v.get::<0>()) + v.get::<1>(), at [1.5, 2.5];
"or": |v| or(v.get::<0>(), v.get::<1>()), at [1.5, 2.5];
}
}
#[test]
fn nothing_compares_a_declination() {
use trading_data_expr::{Ast, lt, select};
if !cfg!(debug_assertions) {
return;
}
let nan = || constant(0.0) / constant(0.0);
let b = |a: Ast| Box::new(a);
let quiet = std::panic::take_hook();
std::panic::set_hook(Box::new(|_| {}));
let refused = |label: &str, f: &(dyn Fn() -> f64 + std::panic::RefUnwindSafe)| {
assert!(std::panic::catch_unwind(f).is_err(), "{label} compared a NaN operand instead of refusing it");
};
refused("cmp", &|| lt(nan(), constant(1.0)).0.eval(&[]));
refused("select's condition", &|| select(nan(), constant(1.0), constant(2.0)).0.eval(&[]));
refused("ast cmp", &|| Ast::Cmp(b(Ast::Const(f64::NAN)), b(Ast::Const(1.0))).eval(&[]));
refused("ast select's condition", &|| {
Ast::Select(b(Ast::Const(f64::NAN)), b(Ast::Const(1.0)), b(Ast::Const(2.0))).eval(&[])
});
std::panic::set_hook(quiet);
let declined = select(lt(constant(0.0), constant(1.0)), absent(), constant(2.0));
assert!(declined.0.eval(&[]).is_nan(), "a `Select` branch is where a body declines");
assert!(declined.0.lower().eval(&[]).is_nan());
}
#[test]
fn min_and_max_skip_an_absence() {
use trading_data_expr::min;
macro_rules! skips {
($label:literal : $e:expr,at $env:expr => $want:expr,seed_on $i:expr) => {{
let e = $e;
let env: [f64; 2] = $env;
assert_eq!(e.eval(&env), $want, "{}: eval", $label);
assert_eq!(e.lower().eval(&env), $want, "{}: the lowered reading", $label);
let mut g = [0.0; 2];
assert_eq!(e.grad(&env, 1.0, &mut g), $want, "{}: grad's value", $label);
assert_eq!(g[$i], 1.0, "{}: the seed lands on the operand that came out, {g:?}", $label);
let ast = e.lower();
for i in 0..2 {
assert_eq!(ast.diff(i).simplify().eval(&env), g[i], "{} ∂{i}", $label);
}
}};
}
let v = Vars;
skips!("max, absent left": max(v.get::<0>(), v.get::<1>()), at [f64::NAN, 2.0] => 2.0, seed_on 1);
skips!("max, absent right": max(v.get::<0>(), v.get::<1>()), at [2.0, f64::NAN] => 2.0, seed_on 0);
skips!("min, absent left": min(v.get::<0>(), v.get::<1>()), at [f64::NAN, 2.0] => 2.0, seed_on 1);
skips!("min, absent right": min(v.get::<0>(), v.get::<1>()), at [2.0, f64::NAN] => 2.0, seed_on 0);
assert!(!<trading_data_expr::Max<trading_data_expr::Absent, trading_data_expr::Const> as Expr>::MAYBE);
assert!(<trading_data_expr::Max<trading_data_expr::Absent, trading_data_expr::Absent> as Expr>::MAYBE);
assert!(max(absent(), constant(2.0)).0.eval(&[]) == 2.0);
}
#[test]
fn present_and_or_read_an_absence() {
use trading_data_expr::or;
assert_eq!(present(absent()).0.eval(&[]), 0.0);
assert_eq!(present(constant(3.0)).0.eval(&[]), 1.0);
assert_eq!(or(absent(), constant(7.0)).0.eval(&[]), 7.0);
assert_eq!(or(constant(3.0), constant(7.0)).0.eval(&[]), 3.0);
assert_eq!(or(absent(), constant(7.0)).0.lower().eval(&[]), 7.0);
assert_eq!(present(absent()).0.lower().eval(&[]), 0.0);
assert_eq!(lt(or(absent(), constant(7.0)), constant(9.0)).0.eval(&[]), 1.0);
}
#[test]
fn min_and_max_break_ties_the_same_way_in_both_readings() {
use trading_data_expr::{max, min};
for build in [0, 1] {
let v = Vars;
let (mut g, env) = ([0.0; 2], [2.0, 2.0]);
let ast = match build {
0 => {
let e = min(v.get::<0>(), v.get::<1>());
e.grad(&env, 1.0, &mut g);
e.lower()
}
_ => {
let e = max(v.get::<0>(), v.get::<1>());
e.grad(&env, 1.0, &mut g);
e.lower()
}
};
assert_eq!(g, [0.0, 1.0], "build {build}");
for i in 0..2 {
assert_eq!(ast.diff(i).simplify().eval(&env), g[i], "build {build} ∂{i}");
}
}
}
mod fuzz {
use trading_data_expr::Ast;
struct Lcg(u64);
impl Lcg {
fn next(&mut self) -> u64 {
self.0 = self.0.wrapping_mul(6364136223846793005).wrapping_add(1442695040888963407);
self.0 >> 33
}
fn below(&mut self, n: u64) -> u64 {
self.next() % n
}
fn span(&mut self, lo: f64, hi: f64) -> f64 {
lo + (hi - lo) * (self.next() % 4096) as f64 / 4095.0
}
}
const VARS: usize = 3;
fn tree(r: &mut Lcg, depth: u32) -> Ast {
let leaf = |r: &mut Lcg| match r.below(3) {
0 => Ast::Const(r.span(-3.0, 3.0)),
_ => Ast::Var(r.below(VARS as u64) as usize),
};
if depth == 0 {
return leaf(r);
}
fn sub(r: &mut Lcg, depth: u32) -> Box<Ast> {
Box::new(tree(r, depth - 1))
}
match r.below(17) {
0 => Ast::Add(sub(r, depth), sub(r, depth)),
1 => Ast::Sub(sub(r, depth), sub(r, depth)),
2 => Ast::Mul(sub(r, depth), sub(r, depth)),
3 => Ast::Div(sub(r, depth), Box::new(Ast::Add(Box::new(Ast::Abs(sub(r, depth))), Box::new(Ast::Const(1.0))))),
4 => Ast::Neg(sub(r, depth)),
5 => Ast::Square(sub(r, depth)),
6 => Ast::Abs(sub(r, depth)),
7 => Ast::Sqrt(Box::new(Ast::Abs(sub(r, depth)))),
8 => Ast::Exp(Box::new(Ast::Min(sub(r, depth), Box::new(Ast::Const(4.0))))),
9 => Ast::Powi(sub(r, depth), r.below(4) as i32),
10 => Ast::Min(sub(r, depth), sub(r, depth)),
11 => Ast::Max(sub(r, depth), sub(r, depth)),
12 => Ast::Cmp(sub(r, depth), sub(r, depth)),
13 => Ast::Select(sub(r, depth), sub(r, depth), sub(r, depth)),
14 => Ast::Sum((0..2 + r.below(2)).map(|_| tree(r, depth - 1)).collect()),
15 => Ast::IsNan(sub(r, depth)),
_ => leaf(r),
}
}
fn finite_everywhere(e: &Ast, env: &[f64]) -> bool {
if !e.eval(env).is_finite() {
return false;
}
let kids: Vec<&Ast> = match e {
Ast::Const(_) | Ast::Var(_) => vec![],
Ast::Neg(a) | Ast::Square(a) | Ast::Abs(a) | Ast::Sqrt(a) | Ast::Exp(a) | Ast::Powi(a, _) | Ast::IsNan(a) => vec![&**a],
Ast::Add(a, b) | Ast::Sub(a, b) | Ast::Mul(a, b) | Ast::Div(a, b) | Ast::Min(a, b) | Ast::Max(a, b) | Ast::Cmp(a, b) => vec![&**a, &**b],
Ast::Select(a, b, c) => vec![&**a, &**b, &**c],
Ast::Sum(xs) => xs.iter().collect(),
};
kids.into_iter().all(|k| finite_everywhere(k, env))
}
fn difference(e: &Ast, env: &[f64], i: usize) -> Option<f64> {
let at = |h: f64| {
let (mut p, mut m) = (env.to_vec(), env.to_vec());
p[i] += h;
m[i] -= h;
let (a, b) = (e.eval(&p), e.eval(&m));
(a.is_finite() && b.is_finite() && a.abs() < 1e9 && b.abs() < 1e9).then(|| (a - b) / (2.0 * h))
};
let h = 1e-5;
let (fine, coarse) = (at(h)?, at(2.0 * h)?);
((fine - coarse).abs() <= 1e-4 * (1.0 + fine.abs())).then(|| (4.0 * fine - coarse) / 3.0)
}
#[test]
fn the_symbolic_derivative_is_the_numeric_one() {
let mut r = Lcg(0x9e37_79b9_7f4a_7c15);
let (mut checked, mut skipped, mut recovered) = (0u32, 0u32, 0u32);
for _ in 0..2_000 {
let depth = 1 + r.below(4) as u32;
let e = tree(&mut r, depth);
let env: Vec<f64> = (0..VARS).map(|_| r.span(0.4, 2.6)).collect();
if !finite_everywhere(&e, &env) {
continue;
}
for i in 0..VARS {
let d = e.diff(i);
let (raw, exact) = (d.eval(&env), d.simplify().eval(&env));
if raw.is_finite() {
assert!((raw - exact).abs() <= 1e-9 * (1.0 + raw.abs()), "simplify moved ∂{i} of {e} from {raw} to {exact} at {env:?}");
} else {
recovered += 1;
}
let Some(fd) = difference(&e, &env, i) else {
skipped += 1;
continue;
};
if !exact.is_finite() {
skipped += 1;
continue;
}
checked += 1;
assert!(
(exact - fd).abs() <= 1e-4 * (1.0 + exact.abs().max(fd.abs())),
"∂{i} of {e} at {env:?}: algebra says {exact}, the difference says {fd}"
);
}
}
eprintln!("expr fuzz: {checked} derivatives checked, {skipped} points too ill-conditioned to be evidence, {recovered} indeterminacies simplify removed");
assert!(checked > 2_000, "only {checked} of {} points were well-conditioned enough to check", checked + skipped);
}
}