nlcalc 0.1.0

Plugin-based natural language calculator for Rust and the command line
Documentation
//! Complete supplied-property clauses reuse absolute-coordinate and interval kernels.
use super::*;
use crate::plugins::model_coordinates;
use num_rational::BigRational;

fn supplied_capacity_coordinate(
    request: &ThermalRequest<'_>,
    input: &str,
    validated: &str,
) -> Result<model_coordinates::Coordinate, Error> {
    // The capacity wording accepts whitespace-separated unit products (kg K).
    // Normalize that unit spelling before trying the authored coordinate reader.
    for (index, _) in input.char_indices().skip(1) {
        let scalar = input[..index].trim();
        if integer_queries::ratio_value(scalar).is_err() {
            continue;
        }
        let units = request.capacity_units(input[index..].trim());
        let normalized = format!("{scalar} {units}");
        if let Ok(coordinate) =
            model_coordinates::read(&normalized, "J/(kg*K)", request.engine, request.context)
            && coordinate.authored
        {
            return Ok(coordinate);
        }
    }
    model_coordinates::read(validated, "J/(kg*K)", request.engine, request.context)
}

impl ThermalRequest<'_> {
    pub(super) fn supplied_wording(&self, input: &str) -> Outcome {
        if input.len() > 4096 {
            return None;
        }
        macro_rules! rule {
            ($pattern:literal, $c:ident, $body:block) => {
                if let Some($c) = re!($pattern).captures(input) {
                    return Some((|| -> Result<String, Error> { $body })());
                }
            };
        }
        rule!(
            r"(?i)^a sample follows the supplied model Q\s*=\s*mcΔT with m\s*=\s*(.+?), c\s*=\s*(.+?), and temperatures (.+?) to (.+?); calculate Q in joules and kilojoules$",
            c,
            {
                let mass = self.role(&c[1], "kg", true)?;
                let capacity = self.capacity(&c[2], "J/(kg*K)")?;
                let change = self.difference(&c[3], &c[4])?;
                let exact_mass = model_coordinates::read(&c[1], "kg", self.engine, self.context)?;
                let exact_capacity = supplied_capacity_coordinate(self, &c[2], &capacity)?;
                let exact_change = integer_queries::ratio_value(&change).ok();
                let energy = if exact_mass.authored
                    && exact_capacity.authored
                    && let Some((numerator, denominator)) = exact_change
                {
                    let change = BigRational::new(numerator, denominator);
                    let joules = model_coordinates::bounded(
                        exact_mass.value * exact_capacity.value * change,
                    )?;
                    format!("(rational({},{}) J)", joules.numer(), joules.denom())
                } else {
                    format!("{mass}*{capacity}*({change})*(1 K)")
                };
                self.engine.quantity_value(&energy, "J", self.context)?;
                Ok(format!(
                    "thermal_report(energy|J|{energy};energy|kJ|{energy})"
                ))
            }
        );
        rule!(
            r"(?i)^a (.+?) [a-z]+ sample warms by (.+?); use specific heat (.+?) to calculate energy in (.+)$",
            c,
            {
                let mass = self.role(&c[1], "kg", false)?;
                let change = self.rise(&c[2])?;
                let capacity = self.capacity(&c[3], "J/(kg*K)")?;
                self.engine
                    .quantity_value(&format!("1 {}", &c[4]), "J", self.context)?;
                Ok(format!("{mass}*{capacity}*({change})*(1 K) in {}", &c[4]))
            }
        );
        rule!(
            r"(?i)^mix (.+?) ([a-z]+) at (.+?) with (.+?) ([a-z]+) at (.+?); assume no heat loss and equal specific heat, and find final temperature$",
            c,
            {
                let first_mass = self.role(&c[1], "kg", false)?;
                let first_temperature = self.temperature(&c[3])?;
                let second_mass = self.role(&c[4], "kg", false)?;
                let second_temperature = self.temperature(&c[6])?;
                let total = self.role(&format!("{first_mass}+{second_mass}"), "kg", true)?;
                // The explicitly common constant specific heat cancels from energy balance.
                let kelvin = format!(
                    "({first_mass}*({first_temperature})+{second_mass}*({second_temperature}))/{total}"
                );
                let expression = format!("({kelvin})*(1 K)");
                self.role(&expression, "K", false)?;
                Ok(format!("{expression} in °C"))
            }
        );
        rule!(
            r"(?i)^a (.+?) heater warms a (.+?) sample for (.+?); if all energy enters the sample and its specific heat is (.+?), calculate temperature rise$",
            c,
            {
                let power = self.role(&c[1], "W", false)?;
                let mass = self.role(&c[2], "kg", true)?;
                let time = self.role(&c[3], "s", false)?;
                let capacity = self.capacity(&c[4], "J/(kg*K)")?;
                Ok(format!(
                    "thermal_interval(({power}*{time})/({mass}*{capacity});°C)"
                ))
            }
        );
        rule!(
            r"(?i)^a [a-z]+ wire is (.+?) long and expands (.+?) for a (.+?) increase; calculate its linear expansion coefficient per degree Celsius$",
            c,
            {
                let length = self.role(&c[1], "m", true)?;
                let expansion = self.role(&c[2], "m", false)?;
                let change = self.rise(&c[3])?;
                let change = self.role(&change, "1", true)?;
                let coefficient = format!("{expansion}/({length}*{change}*(1 K))");
                self.engine
                    .quantity_value(&coefficient, "1/K", self.context)?;
                // Reciprocal Celsius degrees refer to an interval, not an affine absolute value.
                Ok(format!("thermal_coefficient({coefficient})"))
            }
        );
        rule!(
            r"(?i)^a (.+?) (?:kettle|heater|oven) runs for (.+?); report energy in (.+?), (.+?), and (.+)$",
            c,
            {
                let power = self.role(&c[1], "W", false)?;
                let time = self.role(&c[2], "s", false)?;
                let energy = format!("{power}*{time}");
                let mut fields = Vec::new();
                for target in [&c[3], &c[4], &c[5]] {
                    self.engine
                        .quantity_value(&format!("1 {target}"), "J", self.context)?;
                    let target = self
                        .engine
                        .units
                        .unit(target)
                        .ok_or_else(|| Error("incompatible_units".into()))?
                        .symbol;
                    fields.push(format!("energy|{target}|{energy}"));
                }
                let report = format!("thermal_report({})", fields.join(";"));
                if report.len() > 4096 {
                    return Err(Error("invalid_expression".into()));
                }
                Ok(report)
            }
        );
        rule!(
            r"(?i)^a (?:person's body|sample's) temperature changes from (.+?) to (.+?); give the change in Celsius degrees and Fahrenheit degrees$",
            c,
            {
                let difference = self.difference(&c[1], &c[2])?;
                let change = format!("({difference})*(1 K)");
                Ok(format!(
                    "thermal_report(change|°C|{change};change|°F|{change})"
                ))
            }
        );
        rule!(
            r"(?i)^what is the temperature increase in (celsius|fahrenheit|kelvin) if a sample warms from (.+?) to (.+)$",
            c,
            {
                let target = match &c[1].to_ascii_lowercase()[..] {
                    "celsius" => "°C",
                    "fahrenheit" => "°F",
                    _ => "K",
                };
                let difference = self.difference(&c[2], &c[3])?;
                self.role(&difference, "1", false)?;
                Ok(self.interval(&difference, target))
            }
        );
        rule!(
            r"(?i)^report (.+?) as (celsius|fahrenheit|kelvin), then report a (.+?) temperature interval as (celsius|fahrenheit|kelvin) degrees$",
            c,
            {
                self.temperature(&c[1])?;
                let interval = self.rise(&c[3])?;
                let absolute_target = self
                    .engine
                    .units
                    .unit(&c[2])
                    .ok_or_else(|| Error("incompatible_units".into()))?
                    .symbol;
                let interval_target = self
                    .engine
                    .units
                    .unit(&c[4])
                    .ok_or_else(|| Error("incompatible_units".into()))?
                    .symbol;
                Ok(format!(
                    "thermal_report(temperature|{absolute_target}|{};change|{interval_target}|({interval})*(1 K))",
                    &c[1]
                ))
            }
        );
        rule!(
            r"(?i)^a (.+?) sample of [a-z]+ at (.+?) receives (.+?); use specific heat (.+?) and calculate final temperature with no phase change assumed$",
            c,
            {
                let heat = self.role(&c[3], "J", false)?;
                Ok(format!(
                    "{} in °C",
                    self.final_temperature(&c[1], &c[4], &c[2], &heat)?
                ))
            }
        );
        None
    }
}