use super::{PracticalRequest, calculate};
use crate::plugins::{
compositions::Compositions, finance, integer_queries, model_coordinates, syntax,
};
use crate::{Context, Error, Outcome, re};
use num_bigint::BigInt;
use num_integer::Integer;
use num_rational::BigRational;
use num_traits::{One, Signed, ToPrimitive, Zero};
fn invalid() -> Error {
Error("invalid_physical_quantity".into())
}
fn literal(value: BigRational) -> Result<String, Error> {
let value = model_coordinates::bounded(value)?;
Ok(format!("rational({},{})", value.numer(), value.denom()))
}
fn person_number(input: &str, ordinal: bool) -> Result<usize, Error> {
let word = input.trim().to_ascii_lowercase();
let names = if ordinal {
[
"first", "second", "third", "fourth", "fifth", "sixth", "seventh", "eighth", "ninth",
"tenth", "eleventh", "twelfth",
]
} else {
[
"one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten",
"eleven", "twelve",
]
};
let number = if let Some(index) = names.iter().position(|name| *name == word) {
BigInt::from(index + 1)
} else if ordinal {
let digits = re!(r"^([0-9]+)(?:st|nd|rd|th)$")
.captures(&word)
.ok_or_else(invalid)?;
integer_queries::value(&digits[1])?
} else {
integer_queries::value(&word)?
};
let number = integer_queries::bounded(&number, 256)? as usize;
if number == 0 {
return Err(invalid());
}
Ok(number)
}
fn share_cents(expression: &str, target: &str) -> Result<String, Error> {
let symbol = match target {
"AUD" => "$",
"USD" => "US$",
"EUR" => "€",
"GBP" => "£",
_ => return Err(Error("incompatible_units".into())),
};
let (cents, denominator) = integer_queries::ratio_value(expression)?;
if denominator != BigInt::one() || cents.is_negative() {
return Err(Error("invalid_financial_argument".into()));
}
let (whole, minor) = cents.div_rem(&BigInt::from(100));
let minor = minor.to_u8().ok_or_else(invalid)?;
Ok(format!(
"{symbol}{}.{minor:02}",
integer_queries::decimal(&whole)
))
}
fn product_plural(singular: &str, plural: &str) -> bool {
let singular = singular.to_ascii_lowercase();
let plural = plural.to_ascii_lowercase();
plural == format!("{singular}s")
|| plural == format!("{singular}es")
|| singular
.strip_suffix('y')
.is_some_and(|stem| plural == format!("{stem}ies"))
|| singular
.strip_suffix('f')
.is_some_and(|stem| plural == format!("{stem}ves"))
|| singular
.strip_suffix("fe")
.is_some_and(|stem| plural == format!("{stem}ves"))
}
struct Recipe<'a> {
request: &'a PracticalRequest<'a>,
authored: bool,
}
impl Recipe<'_> {
fn read(&mut self, input: &str, unit: &str, positive: bool) -> Result<BigRational, Error> {
let coordinate =
model_coordinates::read(input, unit, self.request.engine, self.request.context)?;
self.authored &= coordinate.authored;
if coordinate.value.is_negative() || (positive && coordinate.value.is_zero()) {
return Err(invalid());
}
Ok(coordinate.value)
}
fn volume_target(&mut self, target: &str) -> Result<(String, BigRational), Error> {
let scale = self.read(&format!("1 {target}"), "L", true)?;
let symbol = self
.request
.engine
.units
.unit(target)
.ok_or_else(|| Error("incompatible_units".into()))?
.symbol;
Ok((symbol, scale))
}
fn packing(
&mut self,
stock: &str,
consumption: &str,
count_label: &str,
remainder_label: &str,
target: &str,
) -> Result<String, Error> {
let total = self.read(stock, "g", false)?;
let portion = self.read(consumption, "g", true)?;
let scale = self.read(&format!("1 {target}"), "g", true)?;
let target = self
.request
.engine
.units
.unit(target)
.ok_or_else(|| Error("incompatible_units".into()))?
.symbol;
let count = BigRational::from_integer((&total / &portion).to_integer());
self.report(&[
self.field(count_label, "1", count.clone())?,
self.field(remainder_label, &target, (total - count * portion) / scale)?,
])
}
fn expression(&self, value: BigRational) -> Result<String, Error> {
let value = model_coordinates::bounded(value)?;
let expression = if self.authored {
literal(value)?
} else {
let float = value
.to_f64()
.filter(|v| v.is_finite())
.ok_or_else(|| Error("numeric_overflow".into()))?;
if float == 0.0 && !value.is_zero() {
return Err(Error("numeric_underflow".into()));
}
format!("real({float})")
};
Ok(expression)
}
fn field(&self, label: &str, target: &str, value: BigRational) -> Result<String, Error> {
Ok(format!("{label}|{target}|{}", self.expression(value)?))
}
fn report(&self, fields: &[String]) -> Result<String, Error> {
let report = format!("practical_summary({})", fields.join(";"));
if report.len() > 4096 {
return Err(Error("invalid_expression".into()));
}
Ok(report)
}
}
impl PracticalRequest<'_> {
pub(super) fn recipes(&self, input: &str) -> Outcome {
if input.len() > 4096 {
return None;
}
let mut r = Recipe {
request: self,
authored: true,
};
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 network transmits (.+?) of payload in each packet and has (.+?) of overhead per packet\. for exactly (.+?) packets, calculate total transmitted bytes and payload efficiency as a percentage of transmitted bytes$",
c,
{
let payload = r.read(&c[1], "B", false)?;
let overhead = r.read(&c[2], "B", false)?;
let packets = r.read(&c[3], "1", false)?;
if !packets.is_integer() {
return Err(Error("integer_required".into()));
}
let total = model_coordinates::bounded(&packets * (&payload + overhead))?;
if total.is_zero() {
return Err(invalid());
}
let efficiency = model_coordinates::bounded(packets * payload / &total)?;
r.report(&[
r.field("total transmitted bytes", "B", total)?,
r.field("payload efficiency", "pct", efficiency)?,
])
}
);
rule!(
r"(?i)^a solution contains (.+?) salt in (.+?) water; calculate salt mass (?:percentage|%) and total solution mass$",
c,
{
let salt = r.read(&c[1], "g", false)?;
let water = r.read(&c[2], "g", false)?;
let total = &salt + water;
if total.is_zero() {
return Err(invalid());
}
r.report(&[
r.field("salt mass proportion", "pct", salt / &total)?,
r.field("total solution mass", "g", total)?,
])
}
);
rule!(
r"(?i)^(.+?) (?:people|person) split a (.+?) (?:restaurant )?bill equally; calculate each person's share rounded to cents and assign any (one-cent rounding remainder|rounding remainder) to the (.+?) person$",
c,
{
let count = person_number(&c[1], false)?;
let recipient = person_number(&c[4], true)?;
if recipient > count {
return Err(invalid());
}
let (amount, code) = crate::plugins::finance_queries::nonnegative_money_coordinate(
&c[2],
self.engine,
self.context,
)?;
if !matches!(code, "AUD" | "USD" | "EUR" | "GBP") {
return Err(Error("incompatible_units".into()));
}
let cents = model_coordinates::bounded(amount.value * BigInt::from(100))?;
if !cents.is_integer() {
return Err(Error("invalid_financial_argument".into()));
}
let cents = cents.to_integer();
let count_big = BigInt::from(count);
let (whole, fraction) = cents.div_rem(&count_big);
let each = whole
+ if fraction * 2u8 >= count_big {
1u8
} else {
0u8
};
let residual = ¢s - &each * BigInt::from(count);
if c[3].eq_ignore_ascii_case("one-cent rounding remainder")
&& residual.abs() > BigInt::one()
{
return Err(Error("invalid_financial_argument".into()));
}
let mut shares = vec![each; count];
shares[recipient - 1] += residual;
if shares.iter().any(Signed::is_negative) {
return Err(Error("invalid_financial_argument".into()));
}
r.report(
&shares
.into_iter()
.enumerate()
.map(|(index, share)| format!("person {}|{code}|{share}", index + 1))
.collect::<Vec<_>>(),
)
}
);
rule!(
r"(?i)^a household divides (.+?) among (.+?) people in ratio (.+?); report each share to cents using the largest-remainder method for any rounding remainder(?:, breaking ties in listed order)?$",
c,
{
let code = finance::amount(&c[1]).ok_or_else(invalid)?.1;
if !matches!(code, "AUD" | "USD" | "EUR" | "GBP") {
return Err(Error("incompatible_units".into()));
}
self.engine.evaluate_money(&c[1], self.context)?;
let number = re!(r"(?i)[+-]?(?:\d[\d,]*(?:\.\d+)?|\.\d+)(?:e[+-]?\d+)?")
.find(&c[1])
.ok_or_else(invalid)?;
let (numerator, denominator) = integer_queries::ratio_value(number.as_str())?;
let cents = model_coordinates::bounded(
BigRational::new(numerator, denominator) * BigInt::from(100),
)?;
if cents.is_negative() {
return Err(Error("invalid_financial_argument".into()));
}
if !cents.is_integer() {
return Err(Error("invalid_financial_argument".into()));
}
let cents = cents.to_integer();
let count =
integer_queries::bounded(&integer_queries::value(&c[2])?, 256)? as usize;
let weights = c[3]
.split(':')
.map(|part| {
let weight = r.read(part, "1", true)?;
if !weight.is_integer() {
return Err(invalid());
}
Ok(weight.to_integer())
})
.collect::<Result<Vec<BigInt>, Error>>()?;
if count < 2 || weights.len() != count {
return Err(invalid());
}
let total = weights.iter().sum::<BigInt>();
model_coordinates::bounded(BigRational::from_integer(total.clone()))?;
let mut shares = Vec::with_capacity(count);
let mut remainders = Vec::with_capacity(count);
for (index, weight) in weights.iter().enumerate() {
let (whole, remainder) = (¢s * weight).div_mod_floor(&total);
shares.push(whole);
remainders.push((index, remainder));
}
let missing = (¢s - shares.iter().sum::<BigInt>())
.to_usize()
.ok_or_else(invalid)?;
remainders.sort_by(|a, b| b.1.cmp(&a.1).then(a.0.cmp(&b.0)));
if missing > 0
&& missing < count
&& remainders[missing - 1].1 == remainders[missing].1
&& !input
.to_ascii_lowercase()
.ends_with("breaking ties in listed order")
{
return Err(Error("ambiguous_allocation".into()));
}
for (index, _) in remainders.into_iter().take(missing) {
shares[index] += 1u8;
}
r.report(
&shares
.into_iter()
.map(|share| format!("share|{code}|{share}"))
.collect::<Vec<_>>(),
)
}
);
rule!(
r"(?i)^a (.+?) rope is cut into (two|three|four|[2-4]) pieces in the ratio (.+?); give each length in (.+)$",
c,
{
let count = match c[2].to_ascii_lowercase().as_str() {
"two" | "2" => 2,
"three" | "3" => 3,
_ => 4,
};
self.engine
.quantity_value(&format!("1 {}", &c[4]), "m", self.context)?;
let target = self.engine.units.unit(&c[4]).ok_or_else(invalid)?.symbol;
let total = r.read(&c[1], &target, false)?;
let entries = c[3].split(':').collect::<Vec<_>>();
if entries.len() != count {
return Err(invalid());
}
let parts = entries
.iter()
.map(|part| r.read(part, "1", false))
.collect::<Result<Vec<_>, _>>()?;
let sum = parts.iter().cloned().sum::<BigRational>();
if sum.is_zero() {
return Err(invalid());
}
let labels = ["first piece", "second piece", "third piece", "fourth piece"];
let fields = parts
.into_iter()
.enumerate()
.map(|(index, part)| r.field(labels[index], &target, &total * part / &sum))
.collect::<Result<Vec<_>, _>>()?;
r.report(&fields)
}
);
rule!(
r"(?i)^a (.+?)% salt solution has total mass (.+?); report salt and water masses in (.+)$",
c,
{
let fraction = r.read(&c[1], "1", false)? / BigRational::from_integer(100.into());
if fraction > BigRational::one() {
return Err(invalid());
}
self.engine
.quantity_value(&format!("1 {}", &c[3]), "g", self.context)?;
let target = self.engine.units.unit(&c[3]).ok_or_else(invalid)?.symbol;
let total = r.read(&c[2], &target, false)?;
let salt = &total * fraction;
r.report(&[
r.field("salt mass", &target, salt.clone())?,
r.field("water mass", &target, total - salt)?,
])
}
);
rule!(
r"(?i)^how many litres of paint cover a (.+?) wall at (.+?), allowing (.+?)% extra for waste$",
c,
{
let area = r.read(&c[1], "m²", false)?;
let coverage = r.read(&c[2], "m²/L", true)?;
let allowance = r.read(&c[3], "1", false)? / BigRational::from_integer(100.into());
let volume = area / coverage * (BigRational::one() + allowance);
Ok(format!("(({}) L) in L", r.expression(volume)?))
}
);
rule!(
r"(?i)^a recipe for (.+?) servings uses (.+?) flour and (.+?) milk; give both quantities for (.+?) servings$",
c,
{
let original = r.read(&c[1], "1", true)?;
let flour = r.read(&c[2], "g", false)?;
let milk = r.read(&c[3], "mL", false)?;
let scale = r.read(&c[4], "1", false)? / original;
r.report(&[
r.field("flour", "g", flour * &scale)?,
r.field("milk", "mL", milk * scale)?,
])
}
);
rule!(
r"(?i)^i have (.+?) of ([a-z]+) and each meal uses (.+?); how many complete meals can i make and how much ([a-z]+) is left$",
c,
{
if !c[2].eq_ignore_ascii_case(&c[4]) {
return Err(invalid());
}
r.packing(
&c[1],
&c[3],
"complete meals",
&format!("{} left", c[2].to_ascii_lowercase()),
"g",
)
}
);
rule!(
r"(?i)^a recipe uses (.+?) of ([a-z]+) per ([a-z]+)\. how many complete ([a-z]+) can be made from (.+?) of ([a-z]+), and how many (.+?) remain$",
c,
{
if !c[2].eq_ignore_ascii_case(&c[6]) || !product_plural(&c[3], &c[4]) {
return Err(invalid());
}
r.packing(
&c[5],
&c[1],
&format!("complete {}", c[4].to_ascii_lowercase()),
&format!("{} remaining", c[2].to_ascii_lowercase()),
&c[7],
)
}
);
rule!(
r"(?i)^on a straight (.+?) wall, place (.+?) ([a-z]+) equally spaced with one at each end\. find the distance between consecutive ([a-z]+) in (.+?) and list positions from the left end in order$",
c,
{
if !c[3].eq_ignore_ascii_case(&c[4]) {
return Err(invalid());
}
let extent_role = re!(r"(?i)(\d)-([a-z]+)").replace_all(&c[1], "$1 $2");
let extent = r.read(&extent_role, "m", false)?;
let count = r.read(&c[2], "1", false)?;
let scale = r.read(&format!("1 {}", &c[5]), "m", true)?;
let target = r
.request
.engine
.units
.unit(c[5].trim())
.ok_or_else(|| Error("incompatible_units".into()))?
.symbol;
if !count.is_integer() {
return Err(Error("integer_required".into()));
}
let count = count.to_integer().to_usize().ok_or_else(invalid)?;
if !(2..=256).contains(&count) || !extent.is_positive() {
return Err(invalid());
}
let extent = model_coordinates::bounded(extent / scale)?;
let expression = r.expression(extent)?;
let carrier = format!("practical_positions({target}|{count}|{expression})");
if carrier.len() > 4096 {
return Err(Error("expression_too_complex".into()));
}
Ok(carrier)
}
);
rule!(
r"(?i)^place (.+?); (?:report|give) every point position in (.+?), sorted left to right, and each neighboring gap$",
c,
{
let target = match c[2].trim().to_ascii_lowercase().as_str() {
"millimetres" | "millimeters" | "mm" => "mm",
"centimetres" | "centimeters" | "cm" => "cm",
"metres" | "meters" | "m" => "m",
"kilometres" | "kilometers" | "km" => "km",
_ => return Err(Error("incompatible_units".into())),
};
let scale = r.read(&format!("1 {target}"), "m", true)?;
let clauses = c[1]
.split(',')
.map(|part| part.trim().strip_prefix("and ").unwrap_or(part.trim()))
.collect::<Vec<_>>();
if !(2..=256).contains(&clauses.len()) {
return Err(invalid());
}
let mut definitions: Vec<(String, Option<String>, BigRational)> = Vec::new();
for clause in clauses {
let (name, reference, offset) = if let Some(anchor) =
re!(r"(?i)^([a-z][a-z0-9_]*) at (.+)$").captures(clause)
{
let value =
model_coordinates::read(&anchor[2], "m", self.engine, self.context)?;
r.authored &= value.authored;
(anchor[1].to_owned(), None, value.value)
} else if let Some(relative) = re!(
r"(?i)^([a-z][a-z0-9_]*) (.+?) to the (left|right) of ([a-z][a-z0-9_]*)$"
)
.captures(clause)
{
let mut distance = r.read(&relative[2], "m", false)?;
if relative[3].eq_ignore_ascii_case("left") {
distance = -distance;
}
(
relative[1].to_owned(),
Some(relative[4].to_owned()),
distance,
)
} else {
return Err(invalid());
};
if definitions
.iter()
.any(|(prior, _, _)| prior.eq_ignore_ascii_case(&name))
{
return Err(invalid());
}
definitions.push((name, reference, offset));
}
let mut resolved = vec![None; definitions.len()];
for _ in 0..definitions.len() {
let mut progressed = false;
for index in 0..definitions.len() {
if resolved[index].is_some() {
continue;
}
let (.., reference, offset) = &definitions[index];
let base = match reference {
Some(name) => definitions
.iter()
.position(|(candidate, _, _)| candidate.eq_ignore_ascii_case(name))
.and_then(|at| resolved[at].clone()),
None => Some(BigRational::zero()),
};
if let Some(base) = base {
resolved[index] = Some(model_coordinates::bounded(base + offset)?);
progressed = true;
}
}
if resolved.iter().all(Option::is_some) {
break;
}
if !progressed {
return Err(invalid());
}
}
let mut points = definitions
.into_iter()
.zip(resolved)
.map(|((name, _, _), value)| Ok((name, value.ok_or_else(invalid)?)))
.collect::<Result<Vec<_>, Error>>()?;
points.sort_by(|a, b| a.1.cmp(&b.1));
if points.windows(2).any(|pair| pair[0].1 == pair[1].1) {
return Err(invalid());
}
let positions = points
.iter()
.map(|(name, value)| {
Ok(format!(
"{name}~{}",
r.expression(model_coordinates::bounded(value / &scale)?)?
))
})
.collect::<Result<Vec<_>, Error>>()?;
let gaps = points
.windows(2)
.map(|pair| {
r.expression(model_coordinates::bounded(
(&pair[1].1 - &pair[0].1) / &scale,
)?)
})
.collect::<Result<Vec<_>, Error>>()?;
let carrier = format!(
"practical_named_positions({target}|{}|{})",
positions.join(";"),
gaps.join(";")
);
if carrier.len() > 4096 {
return Err(Error("expression_too_complex".into()));
}
Ok(carrier)
}
);
rule!(
r"(?i)^([a-z0-9]+) points lie on a straight (.+?) track, with position measured from the left endpoint\. (.+)\. give their positions in the order (.+?), and the consecutive gaps$",
c,
{
let count = match c[1].to_ascii_lowercase().as_str() {
"two" => 2,
"three" => 3,
"four" => 4,
"five" => 5,
_ => integer_queries::bounded(&integer_queries::value(&c[1])?, 256)? as usize,
};
if !(2..=256).contains(&count) {
return Err(invalid());
}
let extent = r.read(&c[2], "m", true)?;
let target = re!(r"(?i)\b(mm|cm|m|km)\s*$")
.captures(&c[2])
.ok_or_else(invalid)?[1]
.to_ascii_lowercase();
let scale = r.read(&format!("1 {target}"), "m", true)?;
let definitions = c.get(3).unwrap().as_str();
let starts = re!(r"(?i)\b(?:point )?([a-z]) is ")
.captures_iter(definitions)
.collect::<Vec<_>>();
if starts.len() != count || starts[0].get(0).unwrap().start() != 0 {
return Err(invalid());
}
let requested = c[4].split(',').map(str::trim).collect::<Vec<_>>();
if requested.len() != count + 2
|| !requested[0].eq_ignore_ascii_case("left endpoint")
|| !requested[count + 1].eq_ignore_ascii_case("right endpoint")
{
return Err(invalid());
}
let mut points: Vec<(String, BigRational)> = Vec::with_capacity(count);
for (index, found) in starts.iter().enumerate() {
let name = found[1].to_ascii_lowercase();
if !requested[index + 1].eq_ignore_ascii_case(&name)
|| points.iter().any(|(prior, _)| *prior == name)
{
return Err(invalid());
}
let end = starts
.get(index + 1)
.map_or(definitions.len(), |next| next.get(0).unwrap().start());
let mut clause = definitions[found.get(0).unwrap().end()..end].trim();
if index + 1 < count {
clause = clause
.strip_suffix(", and")
.or_else(|| clause.strip_suffix(','))
.ok_or_else(invalid)?
.trim();
}
let location = if let Some(offset) =
re!(r"(?i)^(.+?) from the left end$").captures(clause)
{
r.read(&offset[1], "m", false)?
} else if let Some(offset) =
re!(r"(?i)^(.+?) to the left of the right end$").captures(clause)
{
extent.clone() - r.read(&offset[1], "m", false)?
} else if let Some(offset) =
re!(r"(?i)^(.+?) to the (right|left) of ([a-z])$").captures(clause)
{
let anchor = points
.iter()
.find(|(prior, _)| prior.eq_ignore_ascii_case(&offset[3]))
.ok_or_else(invalid)?
.1
.clone();
let distance = r.read(&offset[1], "m", false)?;
if offset[2].eq_ignore_ascii_case("right") {
anchor + distance
} else {
anchor - distance
}
} else {
return Err(invalid());
};
let location = model_coordinates::bounded(location)?;
let previous = points
.last()
.map_or_else(BigRational::zero, |(_, value)| value.clone());
if location <= previous || location >= extent {
return Err(invalid());
}
points.push((name, location));
}
let mut positions = Vec::with_capacity(count + 2);
positions.push(BigRational::zero());
positions.extend(points.into_iter().map(|(_, value)| value));
positions.push(extent);
let gaps = positions
.windows(2)
.map(|pair| &pair[1] - &pair[0])
.collect::<Vec<_>>();
let positions = positions
.into_iter()
.map(|value| r.expression(model_coordinates::bounded(value / &scale)?))
.collect::<Result<Vec<_>, _>>()?;
let gaps = gaps
.into_iter()
.map(|value| r.expression(model_coordinates::bounded(value / &scale)?))
.collect::<Result<Vec<_>, _>>()?;
let carrier = format!(
"practical_relative_positions({target}|{}|{})",
positions.join(";"),
gaps.join(";")
);
if carrier.len() > 4096 {
return Err(Error("expression_too_complex".into()));
}
Ok(carrier)
}
);
rule!(
r"(?i)^a [a-z][a-z ]* is (.+?) long; ([a-z]+) are placed every (.+?) including both ends\. how many ([a-z]+) are needed$",
c,
{
if !c[2].eq_ignore_ascii_case(&c[4]) {
return Err(invalid());
}
let extent = r.read(&c[1], "m", false)?;
let spacing = r.read(&c[3], "m", true)?;
let intervals = model_coordinates::bounded(extent / spacing)?;
if !intervals.is_integer() {
return Err(invalid());
}
r.expression(intervals + BigRational::one())
}
);
rule!(
r"(?i)^scale a mixture with ([a-z]+) and ([a-z]+) in a (.+?):(.+?) ratio to make (.+?) total; give each volume in (.+)$",
c,
{
if c[1].eq_ignore_ascii_case(&c[2]) {
return Err(invalid());
}
let a = r.read(&c[3], "1", false)?;
let b = r.read(&c[4], "1", false)?;
let (target, _) = r.volume_target(&c[6])?;
let total = r.read(&c[5], &target, false)?;
let sum = &a + &b;
if sum.is_zero() {
return Err(invalid());
}
r.report(&[
r.field(&c[1].to_ascii_lowercase(), &target, &total * a / &sum)?,
r.field(&c[2].to_ascii_lowercase(), &target, total * b / sum)?,
])
}
);
rule!(
r"(?i)^a (.+?) loaf is divided into (.+?) equal slices; how many grams per slice and what fraction of the loaf is each$",
c,
{
let mass = r.read(&c[1], "g", false)?;
let slices = r.read(&c[2], "1", true)?;
if !slices.is_integer() {
return Err(Error("integer_required".into()));
}
r.report(&[
r.field("mass per slice", "g", mass / &slices)?,
r.field("fraction of loaf", "fraction", slices.recip())?,
])
}
);
rule!(
r"(?i)^a recipe uses (.+?) cup sugar for (.+?) muffins; how much sugar for (.+?) muffins, in cups and tablespoons using (.+?) tablespoons per cup$",
c,
{
let cups = r.read(&c[1], "1", false)?;
let original = r.read(&c[2], "1", true)?;
let wanted = r.read(&c[3], "1", false)?;
let factor = r.read(&c[4], "1", true)?;
let cups = cups * wanted / original;
r.report(&[
r.field("sugar", "local cup", cups.clone())?,
r.field("sugar", "local tbsp", cups * factor)?,
])
}
);
rule!(
r"(?i)^i need (.+?) of ([a-z]+) for (.+?) people; how much per person in (.+?), and how much for (.+?) people$",
c,
{
let total = r.read(&c[1], "L", false)?;
let original = r.read(&c[3], "1", true)?;
let (target, scale) = r.volume_target(&c[4])?;
let wanted = r.read(&c[5], "1", false)?;
let per = total / original;
let per_target = &per / scale;
r.report(&[
r.field("per person", &target, per_target)?,
r.field(&format!("for {} people", &c[5]), "L", per * wanted)?,
])
}
);
rule!(
r"(?i)^a (.+?)% brine solution is made from (.+?) salt and water; what is the total solution mass and water mass by mass (?:percentage|%)$",
c,
{
let percent = r.read(&c[1], "1", true)? / BigRational::from_integer(100.into());
if percent > BigRational::one() {
return Err(invalid());
}
let salt = r.read(&c[2], "g", false)?;
let total = &salt / percent;
r.report(&[
r.field("total solution mass", "g", total.clone())?,
r.field("water mass", "g", total - salt)?,
])
}
);
rule!(
r"(?i)^a (.+?) tank is (.+?)% full; after pouring in (.+?), report the fill percentage and remaining capacity$",
c,
{
let capacity = r.read(&c[1], "L", true)?;
let fraction = r.read(&c[2], "1", false)? / BigRational::from_integer(100.into());
if fraction > BigRational::one() {
return Err(invalid());
}
let added = r.read(&c[3], "L", false)?;
let final_amount = &capacity * fraction + added;
if final_amount > capacity {
return Err(invalid());
}
r.report(&[
r.field("fill proportion", "pct", &final_amount / &capacity)?,
r.field("remaining capacity", "L", capacity - final_amount)?,
])
}
);
rule!(
r"(?i)^a (.+?):(.+?) concentrate-to-water drink is diluted by adding (.+?) water to (.+?) of the original mix; what is the new concentrate-to-water ratio$",
c,
{
let a = r.read(&c[1], "1", false)?;
let b = r.read(&c[2], "1", false)?;
let added = r.read(&c[3], "mL", false)?;
let total = r.read(&c[4], "mL", false)?;
let sum = &a + &b;
if sum.is_zero() {
return Err(invalid());
}
let concentrate = &total * a / ∑
let water = total * b / sum + added;
if water.is_zero() {
return Err(invalid());
}
r.report(&[r.field("concentrate-to-water ratio", "ratio", concentrate / water)?])
}
);
rule!(
r"(?i)^a (.+?) mixture is (.+?)% concentrate by volume; (.+?) is removed and replaced with the same volume of water[.] assuming it was mixed evenly and volumes add, what is the new concentrate percentage$",
c,
{
let total = r.read(&c[1], "L", true)?;
let fraction = r.read(&c[2], "1", false)? / BigRational::from_integer(100.into());
if fraction > BigRational::one() {
return Err(invalid());
}
let removed = r.read(&c[3], "L", false)?;
if removed > total {
return Err(invalid());
}
let concentrate = fraction * (&total - removed);
r.report(&[r.field("concentrate proportion", "pct", concentrate / total)?])
}
);
rule!(
r"(?i)^a car uses (.+?) per (.+?); estimate fuel for (.+?) and the distance possible on (.+)$",
c,
{
let fuel = r.read(&c[1], "L", true)?;
let distance = r.read(&c[2], "km", true)?;
let trip = r.read(&c[3], "km", false)?;
let available = r.read(&c[4], "L", false)?;
r.report(&[
r.field("fuel needed", "L", &fuel * trip / &distance)?,
r.field("distance possible", "km", distance * available / fuel)?,
])
}
);
None
}
}
pub(super) fn evaluate_positions(engine: &Compositions, input: &str, context: &Context) -> Outcome {
let input = syntax::ungroup(input);
if let Some(inner) = input
.strip_prefix("practical_named_positions(")
.and_then(|s| s.strip_suffix(')'))
{
return Some((|| {
if input.len() > 4096 {
return Err(Error("expression_too_complex".into()));
}
let mut fields = inner.split('|');
let (Some(target), Some(positions), Some(gaps), None) =
(fields.next(), fields.next(), fields.next(), fields.next())
else {
return Err(invalid());
};
engine.quantity_value(&format!("1 {target}"), "m", context)?;
let positions = positions.split(';').collect::<Vec<_>>();
let gaps = gaps.split(';').collect::<Vec<_>>();
if !(2..=256).contains(&positions.len()) || gaps.len() + 1 != positions.len() {
return Err(invalid());
}
let mut names = Vec::new();
let mut values = Vec::new();
let mut shown = Vec::new();
for field in positions {
let (name, expression) = field.split_once('~').ok_or_else(invalid)?;
if name.is_empty()
|| !name
.bytes()
.all(|byte| byte.is_ascii_alphanumeric() || byte == b'_')
|| names
.iter()
.any(|prior: &String| prior.eq_ignore_ascii_case(name))
{
return Err(invalid());
}
let coordinate = model_coordinates::read(expression, "1", engine, context)?;
let display = calculate(
engine,
&format!("(({expression}) {target}) in {target}"),
context,
)?;
names.push(name.to_owned());
values.push(coordinate.value);
shown.push(format!("{name} {display}"));
}
let mut shown_gaps = Vec::new();
for (index, expression) in gaps.into_iter().enumerate() {
let gap = model_coordinates::read(expression, "1", engine, context)?;
if gap.value != &values[index + 1] - &values[index] || !gap.value.is_positive() {
return Err(invalid());
}
shown_gaps.push(calculate(
engine,
&format!("(({expression}) {target}) in {target}"),
context,
)?);
}
let output = format!(
"positions: {}; consecutive gaps: {}",
shown.join(", "),
shown_gaps.join(", ")
);
if output.len() > 4096 {
return Err(Error("expression_too_complex".into()));
}
Ok(output)
})());
}
if let Some(inner) = input
.strip_prefix("practical_relative_positions(")
.and_then(|s| s.strip_suffix(')'))
{
return Some((|| {
if input.len() > 4096 {
return Err(Error("expression_too_complex".into()));
}
let mut fields = inner.split('|');
let (Some(target), Some(positions), Some(gaps), None) =
(fields.next(), fields.next(), fields.next(), fields.next())
else {
return Err(Error("invalid_expression".into()));
};
engine.quantity_value(&format!("1 {target}"), "m", context)?;
let positions = positions.split(';').collect::<Vec<_>>();
let gaps = gaps.split(';').collect::<Vec<_>>();
if !(4..=258).contains(&positions.len()) || gaps.len() + 1 != positions.len() {
return Err(Error("invalid_expression".into()));
}
let display = |expression: &str| -> Result<String, Error> {
engine.quantity_value(expression, "1", context)?;
calculate(
engine,
&format!("(({expression}) {target}) in {target}"),
context,
)
};
let locations = positions
.into_iter()
.map(display)
.collect::<Result<Vec<_>, _>>()?;
let differences = gaps
.into_iter()
.map(display)
.collect::<Result<Vec<_>, _>>()?;
let output = format!(
"positions: {}; consecutive gaps: {}",
locations.join(", "),
differences.join(", ")
);
if output.len() > 4096 {
return Err(Error("expression_too_complex".into()));
}
Ok(output)
})());
}
let inner = input
.strip_prefix("practical_positions(")?
.strip_suffix(')')?;
Some((|| {
if input.len() > 4096 {
return Err(Error("expression_too_complex".into()));
}
let mut fields = inner.splitn(3, '|');
let (Some(target), Some(count), Some(extent)) =
(fields.next(), fields.next(), fields.next())
else {
return Err(Error("invalid_expression".into()));
};
let (numerator, denominator) = integer_queries::ratio_value(count)?;
if denominator != BigInt::one() {
return Err(Error("integer_required".into()));
}
let count = numerator.to_usize().ok_or_else(invalid)?;
if !(2..=256).contains(&count) {
return Err(invalid());
}
let scale = model_coordinates::read(&format!("1 {target}"), "m", engine, context)?;
let distance = model_coordinates::read(extent, "1", engine, context)?;
if !scale.value.is_positive() || !distance.value.is_positive() {
return Err(invalid());
}
let intervals = count - 1;
let mut positions = Vec::with_capacity(count);
for index in 0..count {
let expression =
format!("((({extent}) * rational({index},{intervals})) {target}) in {target}");
engine.quantity_value(&expression, target, context)?;
positions.push(calculate(engine, &expression, context)?);
}
let output = format!(
"spacing: {}; positions from left end: {}",
positions[1],
positions.join(", ")
);
if output.len() > 4096 {
return Err(Error("expression_too_complex".into()));
}
Ok(output)
})())
}
pub(super) fn evaluate(engine: &Compositions, input: &str, context: &Context) -> Outcome {
let inner = syntax::ungroup(input)
.strip_prefix("practical_summary(")?
.strip_suffix(')')?;
Some((|| {
if input.len() > 4096 {
return Err(Error("invalid_expression".into()));
}
let fields = inner.split(';').collect::<Vec<_>>();
let shares = fields.iter().all(|field| field.starts_with("share|"));
let people = fields.iter().all(|field| field.starts_with("person "));
if fields.is_empty() || fields.len() > if shares || people { 256 } else { 4 } {
return Err(Error("invalid_expression".into()));
}
let mut output = Vec::new();
let mut share_currency = None;
for (index, field) in fields.into_iter().enumerate() {
let parts = field.split('|').collect::<Vec<_>>();
let [label, target, expression] = parts.as_slice() else {
return Err(Error("invalid_expression".into()));
};
if label.is_empty()
|| !label
.chars()
.all(|c| c.is_ascii_alphanumeric() || c == ' ' || c == '-')
{
return Err(Error("invalid_expression".into()));
}
if people && *label != format!("person {}", index + 1) {
return Err(Error("invalid_expression".into()));
}
let display = if shares || people {
if share_currency.is_some_and(|currency| currency != *target) {
return Err(Error("incompatible_units".into()));
}
share_currency = Some(*target);
share_cents(expression, target)?
} else {
match *target {
"fraction" | "ratio" => {
let (n, d) = integer_queries::ratio_value(expression)?;
format!("{n}{}{d}", if *target == "ratio" { ':' } else { '/' })
}
"local cup" | "local tbsp" => {
engine.quantity_value(expression, "1", context)?;
format!(
"{} {}",
calculate(engine, expression, context)?,
target.trim_start_matches("local ")
)
}
"pct" => {
let value = engine.quantity_value(expression, "1", context)? * 100.0;
if !value.is_finite() {
return Err(Error("numeric_overflow".into()));
}
format!("{}%", crate::number(value))
}
"1" => calculate(engine, expression, context)?,
_ => calculate(
engine,
&format!("(({expression}) {target}) in {target}"),
context,
)?,
}
};
let label = match (*label, *target) {
("fill proportion", "pct") => "fill percentage",
("salt mass proportion", "pct") => "salt mass percentage",
("concentrate proportion", "pct") => "concentrate percentage",
_ => label,
};
output.push(if shares {
display
} else {
format!("{label}: {display}")
});
}
Ok(if shares {
format!("shares: {}", output.join("; "))
} else {
output.join("; ")
})
})())
}