SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Expressions: a number and its unit are one value (10 mm / 2 mm is 5) (#6331)
ivisaf3bcf77ee3268
diff --git a/crates/doc/src/expr.rs b/crates/doc/src/expr.rsindex 8bb832bfd1..00d281be2d 100644--- a/crates/doc/src/expr.rs+++ b/crates/doc/src/expr.rs@@ -611,6 +611,8 @@ pub fn length_unit_or_mm(units: &str) -> &str {struct Parser<'a> {toks: Vec<Tok>,+ /// Each token's byte range in the source: whether a fraction is written closed up.+ spans: Vec<(usize, usize)>,pos: usize,lookup: &'a dyn Fn(&str) -> Result<Value, DocError>,depth: usize,@@ -670,35 +672,79 @@ impl Parser<'_> {}}fn unary(&mut self) -> Result<Value, DocError> {+ self.signed(true)+ }+ /// A signed operand. `glue`: a number takes the unit written after it (not in an exponent).+ fn signed(&mut self, glue: bool) -> Result<Value, DocError> {match self.peek() {Some(Tok::Op('-')) => {self.pos += 1;self.enter()?;- let v = self.unary()?;+ let v = self.signed(glue)?;self.depth -= 1;Ok(Value { v: -v.v, ..v })}Some(Tok::Op('+')) => {self.pos += 1;self.enter()?;- let v = self.unary()?;+ let v = self.signed(glue)?;self.depth -= 1;Ok(v)}- _ => self.power(),+ _ => self.power(glue),}}- fn power(&mut self) -> Result<Value, DocError> {- let base = self.atom()?;+ fn power(&mut self, glue: bool) -> Result<Value, DocError> {+ let number = matches!(self.peek(), Some(Tok::Num(_)));+ let at = self.pos;+ let mut base = self.atom()?;+ // A number and the unit after it are one quantity, bound tighter than `*` and `/`:+ // `10 mm / 2 mm` is 5, not (10 mm / 2) mm = 5 mm². The unit keeps its own power+ // (`3 mm^2`). A name that is not a unit (`2 width`) stays an ordinary product.+ if glue && number {+ // A fraction of two numbers before a unit is one value, as sizes are written:+ // `1/2"` and `1/2 in` are half an inch (as the mixed number `2 1/8"` is one value).+ // After a division only written closed up: `1 in / 1/2 in` is 2, but+ // `width / 10 / 2 mm` is (width / 10) / 2 mm.+ if let (Some(Tok::Op('/')), Some(Tok::Num(d))) = (self.peek(), self.toks.get(self.pos + 1))+ && self.unit_at(self.pos + 2)+ && (!self.after_division(at) || self.closed_up(at, self.pos + 1))+ {+ let d = Value::num(*d);+ self.pos += 2;+ base = mul(base, d, true)?;+ }+ if self.unit_at(self.pos) {+ let u = self.power(false)?;+ return mul(base, u, false);+ }+ }if let Some(Tok::Op('^')) = self.peek() {self.pos += 1;self.enter()?;- let e = self.unary()?;+ // The exponent is a plain number: `2^3 mm` stays 8 mm.+ let e = self.signed(false)?;self.depth -= 1;return pow(base, e);}Ok(base)}+ /// Whether the operand starting at token `i` is divided by: a `/` before it, past any signs.+ fn after_division(&self, i: usize) -> bool {+ let mut k = i;+ while k > 0 && matches!(self.toks.get(k - 1), Some(Tok::Op('+' | '-'))) {+ k -= 1;+ }+ k > 0 && matches!(self.toks.get(k - 1), Some(Tok::Op('/')))+ }+ /// Whether tokens `a` to `b` are written without spaces between them.+ fn closed_up(&self, a: usize, b: usize) -> bool {+ (a..b).all(|i| matches!((self.spans.get(i), self.spans.get(i + 1)), (Some(x), Some(y)) if x.1 == y.0))+ }+ /// Whether the token at `i` is a unit name, not called as a function.+ fn unit_at(&self, i: usize) -> bool {+ matches!(self.toks.get(i), Some(Tok::Id(id)) if unit(id).is_some()) && !matches!(self.toks.get(i + 1), Some(Tok::Op('(')))+ }fn atom(&mut self) -> Result<Value, DocError> {match self.next() {Some(Tok::Num(v)) => Ok(Value::num(v)),@@ -931,11 +977,11 @@ pub fn eval_with(s: &str, lookup: &dyn Fn(&str) -> Result<Value, DocError>) -> R/// Evaluate an expression reading bare numbers next to lengths / angles in `defaults`.pub fn eval_with_defaults(s: &str, lookup: &dyn Fn(&str) -> Result<Value, DocError>, defaults: Defaults) -> Result<Value, DocError> {- let toks = lex(s)?;+ let (toks, spans): (Vec<Tok>, Vec<(usize, usize)>) = lex_spans(s)?.into_iter().map(|(t, a, b)| (t, (a, b))).unzip();if toks.is_empty() {return Err(DocError::Expr("empty expression".into()));}- let mut p = Parser { toks, pos: 0, lookup, depth: 0, defaults };+ let mut p = Parser { toks, spans, pos: 0, lookup, depth: 0, defaults };let v = p.expr()?;if p.pos < p.toks.len() {return Err(DocError::Expr(format!("unexpected input in `{s}`")));@@ -1192,6 +1238,39 @@ mod tests {}}+ #[test]+ fn a_number_and_its_unit_are_one_quantity() {+ // `10 mm / 2 mm` divides by 2 mm; it is not `(10 mm / 2) mm`, a value in mm².+ assert_eq!(ev("10 mm / 2 mm", Kind::Unitless).unwrap(), 5.0);+ assert_eq!(ev("10mm/2mm", Kind::Unitless).unwrap(), 5.0);+ assert_eq!(ev("width / 4 mm", Kind::Unitless).unwrap(), 10.0);+ assert_eq!(ev("6 mm / 2 mm * 3", Kind::Unitless).unwrap(), 9.0);+ assert!((ev("90 deg / 1 rad", Kind::Unitless).unwrap() - std::f64::consts::FRAC_PI_2).abs() < 1e-12);+ assert!((ev("(ang - 30 deg) / 1 rad * width", Kind::Length).unwrap() - 40.0 * 60f64.to_radians()).abs() < 1e-12);+ assert_eq!(ev("1 in / 1 mm", Kind::Unitless).unwrap(), 25.4);+ assert_eq!(ev("2 1/2 in / 1 in", Kind::Unitless).unwrap(), 2.5);+ assert_eq!(ev("1\" / 1 mm", Kind::Unitless).unwrap(), 25.4);+ assert_eq!(ev("-10 mm / 2 mm", Kind::Unitless).unwrap(), -5.0);+ // A fraction of numbers right before a unit stays one value: half an inch.+ assert_eq!(ev("1/2 in", Kind::Length).unwrap(), 12.7);+ assert_eq!(ev("width + 3/4\"", Kind::Length).unwrap(), 40.0 + 0.75 * 25.4);+ assert_eq!(ev("1 in / 1/2 in", Kind::Unitless).unwrap(), 2.0);+ assert_eq!(ev("10 / 2 mm", Kind::Length).unwrap(), 5.0);+ // After a division, a spaced-out `/` divides again: (width / 10) / 2 mm.+ assert_eq!(ev("width / 10 / 2 mm", Kind::Unitless).unwrap(), 2.0);+ assert_eq!(ev("width / -10 / 2 mm", Kind::Unitless).unwrap(), -2.0);+ assert_eq!(ev("width / 10/2 mm", Kind::Unitless).unwrap(), 8.0);+ // The unit keeps its own power, and an exponent stays a plain number.+ assert_eq!(ev("sqrt(9 mm^2)", Kind::Length).unwrap(), 3.0);+ assert_eq!(ev("8 mm^3 / 2 mm^2", Kind::Length).unwrap(), 4.0);+ assert_eq!(ev("2^3 mm", Kind::Length).unwrap(), 8.0);+ // A number next to a name that is not a unit is a product, as before.+ assert_eq!(ev("2 width", Kind::Length).unwrap(), 80.0);+ // Unchanged: a unit alone, and a unit after a parenthesis.+ assert_eq!(ev("width / mm", Kind::Unitless).unwrap(), 40.0);+ assert_eq!(ev("(10 / 2) mm", Kind::Length).unwrap(), 5.0);+ }+#[test]fn arithmetic_and_units() {assert_eq!(ev("10", Kind::Length).unwrap(), 10.0);diff --git a/docs/book/src/guide/parameters.md b/docs/book/src/guide/parameters.mdindex aed8aa12fe..e00119a997 100644--- a/docs/book/src/guide/parameters.md+++ b/docs/book/src/guide/parameters.md@@ -40,7 +40,10 @@ and the preview follows each step. An expression such as `width / 2` is left asExpressions are unit-aware: `2 * width + 5 mm`, `angle / 2`, `sqrt(area)`, `1 in + 3 mm`, using`+ - * / ^`, parentheses, `sin cos tan asin acos atan atan2 sqrt abs min max floor ceil round mod-trunc` and unit conversion. A decimal comma works too, outside parentheses: `2,5 mm` is+trunc` and unit conversion. A number and the unit after it are one value: `10 mm / 2 mm` is 5+and `90 deg / 1 rad` is π/2, and a fraction of numbers before a unit is one value too (`1/2 in`+is half an inch; after a `/` only written without spaces: `1 in / 1/2 in` is 2, while+`width / 10 / 2 mm` divides by 10 and then by 2 mm). A decimal comma works too, outside parentheses: `2,5 mm` is`2.5 mm` (inside a function's parentheses the comma separates its arguments, so write`max(2.5, 3)` there). A mixed number is one value, as imperial sizes are written: `2 1/8"` and`3 7/16 in` are 2.125 in and 3.4375 in (a whole number, a space, then a proper fraction of whole