GraphiteEditor · urisinger · Dec 24, 2024 · Jun 3, 2025 · Jun 3, 2025 · Jun 3, 2025
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/frontend/wasm/src/editor_api.rs b/frontend/wasm/src/editor_api.rs
@@ -744,9 +744,9 @@ impl EditorHandle {
 #[wasm_bindgen(js_name = evaluateMathExpression)]
 pub fn evaluate_math_expression(expression: &str) -> Option<f64> {
 	let value = math_parser::evaluate(expression)
-		.inspect_err(|err| error!("Math parser error on \"{expression}\": {err}"))
+		// TODO: Render to html here
+		.inspect_err(|err| error!("Math parser error on \"{expression}\""))
 		.ok()?
-		.0
 		.inspect_err(|err| error!("Math evaluate error on \"{expression}\": {err} "))
 		.ok()?;
 	let Some(real) = value.as_real() else {

diff --git a/libraries/math-parser/Cargo.toml b/libraries/math-parser/Cargo.toml
@@ -8,11 +8,11 @@ description = "Parser for Graphite style mathematics expressions"
 license = "MIT OR Apache-2.0"
 
 [dependencies]
-pest = "2.7"
-pest_derive = "2.7.11"
 thiserror = "2.0"
 lazy_static = "1.5"
 num-complex = "0.4"
+chumsky = { version = "0.10", default-features = false, features = ["std"] }
+codespan-reporting = { git = "https://github.com/urisinger/codespan-style-writer.git"}
 
 [dev-dependencies]
 criterion = { workspace = true }

diff --git a/libraries/math-parser/benches/bench.rs b/libraries/math-parser/benches/bench.rs
@@ -8,15 +8,21 @@ macro_rules! generate_benchmarks {
 			$(
 				c.bench_function(concat!("parse ", $input), |b| {
 					b.iter(|| {
-						let _ = black_box(ast::Node::try_parse_from_str($input)).unwrap();
+						let _ = black_box(ast::Node::try_parse_from_str($input));
 					});
 				});
 			)*
 		}
 
 		fn evaluation_bench(c: &mut Criterion) {
 			$(
-				let expr = ast::Node::try_parse_from_str($input).unwrap().0;
+			let expr = match ast::Node::try_parse_from_str($input) {
+				Ok(expr) => expr,
+				Err(err) => {
+					err.print();
+					panic!(concat!("failed to parse `", $input, "`"));
+				}
+			};
 				let context = EvalContext::default();
 
 				c.bench_function(concat!("eval ", $input), |b| {

diff --git a/libraries/math-parser/src/ast.rs b/libraries/math-parser/src/ast.rs
@@ -37,7 +37,7 @@ impl Unit {
 	}
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug, Clone, PartialEq)]
 pub enum Literal {
 	Float(f64),
 	Complex(Complex),
@@ -56,6 +56,11 @@ pub enum BinaryOp {
 	Mul,
 	Div,
 	Pow,
+	Leq,
+	Lt,
+	Geq,
+	Gt,
+	Eq,
 }
 
 #[derive(Debug, PartialEq, Clone, Copy)]
@@ -72,4 +77,5 @@ pub enum Node {
 	FnCall { name: String, expr: Vec<Node> },
 	BinOp { lhs: Box<Node>, op: BinaryOp, rhs: Box<Node> },
 	UnaryOp { expr: Box<Node>, op: UnaryOp },
+	Conditional { condition: Box<Node>, if_block: Box<Node>, else_block: Box<Node> },
 }
diff --git a/libraries/math-parser/src/constants.rs b/libraries/math-parser/src/constants.rs
@@ -2,13 +2,21 @@ use crate::value::{Number, Value};
 use lazy_static::lazy_static;
 use num_complex::{Complex, ComplexFloat};
 use std::collections::HashMap;
-use std::f64::consts::PI;
+use std::f64::consts::{LN_2, PI};
 
 type FunctionImplementation = Box<dyn Fn(&[Value]) -> Option<Value> + Send + Sync>;
 lazy_static! {
 	pub static ref DEFAULT_FUNCTIONS: HashMap<&'static str, FunctionImplementation> = {
 		let mut map: HashMap<&'static str, FunctionImplementation> = HashMap::new();
 
+		map.insert(
+			"sqrt",
+			Box::new(|values| match values{
+				[Value::Number(Number::Real(real))] => Some(Value::Number(Number::Real(real.sqrt()))),
+				[Value::Number(Number::Complex(complex))] => Some(Value::Number(Number::Complex(complex.sqrt()))),
+				_ => None,
+			})
+		);
 		map.insert(
 			"sin",
 			Box::new(|values| match values {
@@ -116,6 +124,227 @@ lazy_static! {
 				_ => None,
 			}),
 		);
+		// Hyperbolic Functions
+		map.insert(
+			"sinh",
+			Box::new(|values| match values {
+				[Value::Number(Number::Real(real))] => Some(Value::Number(Number::Real(real.sinh()))),
+				[Value::Number(Number::Complex(complex))] => Some(Value::Number(Number::Complex(complex.sinh()))),
+				_ => None,
+			}),
+		);
+
+		map.insert(
+			"cosh",
+			Box::new(|values| match values {
+				[Value::Number(Number::Real(real))] => Some(Value::Number(Number::Real(real.cosh()))),
+				[Value::Number(Number::Complex(complex))] => Some(Value::Number(Number::Complex(complex.cosh()))),
+				_ => None,
+			}),
+		);
+
+		map.insert(
+			"tanh",
+			Box::new(|values| match values {
+				[Value::Number(Number::Real(real))] => Some(Value::Number(Number::Real(real.tanh()))),
+				[Value::Number(Number::Complex(complex))] => Some(Value::Number(Number::Complex(complex.tanh()))),
+				_ => None,
+			}),
+		);
+
+		// Inverse Hyperbolic Functions
+		map.insert(
+			"asinh",
+			Box::new(|values| match values {
+				[Value::Number(Number::Real(real))] => Some(Value::Number(Number::Real(real.asinh()))),
+				[Value::Number(Number::Complex(complex))] => Some(Value::Number(Number::Complex(complex.asinh()))),
+				_ => None,
+			}),
+		);
+
+		map.insert(
+			"acosh",
+			Box::new(|values| match values {
+				[Value::Number(Number::Real(real))] => Some(Value::Number(Number::Real(real.acosh()))),
+				[Value::Number(Number::Complex(complex))] => Some(Value::Number(Number::Complex(complex.acosh()))),
+				_ => None,
+			}),
+		);
+
+		map.insert(
+			"atanh",
+			Box::new(|values| match values {
+				[Value::Number(Number::Real(real))] => Some(Value::Number(Number::Real(real.atanh()))),
+				[Value::Number(Number::Complex(complex))] => Some(Value::Number(Number::Complex(complex.atanh()))),
+				_ => None,
+			}),
+		);
+
+		// Logarithm Functions
+		map.insert(
+			"ln",
+			Box::new(|values| match values {
+				[Value::Number(Number::Real(real))] => Some(Value::Number(Number::Real(real.ln()))),
+				[Value::Number(Number::Complex(complex))] => Some(Value::Number(Number::Complex(complex.ln()))),
+				_ => None,
+			}),
+		);
+
+		map.insert(
+			"log",
+			Box::new(|values| match values {
+				[Value::Number(Number::Real(real))] => Some(Value::Number(Number::Real(real.log10()))),
+				[Value::Number(Number::Complex(complex))] => Some(Value::Number(Number::Complex(complex.log10()))),
+				[Value::Number(n), Value::Number(base)] => {
+					// Custom base logarithm using change of base formula
+					let compute_log = |x: f64, b: f64| -> f64 { x.ln() / b.ln() };
+					match (n, base) {
+						(Number::Real(x), Number::Real(b)) => Some(Value::Number(Number::Real(compute_log(*x, *b)))),
+						_ => None,
+					}
+				}
+				_ => None,
+			}),
+		);
+
+		map.insert(
+			"log2",
+			Box::new(|values| match values {
+				[Value::Number(Number::Real(real))] => Some(Value::Number(Number::Real(real.log2()))),
+				[Value::Number(Number::Complex(complex))] => Some(Value::Number(Number::Complex(complex / LN_2))),
+				_ => None,
+			}),
+		);
+
+		// Root Functions
+		map.insert(
+			"sqrt",
+			Box::new(|values| match values {
+				[Value::Number(Number::Real(real))] => Some(Value::Number(Number::Real(real.sqrt()))),
+				[Value::Number(Number::Complex(complex))] => Some(Value::Number(Number::Complex(complex.sqrt()))),
+				_ => None,
+			}),
+		);
+
+		map.insert(
+			"cbrt",
+			Box::new(|values| match values {
+				[Value::Number(Number::Real(real))] => Some(Value::Number(Number::Real(real.cbrt()))),
+				[Value::Number(Number::Complex(complex))] => Some(Value::Number(Number::Complex(complex.powf(1.0/3.0)))),
+				_ => None,
+			}),
+		);
+
+		// Geometry Functions
+		map.insert(
+			"hypot",
+			Box::new(|values| match values {
+				[Value::Number(Number::Real(a)), Value::Number(Number::Real(b))] => {
+					Some(Value::Number(Number::Real(a.hypot(*b))))
+				},
+				_ => None,
+			}),
+		);
+
+		// Mapping Functions
+		map.insert(
+			"abs",
+			Box::new(|values| match values {
+				[Value::Number(Number::Real(real))] => Some(Value::Number(Number::Real(real.abs()))),
+				[Value::Number(Number::Complex(complex))] => Some(Value::Number(Number::Real(complex.abs()))),
+				_ => None,
+			}),
+		);
+
+		map.insert(
+			"floor",
+			Box::new(|values| match values {
+				[Value::Number(Number::Real(real))] => Some(Value::Number(Number::Real(real.floor()))),
+				_ => None,
+			}),
+		);
+
+		map.insert(
+			"ceil",
+			Box::new(|values| match values {
+				[Value::Number(Number::Real(real))] => Some(Value::Number(Number::Real(real.ceil()))),
+				_ => None,
+			}),
+		);
+
+		map.insert(
+			"round",
+			Box::new(|values| match values {
+				[Value::Number(Number::Real(real))] => Some(Value::Number(Number::Real(real.round()))),
+				_ => None,
+			}),
+		);
+
+		map.insert(
+			"clamp",
+			Box::new(|values| match values {
+				[Value::Number(Number::Real(x)), Value::Number(Number::Real(min)), Value::Number(Number::Real(max))] => {
+					Some(Value::Number(Number::Real(x.clamp(*min, *max))))
+				},
+				_ => None,
+			}),
+		);
+
+		map.insert(
+			"lerp",
+			Box::new(|values| match values {
+				[Value::Number(Number::Real(a)), Value::Number(Number::Real(b)), Value::Number(Number::Real(t))] => {
+					Some(Value::Number(Number::Real(a + (b - a) * t)))
+				},
+				_ => None,
+			}),
+		);
+
+		// Complex Number Functions
+		map.insert(
+			"real",
+			Box::new(|values| match values {
+				[Value::Number(Number::Complex(complex))] => Some(Value::Number(Number::Real(complex.re))),
+				[Value::Number(Number::Real(real))] => Some(Value::Number(Number::Real(*real))),
+				_ => None,
+			}),
+		);
+
+		map.insert(
+			"imag",
+			Box::new(|values| match values {
+				[Value::Number(Number::Complex(complex))] => Some(Value::Number(Number::Real(complex.im))),
+				[Value::Number(Number::Real(_))] => Some(Value::Number(Number::Real(0.0))),
+				_ => None,
+			}),
+		);
+
+		// Logical Functions
+		map.insert(
+			"isnan",
+			Box::new(|values| match values {
+				[Value::Number(Number::Real(real))] => Some(Value::Number(Number::Real(if real.is_nan() { 1.0 } else { 0.0 }))),
+				_ => None,
+			}),
+		);
+
+		map.insert(
+			"eq",
+			Box::new(|values| match values {
+				[Value::Number(a), Value::Number(b)] => Some(Value::Number(Number::Real(if a == b { 1.0 } else { 0.0 }))),
+				_ => None,
+			}),
+		);
+
+		map.insert(
+			"greater",
+			Box::new(|values| match values {
+				[Value::Number(Number::Real(a)), Value::Number(Number::Real(b))] => {
+					Some(Value::Number(Number::Real(if a > b { 1.0 } else { 0.0 })))
+				},
+				_ => None,
+			}),
+		);
 
 		map
 	};