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> {
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)?;
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)?;
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
}
}