ops: thread sharpness through ceil_int to its inner floor_int

ceil_int(x) = -floor_int(-x); floor_int already takes a sharpness override
but ceil_int did not forward it, pinning ceil to the default 0.1-wide ramp.
The DOOM screen-y staircase (CEIL_Y) needs sharpness=10000 (1e-4 ramp) so a
raw screen-y carrying ~0.077 of piecewise-linear multiply noise stays in the
flat zone and ceils to an exact scanline integer. Additive kwarg; the default
(None) path is byte-identical, so the measured noise footer is unchanged.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: physicsrob

tests/ops/test_arithmetic_ops.py

@@ -941,6 +941,32 @@ def test_ceil_int_wide_range_large_magnitude():
         assert abs(r - math.ceil(v)) < 0.01, f"ceil_int({v}) should be {math.ceil(v)}, got {r}"
 
 
+def test_ceil_int_high_sharpness_screen_y():
+    """ceil_int must forward sharpness to its inner floor_int (the DOOM screen-y
+    CEIL_Y staircase). At sharpness=10000 the ramp is 1e-4 wide, so a raw screen-y
+    carrying ~0.077 of piecewise-linear multiply noise stays in the flat zone and
+    ceils to an exact integer instead of interpolating across a scanline boundary.
+    Covers the narrow [0,49] and wide [0,128] / [-128,49] ranges H actually uses."""
+    import math
+
+    x = create_input("x", 1)
+    # Mid-bin offsets (well outside the 1e-4 ramp) over the screen-y ranges.
+    ranges = [(0, 49), (0, 128), (-128, 49)]
+    offsets = (0.077, 0.4, -0.077, -0.4, 0.953)
+    for lo, hi in ranges:
+        c = ceil_int(x, min_value=lo, max_value=hi, sharpness=10000.0)
+        for k in range(lo, hi):
+            for off in offsets:
+                v = k + off
+                if not (lo <= v <= hi):
+                    continue
+                r = c.compute(n_pos=1, input_values={"x": torch.tensor([[v]])}).item()
+                assert abs(r - math.ceil(v)) < 0.01, (
+                    f"ceil_int({v}, [{lo},{hi}], s=10000) should be "
+                    f"{math.ceil(v)}, got {r}"
+                )
+
+
 def test_signed_multiply():
     """Test all sign combinations."""
     a = create_input("a", 1)

torchwright/ops/arithmetic_ops.py

@@ -2361,13 +2361,24 @@ def floor_int(
     )
 
 
-def ceil_int(inp: Node, min_value: int, max_value: int) -> Node:
+def ceil_int(
+    inp: Node,
+    min_value: int,
+    max_value: int,
+    sharpness: Optional[float] = None,
+) -> Node:
     """Compute ceil(x) using the identity ``ceil(x) = -floor(-x)``.
 
     Args:
         inp: 1D scalar node with value in [min_value, max_value].
         min_value: Lower bound (integer).
         max_value: Upper bound (integer).
+        sharpness: Override the global ``step_sharpness`` for the inner
+            ``floor_int``. Higher values narrow the ramp zone at each
+            integer boundary (e.g. 10000 gives a 1e-4-wide ramp vs. the
+            default 10 which gives 0.1) so inputs carrying a few tenths of
+            piecewise-linear noise stay in the flat zone and ceil exactly.
+            Mirrors :func:`floor_int`'s ``sharpness``.
 
     Returns:
         1D scalar node containing ceil(x).
@@ -2378,7 +2389,9 @@ def ceil_int(inp: Node, min_value: int, max_value: int) -> Node:
        measured at commit 2e04d93. See docs/numerical_noise.md.
     """
     assert len(inp) == 1, "Input must be a 1D scalar node"
-    return negate(floor_int(negate(inp), -max_value, -min_value))
+    return negate(
+        floor_int(negate(inp), -max_value, -min_value, sharpness=sharpness)
+    )
 
 
 # ---------------------------------------------------------------------------