use std::collections::HashMap;
use std::f64::consts::PI;
pub(crate) fn eval(src: &str, vars: &HashMap<String, f64>) -> Result<f64, String> {
let mut p = Parser {
chars: src.char_indices().peekable(),
src,
vars,
};
let value = p.expr()?;
p.skip_space();
if let Some((_, c)) = p.chars.peek() {
return Err(format!("invalid angle `{src}` (unexpected `{c}`)"));
}
if !value.is_finite() {
return Err(format!("invalid angle `{src}` (not a finite number)"));
}
Ok(value)
}
struct Parser<'a> {
chars: std::iter::Peekable<std::str::CharIndices<'a>>,
src: &'a str,
vars: &'a HashMap<String, f64>,
}
impl Parser<'_> {
fn invalid(&self) -> String {
format!("invalid angle `{}`", self.src)
}
fn skip_space(&mut self) {
while matches!(self.chars.peek(), Some((_, c)) if c.is_whitespace()) {
self.chars.next();
}
}
fn eat(&mut self, c: char) -> bool {
self.skip_space();
if matches!(self.chars.peek(), Some((_, got)) if *got == c) {
self.chars.next();
true
} else {
false
}
}
fn peek(&mut self) -> Option<char> {
self.skip_space();
self.chars.peek().map(|(_, c)| *c)
}
fn expr(&mut self) -> Result<f64, String> {
let mut value = self.term()?;
loop {
if self.eat('+') {
value += self.term()?;
} else if self.eat('-') {
value -= self.term()?;
} else {
return Ok(value);
}
}
}
fn term(&mut self) -> Result<f64, String> {
let mut value = self.unary()?;
loop {
if self.eat('*') {
value *= self.unary()?;
} else if self.eat('/') {
let divisor = self.unary()?;
if divisor == 0.0 {
return Err(format!("invalid angle `{}` (division by zero)", self.src));
}
value /= divisor;
} else {
return Ok(value);
}
}
}
fn unary(&mut self) -> Result<f64, String> {
if self.eat('-') {
return Ok(-self.unary()?);
}
if self.eat('+') {
return self.unary();
}
self.power()
}
fn power(&mut self) -> Result<f64, String> {
let base = self.atom()?;
if self.eat('^') {
return Ok(base.powf(self.unary()?));
}
Ok(base)
}
fn atom(&mut self) -> Result<f64, String> {
match self.peek().ok_or_else(|| self.invalid())? {
'(' => {
self.chars.next();
let value = self.expr()?;
if !self.eat(')') {
return Err(format!("invalid angle `{}` (missing `)`)", self.src));
}
Ok(value)
}
c if c.is_ascii_digit() || c == '.' => {
let number = self.number()?;
match self.peek() {
Some(next) if next.is_ascii_alphabetic() || next == '(' => {
Ok(number * self.atom()?)
}
_ => Ok(number),
}
}
c if c.is_ascii_alphabetic() || c == '_' => self.name(),
_ => Err(self.invalid()),
}
}
fn number(&mut self) -> Result<f64, String> {
let mut text = String::new();
while let Some((_, c)) = self.chars.peek() {
let c = *c;
let is_exponent_sign =
(c == '+' || c == '-') && matches!(text.chars().last(), Some('e') | Some('E'));
if c.is_ascii_digit() || c == '.' || c == 'e' || c == 'E' || is_exponent_sign {
if (c == 'e' || c == 'E') && !self.exponent_follows() {
break;
}
text.push(c);
self.chars.next();
} else {
break;
}
}
text.parse().map_err(|_| self.invalid())
}
fn exponent_follows(&mut self) -> bool {
let mut lookahead = self.chars.clone();
lookahead.next(); match lookahead.next() {
Some((_, c)) if c.is_ascii_digit() => true,
Some((_, '+')) | Some((_, '-')) => {
matches!(lookahead.next(), Some((_, c)) if c.is_ascii_digit())
}
_ => false,
}
}
fn name(&mut self) -> Result<f64, String> {
let mut text = String::new();
while let Some((_, c)) = self.chars.peek() {
if c.is_ascii_alphanumeric() || *c == '_' {
text.push(*c);
self.chars.next();
} else {
break;
}
}
if text == "pi" {
return Ok(PI);
}
if let Some(value) = self.vars.get(&text) {
return Ok(*value);
}
let func = match text.as_str() {
"sin" | "cos" | "tan" | "exp" | "ln" | "sqrt" => text,
_ => {
return Err(format!(
"invalid angle `{}` (unknown name `{text}`)",
self.src
))
}
};
if !self.eat('(') {
return Err(format!("invalid angle `{}` (`{func}` needs `(`)", self.src));
}
let arg = self.expr()?;
if !self.eat(')') {
return Err(format!("invalid angle `{}` (missing `)`)", self.src));
}
Ok(match func.as_str() {
"sin" => arg.sin(),
"cos" => arg.cos(),
"tan" => arg.tan(),
"exp" => arg.exp(),
"ln" => arg.ln(),
_ => arg.sqrt(),
})
}
}
#[cfg(test)]
mod tests {
use super::*;
fn ev(s: &str) -> Result<f64, String> {
eval(s, &HashMap::new())
}
fn close(a: f64, b: f64) -> bool {
(a - b).abs() < 1e-12
}
#[test]
fn legacy_angle_forms_still_parse() {
for (src, want) in [
("0.7", 0.7),
("-1.5", -1.5),
("1e-5", 1e-5),
("2E3", 2000.0),
("pi", PI),
("pi/2", PI / 2.0),
("-pi/4", -PI / 4.0),
("2pi", 2.0 * PI),
("2*pi", 2.0 * PI),
("0.5*pi", 0.5 * PI),
] {
assert!(close(ev(src).unwrap(), want), "{src}");
}
}
#[test]
fn arithmetic_and_precedence() {
for (src, want) in [
("1+2*3", 7.0),
("(1+2)*3", 9.0),
("-2^2", -4.0), ("2^-1", 0.5), ("2^3^2", 512.0), ("pi/8", PI / 8.0),
("pi/2 + pi/2", PI),
("--3", 3.0),
("+4", 4.0),
(" 1 + 1 ", 2.0),
] {
assert!(close(ev(src).unwrap(), want), "{src} -> {:?}", ev(src));
}
}
#[test]
fn functions_evaluate() {
assert!(close(ev("sin(0)").unwrap(), 0.0));
assert!(close(ev("cos(0)").unwrap(), 1.0));
assert!(close(ev("tan(0)").unwrap(), 0.0));
assert!(close(ev("ln(1)").unwrap(), 0.0));
assert!(close(ev("exp(0)").unwrap(), 1.0));
assert!(close(ev("sqrt(4)").unwrap(), 2.0));
assert!(close(ev("2exp(0)").unwrap(), 2.0)); }
#[test]
fn variables_resolve() {
let vars = HashMap::from([("theta".to_string(), 0.8), ("phi".to_string(), -0.2)]);
assert!(close(eval("theta", &vars).unwrap(), 0.8));
assert!(close(eval("-theta/2", &vars).unwrap(), -0.4));
assert!(close(eval("theta+phi", &vars).unwrap(), 0.6));
assert!(close(eval("2*theta", &vars).unwrap(), 1.6));
}
#[test]
fn errors_name_the_problem() {
for (src, needle) in [
("bogus", "unknown name"),
("pi/0", "division by zero"),
("(1+2", "missing `)`"),
("1+", "invalid angle"),
("", "invalid angle"),
("1 2", "unexpected"),
("sin 1", "needs `(`"),
("1/0", "division by zero"),
] {
let err = ev(src).unwrap_err();
assert!(err.contains(needle), "for `{src}`: {err}");
}
}
#[test]
fn unknown_variable_is_an_error_not_zero() {
let vars = HashMap::from([("theta".to_string(), 0.8)]);
assert!(eval("lambda", &vars).is_err());
}
}