use crate::{Context, Error, Outcome, Plugin, number, re};
pub struct Arithmetic;
impl Plugin for Arithmetic {
fn evaluate(&self, input: &str, _: &Context) -> Outcome {
if standard_trig_no_value(input) {
return Some(Err(Error("null_result".into())));
}
if input.trim() != "-0"
&& re!(r"(?i)^\s*-?[\d.,_ ]+(?:e[+-]?\d+)?\s*%*\s*$").is_match(input)
{
return None;
}
if input.starts_with('(') && !input.contains(')') && !input.contains(['+', '-', '*', '/']) {
return None;
}
if let Some(c) = re!(r"(?i)^log base ([\d.]+) of ([\d.]+)$").captures(input) {
let n = c[2].parse::<f64>().ok()?.log(c[1].parse().ok()?);
return Some(if n.is_finite() {
Ok(number(n))
} else {
Err(Error("internal_error".into()))
});
}
let value = parse(input)?;
let mut display = number(value.n);
match value.kind {
Kind::Percent => display = format!("{}%", number(value.n * 100.0)),
Kind::Angle => display.push_str(" rad"),
_ => {}
}
Some(if value.n.is_finite() {
Ok(display)
} else {
Err(Error("internal_error".into()))
})
}
}
#[derive(Clone, Copy, PartialEq)]
enum Kind {
Number,
Percent,
Angle,
}
#[derive(Clone, Copy)]
struct Value {
n: f64,
kind: Kind,
}
impl Value {
fn new(n: f64) -> Self {
Self {
n,
kind: Kind::Number,
}
}
}
#[derive(Clone, Debug, PartialEq)]
enum Token {
Number(f64),
Word(String),
Op(char),
Open,
Close,
}
pub fn eval(input: &str) -> Option<f64> {
parse(input).map(|v| v.n).filter(|v| v.is_finite())
}
pub(super) fn trig(name: &str, radians: f64) -> Option<f64> {
match name {
"sin" => Some(radians.sin()),
"cos" => Some(radians.cos()),
"tan" => Some(radians.tan()),
_ => None,
}
}
pub(crate) fn standard_trig_no_value(input: &str) -> bool {
let Some(c) = re!(r"(?i)^(?:sin|cos|tan)\(\s*([+-]?(?:\d+(?:\.\d+)?|\.\d+)(?:e[+-]?\d+)?)\s*([a-zµμΩ°]*)\s*\)$")
.captures(input.trim())
else {
return false;
};
c[1].split(['e', 'E'])
.next()
.unwrap()
.bytes()
.any(|b| matches!(b, b'1'..=b'9'))
&& c[1].parse::<f64>().is_ok_and(|value| value.abs() <= 1e-128)
&& (c[2].is_empty() || super::units::Units::default().unit(&c[2]).is_some())
}
fn parse(input: &str) -> Option<Value> {
if input.contains('"') && !re!(r#"^"[^"\n]*" \+ [+-]?\d+(?:\.\d+)?$"#).is_match(input) {
return None;
}
if input.contains("one half") || input.starts_with("0X") {
return None;
}
let mut normalized = input.to_string();
let mut edits = vec![];
let mut stack = vec![];
for (i, ch) in input.char_indices() {
match ch {
'(' => stack.push((i, false)),
'+' | '-' | '*' | '/' | '^' => {
if let Some((start, compound)) = stack.last_mut() {
*compound |= !input[*start + 1..i].trim().is_empty();
}
}
',' => {
if input[..i].trim_end().ends_with(')')
&& let Some((start, false)) = stack.last()
{
edits.push((start + 1, i + 1));
continue;
}
if let Some((_, true)) = stack.last()
&& let Some(m) = re!(r"^, +[+-]?\d+(?:\.\d+)?\)").find(&input[i..])
{
edits.push((i, i + m.end() - 1));
}
}
')' => {
stack.pop();
}
_ => {}
}
}
edits.sort_unstable();
let mut ranges: Vec<(usize, usize)> = vec![];
for (start, end) in edits {
if let Some((_, previous_end)) = ranges.last_mut()
&& start <= *previous_end
{
*previous_end = (*previous_end).max(end);
} else {
ranges.push((start, end));
}
}
for (a, b) in ranges.into_iter().rev() {
normalized.replace_range(a..b, "");
}
let input = normalized.as_str();
let input = re!(r",\s*-").replace_all(input, " -");
let input = input.as_ref();
let multi =
re!(r"\b(?:round|sqrt|sin|cos|tan|abs|floor|ceil|exp|ln|log)\([^()]*,\s*[^\s)][^()]*\)");
if multi.find(input).is_some_and(|m| m.as_str() == input) {
return None;
}
let input = multi.replace_all(input, "0");
let unknown = re!(r"\b(?:sqrt|ln|log|sin|cos|tan|abs|exp)\(([a-z]+)(?:\^[\d.]+)?\)");
if let Some(c) = unknown.captures(&input)
&& c[0].len() == input.len()
&& eval(&c[1]).is_none()
{
return None;
}
let input = unknown.replace_all(&input, |c: ®ex::Captures| {
if eval(&c[1]).is_some() {
c[0].to_string()
} else {
"0".into()
}
});
let input = re!(r",\s*\)").replace_all(&input, ")");
let mut text = input
.to_lowercase()
.replace('−', "-")
.replace("××", "*")
.replace('×', "*")
.replace(['·', '⋅'], "*")
.replace('÷', "/")
.replace('Ï€', "pi")
.replace('√', "sqrt ")
.replace('°', " degrees");
text = text.replace("_", "").trim_end_matches(';').to_string();
text = re!(r#""[^"]*""#).replace_all(&text, "0").into_owned();
for (from, to) in [
("½", "0.5"),
("¼", "0.25"),
("¾", "0.75"),
("one hundred", "100"),
("twenty-one", "21"),
("minus ", "-"),
("true", "1"),
("false", "0"),
("one", "1"),
("two", "2"),
("three", "3"),
("four", "4"),
("five", "5"),
("six", "6"),
("seven", "7"),
("eight", "8"),
("nine", "9"),
("ten", "10"),
] {
text = text
.split_whitespace()
.map(|w| if w == from { to } else { w })
.collect::<Vec<_>>()
.join(" ");
}
text = text
.replace("1 hundred", "100")
.replace("minus ", "-")
.replace("twenty-1", "21")
.replace("twenty-one", "21");
text = re!(r"([1-9])[xX](\d)")
.replace_all(&text, "$1*$2")
.into_owned();
text = re!(r"\b\d+:\s+").replace_all(&text, "").into_owned();
text = text.replace("()", "");
for (from, to) in [
("square root of ", "sqrt "),
("squared root of ", "sqrt "),
("cubed root of ", "cbrt "),
("cube root of ", "cbrt "),
("half of ", "0.5 * "),
(" to the power of ", " ^ "),
(" raised to ", " ^ "),
(" power ", " ^ "),
(" plus ", " + "),
(" minus ", " - "),
(" multiplied by ", " * "),
(" divided by ", " / "),
(" times ", " * "),
(" mod ", " % "),
("**", "^"),
] {
text = text.replace(from, to);
}
let mut tokens = lex(&text)?;
let mut i = 0;
while i + 1 < tokens.len() {
if matches!(
(&tokens[i], &tokens[i + 1]),
(Token::Number(_), Token::Number(_))
) {
tokens.remove(i);
} else {
i += 1;
}
}
while tokens.len() > 1 && matches!(tokens.last(), Some(Token::Op('+'))) {
tokens.pop();
}
if tokens.is_empty() {
return None;
}
if matches!(tokens.as_slice(), [Token::Number(_), Token::Op('%')]) {
return None;
}
if tokens.len() == 1 && text.contains(['e', 'E']) && text.parse::<f64>().is_ok() {
return None;
}
let mut paired = vec![true; tokens.len()];
let mut stack = vec![];
for (i, t) in tokens.iter().enumerate() {
match t {
Token::Open => stack.push(i),
Token::Close if stack.pop().is_none() => paired[i] = false,
_ => {}
}
}
for i in stack {
paired[i] = false;
}
let tokens: Vec<_> = tokens
.into_iter()
.enumerate()
.filter_map(|(i, t)| paired[i].then_some(t))
.collect();
let mut p = Parser {
tokens: &tokens,
i: 0,
depth: 0,
};
let v = p.sum()?;
(p.i == tokens.len()).then_some(v)
}
fn lex(text: &str) -> Option<Vec<Token>> {
let chars: Vec<_> = text.chars().collect();
let mut out = vec![];
let mut i = 0;
while i < chars.len() {
let c = chars[i];
if c.is_whitespace() {
i += 1;
continue;
}
if c == '0' && i + 2 < chars.len() && matches!(chars[i + 1], 'x' | 'b') {
let base = if chars[i + 1] == 'x' { 16 } else { 2 };
let start = i + 2;
i = start;
while i < chars.len() && chars[i].is_digit(base) {
i += 1;
}
let n = u64::from_str_radix(&chars[start..i].iter().collect::<String>(), base).ok()?;
out.push(Token::Number(n as f64));
continue;
}
if c.is_ascii_digit() || c == '.' {
let start = i;
i += 1;
while i < chars.len()
&& (chars[i].is_ascii_digit() || chars[i] == '.' || chars[i] == ',')
{
i += 1;
}
if i < chars.len() && chars[i] == 'e' {
i += 1;
if i < chars.len() && matches!(chars[i], '-' | '+') {
i += 1;
}
while i < chars.len() && chars[i].is_ascii_digit() {
i += 1;
}
}
let raw: String = chars[start..i].iter().collect();
if raw.ends_with('.') || raw.split_once('.').is_some_and(|(_, s)| s.contains(',')) {
return None;
}
let s: String = chars[start..i].iter().filter(|c| **c != ',').collect();
let n: f64 = s.parse().ok()?;
if n != 0.0 && (n.abs() < 1e-128 || n.abs() > 1e128) {
return None;
}
out.push(Token::Number(n));
continue;
}
if c.is_ascii_alphabetic() {
let start = i;
i += 1;
while i < chars.len() && chars[i].is_ascii_alphanumeric() {
i += 1;
}
out.push(Token::Word(chars[start..i].iter().collect()));
continue;
}
out.push(match c {
'(' => Token::Open,
')' => Token::Close,
'+' | '-' | '*' | '/' | '%' | '^' | '!' => Token::Op(c),
_ => return None,
});
i += 1;
}
Some(out)
}
struct Parser<'a> {
tokens: &'a [Token],
i: usize,
depth: usize,
}
impl Parser<'_> {
fn eat(&mut self, t: Token) -> bool {
if self.tokens.get(self.i) == Some(&t) {
self.i += 1;
true
} else {
false
}
}
fn exhausted(&self) -> bool {
self.i >= self.tokens.len() || self.tokens.get(self.i) == Some(&Token::Close)
}
fn sum(&mut self) -> Option<Value> {
let mut a = self.product()?;
loop {
let sign = if self.eat(Token::Op('+')) {
1.0
} else if self.eat(Token::Op('-')) {
-1.0
} else {
return Some(a);
};
if self.exhausted() {
return Some(a);
}
while matches!(self.tokens.get(self.i), Some(Token::Op('*' | '/'))) {
self.i += 1;
}
let b = self.product()?;
a.n += sign
* b.n
* if b.kind == Kind::Percent && a.kind != Kind::Percent {
a.n
} else {
1.0
};
}
}
fn product(&mut self) -> Option<Value> {
let mut a = self.unary()?;
loop {
let mut op = if self.eat(Token::Op('*')) {
'*'
} else if self.eat(Token::Op('/')) {
'/'
} else if self.eat(Token::Op('%')) {
'%'
} else if self.tokens.get(self.i) == Some(&Token::Open) {
'*'
} else {
return Some(a);
};
while let Some(Token::Op(next @ ('*' | '/'))) = self.tokens.get(self.i) {
op = *next;
self.i += 1;
}
if self.exhausted() {
return Some(a);
}
let b = self.unary()?;
a.n = match op {
'*' => a.n * b.n,
'/' => a.n / b.n,
_ => ((a.n % b.n) + b.n) % b.n,
};
a.kind = Kind::Number;
}
}
fn unary(&mut self) -> Option<Value> {
if self.eat(Token::Op('+')) {
return self.unary();
}
if self.eat(Token::Op('-')) {
let start = self.i;
let mut a = self.unary()?;
if self.tokens[start..self.i].contains(&Token::Op('!')) {
return None;
}
a.n = -a.n;
return Some(a);
}
self.power()
}
fn power(&mut self) -> Option<Value> {
let mut a = self.atom()?;
if self.eat(Token::Op('^')) {
if self.eat(Token::Op('^')) {
return self.unary();
}
if self.exhausted() {
return Some(a);
}
let b = self.unary()?;
a.n = if a.n < 0.0
&& b.n != 0.0
&& (1.0 / b.n).round() % 2.0 == 1.0
&& (1.0 / b.n - (1.0 / b.n).round()).abs() < 1e-12
{
-(-a.n).powf(b.n)
} else {
a.n.powf(b.n)
};
a.kind = Kind::Number;
if a.n.abs() > 1e128 || (a.n == 0.0 && b.n < 0.0) {
return None;
}
}
Some(a)
}
fn atom(&mut self) -> Option<Value> {
if self.depth > 128 {
return None;
}
self.depth += 1;
let mut a = match self.tokens.get(self.i)?.clone() {
Token::Number(n) => {
self.i += 1;
Value::new(n)
}
Token::Open => {
self.i += 1;
let a = self.sum()?;
if !self.eat(Token::Close) {
return None;
}
a
}
Token::Word(name) => {
self.i += 1;
match name.as_str() {
"pi" => Value::new(std::f64::consts::PI),
"tau" => Value::new(std::f64::consts::TAU),
_ => {
if name == "factorial" && self.tokens.get(self.i) != Some(&Token::Open) {
return None;
}
let x = if self.eat(Token::Open) {
let x = self.sum()?;
if !self.eat(Token::Close) {
return None;
}
x
} else {
self.unary()?
};
let n = match name.as_str() {
"sqrt" => x.n.sqrt(),
"cbrt" => x.n.cbrt(),
"sin" | "cos" | "tan" => trig(name.as_str(), x.n)?,
"asin" => x.n.asin(),
"acos" => x.n.acos(),
"atan" => x.n.atan(),
"sinh" => x.n.sinh(),
"cosh" => x.n.cosh(),
"tanh" => x.n.tanh(),
"log" | "log10" => x.n.log10(),
"log2" => x.n.log2(),
"ln" => x.n.ln(),
"exp" => super::decimal::exponent(x.n).exp(),
"abs" => x.n.abs(),
"floor" => x.n.floor(),
"ceil" => x.n.ceil(),
"round" => x.n.round(),
"fact" | "factorial" => factorial(x.n)?,
_ => return None,
};
Value {
n,
kind: if matches!(name.as_str(), "asin" | "acos" | "atan") {
Kind::Angle
} else {
Kind::Number
},
}
}
}
}
_ => return None,
};
if self.eat(Token::Op('!')) {
a.n = factorial(a.n)?;
if self.tokens.get(self.i) == Some(&Token::Op('!')) {
return None;
}
}
if self.tokens.get(self.i) == Some(&Token::Op('%'))
&& !matches!(
self.tokens.get(self.i + 1),
Some(Token::Number(_) | Token::Word(_) | Token::Open)
)
{
self.i += 1;
a.n /= 100.0;
a.kind = Kind::Percent;
}
if let Some(Token::Word(unit)) = self.tokens.get(self.i) {
if matches!(unit.as_str(), "degrees" | "degree" | "deg") {
self.i += 1;
a.n = a.n.to_radians();
a.kind = Kind::Angle;
} else if matches!(unit.as_str(), "rad" | "radians") {
self.i += 1;
a.kind = Kind::Angle;
}
}
self.depth -= 1;
Some(a)
}
}
pub fn factorial(x: f64) -> Option<f64> {
if !(0.0..=170.0).contains(&x) {
return None;
}
if x.fract() == 0.0 {
return Some((1..=x as u32).fold(1.0, |a, n| a * n as f64));
}
let coefficients = [
676.5203681218851,
-1259.1392167224028,
771.3234287776531,
-176.6150291621406,
12.507343278686905,
-0.13857109526572012,
9.984369578019572e-6,
1.5056327351493116e-7,
];
let mut a = 0.9999999999998099;
for (i, c) in coefficients.iter().enumerate() {
a += c / (x + i as f64 + 1.0);
}
let t = x + 7.5;
Some((2.0 * std::f64::consts::PI).sqrt() * t.powf(x + 0.5) * (-t).exp() * a)
}
pub(crate) fn operators(s: &str) -> Option<Vec<(usize, char)>> {
let mut nesting = 0i32;
let mut operators = vec![];
for (i, c) in s.char_indices() {
match c {
'(' => nesting += 1,
')' => {
nesting -= 1;
if nesting < 0 {
return None;
}
}
'+' | '-' | '*' | '/' | '^' if nesting == 0 && i > 0 => {
let previous = s[..i].trim_end().chars().last()?;
if !matches!(previous, '+' | '-' | '*' | '/' | '^')
&& !(matches!(previous, 'e' | 'E')
&& s[..i]
.chars()
.rev()
.nth(1)
.is_some_and(|c| c.is_ascii_digit()))
{
operators.push((i, c));
}
}
_ => {}
}
}
if nesting != 0 {
return None;
}
Some(operators)
}