use super::arithmetic::eval;
use crate::{Context, Outcome, Plugin, number, re};
mod comparisons;
pub(crate) use comparisons::comparisons as comparison_operators;
pub struct Statistics;
fn scalar(s: &str) -> Option<f64> {
s.trim()
.replace(',', "")
.parse::<f64>()
.ok()
.filter(|n| n.is_finite())
.or_else(|| eval(s))
}
impl Plugin for Statistics {
fn evaluate(&self, input: &str, ctx: &Context) -> Outcome {
let s = input
.to_lowercase()
.replace("<>", " > ")
.replace("=>", " >= ");
if let Some(c) =
re!(r"^(lesser|greater|midpoint|halfway) (?:of|between) (.+) and (.+)$").captures(&s)
{
if re!(r"\d{4}-\d{2}-\d{2}").is_match(&s) {
return None;
}
let (a, b) = (scalar(&c[2])?, scalar(&c[3])?);
return Some(Ok(number(match &c[1] {
"lesser" => a.min(b),
"greater" => a.max(b),
_ => (a + b) / 2.0,
})));
}
let s =
re!(r"^clamp ([\d.]+) ([\d.]+) ([\d.]+)$").replace(&s, "clamp $1 between $2 and $3");
let s = re!(r"^round (up|down) (.+) to ").replace(&s, "round $2 $1 to ");
if re!(r"^(?:average|sum): ").is_match(&s) {
return Some(Err(crate::Error("null_result".into())));
}
let n = if let Some(c) = re!(r"^(min and max|average|avg|mean|median|sum|total|min|max|standard deviation)(?: of| between)? (.+)$").captures(&s) {
let tail = c[2].replace(" and ", ",").replace(';', ",");
if tail.contains('/') || tail.contains(",,") { return None; }
if tail.starts_with('(') && tail.ends_with(')') { return Some(Err(crate::Error("internal_error".into()))); }
let tail = tail.trim_end_matches("and").trim();
let pieces: Vec<_> = if re!(r"^[\d.+ -]+$").is_match(tail) && !tail.contains(" + ") && !tail.contains(" - ") {
tail.split_whitespace().collect()
} else { tail.split(',').map(str::trim).filter(|s| !s.is_empty()).collect() };
if pieces.iter().any(|p| p.starts_with('+') || p.ends_with('.') || (p.starts_with('-') && scalar(p) == Some(0.0))) { return None; }
return list_statistic(&c[1], &pieces, ctx);
} else if let Some(c) =
re!(r"^clamp (.+) (?:between|from) (.+) (?:and|to) (.+)$").captures(&s)
{
scalar(&c[1])?.max(scalar(&c[2])?).min(scalar(&c[3])?)
} else if let Some(c) =
re!(r"^round (.+?) (up|down)?\s*(?:to (?:nearest |next |last )?)(.+)$").captures(&s)
{
let x = scalar(&c[1])?;
let step = scalar(&c[3])?;
let v = x / step;
match c.get(2).map(|m| m.as_str()) {
Some("up") => v.ceil() * step,
Some("down") => v.floor() * step,
_ => (v + 0.5).floor() * step,
}
} else if let Some(c) = re!(r"^round (.+) (up|down)$").captures(&s) {
let x = scalar(&c[1])?;
if &c[2] == "up" { x.ceil() } else { x.floor() }
} else {
return comparisons::evaluate(input,ctx);
};
n.is_finite().then(|| Ok(number(n)))
}
}
fn statistic(kind: &str, values: &mut [f64]) -> Option<f64> {
if values.is_empty() {
return None;
}
let sum: f64 = values.iter().sum();
let len = values.len() as f64;
Some(match kind {
"average" | "avg" | "mean" => sum / len,
"sum" | "total" => sum,
"min" => values.iter().copied().fold(f64::INFINITY, f64::min),
"max" | "min and max" => values.iter().copied().fold(f64::NEG_INFINITY, f64::max),
"standard deviation" => {
if values.len() < 2 {
return None;
}
let mean = sum / len;
(values.iter().map(|v| (v - mean).powi(2)).sum::<f64>() / (len - 1.0)).sqrt()
}
_ => {
values.sort_by(f64::total_cmp);
let mid = values.len() / 2;
if values.len().is_multiple_of(2) {
(values[mid - 1] + values[mid]) / 2.0
} else {
values[mid]
}
}
})
}
fn list_statistic(kind: &str, pieces: &[&str], ctx: &Context) -> Outcome {
if pieces.is_empty() {
return None;
}
if pieces.len() == 1 && pieces[0].contains('|') {
let value = super::integers::Integers.evaluate(pieces[0], ctx)?.ok()?;
return Some(Ok(number(statistic(kind, &mut [scalar(&value)?])?)));
}
if let Some(mut values) = pieces.iter().map(|p| scalar(p)).collect::<Option<Vec<_>>>() {
let logs: Vec<_> = values
.iter()
.filter(|v| **v != 0.0)
.map(|v| v.abs().log10())
.collect();
if logs.iter().copied().fold(f64::NEG_INFINITY, f64::max)
- logs.iter().copied().fold(f64::INFINITY, f64::min)
> 165.0
{
return Some(Err(crate::Error("internal_error".into())));
}
return Some(Ok(number(statistic(kind, &mut values)?)));
}
if let Some(amounts) = pieces
.iter()
.map(|p| super::finance::amount(p))
.collect::<Option<Vec<_>>>()
{
let code = amounts.iter().rev().find(|(_, c)| !c.is_empty())?.1;
let mut values = amounts
.iter()
.map(|(n, c)| {
if c.is_empty() || *c == code {
Some(*n)
} else {
Some(n / ctx.rates.get(*c)? * ctx.rates.get(code)?)
}
})
.collect::<Option<Vec<_>>>()?;
return super::finance::render(statistic(kind, &mut values)?, code);
}
let units = super::units::Units::default();
let temporal = pieces
.iter()
.any(|s| re!(r"\b(?:seconds?|minutes?|hours?|s)\b").is_match(s));
let mut items = pieces
.iter()
.map(|p| {
let text = if temporal {
re!(r"\bm\b").replace_all(p, "min").into_owned()
} else {
p.to_string()
};
units
.quantity(&text)
.map(|q| ((q.base - q.unit.offset) / q.unit.scale, Some(q.unit)))
.or_else(|| scalar(p).map(|n| (n, None)))
})
.collect::<Option<Vec<_>>>()?;
if kind == "standard deviation" {
let mut values: Vec<_> = items.iter().map(|(n, _)| *n).collect();
return Some(Ok(number(statistic(kind, &mut values)?)));
}
let kind = if kind == "median" {
items.sort_by(|a, b| a.0.total_cmp(&b.0));
let mid = items.len() / 2;
items = if items.len().is_multiple_of(2) {
items[mid - 1..=mid].to_vec()
} else {
vec![items[mid].clone()]
};
if items.len() == 1 {
let (value, unit) = &items[0];
return Some(Ok(unit.as_ref().map_or_else(
|| number(*value),
|u| super::units::format_quantity(*value, u),
)));
}
"average"
} else {
kind
};
if matches!(kind, "min" | "max" | "min and max") {
let selected = items.iter().reduce(|a, b| {
let (x, y) = match (&a.1, &b.1) {
(Some(u), Some(v)) if u.dimension == v.dimension => {
(a.0 * u.scale + u.offset, b.0 * v.scale + v.offset)
}
(Some(_), Some(_)) => return b,
_ => (a.0, b.0),
};
if (kind == "min" && x <= y) || (kind != "min" && x >= y) {
a
} else {
b
}
})?;
return Some(Ok(selected.1.as_ref().map_or_else(
|| number(selected.0),
|u| super::units::format_quantity(selected.0, u),
)));
}
let mut target: Option<super::units::Unit> = None;
let mut values: Vec<f64> = vec![];
for (n, unit) in items {
if let Some(unit) = unit {
let base = n * unit.scale + unit.offset;
if let Some(previous) = &target {
if unit.dimension != previous.dimension {
values.fill(0.0);
target = Some(unit);
} else if unit.scale > previous.scale {
for value in &mut values {
*value =
(*value * previous.scale + previous.offset - unit.offset) / unit.scale;
}
target = Some(unit);
}
} else {
target = Some(unit);
}
let target = target.as_ref()?;
values.push((base - target.offset) / target.scale);
} else {
let scale = target
.as_ref()
.filter(|u| u.dimension == [0, 0, 1, 0, 0, 0, 0, 0])
.map_or(1.0, |u| {
let seconds = (values.iter().sum::<f64>() * u.scale).abs();
let scale = [604800.0, 86400.0, 3600.0, 60.0, 1.0]
.into_iter()
.find(|s| seconds >= *s)
.unwrap_or(1.0);
scale / u.scale
});
values.push(n * scale);
}
}
let target = target?;
let value = statistic(kind, &mut values)?;
Some(Ok(if target.dimension == [0, 0, 1, 0, 0, 0, 0, 0] {
super::time::span(value * target.scale, 86400.0)
} else {
super::units::format_quantity(value, &target)
}))
}