use fancy_regex::{Captures, Regex};
use std::collections::HashMap;
use std::sync::LazyLock;
fn normalization_regex_error(stage: &'static str, err: fancy_regex::Error) -> String {
format!("calculator normalization regex stage '{stage}' failed: {err}")
}
fn try_replace_all<R>(
stage: &'static str,
re: &Regex,
text: &str,
replacement: R,
) -> Result<String, String>
where
R: fancy_regex::Replacer,
{
re.try_replacen(text, 0, replacement)
.map(|value| value.into_owned())
.map_err(|err| normalization_regex_error(stage, err))
}
static PCT_SYMBOL_RE: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"(\d+(?:\.\d+)?)\s*%(?!\s*\d)").unwrap());
static PERCENT_RE: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"(\d+(?:\.\d+)?)\s*percent\b").unwrap());
static COMPLEX_RE: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"(\d+(?:\.\d+)?)\s*([+-])\s*(\d+(?:\.\d+)?)\s*i").unwrap());
static UNIT_ALT: LazyLock<String> = LazyLock::new(|| {
let mut keys: Vec<&str> = crate::calc::units::UNIT_ALIASES.keys().copied().collect();
keys.sort_by(|a, b| b.len().cmp(&a.len()).then_with(|| a.cmp(b)));
keys.iter()
.map(|u| regex_escape(u))
.collect::<Vec<_>>()
.join("|")
});
static NUMBER_WORD_ALT: LazyLock<String> = LazyLock::new(|| {
NUMBER_WORDS
.keys()
.map(|w| regex_escape(w))
.collect::<Vec<_>>()
.join("|")
});
static TEMP_UNITS_LIST: LazyLock<Vec<&'static str>> = LazyLock::new(|| {
vec![
"f",
"c",
"k",
"fahrenheit",
"celsius",
"kelvin",
"rankine",
"degf",
"degc",
"degk",
"degr",
"ra",
]
});
static TEMP_CONVERSION_RE: LazyLock<Regex> = LazyLock::new(|| {
let temp_unit = r"(?:[cfk]|celsius|fahrenheit|kelvin|rankine|degc|degf|degk|degr|ra)";
Regex::new(&format!(
r"(?i)(\d+(?:\.\d+)?)\s*({temp_unit})\s+(in|to|as|into)\s+({temp_unit})\b"
))
.unwrap()
});
static BINARY_WORD_RE: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(
r"(?i)(\d+(?:\.\d+)?|\((?:[^()]|\([^()]*\))*\))\s+(not|in|to|as|into)\s+(\d+(?:\.\d+)?)\b",
)
.unwrap()
});
static BINARY_WORD_INNER_RE: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"(?i)\b(not|in|to|as|into)\b").unwrap());
static TO_THE_POWER_RE: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"(\d+(?:\.\d+)?)\s+to\s+the\s+(\d+(?:\.\d+)?)").unwrap());
static DEGREES_NON_TEMP_RE: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"(\d+(?:\.\d+)?)\s*(?:degrees?|deg)\s+(\w+)").unwrap());
static DEGREES_RE: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"(\d+(?:\.\d+)?)\s*(?:degrees?|deg)\b").unwrap());
static POINT_RE: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"(?<=[\d)])\s*point\s*").unwrap());
static MERGE_DECIMAL_RE: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"(\d+\.\d*)\s+(\d)").unwrap());
static IMPLICIT_MUL_FUNC_RE: LazyLock<Regex> = LazyLock::new(|| {
let funcs = [
"sqrt",
"sin",
"cos",
"tan",
"asin",
"acos",
"atan",
"sinh",
"cosh",
"tanh",
"log",
"log10",
"log2",
"exp",
"abs",
"factorial",
"cbrt",
"floor",
"ceil",
"round",
"sign",
"mean",
"median",
"mode",
"std",
"variance",
"gcd",
"lcm",
"perm",
"comb",
"isprime",
"nextprime",
"prevprime",
"primefactors",
"random",
"randint",
"gauss",
"sum",
"max",
"min",
"hypot",
"clamp",
"asinh",
"acosh",
"atanh",
];
Regex::new(&format!(r"(\d|\))\s*({})\b", funcs.join("|"))).unwrap()
});
static IMPLICIT_MUL_PAREN_RE: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"(\))\s*(\d|\()").unwrap());
static IMPLICIT_MUL_DIGIT_PAREN_RE: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"(\d)\s*\(").unwrap());
static FACTORIAL_RE: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(
r"(\d+(?:\.\d+)?|\((?:[^()]*|\([^()]*\))*\)|[a-zA-Z_]\w*\((?:[^()]*|\([^()]*\))*\))(\!+)",
)
.unwrap()
});
static SPLIT_NUM_MINUS_RE: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"^\d+(?:-\d+)+$").unwrap());
static SPLIT_DOUBLE_MINUS_RE: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"^\d+--\d+").unwrap());
static SPLIT_TRAILING_MINUS_RE: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"^\d+-$").unwrap());
static UNIT_INLINE_RE: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(r"(?P<num>\d+(?:\.\d+)?)\*?(?P<unit>[a-zA-Z°]+(?:/[a-zA-Z°]+)?)\b").unwrap()
});
static SAME_UNIT_DIV_RE: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"\b([a-zA-Z]+)/(\d+(?:\.\d+)?)\*([a-zA-Z]+)\b").unwrap());
static CONVERT_SIMPLE_RE: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(r"^convert\((\d+(?:\.\d+)?)\*([a-zA-Z°][a-zA-Z0-9°/]*),([a-zA-Z°][a-zA-Z0-9°/]*)\)$")
.unwrap()
});
static CONVERT_BARE_RE: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(r"^convert\((\d+(?:\.\d+)?),([a-zA-Z°][a-zA-Z0-9°/]*)\)$").unwrap()
});
static TEMP_HANDLE_RE: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(r"^temp\(([^,]+),([a-zA-Z°][a-zA-Z0-9°]*),([a-zA-Z°][a-zA-Z0-9°]*)\)$").unwrap()
});
static HYPHEN_RE: LazyLock<Regex> = LazyLock::new(|| {
let nwa = &*NUMBER_WORD_ALT;
Regex::new(&format!(r"\b({})-({})\b", nwa, nwa)).unwrap()
});
static NUMBER_WORD_RE: LazyLock<Regex> = LazyLock::new(|| {
let nwa = &*NUMBER_WORD_ALT;
Regex::new(&format!("\\b({})\\b", nwa)).unwrap()
});
fn unit_caret_attach_re() -> &'static Regex {
static RE: LazyLock<Regex> = LazyLock::new(|| {
let ua = &*UNIT_ALT;
Regex::new(&format!(r"(?i)(\d+(?:\.\d+)?)\s+({ua})\s*\^\s*([23])\b")).unwrap()
});
&RE
}
fn unit_caret_denom_re() -> &'static Regex {
static RE: LazyLock<Regex> = LazyLock::new(|| {
let ua = &*UNIT_ALT;
Regex::new(&format!(r"(?i)/\s*({ua})\s*\^\s*(\d+)\b")).unwrap()
});
&RE
}
fn unit_caret_paren_re() -> &'static Regex {
static RE: LazyLock<Regex> = LazyLock::new(|| {
let ua = &*UNIT_ALT;
Regex::new(&format!(r"(?i)/\(\s*({ua})\s*\)\s*\^\s*(\d+)\b")).unwrap()
});
&RE
}
static UNIT_POWER_RE: LazyLock<Regex> = LazyLock::new(|| {
let ua = &*UNIT_ALT;
Regex::new(&format!(r"(?i)\b({ua})\s+(squared|cubed)\b")).unwrap()
});
static UNIT_SPELLED_RE: LazyLock<Regex> = LazyLock::new(|| {
let ua = &*UNIT_ALT;
Regex::new(&format!(
r"(?i)(\d+(?:\.\d+)?)\s*\*?\s*({ua})\s+(?:in|to)\s+({ua})\b"
))
.unwrap()
});
static UNIT_COMPOUND_RE: LazyLock<Regex> = LazyLock::new(|| {
let ua = &*UNIT_ALT;
Regex::new(&format!(
r"(?i)(\d+(?:\.\d+)?)\s*\*?\s*({ua})\s*/\s*({ua})\s+(?:in|to)\s*({ua})\s*/\s*({ua})\b"
))
.unwrap()
});
static BARE_COMPOUND_UNITS: &[&str] = &[
"km/h",
"mi/h",
"m/s",
"km/s",
"mi/s",
"bit/s",
"bits/s",
"kilobit/s",
"kilobits/s",
"megabit/s",
"megabits/s",
"gigabit/s",
"gigabits/s",
];
static BARE_COMPOUND_UNIT_RE: LazyLock<Regex> = LazyLock::new(|| {
let alt = BARE_COMPOUND_UNITS
.iter()
.map(|u| regex_escape(u))
.collect::<Vec<_>>()
.join("|");
Regex::new(&format!(r"(?i)(\d+(?:\.\d+)?)(\s*)({alt})\b")).unwrap()
});
static SPLIT_UNIT_DIV_RE: LazyLock<Regex> = LazyLock::new(|| {
let pairs = [
("km", "h"),
("km", "hr"),
("km", "hour"),
("km", "hours"),
("mi", "h"),
("mi", "hr"),
("mi", "hour"),
("mi", "hours"),
("m", "s"),
("m", "sec"),
("m", "second"),
("m", "seconds"),
("km", "s"),
("km", "sec"),
("km", "second"),
("km", "seconds"),
("mi", "s"),
("mi", "sec"),
("mi", "second"),
("mi", "seconds"),
("km", "min"),
("km", "minute"),
("km", "minutes"),
("mi", "min"),
("mi", "minute"),
("mi", "minutes"),
];
let alt = pairs
.iter()
.map(|(a, b)| format!(r"({})\s+/\s+({})", regex_escape(a), regex_escape(b)))
.collect::<Vec<_>>()
.join("|");
Regex::new(&format!(r"(?i)(\d+(?:\.\d+)?)\s*(?:{})", alt)).unwrap()
});
static PER_UNIT_RE: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(
r"(?i)(\d+(?:\.\d+)?)\s*(kilometers?|kilometres?|miles?|meters?|metres?|feet|foot|inches?|inch|km|mi|yd|ft)\s+per\s+(hours?|hr|minutes?|min|seconds?|sec|h|s)\b",
).unwrap()
});
static BARE_SIMPLE_UNIT_RE: LazyLock<Regex> = LazyLock::new(|| {
let units = [
"mph",
"kph",
"knot",
"knots",
"ft/s",
"ft/min",
"ft/h",
"yd/s",
"yd/min",
"yd/h",
"mi/s",
"mi/min",
"mi/h",
"km/s",
"km/min",
"km/h",
"m/s",
"m/min",
"m/h",
"mach",
"m",
"cm",
"mm",
"km",
"ft",
"yd",
"mi",
"in",
"inch",
"inches",
"foot",
"feet",
"mile",
"miles",
"meter",
"meters",
"metre",
"metres",
"yard",
"yards",
"rod",
"fathom",
"kg",
"g",
"mg",
"lb",
"lbs",
"oz",
"ton",
"tonne",
"s",
"sec",
"secs",
"second",
"seconds",
"min",
"mins",
"minute",
"minutes",
"h",
"hr",
"hrs",
"hour",
"hours",
"day",
"days",
"week",
"weeks",
"year",
"years",
"l",
"L",
"ml",
"liter",
"liters",
"litre",
"litres",
"gal",
"qt",
"pt",
"cup",
"j",
"J",
"kJ",
"kj",
"cal",
"kcal",
"wh",
"kWh",
"kwh",
"w",
"W",
"kw",
"KW",
"hp",
"pa",
"Pa",
"kpa",
"KPa",
"kPa",
"mpa",
"MPa",
"psi",
"bar",
"atm",
"torr",
"mmHg",
"celsius",
"fahrenheit",
"kelvin",
"rankine",
"degc",
"degf",
"degk",
"degr",
"bit",
"bits",
"byte",
"bytes",
"kb",
"mb",
"gb",
"tb",
];
let alt = {
let mut sorted = units.to_vec();
sorted.sort_by(|a, b| b.len().cmp(&a.len()).then_with(|| a.cmp(b)));
sorted
.iter()
.map(|u| regex_escape(u))
.collect::<Vec<_>>()
.join("|")
};
Regex::new(&format!(r"(?i)(\d+(?:\.\d+)?)(\s+)({})\b", alt)).unwrap()
});
static TEMP_DEG_CONV_PATTERNS: LazyLock<Vec<Regex>> = LazyLock::new(|| {
TEMP_UNITS_LIST
.iter()
.map(|tu| {
Regex::new(&format!(
r"(?i)(\d+(?:\.\d+)?)\s*(?:degrees?|deg)\s+(?:in|to|as|into)\s+{}\b",
regex_escape(tu)
))
.unwrap()
})
.collect()
});
static TEMP_DEG_UNIT_PATTERNS: LazyLock<Vec<Regex>> = LazyLock::new(|| {
TEMP_UNITS_LIST
.iter()
.map(|tu| {
Regex::new(&format!(
r"(?i)(\d+(?:\.\d+)?)\s*(?:degrees?|deg)\s+{}\b",
regex_escape(tu)
))
.unwrap()
})
.collect()
});
static DIGIT_SCALE_PATTERNS: LazyLock<Vec<(Regex, f64)>> = LazyLock::new(|| {
let scales: &[(&str, &str)] = &[
("hundred", "100"),
("thousand", "1000"),
("million", "1000000"),
("billion", "1000000000"),
("trillion", "1000000000000"),
("quadrillion", "1000000000000000"),
("quintillion", "1000000000000000000"),
];
scales
.iter()
.map(|(word, val)| {
let re = Regex::new(&format!(r"\b(\d+(?:\.\d+)?)\s*{}\b", regex_escape(word))).unwrap();
(re, val.parse::<f64>().unwrap())
})
.collect()
});
static CONSTANT_PATTERNS: LazyLock<Vec<(Regex, &'static str)>> = LazyLock::new(|| {
let mut entries: Vec<_> = CONSTANT_WORDS.iter().collect::<Vec<_>>();
entries.sort_by_key(|(phrase, _)| std::cmp::Reverse(phrase.len()));
entries
.iter()
.map(|(phrase, canonical)| {
(
Regex::new(&word_boundary_regex(phrase)).unwrap(),
**canonical,
)
})
.collect()
});
static MULTI_WORD_PATTERNS: LazyLock<Vec<(Regex, &'static str)>> = LazyLock::new(|| {
MULTI_WORD_NUMBERS
.iter()
.map(|(phrase, replacement)| {
(
Regex::new(&word_boundary_regex(phrase)).unwrap(),
*replacement,
)
})
.collect()
});
static STRIPPED_LONG_PATTERNS: LazyLock<Vec<Regex>> = LazyLock::new(|| {
STRIPPED_PHRASES
.iter()
.filter(|p| p.len() > 10)
.map(|p| Regex::new(&word_boundary_regex(p)).unwrap())
.collect()
});
static STRIPPED_SHORT_PATTERNS: LazyLock<Vec<Regex>> = LazyLock::new(|| {
STRIPPED_PHRASES
.iter()
.filter(|p| p.len() <= 10)
.map(|p| Regex::new(&word_boundary_regex(p)).unwrap())
.collect()
});
static OPERATOR_PATTERNS: LazyLock<Vec<(Regex, &'static str)>> = LazyLock::new(|| {
let mut entries: Vec<_> = OPERATOR_CONVERSIONS.iter().collect::<Vec<_>>();
entries.sort_by_key(|(word, _)| std::cmp::Reverse(word.len()));
entries
.iter()
.map(|(word, symbol)| (Regex::new(&word_boundary_regex(word)).unwrap(), **symbol))
.collect()
});
static FUNC_NAME_PATTERNS: LazyLock<Vec<(Regex, &'static str)>> = LazyLock::new(|| {
let mut entries: Vec<_> = FUNCTION_MAPPINGS.iter().collect::<Vec<_>>();
entries.sort_by_key(|(name, _)| std::cmp::Reverse(name.len()));
entries
.iter()
.map(|(name, standard)| (Regex::new(&word_boundary_regex(name)).unwrap(), **standard))
.collect()
});
static COMPACT_FUNC_RE: LazyLock<Option<Regex>> = LazyLock::new(|| {
let funcs: Vec<&str> = FUNCTION_MAPPINGS
.values()
.copied()
.filter(|name| {
!name.ends_with(|c: char| c.is_ascii_digit()) && *name != "log10" && *name != "log2"
})
.collect();
if funcs.is_empty() {
None
} else {
Some(
Regex::new(&format!(
r"(?<![A-Za-z_])({})\s*([+-]?\d+(?:\.\d+)?)",
funcs
.iter()
.map(|f| regex_escape(f))
.collect::<Vec<_>>()
.join("|")
))
.unwrap(),
)
}
});
static FUNC_FIX_PATTERNS: LazyLock<Vec<(Regex, bool, &'static str)>> = LazyLock::new(|| {
let multi_arg_funcs: &[&str] = &[
"mean", "median", "mode", "std", "variance", "var", "gcd", "lcm", "perm", "comb", "nPr",
"nCr", "sum", "max", "min", "clamp", "gauss", "hypot", "randint",
];
FUNCTION_MAPPINGS
.values()
.copied()
.map(|func| {
let escaped = regex_escape(func);
let is_multi = multi_arg_funcs.contains(&func);
let pattern = if is_multi {
format!(r"\b{0}\s*\*\s*([^()]+)", escaped)
} else {
format!(r"\b{0}\s*\*\s*([^()+\-]*)", escaped)
};
let re = Regex::new(&pattern).unwrap_or_else(|e| {
panic!(
"FUNC_FIX_PATTERNS: invalid regex for func '{func}': {e} (pattern: {pattern})"
)
});
(re, is_multi, func)
})
.collect()
});
fn regex_escape(s: &str) -> String {
let mut result = String::new();
for c in s.chars() {
match c {
'\\' | '(' | ')' | '[' | ']' | '{' | '}' | '.' | '*' | '+' | '?' | '^' | '$' | '|' => {
result.push('\\');
result.push(c);
}
_ => result.push(c),
}
}
result
}
const MAX_TEXT_LENGTH: usize = 100_000;
#[doc(hidden)]
pub static NUMBER_WORDS: LazyLock<HashMap<&'static str, &'static str>> = LazyLock::new(|| {
let mut m = HashMap::new();
m.insert("zero", "0");
m.insert("one", "1");
m.insert("two", "2");
m.insert("three", "3");
m.insert("four", "4");
m.insert("five", "5");
m.insert("six", "6");
m.insert("seven", "7");
m.insert("eight", "8");
m.insert("nine", "9");
m.insert("ten", "10");
m.insert("eleven", "11");
m.insert("twelve", "12");
m.insert("thirteen", "13");
m.insert("fourteen", "14");
m.insert("fifteen", "15");
m.insert("sixteen", "16");
m.insert("seventeen", "17");
m.insert("eighteen", "18");
m.insert("nineteen", "19");
m.insert("twenty", "20");
m.insert("thirty", "30");
m.insert("forty", "40");
m.insert("fifty", "50");
m.insert("sixty", "60");
m.insert("seventy", "70");
m.insert("eighty", "80");
m.insert("ninety", "90");
m.insert("hundred", "100");
m.insert("thousand", "1000");
m.insert("million", "1000000");
m.insert("billion", "1000000000");
m.insert("trillion", "1000000000000");
m.insert("quadrillion", "1000000000000000");
m.insert("quintillion", "1000000000000000000");
m.insert("half", "0.5");
m.insert("quarter", "0.25");
m.insert("thousandth", "0.001");
m.insert("millionth", "0.000001");
m.insert("billionth", "0.000000001");
m
});
#[doc(hidden)]
pub static MULTI_WORD_NUMBERS: LazyLock<Vec<(&'static str, &'static str)>> = LazyLock::new(|| {
vec![
("one half", "0.5"),
("one quarter", "0.25"),
("one third", "0.3333333333333333"),
("two thirds", "0.6666666666666666"),
("three quarters", "0.75"),
]
});
#[doc(hidden)]
pub static OPERATOR_CONVERSIONS: LazyLock<HashMap<&'static str, &'static str>> =
LazyLock::new(|| {
let mut m = HashMap::new();
m.insert("plus", "+");
m.insert("positive", "+");
m.insert("minus", "-");
m.insert("negative", "-");
m.insert("times", "*");
m.insert("multiplied by", "*");
m.insert("divided by", "/");
m.insert("over", "/");
m.insert("per", "/");
m.insert("divide", "/");
m.insert("raised to the power of", "**");
m.insert("raised to", "**");
m.insert("to the power of", "**");
m.insert("mod", "%");
m.insert("modulo", "%");
m.insert("remainder", "%");
m.insert("bitand", "&");
m.insert("bit and", "&");
m.insert("bitor", "|");
m.insert("bit or", "|");
m.insert("or", "|");
m.insert("bitxor", "^");
m.insert("bit xor", "^");
m.insert("xor", "^");
m.insert("bitnot", "~");
m.insert("bit not", "~");
m.insert("not", "~");
m.insert("left shift", "<<");
m.insert("shift left", "<<");
m.insert("lshift", "<<");
m.insert("right shift", ">>");
m.insert("shift right", ">>");
m.insert("rshift", ">>");
m.insert("of", "*");
m.insert("in", "IN");
m.insert("into", "IN");
m.insert("to", "TO");
m.insert("as", "TO");
m
});
#[doc(hidden)]
pub static FUNCTION_MAPPINGS: LazyLock<HashMap<&'static str, &'static str>> = LazyLock::new(|| {
let mut m = HashMap::new();
m.insert("sine", "sin");
m.insert("cosine", "cos");
m.insert("tangent", "tan");
m.insert("arc sine", "asin");
m.insert("arcsine", "asin");
m.insert("arcsin", "asin");
m.insert("arc cosine", "acos");
m.insert("arccos", "acos");
m.insert("arccosine", "acos");
m.insert("arc tangent", "atan");
m.insert("arctan", "atan");
m.insert("arctangent", "atan");
m.insert("hyperbolic sine", "sinh");
m.insert("hyperbolic cosine", "cosh");
m.insert("hyperbolic tangent", "tanh");
m.insert("arcsinh", "asinh");
m.insert("arccosh", "acosh");
m.insert("arctanh", "atanh");
m.insert("inverse sine", "asin");
m.insert("inverse cosine", "acos");
m.insert("inverse tangent", "atan");
m.insert("inverse hyperbolic sine", "asinh");
m.insert("inverse hyperbolic cosine", "acosh");
m.insert("inverse hyperbolic tangent", "atanh");
m.insert("arc cos", "acos");
m.insert("arc sin", "asin");
m.insert("arc tan", "atan");
m.insert("hyperbolic arcsine", "asinh");
m.insert("hyperbolic arccosine", "acosh");
m.insert("hyperbolic arctangent", "atanh");
m.insert("logarithm", "log");
m.insert("natural log", "log");
m.insert("natural logarithm", "log");
m.insert("ln", "log");
m.insert("log base ten", "log10");
m.insert("log ten", "log10");
m.insert("log two", "log2");
m.insert("log base two", "log2");
m.insert("square root", "sqrt");
m.insert("cube root", "cbrt");
m.insert("root", "sqrt");
m.insert("absolute value", "abs");
m.insert("abs value", "abs");
m.insert("absolute", "abs");
m.insert("magnitude", "abs");
m.insert("ceiling", "ceil");
m.insert("fact", "factorial");
m.insert("factorial", "factorial");
m.insert("nPr", "nPr");
m.insert("nCr", "nCr");
m.insert("average", "mean");
m.insert("stdev", "std");
m.insert("gcd", "gcd");
m.insert("lcm", "lcm");
m.insert("perm", "perm");
m.insert("comb", "comb");
m.insert("percent_of", "percentof");
m.insert("as_percent", "aspercent");
m.insert("is_prime", "isprime");
m.insert("prime_factors", "primefactors");
m.insert("next_prime", "nextprime");
m.insert("prev_prime", "prevprime");
m.insert("convert", "convert");
m.insert("temp", "temp");
m.insert("floor", "floor");
m.insert("trunc", "trunc");
m.insert("sign", "sign");
m.insert("degrees", "degrees");
m.insert("radians", "radians");
m.insert("hypot", "hypot");
m.insert("round", "round");
m.insert("pow", "pow");
m.insert("atan2", "atan2");
m.insert("log1p", "log1p");
m.insert("expm1", "expm1");
m.insert("uniform", "uniform");
m.insert("cbrt", "cbrt");
m.insert("sqrt", "sqrt");
m.insert("log", "log");
m.insert("log10", "log10");
m.insert("log2", "log2");
m.insert("abs", "abs");
m.insert("exp", "exp");
m.insert("ceil", "ceil");
m.insert("clamp", "clamp");
m.insert("sin", "sin");
m.insert("cos", "cos");
m.insert("tan", "tan");
m.insert("asin", "asin");
m.insert("acos", "acos");
m.insert("atan", "atan");
m.insert("sinh", "sinh");
m.insert("cosh", "cosh");
m.insert("tanh", "tanh");
m.insert("asinh", "asinh");
m.insert("acosh", "acosh");
m.insert("atanh", "atanh");
m.insert("mean", "mean");
m.insert("median", "median");
m.insert("mode", "mode");
m.insert("std", "std");
m.insert("std_sample", "std_sample");
m.insert("stds", "std_sample");
m.insert("variance", "variance");
m.insert("var", "var");
m.insert("variance_sample", "variance_sample");
m.insert("vars", "vars");
m.insert("var_sample", "var_sample");
m.insert("sum", "sum");
m.insert("max", "max");
m.insert("min", "min");
m.insert("product", "product");
m.insert("real", "real");
m.insert("imag", "imag");
m.insert("conj", "conj");
m.insert("conjugate", "conj");
m.insert("phase", "phase");
m.insert("polar", "polar");
m.insert("rect", "rect");
m.insert("bitand", "bitand");
m.insert("bitor", "bitor");
m.insert("bitxor", "bitxor");
m.insert("bitnot", "bitnot");
m.insert("bitlshift", "bitlshift");
m.insert("bitrshift", "bitrshift");
m.insert("store", "store");
m.insert("recall", "recall");
m.insert("Mplus", "Mplus");
m.insert("Mminus", "Mminus");
m.insert("MC", "MC");
m.insert("MR", "MR");
m.insert("M", "MR");
m.insert("setvar", "setvar");
m.insert("getvar", "getvar");
m.insert("delvar", "delvar");
m.insert("listvars", "listvars");
m.insert("clearvars", "clearvars");
m.insert("random", "random");
m.insert("randint", "randint");
m.insert("randrange", "randrange");
m.insert("randn", "randn");
m.insert("gauss", "gauss");
m.insert("seed", "seed");
m
});
#[doc(hidden)]
pub static CONSTANT_WORDS: LazyLock<HashMap<&'static str, &'static str>> = LazyLock::new(|| {
let mut m = HashMap::new();
m.insert("avogadro number", "na");
m.insert("avogadro", "na");
m.insert("avogadros", "na");
m.insert("gas constant", "r");
m.insert("molar gas constant", "r");
m.insert("ideal gas constant", "r");
m.insert("planck constant", "planckconstant");
m.insert("planck", "planckconstant");
m.insert("boltzmann constant", "k");
m.insert("boltzmann", "k");
m.insert("speed of light", "c");
m.insert("speed of light in vacuum", "c");
m.insert("c zero", "c");
m.insert("elementary charge", "elementarycharge");
m.insert("e charge", "elementarycharge");
m.insert("faraday constant", "f");
m.insert("faraday", "f");
m.insert("atomic mass", "u");
m.insert("atomic mass unit", "u");
m.insert("amu", "u");
m.insert("vacuum permittivity", "epsilon0");
m.insert("permittivity of free space", "epsilon0");
m.insert("vacuum permeability", "mu0");
m.insert("permeability of free space", "mu0");
m.insert("magnetic constant", "mu0");
m.insert("standard gravity", "standardgravity");
m.insert("gravity", "standardgravity");
m.insert("earth gravity", "standardgravity");
m.insert("gravitational constant", "gravitationalconstant");
m.insert("newton constant", "gravitationalconstant");
m.insert("big g", "G");
m.insert("electron mass", "me");
m.insert("proton mass", "mp");
m.insert("neutron mass", "mn");
m.insert("classical electron radius", "re");
m.insert("electron radius", "re");
m.insert("fine structure constant", "alpha");
m.insert("sommerfeld", "alpha");
m.insert("rydberg constant", "rydberg");
m.insert("stefan boltzmann", "stefan");
m.insert("stefan-boltzmann constant", "stefan");
m.insert("wien constant", "wien");
m.insert("wien displacement", "wien");
m
});
#[doc(hidden)]
pub static STRIPPED_PHRASES: LazyLock<Vec<&'static str>> = LazyLock::new(|| {
vec![
"what's",
"what is",
"a",
"?",
"calculate",
"compute",
"tell me",
"give me",
"the ",
"please ",
"hey ",
"hi ",
"can you ",
"could you ",
"would you ",
"i want to know ",
"i'd like to know ",
"what's the value of ",
"what's the result of ",
"what is the value of ",
"what is the result of ",
"the value of ",
"the result of ",
"the answer is ",
"and ",
]
});
fn word_boundary_regex(word: &str) -> String {
format!(r"\b{}\b", regex_escape(word))
}
pub fn warm_calculator_regex_cache() {
let _ = &*PCT_SYMBOL_RE;
let _ = &*PERCENT_RE;
let _ = &*COMPLEX_RE;
let _ = &*UNIT_ALT;
let _ = &*NUMBER_WORD_ALT;
let _ = &*TEMP_UNITS_LIST;
let _ = &*TEMP_CONVERSION_RE;
let _ = &*BINARY_WORD_RE;
let _ = &*BINARY_WORD_INNER_RE;
let _ = &*TO_THE_POWER_RE;
let _ = &*DEGREES_NON_TEMP_RE;
let _ = &*DEGREES_RE;
let _ = &*POINT_RE;
let _ = &*MERGE_DECIMAL_RE;
let _ = &*IMPLICIT_MUL_FUNC_RE;
let _ = &*IMPLICIT_MUL_PAREN_RE;
let _ = &*IMPLICIT_MUL_DIGIT_PAREN_RE;
let _ = &*FACTORIAL_RE;
let _ = &*SPLIT_NUM_MINUS_RE;
let _ = &*SPLIT_DOUBLE_MINUS_RE;
let _ = &*SPLIT_TRAILING_MINUS_RE;
let _ = &*UNIT_INLINE_RE;
let _ = &*SAME_UNIT_DIV_RE;
let _ = &*CONVERT_SIMPLE_RE;
let _ = &*CONVERT_BARE_RE;
let _ = &*TEMP_HANDLE_RE;
let _ = &*HYPHEN_RE;
let _ = &*NUMBER_WORD_RE;
let _ = unit_caret_attach_re();
let _ = unit_caret_denom_re();
let _ = unit_caret_paren_re();
let _ = &*UNIT_POWER_RE;
let _ = &*UNIT_SPELLED_RE;
let _ = &*UNIT_COMPOUND_RE;
let _ = &*BARE_COMPOUND_UNIT_RE;
let _ = &*SPLIT_UNIT_DIV_RE;
let _ = &*PER_UNIT_RE;
let _ = &*BARE_SIMPLE_UNIT_RE;
let _ = &*TEMP_DEG_CONV_PATTERNS;
let _ = &*TEMP_DEG_UNIT_PATTERNS;
let _ = &*DIGIT_SCALE_PATTERNS;
let _ = &*CONSTANT_PATTERNS;
let _ = &*MULTI_WORD_PATTERNS;
let _ = &*STRIPPED_LONG_PATTERNS;
let _ = &*STRIPPED_SHORT_PATTERNS;
let _ = &*OPERATOR_PATTERNS;
let _ = &*FUNC_NAME_PATTERNS;
let _ = &*COMPACT_FUNC_RE;
let _ = &*FUNC_FIX_PATTERNS;
let _ = &*NUMBER_WORDS;
let _ = &*MULTI_WORD_NUMBERS;
let _ = &*OPERATOR_CONVERSIONS;
let _ = &*FUNCTION_MAPPINGS;
let _ = &*CONSTANT_WORDS;
let _ = &*STRIPPED_PHRASES;
}
fn combine_consecutive_number_words(input: &str) -> String {
let parts: Vec<&str> = input.split_whitespace().collect();
if parts.is_empty() {
return input.to_string();
}
let mut result = Vec::new();
let mut i = 0;
while i < parts.len() {
if let Some(first_num) = parse_simple_number(parts[i]) {
let mut run: Vec<(String, f64)> = vec![(parts[i].to_string(), first_num)];
let mut j = i + 1;
while j < parts.len() {
if let Some(n) = parse_simple_number(parts[j]) {
run.push((parts[j].to_string(), n));
j += 1;
} else {
break;
}
}
if run.len() > 1 {
let combined = combine_number_run(&run);
for token in combined {
result.push(token);
}
} else {
result.push(parts[i].to_string());
}
i = j;
} else {
result.push(parts[i].to_string());
i += 1;
}
}
result.join(" ")
}
fn parse_simple_number(token: &str) -> Option<f64> {
let s = token.strip_prefix('+').unwrap_or(token);
s.parse::<f64>().ok()
}
fn combine_number_run(run: &[(String, f64)]) -> Vec<String> {
if run.is_empty() {
return vec![];
}
let values: Vec<f64> = run.iter().map(|(_, v)| *v).collect();
let has_scientific = run.iter().any(|(s, _)| s.contains('e'));
let has_compound = !has_scientific
&& values
.iter()
.any(|&v| v >= 100.0 || ((20.0..100.0).contains(&v) && v % 10.0 == 0.0));
if has_compound && values.len() > 1 {
combine_number_parts(&values)
} else {
let mut result = Vec::new();
for (i, (orig, _)) in run.iter().enumerate() {
if i > 0 {
result.push("+".to_string());
}
result.push(orig.clone());
}
result
}
}
fn combine_number_parts(values: &[f64]) -> Vec<String> {
if values.is_empty() {
return vec![];
}
let mut total = 0.0;
let mut group = 0.0;
for &part in values {
if part == 100.0 {
if group == 0.0 {
group = 1.0;
}
group *= part;
} else if part >= 1000.0 {
if group == 0.0 {
group = 1.0;
}
total += group * part;
group = 0.0;
} else {
group += part;
}
}
vec![format_integer_or_float(total + group)]
}
pub(crate) fn format_integer_or_float(v: f64) -> String {
if v.fract() == 0.0
&& v.abs() <= 9_007_199_254_740_992.0
&& v >= i64::MIN as f64
&& v < 9_223_372_036_854_775_808.0
{
format!("{}", v as i64)
} else {
format!("{}", v)
}
}
fn normalize_lowercase_temperature_conversion(expr: &str) -> Result<String, String> {
try_replace_all(
"normalize_lowercase_temperature_conversion",
&TEMP_CONVERSION_RE,
expr,
|caps: &Captures| {
let from_unit = caps[2].to_uppercase();
let to_unit = caps[4].to_uppercase();
let conv_word = caps[3].to_uppercase();
format!("{} {} {} {}", &caps[1], from_unit, conv_word, to_unit)
},
)
}
fn binary_word_check(expr: &str) -> Result<(), String> {
let m = BINARY_WORD_RE
.find(expr)
.map_err(|err| normalization_regex_error("binary_word_check", err))?;
if let Some(m) = m {
let matched = m.as_str();
let wm = BINARY_WORD_INNER_RE
.find(matched)
.map_err(|err| normalization_regex_error("binary_word_check_inner", err))?;
if let Some(wm) = wm {
let word = wm.as_str().to_lowercase();
return Err(format!(
"Syntax error: '{}' is not a binary operator in this context. \
Use parentheses for unary 'not' (e.g., '~(5+6)'); \
for unit conversion, follow the pattern '<value> in <unit>'.",
word
));
}
}
Ok(())
}
pub fn normalize(expr: &str) -> Result<String, String> {
if expr.len() > MAX_TEXT_LENGTH {
return Err(format!("Input exceeds {} bytes", MAX_TEXT_LENGTH));
}
let mut result = expr.replace('\u{00d7}', "*"); result = result.replace('\u{00f7}', "/"); result = result.replace('\u{2212}', "-");
let result = result.to_lowercase();
binary_word_check(&result)?;
let result = normalize_lowercase_temperature_conversion(&result)?;
let mut result = try_replace_all("hyphen_between_number_words", &HYPHEN_RE, &result, "$1 $2")?;
for re in STRIPPED_LONG_PATTERNS.iter() {
result = try_replace_all("strip_long_phrases", re, &result, "")?;
}
result = try_replace_all("to_the_power", &TO_THE_POWER_RE, &result, "$1**$2")?;
for tu_re in TEMP_DEG_CONV_PATTERNS.iter() {
result = try_replace_all("temp_deg_conv", tu_re, &result, "$1")?;
}
for tu_re in TEMP_DEG_UNIT_PATTERNS.iter() {
result = try_replace_all("temp_deg_unit", tu_re, &result, "$1")?;
}
result = try_replace_all(
"degrees_non_temp",
&DEGREES_NON_TEMP_RE,
&result,
"($1*pi/180)*$2",
)?;
result = try_replace_all("degrees", &DEGREES_RE, &result, "($1*pi/180)")?;
if result.contains('^') {
result = try_replace_all(
"unit_caret_attach",
unit_caret_attach_re(),
&result,
|caps: &Captures| {
let unit = &caps[2];
let power = &caps[3];
format!("{} {}{}", &caps[1], unit, power)
},
)?;
result = try_replace_all(
"unit_caret_denom",
unit_caret_denom_re(),
&result,
|caps: &Captures| {
let unit = caps[1].to_lowercase();
format!("/{}**{}", unit, &caps[2])
},
)?;
result = try_replace_all(
"unit_caret_paren",
unit_caret_paren_re(),
&result,
|caps: &Captures| {
let unit = caps[1].to_lowercase();
format!("/({})**{}", unit, &caps[2])
},
)?;
}
for (re, sv) in DIGIT_SCALE_PATTERNS.iter() {
result = try_replace_all("digit_scale", re, &result, |caps: &Captures| {
let v: f64 = caps[1].parse().unwrap_or(0.0);
let product = v * sv;
if product.fract() == 0.0 && product.abs() < 1e15 {
format!("{}", product as i64)
} else {
format!("{}", product)
}
})?;
}
result = try_replace_all("pct_symbol", &PCT_SYMBOL_RE, &result, "($1/100)")?;
result = try_replace_all("percent", &PERCENT_RE, &result, "($1/100)")?;
for (re, canonical) in CONSTANT_PATTERNS.iter() {
result = try_replace_all("constant_phrases", re, &result, *canonical)?;
}
for (re, replacement) in MULTI_WORD_PATTERNS.iter() {
result = try_replace_all("multi_word_fractions", re, &result, *replacement)?;
}
result = try_replace_all(
"number_words",
&NUMBER_WORD_RE,
&result,
|caps: &Captures| {
NUMBER_WORDS
.get(caps.get(1).map(|m| m.as_str()).unwrap_or(""))
.copied()
.unwrap_or("")
},
)?;
result = try_replace_all("point_decimal", &POINT_RE, &result, ".")?;
for _ in 0..16 {
let next_result = try_replace_all("merge_decimal", &MERGE_DECIMAL_RE, &result, "$1$2")?;
if next_result == result {
break;
}
result = next_result;
}
result = combine_consecutive_number_words(&result);
result = try_replace_all("per_unit", &PER_UNIT_RE, &result, |caps: &Captures| {
let num = &caps[1];
let distance = caps[2].to_lowercase();
let time = caps[3].to_lowercase();
let dist_unit: &str = match distance.as_str() {
"kilometer" | "kilometers" | "kilometre" | "kilometres" | "km" => "km",
"mile" | "miles" | "mi" => "mi",
"meter" | "meters" | "metre" | "metres" | "m" => "m",
"foot" | "feet" | "ft" => "ft",
"inch" | "inches" => "in",
"yard" | "yards" | "yd" => "yd",
_ => return caps[0].to_string(),
};
let time_unit: &str = match time.as_str() {
"hour" | "hours" | "hr" | "h" => "h",
"minute" | "minutes" | "min" => "min",
"second" | "seconds" | "sec" | "s" => "s",
_ => return caps[0].to_string(),
};
format!("{}*{}/{}", num, dist_unit, time_unit)
})?;
result = try_replace_all(
"split_unit_div",
&SPLIT_UNIT_DIV_RE,
&result,
|caps: &Captures| {
let num = caps.get(1).map(|m| m.as_str()).unwrap_or("0");
let u1 = caps.get(2).map(|m| m.as_str()).unwrap_or("");
let u2 = caps.get(3).map(|m| m.as_str()).unwrap_or("");
format!("{}*{}/{}", num, u1, u2)
},
)?;
result = try_replace_all(
"bare_compound_unit",
&BARE_COMPOUND_UNIT_RE,
&result,
"$1*$3",
)?;
result = try_replace_all("bare_simple_unit", &BARE_SIMPLE_UNIT_RE, &result, "$1*$3")?;
if let Some(ref compact_re) = *COMPACT_FUNC_RE {
result = try_replace_all("compact_func", compact_re, &result, "$1 $2")?;
}
for (re, symbol) in OPERATOR_PATTERNS.iter() {
result = try_replace_all("operator_words", re, &result, *symbol)?;
}
for (re, standard) in FUNC_NAME_PATTERNS.iter() {
result = try_replace_all("function_names", re, &result, *standard)?;
}
for (re, is_multi, func) in FUNC_FIX_PATTERNS.iter() {
result = try_replace_all("func_fix", re, &result, |caps: &Captures| {
let arg = caps[1].trim();
if arg.is_empty() {
format!("{} *", func)
} else if *is_multi {
let mut comma_parts = Vec::new();
let mut current = String::new();
let mut paren_depth = 0;
let chars: Vec<char> = arg.chars().collect();
let mut i = 0;
while i < chars.len() {
match chars[i] {
'(' => {
paren_depth += 1;
current.push(chars[i]);
i += 1;
}
')' => {
paren_depth -= 1;
current.push(chars[i]);
i += 1;
}
'+' | '-' if paren_depth == 0 && !current.is_empty() => {
let last_non_space = current.trim_end().chars().last();
match last_non_space {
Some('(') | Some('+') | Some('-') | Some('*') | Some('/')
| Some(',') => {
current.push(chars[i]);
i += 1;
}
_ => {
let trimmed = current.trim().to_string();
if !trimmed.is_empty() {
comma_parts.push(trimmed);
}
current = String::new();
if chars[i] == '-' {
current.push('-');
}
i += 1;
}
}
}
_ => {
current.push(chars[i]);
i += 1;
}
}
}
let trimmed = current.trim().to_string();
if !trimmed.is_empty() {
comma_parts.push(trimmed);
}
format!("{}({})", func, comma_parts.join(","))
} else {
format!("{}({})", func, arg)
}
})?;
}
result = try_replace_all("unit_power", &UNIT_POWER_RE, &result, |caps: &Captures| {
let unit = &caps[1];
let power = if caps[2].eq_ignore_ascii_case("squared") {
"2"
} else {
"3"
};
format!("{}{}", unit, power)
})?;
result = try_replace_all(
"unit_spelled",
&UNIT_SPELLED_RE,
&result,
"convert($1*$2,$3)",
)?;
result = try_replace_all(
"unit_compound",
&UNIT_COMPOUND_RE,
&result,
|caps: &Captures| {
let num = &caps[1];
let from_num = &caps[2];
let from_den = &caps[3];
let to_num = &caps[4];
let to_den = &caps[5];
format!(
"convert({}*{}/{},{}/{})",
num, from_num, from_den, to_num, to_den
)
},
)?;
for re in STRIPPED_SHORT_PATTERNS.iter() {
result = try_replace_all("strip_short_phrases", re, &result, "")?;
}
result = try_replace_all("complex_number", &COMPLEX_RE, &result, "($1$2$3j)")?;
let mut result = result.split_whitespace().collect::<Vec<_>>().join(" ");
result = try_replace_all("implicit_mul_func", &IMPLICIT_MUL_FUNC_RE, &result, "$1*$2")?;
result = try_replace_all(
"implicit_mul_paren",
&IMPLICIT_MUL_PAREN_RE,
&result,
"$1*$2",
)?;
result = try_replace_all(
"implicit_mul_digit_paren",
&IMPLICIT_MUL_DIGIT_PAREN_RE,
&result,
"$1*(",
)?;
loop {
let next = try_replace_all("factorial", &FACTORIAL_RE, &result, |caps: &Captures| {
let content = &caps[1];
let bangs = &caps[2];
let mut out = format!("factorial({})", content);
if bangs.len() > 1 {
out.push_str(&"!".repeat(bangs.len() - 1));
}
out
})?;
if next == result {
break;
}
result = next;
}
Ok(result)
}
pub fn split_at_operators(expr: &str) -> Vec<String> {
let mut tokens = Vec::new();
let mut current = String::new();
let mut paren_depth = 0;
let chars: Vec<char> = expr.chars().collect();
let mut i = 0;
while i < chars.len() {
let ch = chars[i];
match ch {
'(' | '[' => {
paren_depth += 1;
current.push(ch);
i += 1;
}
')' | ']' => {
paren_depth -= 1;
current.push(ch);
i += 1;
}
'+' | '-' if paren_depth == 0 => {
let is_scientific =
!current.is_empty() && matches!(current.chars().last(), Some('e') | Some('E'));
if is_scientific {
current.push(ch);
i += 1;
continue;
}
if !current.trim().is_empty() {
tokens.push(current.trim().to_string());
}
tokens.push(ch.to_string());
current = String::new();
i += 1;
}
'/' | '%' if paren_depth == 0 => {
if !current.trim().is_empty() {
tokens.push(current.trim().to_string());
}
tokens.push(ch.to_string());
current = String::new();
i += 1;
}
'*' | '^' if paren_depth == 0 => {
if ch == '*' && i + 1 < chars.len() && chars[i + 1] == '*' {
if !current.trim().is_empty() {
tokens.push(current.trim().to_string());
}
tokens.push("**".to_string());
current = String::new();
i += 2;
continue;
}
if !current.trim().is_empty() {
tokens.push(current.trim().to_string());
}
tokens.push(ch.to_string());
current = String::new();
i += 1;
}
_ => {
current.push(ch);
i += 1;
}
}
}
if !current.trim().is_empty() {
tokens.push(current.trim().to_string());
}
let mut i = 0;
while i < tokens.len() {
let token = tokens[i].clone();
let is_op = token == "+"
|| token == "-"
|| token == "/"
|| token == "%"
|| token == "*"
|| token == "**"
|| token == "^";
if !is_op {
if should_split_number_minus(&token) {
let parts: Vec<&str> = token.splitn(2, '-').collect();
tokens[i] = parts[0].to_string();
tokens.insert(i + 1, "-".to_string());
tokens.insert(i + 2, parts[1].to_string());
continue; }
else if should_split_trailing_minus(&token) {
let num_part = &token[..token.len() - 1];
tokens[i] = num_part.to_string();
tokens.insert(i + 1, "-".to_string());
continue; }
else if should_split_double_minus(&token) {
let parts: Vec<&str> = token.splitn(2, "--").collect();
tokens[i] = parts[0].to_string();
tokens.insert(i + 1, "-".to_string());
tokens.insert(i + 2, format!("-{}", parts[1]));
continue;
}
else if should_split_number_sequence(&token) {
let parts: Vec<&str> = token.split_whitespace().collect();
let mut new_tokens: Vec<String> = Vec::new();
for (pi, part) in parts.iter().enumerate() {
if pi > 0 {
new_tokens.push("+".to_string());
}
new_tokens.push(part.to_string());
}
tokens.splice(i..i + 1, new_tokens);
continue; }
}
i += 1;
}
tokens
}
fn should_split_number_minus(token: &str) -> bool {
SPLIT_NUM_MINUS_RE.is_match(token).unwrap_or(false)
}
fn should_split_double_minus(token: &str) -> bool {
SPLIT_DOUBLE_MINUS_RE.is_match(token).unwrap_or(false)
}
fn should_split_trailing_minus(token: &str) -> bool {
SPLIT_TRAILING_MINUS_RE.is_match(token).unwrap_or(false)
}
fn should_split_number_sequence(token: &str) -> bool {
if !token.contains(' ') {
return false;
}
let parts: Vec<&str> = token.split_whitespace().collect();
if parts.len() < 2 {
return false;
}
for part in &parts {
let stripped = part.trim_start_matches('+').trim_start_matches('-');
if stripped.is_empty() {
return false;
}
if stripped.parse::<f64>().is_err() {
return false;
}
}
true
}
#[doc(hidden)]
pub fn preprocess_units(tokens: &[String]) -> Result<(Vec<String>, Option<String>), String> {
let joined = tokens.join("");
let mut detected_unit: Option<String> = UNIT_INLINE_RE
.captures(&joined)
.map_err(|err| normalization_regex_error("preprocess_units_detect", err))?
.and_then(|caps| {
let unit = caps.name("unit").map(|m| m.as_str()).unwrap_or("");
if let Some(canon) = resolve_unit_alias(unit) {
return Some(canon);
}
if unit.contains('/') {
return Some(unit.to_string());
}
None
});
if detected_unit.is_none() {
if let Some(idx) = joined.find('%') {
let prefix = &joined[..idx];
if prefix.ends_with(|c: char| c.is_ascii_digit() || c == '.') {
let after = joined.as_bytes().get(idx + 1).copied().unwrap_or(b' ');
if !after.is_ascii_digit() {
detected_unit = Some("%".to_string());
}
}
}
}
let target_unit = match detected_unit.as_deref() {
Some(u) => u,
None => return Ok((tokens.to_vec(), None)),
};
let rewritten = try_replace_all(
"preprocess_units_convert",
&UNIT_INLINE_RE,
&joined,
|caps: &Captures| {
let num_str = caps.name("num").map(|m| m.as_str()).unwrap_or("0");
let unit = caps.name("unit").map(|m| m.as_str()).unwrap_or("");
match resolve_unit_alias(unit) {
None => caps[0].to_string(),
Some(canon) if canon == target_unit => num_str.to_string(),
Some(canon) => {
if canon.contains('/')
&& !crate::calc::units::UNIT_ALIASES.contains_key(canon.as_str())
{
return caps[0].to_string();
}
match crate::calc::units::get_conversion_factor(&canon, target_unit) {
Ok(factor) => {
if let Ok(num) = num_str.parse::<f64>() {
let converted = num * factor;
if converted.fract() == 0.0 && converted.abs() < 1e15 {
format!("{}", converted as i64)
} else {
format!("{}", converted)
}
} else {
num_str.to_string()
}
}
Err(_) => caps[0].to_string(),
}
}
}
},
)?;
let mut re_tokens = split_at_operators(&rewritten);
if target_unit == "%" {
re_tokens.retain(|t| t != "%");
}
Ok((re_tokens, Some(target_unit.to_string())))
}
fn resolve_unit_alias(unit: &str) -> Option<String> {
if let Some(canon) = crate::calc::units::UNIT_ALIASES.get(unit) {
return Some(canon.to_string());
}
let lower = unit.to_lowercase();
if let Some(canon) = crate::calc::units::UNIT_ALIASES.get(lower.as_str()) {
return Some(canon.to_string());
}
None
}
pub type RunResult = (String, String);
#[derive(Debug, Clone)]
pub enum RunError {
Evaluation(String),
Internal(String),
}
impl std::fmt::Display for RunError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
RunError::Evaluation(msg) => write!(f, "{}", msg),
RunError::Internal(msg) => write!(f, "{}", msg),
}
}
}
impl std::error::Error for RunError {}
pub fn add_same_unit_division_parens(expr: &str) -> Result<String, String> {
try_replace_all(
"add_same_unit_division_parens",
&SAME_UNIT_DIV_RE,
expr,
|caps: &Captures| {
let left_unit = &caps[1];
let denom = &caps[2];
let right_unit = &caps[3];
format!("{}/({}*{})", left_unit, denom, right_unit)
},
)
}
pub fn run(expr: &str) -> Result<RunResult, RunError> {
let normalized = normalize(expr).map_err(RunError::Internal)?;
if let Some(result) = handle_convert_pattern(&normalized) {
return result.map_err(RunError::Evaluation);
}
if let Some(result) = handle_temp_pattern(&normalized) {
return result.map_err(RunError::Evaluation);
}
let tokens = split_at_operators(&normalized);
let (tokens, detected_unit) = preprocess_units(&tokens).map_err(RunError::Internal)?;
let processed = tokens.join("");
let processed = add_same_unit_division_parens(&processed).map_err(RunError::Internal)?;
let (value, value_type) =
crate::calc::evaluator::evaluate(&processed).map_err(RunError::Evaluation)?;
if let Some(unit) = detected_unit {
Ok((format!("{} {}", value, unit), value_type))
} else {
Ok((value, value_type))
}
}
pub fn run_with_context(
expr: &str,
ctx: &mut crate::calc::context::EvalContext,
) -> Result<RunResult, RunError> {
let normalized = normalize(expr).map_err(RunError::Internal)?;
if let Some(result) = handle_convert_pattern(&normalized) {
return result.map_err(RunError::Evaluation);
}
if let Some(result) = handle_temp_pattern(&normalized) {
return result.map_err(RunError::Evaluation);
}
let tokens = split_at_operators(&normalized);
let (tokens, detected_unit) = preprocess_units(&tokens).map_err(RunError::Internal)?;
let processed = tokens.join("");
let processed = add_same_unit_division_parens(&processed).map_err(RunError::Internal)?;
let (value, value_type) = crate::calc::evaluator::evaluate_with_context(&processed, ctx)
.map_err(RunError::Evaluation)?;
if let Some(unit) = detected_unit {
Ok((format!("{} {}", value, unit), value_type))
} else {
Ok((value, value_type))
}
}
fn handle_convert_pattern(normalized: &str) -> Option<Result<RunResult, String>> {
if let Ok(Some(caps)) = CONVERT_SIMPLE_RE.captures(normalized) {
let num_str = &caps[1];
let from_unit = &caps[2];
let to_unit = &caps[3];
let value = num_str.parse::<f64>().ok()?;
return Some(handle_convert_value(value, from_unit, to_unit));
}
if let Ok(Some(caps)) = CONVERT_BARE_RE.captures(normalized) {
let num_str = &caps[1];
let to_unit = &caps[2];
let value = num_str.parse::<f64>().ok()?;
return Some(Ok((
format!("{} {}", format_integer_or_float(value), to_unit),
"float".to_string(),
)));
}
None
}
fn resolve_unit_canon(unit: &str) -> String {
if let Some(canon) = crate::calc::units::UNIT_ALIASES.get(unit).copied() {
return canon.to_string();
}
let lower = unit.to_lowercase();
if let Some(canon) = crate::calc::units::UNIT_ALIASES
.get(lower.as_str())
.copied()
{
return canon.to_string();
}
unit.to_string()
}
fn handle_convert_value(value: f64, from_unit: &str, to_unit: &str) -> Result<RunResult, String> {
let from_resolved = resolve_unit_canon(from_unit);
let to_resolved = resolve_unit_canon(to_unit);
let from_is_temp = crate::calc::units::UNIT_BASE
.get(from_resolved.as_str())
.map(|d| d.category == "temperature")
.unwrap_or(false);
let to_is_temp = crate::calc::units::UNIT_BASE
.get(to_resolved.as_str())
.map(|d| d.category == "temperature")
.unwrap_or(false);
if from_is_temp && to_is_temp {
let converted =
crate::calc::units::convert_temperature(value, &from_resolved, &to_resolved)?;
Ok((
format!("{} {}", format_integer_or_float(converted), to_resolved),
"float".to_string(),
))
} else {
let factor = crate::calc::units::get_conversion_factor(&from_resolved, &to_resolved)?;
let converted = value * factor;
Ok((
format!("{} {}", format_integer_or_float(converted), to_resolved),
"float".to_string(),
))
}
}
fn handle_temp_pattern(normalized: &str) -> Option<Result<RunResult, String>> {
if let Ok(Some(caps)) = TEMP_HANDLE_RE.captures(normalized) {
let value_str = &caps[1];
let from_unit = &caps[2];
let to_unit = &caps[3];
if let Ok(value) = value_str.parse::<f64>() {
match crate::calc::units::convert_temperature(value, from_unit, to_unit) {
Ok(converted) => {
return Some(Ok((
format!("{} {}", format_integer_or_float(converted), to_unit),
"float".to_string(),
)));
}
Err(e) => {
return Some(Err(e));
}
}
}
}
None
}