Expression Evaluation

MathHook provides two fundamental operations for working with expressions: 1. **Evaluation** - Compute numerical values with domain checking 2. **Simplification** - Algebraic reduction while staying symbolic Understanding when to use each operation is critical for correct mathematical computation.

šŸ“

Mathematical Definition

Function Evaluation:

f(a)=f(x)∣x=af(a) = f(x)|_{x=a}

Evaluation with Context: For expression f(x1,…,xn)f(x_1, \ldots, x_n) and substitutions {xi↦vi}\{x_i \mapsto v_i\}:

evaluate(f,{xi↦vi})=f(v1,…,vn)\text{evaluate}(f, \{x_i \mapsto v_i\}) = f(v_1, \ldots, v_n)

Domain Constraints: - x\sqrt{x} requires x≄0x \geq 0 in R\mathbb{R} - log⁔(x)\log(x) requires x>0x > 0 (pole at 0) - tan⁔(x)\tan(x) has poles at Ļ€2+nĻ€\frac{\pi}{2} + n\pi - arcsin⁔(x),arccos⁔(x)\arcsin(x), \arccos(x) require ∣xāˆ£ā‰¤1|x| \leq 1 in R\mathbb{R}

Code Examples

Constants Evaluate to Numbers

Direct evaluation of constant expressions

use mathhook::prelude::*;

let sum = expr!(2 + 3);
assert_eq!(sum.evaluate().unwrap(), expr!(5));

// Domain checking catches errors
let sqrt_neg = expr!(sqrt(-1));
assert!(matches!(sqrt_neg.evaluate(), Err(MathError::DomainError { .. })));

Evaluation with Context (Substitution)

Substitute variable values and evaluate

use mathhook_core::core::expression::eval_numeric::EvalContext;
use mathhook::prelude::*;
use std::collections::HashMap;

let x = symbol!(x);

// Substitute x = 3 and evaluate
let mut vars = HashMap::new();
vars.insert("x".to_string(), Expression::integer(3));
let ctx = EvalContext::numeric(vars);

let expr = Expression::pow(x.clone(), Expression::integer(2));
assert_eq!(expr.evaluate_with_context(&ctx).unwrap(), Expression::integer(9));

Simplification Without Domain Checking

Simplify operates purely symbolically without domain validation

use mathhook::prelude::*;
use mathhook_core::simplify::Simplify;

let x = symbol!(x);

// Combine like terms
let sum = expr!(x + x);
assert_eq!(sum.simplify(), expr!(2 * x));

// Apply identities
assert_eq!(expr!(x * 1).simplify(), expr!(x));
assert_eq!(expr!(0 * x).simplify(), expr!(0));

šŸ”— Related Topics