| #![allow(unused)] |
|
|
| pub mod ast; |
| mod constants; |
| pub mod context; |
| pub mod executer; |
| pub mod parser; |
| pub mod value; |
|
|
| use ast::Unit; |
| use context::{EvalContext, ValueMap}; |
| use executer::EvalError; |
| use parser::ParseError; |
| use value::Value; |
|
|
| pub fn evaluate(expression: &str) -> Result<(Result<Value, EvalError>, Unit), ParseError> { |
| let expr = ast::Node::try_parse_from_str(expression); |
| let context = EvalContext::default(); |
| expr.map(|(node, unit)| (node.eval(&context), unit)) |
| } |
|
|
| #[cfg(test)] |
| mod tests { |
| use super::*; |
| use ast::Unit; |
| use value::Number; |
|
|
| const EPSILON: f64 = 1e-10_f64; |
|
|
| macro_rules! test_end_to_end{ |
| ($($name:ident: $input:expr_2021 => ($expected_value:expr_2021, $expected_unit:expr_2021)),* $(,)?) => { |
| $( |
| #[test] |
| fn $name() { |
| let expected_value = $expected_value; |
| let expected_unit = $expected_unit; |
|
|
| let expr = ast::Node::try_parse_from_str($input); |
| let context = EvalContext::default(); |
|
|
| let (actual_value, actual_unit) = expr.map(|(node, unit)| (node.eval(&context), unit)).unwrap(); |
| let actual_value = actual_value.unwrap(); |
|
|
|
|
| assert!(actual_unit == expected_unit, "Expected unit {:?} but found unit {:?}", expected_unit, actual_unit); |
|
|
| let expected_value = expected_value.into(); |
|
|
| match (actual_value, expected_value) { |
| (Value::Number(Number::Complex(actual_c)), Value::Number(Number::Complex(expected_c))) => { |
| assert!( |
| (actual_c.re.is_infinite() && expected_c.re.is_infinite()) || (actual_c.re - expected_c.re).abs() < EPSILON, |
| "Expected real part {}, but got {}", |
| expected_c.re, |
| actual_c.re |
| ); |
| assert!( |
| (actual_c.im.is_infinite() && expected_c.im.is_infinite()) || (actual_c.im - expected_c.im).abs() < EPSILON, |
| "Expected imaginary part {}, but got {}", |
| expected_c.im, |
| actual_c.im |
| ); |
| } |
| (Value::Number(Number::Real(actual_f)), Value::Number(Number::Real(expected_f))) => { |
| if actual_f.is_infinite() || expected_f.is_infinite() { |
| assert!( |
| actual_f.is_infinite() && expected_f.is_infinite() && actual_f == expected_f, |
| "Expected infinite value {}, but got {}", |
| expected_f, |
| actual_f |
| ); |
| } else if actual_f.is_nan() || expected_f.is_nan() { |
| assert!(actual_f.is_nan() && expected_f.is_nan(), "Expected NaN, but got {}", actual_f); |
| } else { |
| assert!((actual_f - expected_f).abs() < EPSILON, "Expected {}, but got {}", expected_f, actual_f); |
| } |
| } |
| |
| _ => panic!("Mismatched types: expected {:?}, got {:?}", expected_value, actual_value), |
| } |
|
|
| } |
| )* |
| }; |
| } |
|
|
| test_end_to_end! { |
| |
| infix_addition: "5 + 5" => (10., Unit::BASE_UNIT), |
| infix_subtraction_units: "5m - 3m" => (2., Unit::LENGTH), |
| infix_multiplication_units: "4s * 4s" => (16., Unit { length: 0, mass: 0, time: 2 }), |
| infix_division_units: "8m/2s" => (4., Unit::VELOCITY), |
|
|
| |
| order_of_operations_negative_prefix: "-10 + 5" => (-5., Unit::BASE_UNIT), |
| order_of_operations_add_multiply: "5+1*1+5" => (11., Unit::BASE_UNIT), |
| order_of_operations_add_negative_multiply: "5+(-1)*1+5" => (9., Unit::BASE_UNIT), |
| order_of_operations_sqrt: "sqrt25 + 11" => (16., Unit::BASE_UNIT), |
| order_of_operations_sqrt_expression: "sqrt(25+11)" => (6., Unit::BASE_UNIT), |
|
|
| |
| parentheses_nested_multiply: "(5 + 3) * (2 + 6)" => (64., Unit::BASE_UNIT), |
| parentheses_mixed_operations: "2 * (3 + 5 * (2 + 1))" => (36., Unit::BASE_UNIT), |
| parentheses_divide_add_multiply: "10 / (2 + 3) + (7 * 2)" => (16., Unit::BASE_UNIT), |
|
|
| |
| sqrt_chain_operations: "sqrt(16) + sqrt(9) * sqrt(4)" => (10., Unit::BASE_UNIT), |
| sqrt_nested: "sqrt(sqrt(81))" => (3., Unit::BASE_UNIT), |
| sqrt_divide_expression: "sqrt((25 + 11) / 9)" => (2., Unit::BASE_UNIT), |
|
|
| |
| sqrt_multiply_units: "sqrt(16) * 2g + 5g" => (13., Unit::MASS), |
| sqrt_add_multiply: "sqrt(49) - 1 + 2 * 3" => (12., Unit::BASE_UNIT), |
| sqrt_addition_multiply: "(sqrt(36) + 2) * 2" => (16., Unit::BASE_UNIT), |
|
|
| |
| exponent_single: "2^3" => (8., Unit::BASE_UNIT), |
| exponent_mixed_operations: "2^3 + 4^2" => (24., Unit::BASE_UNIT), |
| exponent_nested: "2^(3+1)" => (16., Unit::BASE_UNIT), |
|
|
| |
| negative_units_add_multiply: "-5s + (-3 * 2)s" => (-11., Unit::TIME), |
| negative_nested_parentheses: "-(5 + 3 * (2 - 1))" => (-8., Unit::BASE_UNIT), |
| negative_sqrt_addition: "-(sqrt(16) + sqrt(9))" => (-7., Unit::BASE_UNIT), |
| multiply_sqrt_subtract: "5 * 2 + sqrt(16) / 2 - 3" => (9., Unit::BASE_UNIT), |
| add_multiply_subtract_sqrt: "4 + 3 * (2 + 1) - sqrt(25)" => (8., Unit::BASE_UNIT), |
| add_sqrt_subtract_nested_multiply: "10 + sqrt(64) - (5 * (2 + 1))" => (3., Unit::BASE_UNIT), |
|
|
| |
| constant_pi: "pi" => (std::f64::consts::PI, Unit::BASE_UNIT), |
| constant_e: "e" => (std::f64::consts::E, Unit::BASE_UNIT), |
| constant_phi: "phi" => (1.61803398875, Unit::BASE_UNIT), |
| constant_tau: "tau" => (2.0 * std::f64::consts::PI, Unit::BASE_UNIT), |
| constant_infinity: "inf" => (f64::INFINITY, Unit::BASE_UNIT), |
| constant_infinity_symbol: "∞" => (f64::INFINITY, Unit::BASE_UNIT), |
| multiply_pi: "2 * pi" => (2.0 * std::f64::consts::PI, Unit::BASE_UNIT), |
| add_e_constant: "e + 1" => (std::f64::consts::E + 1.0, Unit::BASE_UNIT), |
| multiply_phi_constant: "phi * 2" => (1.61803398875 * 2.0, Unit::BASE_UNIT), |
| exponent_tau: "2^tau" => (2f64.powf(2.0 * std::f64::consts::PI), Unit::BASE_UNIT), |
| infinity_subtract_large_number: "inf - 1000" => (f64::INFINITY, Unit::BASE_UNIT), |
|
|
| |
| trig_sin_pi: "sin(pi)" => (0.0, Unit::BASE_UNIT), |
| trig_cos_zero: "cos(0)" => (1.0, Unit::BASE_UNIT), |
| trig_tan_pi_div_four: "tan(pi/4)" => (1.0, Unit::BASE_UNIT), |
| trig_sin_tau: "sin(tau)" => (0.0, Unit::BASE_UNIT), |
| trig_cos_tau_div_two: "cos(tau/2)" => (-1.0, Unit::BASE_UNIT), |
| } |
| } |
|
|
