[Lang] qd.precise: replace -- with single - in comments

Author: duburcqa

python/quadrants/lang/ops.py

@@ -111,14 +111,14 @@ def precise(obj):
     binary ops are reached even when wrapped, e.g.
     ``qd.precise(qd.bit_cast(a + b, qd.f32))``. It stops at loads,
     constants, ``qd.func`` calls, ndarray accesses, etc.; semantics inside
-    a ``qd.func`` body are governed by that body's own ops -- wrap calls
+    a ``qd.func`` body are governed by that body's own ops - wrap calls
     separately if needed.
 
     Notes:
         * Tagging is in-place on the underlying ``Expression`` nodes
           (which are shared via ``shared_ptr``). If you alias a
           subexpression and then wrap one alias in ``qd.precise``, the
-          tag travels with the value -- both uses get IEEE semantics.
+          tag travels with the value - both uses get IEEE semantics.
 
     Args:
         obj: A scalar Quadrants expression (typically a chain of FP ops).

quadrants/codegen/spirv/spirv_codegen.cpp

@@ -889,7 +889,7 @@ void TaskCodegen::visit(UnaryOpStmt *stmt) {
   // meaningful on actual arithmetic instructions (`OpFNegate` from `neg`, `OpFDiv` synthesized by `inv`)
   // where SPIRV-Cross maps it to MSL's `precise` qualifier. For transcendentals emitted via
   // `OpExtInst GLSL.std.450 Sin/Cos/Log/Sqrt/...`, the SPIR-V spec scopes `NoContraction` to arithmetic
-  // instructions so most consumers will ignore it -- there is no standard SPIR-V mechanism to force
+  // instructions so most consumers will ignore it - there is no standard SPIR-V mechanism to force
   // correctly-rounded transcendentals, so on those paths we rely on the driver's default (non-fast-math)
   // stdlib being accurate enough. The decoration is kept as best-effort future-proofing.
   if (stmt->precise && is_real(stmt->element_type())) {

quadrants/ir/expr.cpp

@@ -56,7 +56,7 @@ Expr precise(const Expr &input) {
   // Walk the subtree; tag every BinaryOpExpression we find. We also recurse through UnaryOpExpression and
   // TernaryOpExpression so users can write things like `qd.precise(qd.bit_cast(a + b, qd.f32))` or
   // `qd.precise(qd.select(c, a + b, x - y))` and still have the inner FP ops tagged. Recursion stops at
-  // any other Expression kind (loads, constants, qd.func calls, etc.) -- semantics inside e.g. a qd.func
+  // any other Expression kind (loads, constants, qd.func calls, etc.) - semantics inside e.g. a qd.func
   // body are governed by that body's own ops. A worklist keeps stack depth bounded since deep AST chains
   // in scientific code aren't rare.
   std::vector<Expr> stack{input};

tests/python/test_precise.py

@@ -19,7 +19,7 @@
 @test_utils.test(default_fp=qd.f32, fast_math=True)
 def test_qd_precise_protects_fast_math():
     """Run Dekker 2Sum twice under `fast_math=True`: once unprotected (the
-    compensation term must be folded to zero -- that is the very bug
+    compensation term must be folded to zero - that is the very bug
     `qd.precise` exists to fix) and once with `qd.precise(...)` wrapping
     every FP op (the compensation term must survive).
     """
@@ -91,7 +91,7 @@ def df_accum_precise(in_arr: qd.types.ndarray(qd.f32, ndim=1), out: qd.types.nda
     # distinguishes `precise` from non-`precise` BinaryOpExpressions. The two kernels are structurally
     # identical apart from `qd.precise(...)` wrappers, so if the cache key did not account for `precise`
     # (as was the case before), the second compile would silently reuse the first's artifact and
-    # `df_accum_precise` would produce naive behavior -- caught by the final assertion below.
+    # `df_accum_precise` would produce naive behavior - caught by the final assertion below.
     df_accum_naive(in_arr, out_naive)
     df_accum_precise(in_arr, out_precise)
 
@@ -106,12 +106,12 @@ def df_accum_precise(in_arr: qd.types.ndarray(qd.f32, ndim=1), out: qd.types.nda
     # `qd.precise` must restore IEEE semantics locally: the compensation term must be non-trivially non-zero.
     assert abs(float(lo_precise)) > 1e-10, (
         f"qd.precise failed to protect 2Sum: lo={lo_precise!r} (expected |lo| > 1e-10). "
-        f"The backend folded `(a - aa) + (b - bb)` to zero -- IEEE-strict ordering was not honored."
+        f"The backend folded `(a - aa) + (b - bb)` to zero - IEEE-strict ordering was not honored."
     )
 
     # And the compensated sum must beat the naive f32 sum by orders of magnitude. This is the end-to-end
     # guarantee `qd.precise` exists to provide; it also indirectly validates that the offline-cache key
-    # generator distinguishes `precise` from non-`precise` BinaryOpExpressions -- if it did not, the two
+    # generator distinguishes `precise` from non-`precise` BinaryOpExpressions - if it did not, the two
     # kernels (structurally identical apart from `qd.precise(...)` wrappers) would share a compiled artifact
     # and `out_precise` would match `out_naive`.
     ds_err = abs(float(hi_precise) + float(lo_precise) - expected_f64)
@@ -135,7 +135,7 @@ def test_qd_precise_unary_rounding():
     `fast_math=True` happens to give correctly-rounded transcendentals
     anyway and a comparison against it would be uninformative. `sqrt`
     is included because LLVM FMF's `afn` can substitute `rsqrt+refine`
-    which is ~2-3 ULP -- the precise tag must defeat that substitution.
+    which is ~2-3 ULP - the precise tag must defeat that substitution.
     """
 
     @qd.kernel