onedrop_eval/

math_functions.rs

//! Mathematical functions for MilkDrop expressions.
//!
//! This module provides all the mathematical functions needed for MilkDrop presets,
//! as evalexpr 13.0 does not include trigonometric or advanced math functions by default.

use evalexpr::{ContextWithMutableFunctions, DefaultNumericTypes, Function, HashMapContext, Value};

/// Thread-local persistent scratch buffer for MD2 `gmegabuf` / `megabuf`.
///
/// evalexpr `Function` closures can't capture mutable state, so the backing
/// array lives in a thread-local `RefCell<Vec<f64>>` cleared from
/// `MilkEvaluator::new()` (via `gmegabuf::reset`). Reads at indices past the
/// high-water mark return 0.0 (uninitialised); writes grow the vector lazily
/// up to [`MAX_SLOTS`] so a `loop(1024*1024, gmegabuf(i)=0)` preset doesn't
/// allocate 8 MB up-front for evaluators that never touch the buffer.
pub mod gmegabuf {
    use std::cell::RefCell;

    /// MD2's documented cap (1 048 576 slots = 8 MB at f64). Indices outside
    /// this range silently no-op so a malformed preset can't OOM the eval.
    pub const MAX_SLOTS: usize = 1 << 20;

    thread_local! {
        static BUFFER: RefCell<Vec<f64>> = const { RefCell::new(Vec::new()) };
    }

    /// Clear the buffer. Called by `MilkEvaluator::new()` so each evaluator
    /// starts with fresh state on the current thread. (Within a single
    /// thread, evaluators can stomp on each other's buffer mid-frame; in
    /// practice each preset is loaded → eval'd → dropped sequentially.)
    pub fn reset() {
        BUFFER.with(|b| b.borrow_mut().clear());
    }

    /// Read slot `idx` (clamped to `[0, MAX_SLOTS)`); returns 0.0 if out of
    /// range or past the current high-water mark.
    pub fn read(idx: f64) -> f64 {
        if !idx.is_finite() {
            return 0.0;
        }
        let i = idx as i64;
        if i < 0 || (i as usize) >= MAX_SLOTS {
            return 0.0;
        }
        let i = i as usize;
        BUFFER.with(|b| b.borrow().get(i).copied().unwrap_or(0.0))
    }

    /// Write `val` to slot `idx`. Grows the buffer if needed; out-of-range
    /// indices are silently ignored.
    pub fn write(idx: f64, val: f64) {
        if !idx.is_finite() {
            return;
        }
        let i = idx as i64;
        if i < 0 || (i as usize) >= MAX_SLOTS {
            return;
        }
        let i = i as usize;
        BUFFER.with(|b| {
            let mut v = b.borrow_mut();
            if i >= v.len() {
                v.resize(i + 1, 0.0);
            }
            v[i] = val;
        });
    }
}

/// Coerce a `Value` to `f64`, accepting Int / Float / Boolean.
///
/// `Value::as_number()` only handles Int and Float, so any builtin driven from
/// a Boolean operand (cmp result, `band`/`bor` arg after
/// [`rewrite_logical_to_bandbor`]) trips on "Expected Number". MD2 EEL2's
/// logical/numeric operators all collapse Boolean → 0.0/1.0, so we mirror
/// that for our registered helpers (`band`, `bor`, `bnot`).
fn coerce_to_f64(value: &Value) -> Result<f64, evalexpr::EvalexprError> {
    match value {
        Value::Boolean(b) => Ok(if *b { 1.0 } else { 0.0 }),
        _ => value.as_number(),
    }
}

/// Register all MilkDrop math functions in a HashMapContext.
pub fn register_math_functions(context: &mut HashMapContext<DefaultNumericTypes>) {
    // Trigonometric functions
    context
        .set_function(
            "sin".into(),
            Function::new(|arg| arg.as_number().map(|n: f64| Value::Float(n.sin()))),
        )
        .ok();

    context
        .set_function(
            "cos".into(),
            Function::new(|arg| arg.as_number().map(|n: f64| Value::Float(n.cos()))),
        )
        .ok();

    context
        .set_function(
            "tan".into(),
            Function::new(|arg| arg.as_number().map(|n: f64| Value::Float(n.tan()))),
        )
        .ok();

    context
        .set_function(
            "asin".into(),
            Function::new(|arg| arg.as_number().map(|n: f64| Value::Float(n.asin()))),
        )
        .ok();

    context
        .set_function(
            "acos".into(),
            Function::new(|arg| arg.as_number().map(|n: f64| Value::Float(n.acos()))),
        )
        .ok();

    context
        .set_function(
            "atan".into(),
            Function::new(|arg| arg.as_number().map(|n: f64| Value::Float(n.atan()))),
        )
        .ok();

    context
        .set_function(
            "atan2".into(),
            Function::new(|arg| {
                if let Ok(tuple) = arg.as_tuple()
                    && tuple.len() == 2
                    && let (Ok(y), Ok(x)) = (tuple[0].as_number(), tuple[1].as_number())
                {
                    let y: f64 = y;
                    let x: f64 = x;
                    let y: f64 = y;
                    let x: f64 = x;
                    return Ok(Value::Float(y.atan2(x)));
                }
                Err(evalexpr::EvalexprError::WrongFunctionArgumentAmount {
                    expected: 2..=2,
                    actual: 1,
                })
            }),
        )
        .ok();

    // Exponential and logarithmic functions
    context
        .set_function(
            "sqrt".into(),
            Function::new(|arg| arg.as_number().map(|n: f64| Value::Float(n.sqrt()))),
        )
        .ok();

    context
        .set_function(
            "pow".into(),
            Function::new(|arg| {
                if let Ok(tuple) = arg.as_tuple()
                    && tuple.len() == 2
                    && let (Ok(base), Ok(exp)) = (tuple[0].as_number(), tuple[1].as_number())
                {
                    let base: f64 = base;
                    let exp: f64 = exp;
                    return Ok(Value::Float(base.powf(exp)));
                }
                Err(evalexpr::EvalexprError::WrongFunctionArgumentAmount {
                    expected: 2..=2,
                    actual: 1,
                })
            }),
        )
        .ok();

    context
        .set_function(
            "exp".into(),
            Function::new(|arg| arg.as_number().map(|n: f64| Value::Float(n.exp()))),
        )
        .ok();

    context
        .set_function(
            "log".into(),
            Function::new(|arg| arg.as_number().map(|n: f64| Value::Float(n.ln()))),
        )
        .ok();

    context
        .set_function(
            "ln".into(),
            Function::new(|arg| arg.as_number().map(|n: f64| Value::Float(n.ln()))),
        )
        .ok();

    context
        .set_function(
            "log10".into(),
            Function::new(|arg| arg.as_number().map(|n: f64| Value::Float(n.log10()))),
        )
        .ok();

    // Absolute value and sign
    context
        .set_function(
            "abs".into(),
            Function::new(|arg| arg.as_number().map(|n: f64| Value::Float(n.abs()))),
        )
        .ok();

    context
        .set_function(
            "sign".into(),
            Function::new(|arg| {
                arg.as_number().map(|n: f64| {
                    if n > 0.0 {
                        Value::Float(1.0)
                    } else if n < 0.0 {
                        Value::Float(-1.0)
                    } else {
                        Value::Float(0.0)
                    }
                })
            }),
        )
        .ok();

    // Rounding functions
    context
        .set_function(
            "fract".into(),
            Function::new(|arg| arg.as_number().map(|n: f64| Value::Float(n.fract()))),
        )
        .ok();

    context
        .set_function(
            "trunc".into(),
            Function::new(|arg| arg.as_number().map(|n: f64| Value::Float(n.trunc()))),
        )
        .ok();

    // Modulo and clamping
    context
        .set_function(
            "fmod".into(),
            Function::new(|arg| {
                if let Ok(tuple) = arg.as_tuple()
                    && tuple.len() == 2
                    && let (Ok(a), Ok(b)) = (tuple[0].as_number(), tuple[1].as_number())
                {
                    let a: f64 = a;
                    let b: f64 = b;
                    return Ok(Value::Float(a % b));
                }
                Err(evalexpr::EvalexprError::WrongFunctionArgumentAmount {
                    expected: 2..=2,
                    actual: 1,
                })
            }),
        )
        .ok();

    context
        .set_function(
            "clamp".into(),
            Function::new(|arg| {
                if let Ok(tuple) = arg.as_tuple()
                    && tuple.len() == 3
                    && let (Ok(value), Ok(min_val), Ok(max_val)) = (
                        tuple[0].as_number(),
                        tuple[1].as_number(),
                        tuple[2].as_number(),
                    )
                {
                    let value: f64 = value;
                    let min_val: f64 = min_val;
                    let max_val: f64 = max_val;
                    return Ok(Value::Float(value.max(min_val).min(max_val)));
                }
                Err(evalexpr::EvalexprError::WrongFunctionArgumentAmount {
                    expected: 3..=3,
                    actual: 1,
                })
            }),
        )
        .ok();

    // Hyperbolic functions
    context
        .set_function(
            "sinh".into(),
            Function::new(|arg| arg.as_number().map(|n: f64| Value::Float(n.sinh()))),
        )
        .ok();

    context
        .set_function(
            "cosh".into(),
            Function::new(|arg| arg.as_number().map(|n: f64| Value::Float(n.cosh()))),
        )
        .ok();

    context
        .set_function(
            "tanh".into(),
            Function::new(|arg| arg.as_number().map(|n: f64| Value::Float(n.tanh()))),
        )
        .ok();

    // Additional useful functions
    context
        .set_function(
            "sqr".into(),
            Function::new(|arg| arg.as_number().map(|n: f64| Value::Float(n * n))),
        )
        .ok();

    context
        .set_function(
            "rad".into(),
            Function::new(|arg| arg.as_number().map(|n: f64| Value::Float(n.to_radians()))),
        )
        .ok();

    context
        .set_function(
            "deg".into(),
            Function::new(|arg| arg.as_number().map(|n: f64| Value::Float(n.to_degrees()))),
        )
        .ok();

    // Random and comparison functions
    context
        .set_function(
            "rand".into(),
            Function::new(|arg| {
                use std::time::{SystemTime, UNIX_EPOCH};
                let max = arg.as_number()?;
                let max: f64 = max;
                // `duration_since(UNIX_EPOCH)` only fails on a pre-1970 clock;
                // fall back to 0 so the equation still produces a number
                // rather than panicking mid-frame.
                let seed = SystemTime::now()
                    .duration_since(UNIX_EPOCH)
                    .map(|d| d.as_nanos())
                    .unwrap_or(0);
                let random = ((seed % 1000000) as f64 / 1000000.0) * max;
                Ok(Value::Float(random))
            }),
        )
        .ok();

    context
        .set_function(
            "above".into(),
            Function::new(|arg| {
                if let Ok(tuple) = arg.as_tuple()
                    && tuple.len() == 2
                    && let (Ok(a), Ok(b)) = (tuple[0].as_number(), tuple[1].as_number())
                {
                    let a: f64 = a;
                    let b: f64 = b;
                    return Ok(Value::Float(if a > b { 1.0 } else { 0.0 }));
                }
                Err(evalexpr::EvalexprError::WrongFunctionArgumentAmount {
                    expected: 2..=2,
                    actual: 1,
                })
            }),
        )
        .ok();

    context
        .set_function(
            "below".into(),
            Function::new(|arg| {
                if let Ok(tuple) = arg.as_tuple()
                    && tuple.len() == 2
                    && let (Ok(a), Ok(b)) = (tuple[0].as_number(), tuple[1].as_number())
                {
                    let a: f64 = a;
                    let b: f64 = b;
                    return Ok(Value::Float(if a < b { 1.0 } else { 0.0 }));
                }
                Err(evalexpr::EvalexprError::WrongFunctionArgumentAmount {
                    expected: 2..=2,
                    actual: 1,
                })
            }),
        )
        .ok();

    context
        .set_function(
            "equal".into(),
            Function::new(|arg| {
                if let Ok(tuple) = arg.as_tuple()
                    && tuple.len() == 2
                    && let (Ok(a), Ok(b)) = (tuple[0].as_number(), tuple[1].as_number())
                {
                    let a: f64 = a;
                    let b: f64 = b;
                    return Ok(Value::Float(if (a - b).abs() < 1e-10 { 1.0 } else { 0.0 }));
                }
                Err(evalexpr::EvalexprError::WrongFunctionArgumentAmount {
                    expected: 2..=2,
                    actual: 1,
                })
            }),
        )
        .ok();

    // Boolean functions — coercion accepts `Value::Boolean` so the `&&` /
    // `||` / unary-`!` rewriters can hand us cmp results (Boolean) without
    // `as_number()` rejecting.
    context
        .set_function(
            "bnot".into(),
            Function::new(|arg| {
                coerce_to_f64(arg).map(|n: f64| Value::Float(if n == 0.0 { 1.0 } else { 0.0 }))
            }),
        )
        .ok();

    context
        .set_function(
            "band".into(),
            Function::new(|arg| {
                if let Ok(tuple) = arg.as_tuple()
                    && tuple.len() == 2
                    && let (Ok(a), Ok(b)) = (coerce_to_f64(&tuple[0]), coerce_to_f64(&tuple[1]))
                {
                    return Ok(Value::Float(if a != 0.0 && b != 0.0 { 1.0 } else { 0.0 }));
                }
                Err(evalexpr::EvalexprError::WrongFunctionArgumentAmount {
                    expected: 2..=2,
                    actual: 1,
                })
            }),
        )
        .ok();

    context
        .set_function(
            "bor".into(),
            Function::new(|arg| {
                if let Ok(tuple) = arg.as_tuple()
                    && tuple.len() == 2
                    && let (Ok(a), Ok(b)) = (coerce_to_f64(&tuple[0]), coerce_to_f64(&tuple[1]))
                {
                    return Ok(Value::Float(if a != 0.0 || b != 0.0 { 1.0 } else { 0.0 }));
                }
                Err(evalexpr::EvalexprError::WrongFunctionArgumentAmount {
                    expected: 2..=2,
                    actual: 1,
                })
            }),
        )
        .ok();

    // Type conversion
    context
        .set_function(
            "int".into(),
            Function::new(|arg| arg.as_number().map(|n: f64| Value::Float(n.trunc()))),
        )
        .ok();

    // ---- Numeric-coercion overrides for `min` / `max` ----
    //
    // evalexpr 13 ships `min` and `max` as strict Float builtins; MD2 presets
    // routinely call `max(0, res)` (Int literal as first arg) and the strict
    // builtin errors with "Expected Float, got Int(0)". Override with
    // `as_number()` versions that coerce Int and Boolean to Float
    // transparently.
    context
        .set_function(
            "max".into(),
            Function::new(|arg| {
                if let Ok(tuple) = arg.as_tuple()
                    && tuple.len() == 2
                    && let (Ok(a), Ok(b)) = (tuple[0].as_number(), tuple[1].as_number())
                {
                    let a: f64 = a;
                    let b: f64 = b;
                    return Ok(Value::Float(a.max(b)));
                }
                Err(evalexpr::EvalexprError::WrongFunctionArgumentAmount {
                    expected: 2..=2,
                    actual: 1,
                })
            }),
        )
        .ok();

    context
        .set_function(
            "min".into(),
            Function::new(|arg| {
                if let Ok(tuple) = arg.as_tuple()
                    && tuple.len() == 2
                    && let (Ok(a), Ok(b)) = (tuple[0].as_number(), tuple[1].as_number())
                {
                    let a: f64 = a;
                    let b: f64 = b;
                    return Ok(Value::Float(a.min(b)));
                }
                Err(evalexpr::EvalexprError::WrongFunctionArgumentAmount {
                    expected: 2..=2,
                    actual: 1,
                })
            }),
        )
        .ok();

    // `sigmoid(x, k)` — MD2 logistic: `1 / (1 + exp(-x*k))`. 49 / 470
    // eval-failing presets in `test-presets-2` sample 2000 referenced this.
    context
        .set_function(
            "sigmoid".into(),
            Function::new(|arg| {
                if let Ok(tuple) = arg.as_tuple()
                    && tuple.len() == 2
                    && let (Ok(x), Ok(k)) = (tuple[0].as_number(), tuple[1].as_number())
                {
                    let x: f64 = x;
                    let k: f64 = k;
                    return Ok(Value::Float(1.0 / (1.0 + (-x * k).exp())));
                }
                Err(evalexpr::EvalexprError::WrongFunctionArgumentAmount {
                    expected: 2..=2,
                    actual: 1,
                })
            }),
        )
        .ok();

    // `floor` / `ceil` / `round` — evalexpr 13 has them strict on Float;
    // MD2 presets pass Int literals. Wrap with as_number() coercion so
    // `floor(0)` and `ceil(1)` accept the literal cleanly.
    context
        .set_function(
            "floor".into(),
            Function::new(|arg| arg.as_number().map(|n: f64| Value::Float(n.floor()))),
        )
        .ok();

    context
        .set_function(
            "ceil".into(),
            Function::new(|arg| arg.as_number().map(|n: f64| Value::Float(n.ceil()))),
        )
        .ok();

    context
        .set_function(
            "round".into(),
            Function::new(|arg| arg.as_number().map(|n: f64| Value::Float(n.round()))),
        )
        .ok();

    // `loop(N, body)` is intercepted by `MilkEvaluator::eval` before evalexpr
    // sees it (see `evaluator::extract_top_level_loop`), so this stub is
    // reached only for nested / non-top-level uses. Returning 0.0 keeps those
    // equations parsing.
    context
        .set_function("loop".into(), Function::new(|_arg| Ok(Value::Float(0.0))))
        .ok();

    // EEL2 `while(cond)`, `exec2(a, b)`, `exec3(a, b, c)`. Like `loop`,
    // they're intercepted before evalexpr sees them at the top level
    // (`find_top_level_while_call` / `find_top_level_exec_call`). The stubs
    // here only fire for nested / non-top-level uses where the args have
    // already been collapsed to a single value by an outer interceptor.
    // Returning 0.0 keeps those rare residuals parseable.
    context
        .set_function("while".into(), Function::new(|_arg| Ok(Value::Float(0.0))))
        .ok();
    context
        .set_function("exec2".into(), Function::new(|_arg| Ok(Value::Float(0.0))))
        .ok();
    context
        .set_function("exec3".into(), Function::new(|_arg| Ok(Value::Float(0.0))))
        .ok();

    // MD2 `gmegabuf` / `megabuf` are persistent N-slot scratch buffers
    // (default 1 048 576 slots, indexed by f64 cast to usize). evalexpr
    // `Function`s can't carry mutable state, so the backing lives in a
    // `thread_local!` `RefCell<Vec<f64>>` cleared on every
    // `MilkEvaluator::new()`. Reads out of range return 0.0; writes grow
    // the buffer up to `gmegabuf::MAX_SLOTS`.
    //
    // Semantically, MD2 distinguishes `megabuf` (per-equation-block) from
    // `gmegabuf` (preset-wide). Our backing is per-evaluator for both —
    // close enough that the 163 init-loop presets in the corpus run
    // their N-fold zero-fill without spilling state across presets, and
    // any subsequent reads at the same indices see the values they wrote.
    context
        .set_function(
            "gmegabuf".into(),
            Function::new(|arg| {
                let idx = arg.as_number().unwrap_or(0.0);
                Ok(Value::Float(crate::math_functions::gmegabuf::read(idx)))
            }),
        )
        .ok();

    context
        .set_function(
            "megabuf".into(),
            Function::new(|arg| {
                let idx = arg.as_number().unwrap_or(0.0);
                Ok(Value::Float(crate::math_functions::gmegabuf::read(idx)))
            }),
        )
        .ok();

    context
        .set_function(
            "gmegabuf_set".into(),
            Function::new(|arg| {
                if let Ok(tuple) = arg.as_tuple()
                    && tuple.len() == 2
                    && let (Ok(i), Ok(v)) = (tuple[0].as_number(), tuple[1].as_number())
                {
                    let i: f64 = i;
                    let v: f64 = v;
                    crate::math_functions::gmegabuf::write(i, v);
                    return Ok(Value::Float(v));
                }
                Ok(Value::Float(0.0))
            }),
        )
        .ok();

    context
        .set_function(
            "megabuf_set".into(),
            Function::new(|arg| {
                if let Ok(tuple) = arg.as_tuple()
                    && tuple.len() == 2
                    && let (Ok(i), Ok(v)) = (tuple[0].as_number(), tuple[1].as_number())
                {
                    let i: f64 = i;
                    let v: f64 = v;
                    crate::math_functions::gmegabuf::write(i, v);
                    return Ok(Value::Float(v));
                }
                Ok(Value::Float(0.0))
            }),
        )
        .ok();

    // MilkDrop-style if function (accepts Float condition)
    context
        .set_function(
            "milkif".into(),
            Function::new(|arg| {
                if let Ok(tuple) = arg.as_tuple() {
                    if tuple.len() == 3 {
                        // Get condition (Float or Boolean)
                        let condition = match &tuple[0] {
                            Value::Float(f) => *f != 0.0,
                            Value::Int(i) => *i != 0,
                            Value::Boolean(b) => *b,
                            _ => {
                                return Err(evalexpr::EvalexprError::TypeError {
                                    expected: vec![
                                        evalexpr::ValueType::Float,
                                        evalexpr::ValueType::Boolean,
                                    ],
                                    actual: tuple[0].clone(),
                                });
                            }
                        };

                        // Return true_val or false_val. MD2's `if()` is
                        // numeric, so coerce Int and Boolean branches to
                        // Float — otherwise a `milkif(cond, a>b, c>d)`
                        // would leak a Boolean into the outer expression
                        // and crash the next arithmetic op with
                        // "Expected Float, got Boolean".
                        let result = if condition { &tuple[1] } else { &tuple[2] };
                        match result {
                            Value::Int(i) => Ok(Value::Float(*i as f64)),
                            Value::Boolean(b) => Ok(Value::Float(if *b { 1.0 } else { 0.0 })),
                            other => Ok(other.clone()),
                        }
                    } else {
                        Err(evalexpr::EvalexprError::WrongFunctionArgumentAmount {
                            expected: 3..=3,
                            actual: tuple.len(),
                        })
                    }
                } else {
                    Err(evalexpr::EvalexprError::WrongFunctionArgumentAmount {
                        expected: 3..=3,
                        actual: 1,
                    })
                }
            }),
        )
        .ok();
}

/// List of all registered math functions.
pub fn list_math_functions() -> Vec<&'static str> {
    vec![
        // Trigonometric
        "sin", "cos", "tan", "asin", "acos", "atan", "atan2",
        // Exponential and logarithmic
        "sqrt", "pow", "exp", "log", "ln", "log10", // Absolute and sign
        "abs", "sign", // Rounding
        "fract", "trunc", "floor", "ceil", "round", // Modulo and clamping
        "fmod", "clamp", "min", "max", // Hyperbolic
        "sinh", "cosh", "tanh", // Additional
        "sqr", "rad", "deg", "sigmoid", // Random and comparison
        "rand", "above", "below", "equal", // Boolean
        "bnot", "band", "bor", // Type conversion
        "int", // Control flow
        "milkif",
    ]
}

#[cfg(test)]
mod tests {
    use super::*;
    use approx::assert_relative_eq;
    use evalexpr::ContextWithMutableVariables;

    #[test]
    fn test_register_math_functions() {
        let mut context = HashMapContext::<DefaultNumericTypes>::new();
        register_math_functions(&mut context);

        // Test that basic functions work
        assert!(evalexpr::eval_number_with_context("sin(0)", &context).is_ok());
        assert!(evalexpr::eval_number_with_context("cos(0)", &context).is_ok());
        assert!(evalexpr::eval_number_with_context("sqrt(4)", &context).is_ok());
    }

    #[test]
    fn test_sin_function() {
        let mut context = HashMapContext::<DefaultNumericTypes>::new();
        register_math_functions(&mut context);

        let result = evalexpr::eval_number_with_context("sin(0)", &context).unwrap();
        assert_relative_eq!(result, 0.0, epsilon = 1e-10);

        let result =
            evalexpr::eval_number_with_context("sin(1.5707963267948966)", &context).unwrap();
        assert_relative_eq!(result, 1.0, epsilon = 1e-10);
    }

    #[test]
    fn test_cos_function() {
        let mut context = HashMapContext::<DefaultNumericTypes>::new();
        register_math_functions(&mut context);

        let result = evalexpr::eval_number_with_context("cos(0)", &context).unwrap();
        assert_relative_eq!(result, 1.0, epsilon = 1e-10);
    }

    #[test]
    fn test_sqrt_function() {
        let mut context = HashMapContext::<DefaultNumericTypes>::new();
        register_math_functions(&mut context);

        let result = evalexpr::eval_number_with_context("sqrt(16)", &context).unwrap();
        assert_relative_eq!(result, 4.0, epsilon = 1e-10);
    }

    #[test]
    fn test_abs_function() {
        let mut context = HashMapContext::<DefaultNumericTypes>::new();
        register_math_functions(&mut context);

        let result = evalexpr::eval_number_with_context("abs(-5)", &context).unwrap();
        assert_relative_eq!(result, 5.0, epsilon = 1e-10);
    }

    #[test]
    fn test_pow_function() {
        let mut context = HashMapContext::<DefaultNumericTypes>::new();
        register_math_functions(&mut context);

        let result = evalexpr::eval_number_with_context("pow(2, 3)", &context).unwrap();
        assert_relative_eq!(result, 8.0, epsilon = 1e-10);
    }

    #[test]
    fn test_complex_expression() {
        let mut context = HashMapContext::<DefaultNumericTypes>::new();
        register_math_functions(&mut context);
        context.set_value("time".into(), Value::Float(1.0)).unwrap();

        let result = evalexpr::eval_number_with_context(
            "sin(time) * cos(time * 2) + sqrt(abs(time - 0.5))",
            &context,
        )
        .unwrap();

        let time = 1.0_f64;
        let expected = time.sin() * (time * 2.0).cos() + (time - 0.5).abs().sqrt();
        assert_relative_eq!(result, expected, epsilon = 1e-10);
    }
}