nlcalc 0.1.0

Plugin-based natural language calculator for Rust and the command line
Documentation
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)
    }))
}