use super::units::{self, Length};
pub fn length(text: &str) -> Option<Length> {
let mut parser = Parser { rest: text.trim() };
let value = parser.sum()?;
match parser.rest.trim().is_empty() {
true => Some(value),
false => None,
}
}
pub fn eval(text: &str) -> Option<f64> {
length(text).map(|value| value.value)
}
struct Parser<'a> {
rest: &'a str,
}
impl Parser<'_> {
fn sum(&mut self) -> Option<Length> {
let mut left = self.product()?;
loop {
self.skip();
let operator = match self.rest.chars().next() {
Some(c @ ('+' | '-')) => c,
_ => return Some(left),
};
self.rest = &self.rest[1..];
let right = self.product()?;
left = combine(left, right, |a, b| match operator {
'+' => a + b,
_ => a - b,
});
}
}
fn product(&mut self) -> Option<Length> {
let mut left = self.power()?;
loop {
self.skip();
let operator = match self.rest.chars().next() {
Some(c @ ('*' | '/')) => c,
_ => return Some(left),
};
self.rest = &self.rest[1..];
let right = self.power()?;
if operator == '/' && right.value == 0.0 {
return None;
}
left = combine(left, right, |a, b| match operator {
'*' => a * b,
_ => a / b,
});
}
}
fn power(&mut self) -> Option<Length> {
let base = self.unary()?;
self.skip();
let Some(rest) = self.rest.strip_prefix('^') else {
return Some(base);
};
self.rest = rest;
let exponent = self.power()?;
Some(Length {
value: base.value.powf(exponent.value),
points: None,
})
}
fn unary(&mut self) -> Option<Length> {
self.skip();
if let Some(rest) = self.rest.strip_prefix('-') {
self.rest = rest;
let value = self.unary()?;
return Some(Length {
value: -value.value,
points: value.points.map(|points| -points),
});
}
if let Some(rest) = self.rest.strip_prefix('+') {
self.rest = rest;
return self.unary();
}
self.atom()
}
fn atom(&mut self) -> Option<Length> {
self.skip();
if let Some(rest) = self.rest.strip_prefix('(') {
self.rest = rest;
let value = self.sum()?;
self.skip();
self.rest = self.rest.strip_prefix(')')?;
return Some(value);
}
if let Some(rest) = self.rest.strip_prefix('{') {
self.rest = rest;
let value = self.sum()?;
self.skip();
self.rest = self.rest.strip_prefix('}')?;
return Some(value);
}
if let Some((number, rest)) = units::scan(self.rest) {
self.rest = rest;
return Some(number);
}
let name: String = self
.rest
.chars()
.take_while(|c| c.is_ascii_alphabetic())
.collect();
if name.is_empty() {
return None;
}
self.rest = &self.rest[name.len()..];
self.skip();
let Some(rest) = self.rest.strip_prefix('(') else {
return constant(&name).map(|value| Length {
value,
points: None,
});
};
self.rest = rest;
let mut arguments = Vec::new();
loop {
arguments.push(self.sum()?.value);
self.skip();
match self.rest.chars().next() {
Some(',') => self.rest = &self.rest[1..],
Some(')') => {
self.rest = &self.rest[1..];
break;
}
_ => return None,
}
}
call(&name, &arguments).map(|value| Length {
value,
points: None,
})
}
fn skip(&mut self) {
self.rest = self.rest.trim_start();
}
}
fn combine(a: Length, b: Length, operation: impl Fn(f64, f64) -> f64) -> Length {
match (a.points, b.points) {
(None, None) => Length {
value: operation(a.value, b.value),
points: None,
},
_ => {
let (x, y) = (a.points.unwrap_or(a.value), b.points.unwrap_or(b.value));
Length {
value: operation(a.value, b.value),
points: Some(operation(x, y)),
}
}
}
}
fn constant(name: &str) -> Option<f64> {
match name {
"pi" => Some(std::f64::consts::PI),
"e" => Some(std::f64::consts::E),
_ => None,
}
}
fn call(name: &str, arguments: &[f64]) -> Option<f64> {
let one = arguments.first().copied();
let two = arguments.get(1).copied();
match (name, arguments.len()) {
("sin", 1) => Some(one?.to_radians().sin()),
("cos", 1) => Some(one?.to_radians().cos()),
("tan", 1) => Some(one?.to_radians().tan()),
("asin", 1) => Some(one?.asin().to_degrees()),
("acos", 1) => Some(one?.acos().to_degrees()),
("atan", 1) => Some(one?.atan().to_degrees()),
("atan2", 2) => Some(two?.atan2(one?).to_degrees()),
("sqrt", 1) => Some(one?.sqrt()),
("abs", 1) => Some(one?.abs()),
("exp", 1) => Some(one?.exp()),
("ln", 1) => Some(one?.ln()),
("log10", 1) => Some(one?.log10()),
("log2", 1) => Some(one?.log2()),
("pow", 2) => Some(one?.powf(two?)),
("min", 2) => Some(one?.min(two?)),
("max", 2) => Some(one?.max(two?)),
("mod", 2) => Some(one? % two?),
("round", 1) => Some(one?.round()),
("floor", 1) => Some(one?.floor()),
("ceil", 1) => Some(one?.ceil()),
("int", 1) => Some(one?.trunc()),
("veclen", 2) => Some(one?.hypot(two?)),
_ => None,
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn arithmetic_binds_the_way_it_reads() {
assert_eq!(eval("2*3"), Some(6.0));
assert_eq!(eval("2+3*4"), Some(14.0));
assert_eq!(eval("(2+3)*4"), Some(20.0));
assert_eq!(eval("-2^2"), Some(4.0), "unary minus binds first");
assert_eq!(eval("2^3^2"), Some(512.0), "and the power to the right");
assert_eq!(eval("10/4"), Some(2.5));
assert_eq!(eval("1/0"), None, "which is not a number");
}
#[test]
fn the_trigonometric_functions_take_degrees() {
let sin = eval("sin(30)").unwrap();
assert!((sin - 0.5).abs() < 1e-12, "{sin}");
let cos = eval("cos(60)").unwrap();
assert!((cos - 0.5).abs() < 1e-12, "{cos}");
assert_eq!(eval("sqrt(9)"), Some(3.0));
assert_eq!(eval("veclen(3,4)"), Some(5.0));
assert_eq!(eval("max(2,7)"), Some(7.0));
}
#[test]
fn a_unit_multiplies_through_and_is_kept() {
let centimetres = length("2*1cm").unwrap();
assert!((centimetres.points.unwrap() - 2.0 * 72.27 / 2.54).abs() < 1e-9);
assert_eq!(length("2+3").unwrap().points, None);
}
#[test]
fn what_is_not_an_expression_is_not_read_as_one() {
assert_eq!(eval("north east"), None);
assert_eq!(eval("cycle"), None);
assert_eq!(eval("nosuchfunction(2)"), None);
assert_eq!(eval("2*"), None);
assert_eq!(eval("a"), None);
}
}