Add implicit multiplication to expression parser

- Tokenize infix expressions with identifiers and scientific notation\n- Insert implicit '*' between adjacent values (e.g., 2pi, 3(4+5))\n- Keep function calls intact when followed by parentheses

calculator.py

@@ -11,6 +11,7 @@ import argparse
 import ast
 import json
 import math
+import re
 import struct
 import time
 from dataclasses import dataclass, field
@@ -91,12 +92,82 @@ def resolve_alias_target(name: str, gates: set) -> Optional[str]:
     return None
 
 
+_NUM_RE = re.compile(r"(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?")
+_IDENT_RE = re.compile(r"[A-Za-z_][A-Za-z0-9_]*")
+_FUNC_NAMES = {
+    "sqrt", "rsqrt", "exp", "ln", "log", "log2", "log10",
+    "deg2rad", "rad2deg",
+    "isnan", "is_nan", "isinf", "is_inf", "isfinite", "is_finite",
+    "iszero", "is_zero", "issubnormal", "is_subnormal",
+    "isnormal", "is_normal", "isneg", "is_negative", "signbit",
+    "sin", "cos", "tan", "tanh",
+    "asin", "acos", "atan", "sinh", "cosh",
+    "floor", "ceil", "round", "abs", "neg",
+}
+
+
+def _tokenize_expr(expr: str) -> List[str]:
+    tokens: List[str] = []
+    i = 0
+    while i < len(expr):
+        ch = expr[i]
+        if ch.isspace():
+            i += 1
+            continue
+        if expr.startswith("**", i):
+            tokens.append("**")
+            i += 2
+            continue
+        if ch in "+-*/(),":
+            tokens.append(ch)
+            i += 1
+            continue
+        num_match = _NUM_RE.match(expr, i)
+        if num_match:
+            tokens.append(num_match.group(0))
+            i = num_match.end()
+            continue
+        ident_match = _IDENT_RE.match(expr, i)
+        if ident_match:
+            tokens.append(ident_match.group(0))
+            i = ident_match.end()
+            continue
+        raise RuntimeError(f"bad token near: {expr[i:]}")
+    return tokens
+
+
+def _needs_implicit_mul(left: str, right: str) -> bool:
+    if left in {"+", "-", "*", "/", "**", ",", "("}:
+        return False
+    if right in {"+", "-", "*", "/", "**", ",", ")"}:
+        return False
+    if left in _FUNC_NAMES and right == "(":
+        return False
+    return True
+
+
+def _insert_implicit_mul(expr: str) -> str:
+    tokens = _tokenize_expr(expr)
+    if not tokens:
+        return expr
+    out: List[str] = []
+    for idx, tok in enumerate(tokens):
+        out.append(tok)
+        if idx + 1 >= len(tokens):
+            continue
+        nxt = tokens[idx + 1]
+        if _needs_implicit_mul(tok, nxt):
+            out.append("*")
+    return "".join(out)
+
+
 def normalize_expr(expr: str) -> str:
     """Normalize user-facing calculator syntax to Python AST syntax."""
     expr = expr.replace("\u03c0", "pi")
     expr = expr.replace("\u00d7", "*").replace("\u00f7", "/").replace("\u2212", "-")
     if "^" in expr:
         expr = expr.replace("^", "**")
+    expr = _insert_implicit_mul(expr)
     return expr