Add degree-mode trig LUTs

arithmetic.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:4a24be4920c915a295d057e727c11e68459e5271dcfa6a40831c047f00da7061
-size 361034908
+oid sha256:6bc68cbb34ffc8d5a3dcdda3c63a2a806175e6e90ee83c7fe7ca37ed287e087d
+size 436688020

build.py

@@ -89,6 +89,20 @@ def unary_float32(op_fn: Callable[[torch.Tensor], torch.Tensor]) -> Callable[[to
     return _fn
 
 
+def wrap_deg_trig(op_fn: Callable[[torch.Tensor], torch.Tensor]) -> Callable[[torch.Tensor], torch.Tensor]:
+    """Wrap trig op to interpret input as degrees."""
+    def _fn(x: torch.Tensor) -> torch.Tensor:
+        return op_fn(x.float() * (math.pi / 180.0))
+    return _fn
+
+
+def wrap_inv_trig_deg(op_fn: Callable[[torch.Tensor], torch.Tensor]) -> Callable[[torch.Tensor], torch.Tensor]:
+    """Wrap inverse trig op to return degrees."""
+    def _fn(x: torch.Tensor) -> torch.Tensor:
+        return op_fn(x.float()) * (180.0 / math.pi)
+    return _fn
+
+
 def build_float16_lut_match_tensors(prefix: str) -> Dict[str, torch.Tensor]:
     """Build exact-match gates for all 16-bit patterns under prefix.matchXXXX."""
     tensors: Dict[str, torch.Tensor] = {}
@@ -1302,6 +1316,9 @@ def infer_inputs_for_gate(gate: str, registry: SignalRegistry, routing: dict) ->
            gate.startswith('float16.log2') or gate.startswith('float16.log10') or \
            gate.startswith('float16.sin') or gate.startswith('float16.cos') or \
            gate.startswith('float16.tan') or gate.startswith('float16.tanh') or \
+           gate.startswith('float16.sin_deg') or gate.startswith('float16.cos_deg') or \
+           gate.startswith('float16.tan_deg') or gate.startswith('float16.asin_deg') or \
+           gate.startswith('float16.acos_deg') or gate.startswith('float16.atan_deg') or \
            gate.startswith('float16.asin') or gate.startswith('float16.acos') or \
            gate.startswith('float16.atan') or gate.startswith('float16.sinh') or \
            gate.startswith('float16.cosh') or gate.startswith('float16.floor') or \
@@ -11081,6 +11098,9 @@ def main():
                        k.startswith('float16.log2') or k.startswith('float16.log10') or
                        k.startswith('float16.sin') or k.startswith('float16.cos') or
                        k.startswith('float16.tan') or k.startswith('float16.tanh') or
+                       k.startswith('float16.sin_deg') or k.startswith('float16.cos_deg') or
+                       k.startswith('float16.tan_deg') or k.startswith('float16.asin_deg') or
+                       k.startswith('float16.acos_deg') or k.startswith('float16.atan_deg') or
                        k.startswith('float16.asin') or k.startswith('float16.acos') or
                        k.startswith('float16.atan') or k.startswith('float16.sinh') or
                        k.startswith('float16.cosh') or k.startswith('float16.floor') or
@@ -11205,6 +11225,14 @@ def main():
         "ceil": unary_float32(torch.ceil),
         "round": unary_float32(torch.round),
     }
+    deg_ops = {
+        "sin_deg": wrap_deg_trig(torch.sin),
+        "cos_deg": wrap_deg_trig(torch.cos),
+        "tan_deg": wrap_deg_trig(torch.tan),
+        "asin_deg": wrap_inv_trig_deg(torch.asin),
+        "acos_deg": wrap_inv_trig_deg(torch.acos),
+        "atan_deg": wrap_inv_trig_deg(torch.atan),
+    }
     lut_outputs: Dict[str, List[int]] = {}
     for name, fn in unary_ops.items():
         print(f"  computing float16.{name} LUT...")
@@ -11213,6 +11241,13 @@ def main():
         op_tensors = build_float16_lut_output_tensors(f"float16.{name}", outputs)
         tensors.update(op_tensors)
         print(f"  float16.{name}: {len(op_tensors)} tensors")
+    for name, fn in deg_ops.items():
+        print(f"  computing float16.{name} LUT...")
+        outputs = compute_float16_unary_lut_outputs(fn)
+        lut_outputs[name] = outputs
+        op_tensors = build_float16_lut_output_tensors(f"float16.{name}", outputs)
+        tensors.update(op_tensors)
+        print(f"  float16.{name}: {len(op_tensors)} tensors")
 
     # float16.pow (ln -> mul -> exp)
     pow_tensors = build_float16_pow_tensors(mul_tensors,

calculator.py

@@ -493,11 +493,18 @@ class ThresholdCalculator:
         out_int = bits_to_int(result.bits)
         return float16_bits_to_float(out_int), result
 
-    def evaluate_rpn(self, tokens: Sequence[str], force_gate_eval: bool = True) -> EvalResult:
+    def evaluate_rpn(
+        self,
+        tokens: Sequence[str],
+        force_gate_eval: bool = True,
+        angle_mode: str = "rad",
+    ) -> EvalResult:
         """Evaluate an expression from RPN tokens using float16 circuits."""
         total_elapsed = 0.0
         total_gates = 0
         non_gate_events: List[str] = []
+        angle_mode = (angle_mode or "rad").lower()
+        use_degrees = angle_mode.startswith("deg")
 
         def run_prefix(prefix: str, inputs: Dict[str, object]) -> int:
             nonlocal total_elapsed, total_gates
@@ -550,7 +557,12 @@ class ThresholdCalculator:
                 if not stack:
                     raise RuntimeError("stack underflow")
                 x = stack.pop()
-                out = run_prefix(unary_ops[tok], {"x": x})
+                prefix = unary_ops[tok]
+                if use_degrees and tok in ("sin", "cos", "tan"):
+                    prefix = f"float16.{tok}_deg"
+                elif use_degrees and tok in ("asin", "acos", "atan"):
+                    prefix = f"float16.{tok}_deg"
+                out = run_prefix(prefix, {"x": x})
                 stack.append(out)
                 continue
             if tok in {"+", "-", "*", "/", "^"}:
@@ -590,9 +602,16 @@ class ThresholdCalculator:
             non_gate_events=non_gate_events,
         )
 
-    def evaluate_expr(self, expr: str, force_gate_eval: bool = True) -> EvalResult:
+    def evaluate_expr(
+        self,
+        expr: str,
+        force_gate_eval: bool = True,
+        angle_mode: str = "rad",
+    ) -> EvalResult:
         """Evaluate a calculator expression using float16 circuits."""
         expr = normalize_expr(expr)
+        angle_mode = (angle_mode or "rad").lower()
+        use_degrees = angle_mode.startswith("deg")
         tree = ast.parse(expr, mode="eval")
 
         total_elapsed = 0.0
@@ -666,13 +685,25 @@ class ThresholdCalculator:
                 if fname == "log10":
                     return run_prefix("float16.log10", {"x": x})
                 if fname == "sin":
-                    return run_prefix("float16.sin", {"x": x})
+                    prefix = "float16.sin_deg" if use_degrees else "float16.sin"
+                    return run_prefix(prefix, {"x": x})
                 if fname == "cos":
-                    return run_prefix("float16.cos", {"x": x})
+                    prefix = "float16.cos_deg" if use_degrees else "float16.cos"
+                    return run_prefix(prefix, {"x": x})
                 if fname == "tan":
-                    return run_prefix("float16.tan", {"x": x})
+                    prefix = "float16.tan_deg" if use_degrees else "float16.tan"
+                    return run_prefix(prefix, {"x": x})
                 if fname == "tanh":
                     return run_prefix("float16.tanh", {"x": x})
+                if fname == "asin":
+                    prefix = "float16.asin_deg" if use_degrees else "float16.asin"
+                    return run_prefix(prefix, {"x": x})
+                if fname == "acos":
+                    prefix = "float16.acos_deg" if use_degrees else "float16.acos"
+                    return run_prefix(prefix, {"x": x})
+                if fname == "atan":
+                    prefix = "float16.atan_deg" if use_degrees else "float16.atan"
+                    return run_prefix(prefix, {"x": x})
                 if fname == "asin":
                     return run_prefix("float16.asin", {"x": x})
                 if fname == "acos":
@@ -720,6 +751,7 @@ def main() -> int:
     parser.add_argument("--inputs", nargs="*", help="Explicit inputs as name=value (e.g., a=0x3c00)")
     parser.add_argument("--hex", action="store_true", help="Parse numeric inputs as hex")
     parser.add_argument("--expr", help="Evaluate expression using float16 circuits")
+    parser.add_argument("--angle", default="rad", choices=["rad", "deg"], help="Angle mode for trig functions")
     parser.add_argument("--json", action="store_true", help="Output JSON result")
     parser.add_argument("--strict", action="store_true", help="Warn if any non-gate path is used")
     args = parser.parse_args()
@@ -750,7 +782,7 @@ def main() -> int:
 
     if args.expr or (args.prefix and not args.values and not args.inputs and looks_like_expression(args.prefix)):
         expr = args.expr if args.expr else args.prefix
-        result = calc.evaluate_expr(expr)
+        result = calc.evaluate_expr(expr, angle_mode=args.angle)
         out_int = bits_to_int(result.bits)
         return emit_result("expr", out_int, result, expr=expr)
 

eval.py

@@ -859,6 +859,18 @@ def float16_expected_bits_unary(op: str, a_bits: int) -> Tuple[int, bool]:
         out = torch.ceil(a32).item()
     elif op == "round":
         out = torch.round(a32).item()
+    elif op == "sin_deg":
+        out = torch.sin(a32 * (math.pi / 180.0)).item()
+    elif op == "cos_deg":
+        out = torch.cos(a32 * (math.pi / 180.0)).item()
+    elif op == "tan_deg":
+        out = torch.tan(a32 * (math.pi / 180.0)).item()
+    elif op == "asin_deg":
+        out = (torch.asin(a32) * (180.0 / math.pi)).item()
+    elif op == "acos_deg":
+        out = (torch.acos(a32) * (180.0 / math.pi)).item()
+    elif op == "atan_deg":
+        out = (torch.atan(a32) * (180.0 / math.pi)).item()
     else:
         raise ValueError(f"unknown op: {op}")
     if out != out:
@@ -2707,6 +2719,12 @@ def test_float16_unary(ctx: EvalContext) -> List[TestResult]:
         ("float16.cos", "cos"),
         ("float16.tan", "tan"),
         ("float16.tanh", "tanh"),
+        ("float16.sin_deg", "sin_deg"),
+        ("float16.cos_deg", "cos_deg"),
+        ("float16.tan_deg", "tan_deg"),
+        ("float16.asin_deg", "asin_deg"),
+        ("float16.acos_deg", "acos_deg"),
+        ("float16.atan_deg", "atan_deg"),
         ("float16.asin", "asin"),
         ("float16.acos", "acos"),
         ("float16.atan", "atan"),