Add pattern support in implicit multiplication and backtick precision notation

- Allow patterns (x_, c_., x_Head, etc.) as factors in implicit
  multiplication so expressions like `c_. x_^2` parse correctly
- Add parser support for backtick precision notation (e.g. 0.1`1)
  with bare backtick for machine precision
- Implement BigFloat arithmetic with error-propagation precision
  tracking in both binary_ops and plus_ast
- Add BigFloat to expr_to_number for mixed-type numeric operations

Author: ad-si

src/evaluator/binary_ops.rs

@@ -43,9 +43,16 @@ pub fn thread_binary_op(
       };
       return Ok(crate::functions::math_ast::bigint_to_expr(result));
     }
+    // BigFloat precision-tracked arithmetic
+    if (matches!(l, Expr::BigFloat(_, _)) || matches!(r, Expr::BigFloat(_, _)))
+      && let Some(result) = bigfloat_binary_op(l, r, op)
+    {
+      return Ok(result);
+    }
     let ln = expr_to_number(l);
     let rn = expr_to_number(r);
-    let any_real = matches!(l, Expr::Real(_)) || matches!(r, Expr::Real(_));
+    let any_real = matches!(l, Expr::Real(_) | Expr::BigFloat(_, _))
+      || matches!(r, Expr::Real(_) | Expr::BigFloat(_, _));
     match op {
       BinaryOperator::Plus => {
         if let (Some(a), Some(b)) = (ln, rn) {
@@ -185,6 +192,120 @@ pub fn thread_binary_op(
   }
 }
 
+/// Extract (f64_value, precision_in_digits) from a numeric expression.
+/// For BigFloat, precision comes from the stored value.
+/// For Integer/BigInteger, precision is effectively infinite (use f64::INFINITY).
+/// For Real, precision is machine precision (~16 digits).
+fn bigfloat_value_prec(expr: &Expr) -> Option<(f64, f64)> {
+  match expr {
+    Expr::BigFloat(digits, prec) => {
+      let v: f64 = digits.parse().unwrap_or(0.0);
+      Some((v, *prec as f64))
+    }
+    Expr::Real(f) => Some((*f, 16.0)),
+    Expr::Integer(n) => Some((*n as f64, f64::INFINITY)),
+    Expr::BigInteger(n) => {
+      use num_traits::ToPrimitive;
+      n.to_f64().map(|v| (v, f64::INFINITY))
+    }
+    _ => None,
+  }
+}
+
+/// Compute result precision for addition/subtraction using error propagation.
+fn precision_for_add(lv: f64, lp: f64, rv: f64, rp: f64, result: f64) -> usize {
+  let le = if lp.is_finite() {
+    lv.abs() * 10f64.powf(-lp)
+  } else {
+    0.0
+  };
+  let re = if rp.is_finite() {
+    rv.abs() * 10f64.powf(-rp)
+  } else {
+    0.0
+  };
+  let total_error = le + re;
+  if result.abs() < 1e-300 || total_error <= 0.0 {
+    if lp.is_finite() && rp.is_finite() {
+      (lp.min(rp) as usize).max(1)
+    } else if lp.is_finite() {
+      (lp as usize).max(1)
+    } else {
+      (rp as usize).max(1)
+    }
+  } else {
+    let p = result.abs().log10() - total_error.log10();
+    (p.max(0.0).round() as usize).max(1)
+  }
+}
+
+/// Format an f64 value as a BigFloat string with the given number of significant digits.
+fn format_bigfloat_value(value: f64, sig_digits: usize) -> String {
+  if value == 0.0 {
+    return "0.".to_string();
+  }
+  let sign = if value < 0.0 { "-" } else { "" };
+  let abs_val = value.abs();
+  let magnitude = abs_val.log10().floor() as i32;
+  let decimal_places = ((sig_digits as i32) - magnitude - 1).max(0) as usize;
+  let formatted = format!("{}{:.prec$}", sign, abs_val, prec = decimal_places);
+  // Ensure trailing dot if no decimal point
+  if !formatted.contains('.') {
+    format!("{}.", formatted)
+  } else {
+    formatted
+  }
+}
+
+/// Perform a binary operation on BigFloat operands with precision tracking.
+/// Returns None if operands are not numeric, so the caller can fall through.
+fn bigfloat_binary_op(l: &Expr, r: &Expr, op: BinaryOperator) -> Option<Expr> {
+  let (lv, lp) = bigfloat_value_prec(l)?;
+  let (rv, rp) = bigfloat_value_prec(r)?;
+
+  // If either operand is machine-precision Real (not BigFloat), produce Real
+  if matches!(l, Expr::Real(_)) || matches!(r, Expr::Real(_)) {
+    let result = match op {
+      BinaryOperator::Plus => lv + rv,
+      BinaryOperator::Minus => lv - rv,
+      BinaryOperator::Times => lv * rv,
+      BinaryOperator::Divide if rv != 0.0 => lv / rv,
+      BinaryOperator::Power => lv.powf(rv),
+      _ => return None,
+    };
+    return Some(Expr::Real(result));
+  }
+
+  let result_value = match op {
+    BinaryOperator::Plus => lv + rv,
+    BinaryOperator::Minus => lv - rv,
+    BinaryOperator::Times => lv * rv,
+    BinaryOperator::Divide if rv != 0.0 => lv / rv,
+    BinaryOperator::Power => lv.powf(rv),
+    _ => return None,
+  };
+
+  let result_prec = match op {
+    BinaryOperator::Plus | BinaryOperator::Minus => {
+      precision_for_add(lv, lp, rv, rp, result_value)
+    }
+    _ => {
+      // For Times/Divide/Power, use min precision
+      let p = if lp.is_finite() && rp.is_finite() {
+        lp.min(rp)
+      } else if lp.is_finite() {
+        lp
+      } else {
+        rp
+      };
+      (p.round() as usize).max(1)
+    }
+  };
+
+  let result_str = format_bigfloat_value(result_value, result_prec);
+  Some(Expr::BigFloat(result_str, result_prec))
+}
+
 /// Extract raw string content from an Expr (without quotes for strings)
 pub fn expr_to_raw_string(expr: &Expr) -> String {
   match expr {

src/evaluator/type_helpers.rs

@@ -10,6 +10,7 @@ pub fn expr_to_number(expr: &Expr) -> Option<f64> {
       n.to_f64()
     }
     Expr::Real(f) => Some(*f),
+    Expr::BigFloat(digits, _) => digits.parse::<f64>().ok(),
     Expr::Constant(name) => constant_to_f64(name),
     _ => None,
   }

src/functions/math_ast/arithmetic.rs

@@ -131,12 +131,14 @@ pub fn plus_ast(args: &[Expr]) -> Result<Expr, InterpreterError> {
     });
   }
 
-  // Classify arguments: exact (Integer/Rational), real (Real), or symbolic
+  // Classify arguments: exact (Integer/Rational), real (Real), bigfloat, or symbolic
   let mut has_real = false;
+  let mut has_bigfloat = false;
   let mut all_numeric = true;
   for arg in &flat_args {
     match arg {
       Expr::Real(_) => has_real = true,
+      Expr::BigFloat(_, _) => has_bigfloat = true,
       Expr::Integer(_) => {}
       Expr::FunctionCall { name, args: rargs }
         if name == "Rational"
@@ -149,8 +151,8 @@ pub fn plus_ast(args: &[Expr]) -> Result<Expr, InterpreterError> {
     }
   }
 
-  // If all numeric and no Reals, use exact rational arithmetic
-  if all_numeric && !has_real {
+  // If all numeric and no Reals/BigFloats, use exact rational arithmetic
+  if all_numeric && !has_real && !has_bigfloat {
     // Sum as exact rational: (numer, denom)
     let mut sum_n: i128 = 0;
     let mut sum_d: i128 = 1;
@@ -172,6 +174,11 @@ pub fn plus_ast(args: &[Expr]) -> Result<Expr, InterpreterError> {
     return Ok(make_rational(sum_n, sum_d));
   }
 
+  // If all numeric with BigFloat (no machine Real), use precision-tracked arithmetic
+  if all_numeric && has_bigfloat && !has_real {
+    return bigfloat_plus(&flat_args);
+  }
+
   // If all numeric but has Reals, use f64
   if all_numeric {
     let mut sum = 0.0;
@@ -3257,3 +3264,75 @@ pub fn min_ast(args: &[Expr]) -> Result<Expr, InterpreterError> {
     }
   }
 }
+
+/// Sum BigFloat (precision-tagged) numbers with precision tracking.
+/// Handles BigFloat + BigFloat and BigFloat + Integer/Rational.
+fn bigfloat_plus(args: &[Expr]) -> Result<Expr, InterpreterError> {
+  // Extract (f64_value, precision) for each argument
+  // BigFloat: use stored precision; Integer/Rational: infinite precision
+  let mut sum_val: f64 = 0.0;
+  let mut sum_error: f64 = 0.0;
+
+  for arg in args {
+    match arg {
+      Expr::BigFloat(digits, prec) => {
+        let v: f64 = digits.parse().unwrap_or(0.0);
+        let p = *prec as f64;
+        sum_val += v;
+        sum_error += v.abs() * 10f64.powf(-p);
+      }
+      Expr::Integer(n) => {
+        sum_val += *n as f64;
+        // Integer has infinite precision, contributes 0 error
+      }
+      Expr::FunctionCall { name, args: rargs }
+        if name == "Rational" && rargs.len() == 2 =>
+      {
+        if let (Expr::Integer(n), Expr::Integer(d)) = (&rargs[0], &rargs[1]) {
+          sum_val += *n as f64 / *d as f64;
+        }
+      }
+      _ => {}
+    }
+  }
+
+  // Compute result precision
+  let result_prec = if sum_val.abs() < 1e-300 || sum_error <= 0.0 {
+    // Fallback: use min finite precision among BigFloat args
+    args
+      .iter()
+      .filter_map(|a| {
+        if let Expr::BigFloat(_, p) = a {
+          Some(*p)
+        } else {
+          None
+        }
+      })
+      .min()
+      .unwrap_or(1)
+  } else {
+    let p = sum_val.abs().log10() - sum_error.log10();
+    (p.max(0.0).round() as usize).max(1)
+  };
+
+  // Format result value with the right number of significant digits
+  let result_str = format_bigfloat_value(sum_val, result_prec);
+  Ok(Expr::BigFloat(result_str, result_prec))
+}
+
+/// Format an f64 value as a BigFloat digit string with the given significant digits.
+fn format_bigfloat_value(value: f64, sig_digits: usize) -> String {
+  if value == 0.0 {
+    return "0.".to_string();
+  }
+  let sign = if value < 0.0 { "-" } else { "" };
+  let abs_val = value.abs();
+  let magnitude = abs_val.log10().floor() as i32;
+  let decimal_places = ((sig_digits as i32) - magnitude - 1).max(0) as usize;
+  let formatted = format!("{}{:.prec$}", sign, abs_val, prec = decimal_places);
+  if !formatted.contains('.') {
+    format!("{}.", formatted)
+  } else {
+    formatted
+  }
+}

src/syntax.rs

@@ -1072,6 +1072,21 @@ pub fn pair_to_expr(pair: Pair<Rule>) -> Expr {
         Expr::Real(s.parse().unwrap_or(0.0))
       }
     }
+    Rule::PrecisionReal | Rule::UnsignedPrecisionReal => {
+      let s = pair.as_str();
+      // Split on backtick: "0.1`5" → value="0.1", prec="5"
+      let backtick_pos = s.find('`').unwrap();
+      let value_str = &s[..backtick_pos];
+      let prec_str = &s[backtick_pos + 1..];
+      if prec_str.is_empty() {
+        // Bare backtick = machine precision, just parse as Real
+        Expr::Real(value_str.parse().unwrap_or(0.0))
+      } else {
+        let prec: f64 = prec_str.parse().unwrap_or(0.0);
+        let prec_usize = (prec.round() as usize).max(1);
+        Expr::BigFloat(value_str.to_string(), prec_usize)
+      }
+    }
     Rule::BasePrefix => {
       let s = pair.as_str();
       // Parse base^^digits format (e.g. 16^^FF = 255, 2^^1010 = 10)

src/wolfram.pest

@@ -28,12 +28,26 @@ UnsignedReal = @{
     (ASCII_DIGIT+ ~ "." ~ ASCII_DIGIT* | "." ~ ASCII_DIGIT+)
     ~ ("*^" ~ ("-")? ~ ASCII_DIGIT+)?
 }
+// Precision-tagged real: 0.1`1 means 0.1 with precision 1 digit
+// 0.1` means machine precision (bare backtick)
+// Precision value can be integer or real: 0.1`5, 0.1`5.2
+UnsignedPrecisionReal = @{
+    (ASCII_DIGIT+ ~ "." ~ ASCII_DIGIT* | "." ~ ASCII_DIGIT+)
+    ~ "`"
+    ~ (ASCII_DIGIT+ ~ ("." ~ ASCII_DIGIT*)? | "." ~ ASCII_DIGIT+)?
+}
+PrecisionReal = @{
+    ("-")?
+    ~ (ASCII_DIGIT+ ~ "." ~ ASCII_DIGIT* | "." ~ ASCII_DIGIT+)
+    ~ "`"
+    ~ (ASCII_DIGIT+ ~ ("." ~ ASCII_DIGIT*)? | "." ~ ASCII_DIGIT+)?
+}
 UnsignedConstant = { ("Pi" | "Degree" | "E") ~ !(ASCII_ALPHANUMERIC | "_") }
 // Base-prefix literal: base^^digits (e.g. 16^^FF, 2^^1010)
 BasePrefix = @{ ASCII_DIGIT+ ~ "^^" ~ (ASCII_ALPHANUMERIC)+ }
 Constant = { ("-")? ~ ("Pi" | "Degree" | "E") ~ !(ASCII_ALPHANUMERIC | "_") }
-NumericValue = { BasePrefix | Real | Integer | Constant }
-UnsignedNumericValue = { BasePrefix | UnsignedReal | UnsignedInteger | UnsignedConstant }
+NumericValue = { BasePrefix | PrecisionReal | Real | Integer | Constant }
+UnsignedNumericValue = { BasePrefix | UnsignedPrecisionReal | UnsignedReal | UnsignedInteger | UnsignedConstant }
 
 // PatternName is an identifier that will be followed by _ in a Pattern
 // It must start with a letter and can contain letters, digits, but NOT trailing underscores
@@ -263,6 +277,7 @@ SimpleTerm = _{
   | FunctionCall
   | DerivativeIdentifier
   | NamedCharIdentifier
+  | PatternTest | PatternOptionalWithHead | PatternOptionalSimple | PatternOptionalDefaultWithHead | PatternOptionalDefaultSimple | PatternWithHead | PatternSimple
   | Identifier
   | SlotSequence
   | Slot

tests/interpreter_tests/math/misc.rs

@@ -182,6 +182,64 @@ mod min_symbolic {
   }
 }
 
+mod implicit_times_with_patterns {
+  use super::*;
+
+  #[test]
+  fn pattern_optional_default_implicit_times() {
+    // Regression: c_. x_^2 failed to parse as implicit multiplication
+    assert_eq!(interpret("Hold[c_. x_^2]").unwrap(), "Hold[c_.*x_^2]");
+  }
+
+  #[test]
+  fn pattern_optional_default_implicit_times_with_power() {
+    // c_. x_^2 should be Times[c_., Power[x_, 2]]
+    assert_eq!(
+      interpret("Hold[c_. x_^2] // FullForm").unwrap(),
+      "FullForm[Hold[c_.*x_^2]]"
+    );
+  }
+
+  #[test]
+  fn number_times_pattern_implicit() {
+    assert_eq!(interpret("Hold[2 x_]").unwrap(), "Hold[2*x_]");
+  }
+
+  #[test]
+  fn complex_pattern_expression_implicit_times() {
+    // The expression from compare_output.sh
+    assert_eq!(
+      interpret("Int[(a_.+b_.*x_+c_. x_^2)^n_,x_Symbol] := Foo[x]").unwrap(),
+      "Null"
+    );
+  }
+}
+
+mod precision_real {
+  use super::*;
+
+  #[test]
+  fn parse_precision_real() {
+    assert_eq!(interpret("0.1`1").unwrap(), "0.1`1.");
+  }
+
+  #[test]
+  fn parse_bare_backtick_machine_precision() {
+    // Bare backtick is machine precision, displayed as normal Real
+    assert_eq!(interpret("0.1`").unwrap(), "0.1");
+  }
+
+  #[test]
+  fn precision_real_addition() {
+    assert_eq!(interpret("0.1`1 + 0.2`1").unwrap(), "0.3`1.");
+  }
+
+  #[test]
+  fn precision_real_plus_integer() {
+    assert_eq!(interpret("0.1`1 + 1").unwrap(), "1.1`2.");
+  }
+}
+
 mod max_min_flatten {
   use super::*;