rns-engine 0.6.0__tar.gz → 0.7.0__tar.gz

{rns_engine-0.6.0/src/rns_engine.egg-info → rns_engine-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rns_engine
-Version: 0.6.0
+Version: 0.7.0
 Summary: Exact RNS engine with session/cache API.
 Author: Evan Wesley
 License-Expression: AGPL-3.0-only
@@ -194,7 +194,7 @@ out = session.decode_signed(session.add(a, b))
 
 ## Weighted INT32 partial accumulation
 
-Version 0.6 adds the first direct bridge for digit-plane, chunked-GEMM, and Tensor Core pipelines.
+Version 0.7 provides the fused direct bridge for digit-plane, chunked-GEMM, and Tensor Core pipelines.
 
 Give the engine signed INT32 partial outputs with shape:
 
@@ -246,7 +246,7 @@ Important details:
 - `decode_modular()` always returns the canonical residue in `[0, M)`.
 - Empty term sets produce an exact zero result.
 
-The current implementation is an evidence-first baseline. Python schedules terms, while each per-element encode, scalar-weight multiply, and rail addition runs through the compiled native kernels. It is **not yet one fused C++ weighted-accumulation kernel**, and no fused-kernel speed claim is made.
+The current implementation uses one fused native `_weighted` call to read signed INT32 partials, collect exact per-term magnitude bounds, apply positional weights modulo `M`, and accumulate all four rails. The pre-fusion staged encode → scale → add body remains available internally as an exact reference for A/B tests. Local AVX2 diagnostics measured roughly 2.1×–2.9× speedup at one million outputs and larger gains on tiny many-term cases; those figures are hardware-specific CPU evidence, not CUDA, Tensor Core, or universal performance claims.
 
 A precomputed receipt can also be created without materializing partial arrays:
 
@@ -404,9 +404,11 @@ rns.HAS_AVX2
 
 ## Current release
 
-### v0.6.0
+### v0.7.0
 
-- weighted signed INT32 partial accumulation
+- fused native weighted signed INT32 partial accumulation
+- one compiled pass for magnitude collection, positional weighting, and four-rail accumulation
+- staged reference body retained for exact fused-versus-staged A/B benchmarking
 - exact arbitrary-precision positional weights
 - per-term magnitude receipts and strict no-wrap certification
 - canonical modular and uniqueness-gated signed decode paths

{rns_engine-0.6.0 → rns_engine-0.7.0}/README.md

@@ -171,7 +171,7 @@ out = session.decode_signed(session.add(a, b))
 
 ## Weighted INT32 partial accumulation
 
-Version 0.6 adds the first direct bridge for digit-plane, chunked-GEMM, and Tensor Core pipelines.
+Version 0.7 provides the fused direct bridge for digit-plane, chunked-GEMM, and Tensor Core pipelines.
 
 Give the engine signed INT32 partial outputs with shape:
 
@@ -223,7 +223,7 @@ Important details:
 - `decode_modular()` always returns the canonical residue in `[0, M)`.
 - Empty term sets produce an exact zero result.
 
-The current implementation is an evidence-first baseline. Python schedules terms, while each per-element encode, scalar-weight multiply, and rail addition runs through the compiled native kernels. It is **not yet one fused C++ weighted-accumulation kernel**, and no fused-kernel speed claim is made.
+The current implementation uses one fused native `_weighted` call to read signed INT32 partials, collect exact per-term magnitude bounds, apply positional weights modulo `M`, and accumulate all four rails. The pre-fusion staged encode → scale → add body remains available internally as an exact reference for A/B tests. Local AVX2 diagnostics measured roughly 2.1×–2.9× speedup at one million outputs and larger gains on tiny many-term cases; those figures are hardware-specific CPU evidence, not CUDA, Tensor Core, or universal performance claims.
 
 A precomputed receipt can also be created without materializing partial arrays:
 
@@ -381,9 +381,11 @@ rns.HAS_AVX2
 
 ## Current release
 
-### v0.6.0
+### v0.7.0
 
-- weighted signed INT32 partial accumulation
+- fused native weighted signed INT32 partial accumulation
+- one compiled pass for magnitude collection, positional weighting, and four-rail accumulation
+- staged reference body retained for exact fused-versus-staged A/B benchmarking
 - exact arbitrary-precision positional weights
 - per-term magnitude receipts and strict no-wrap certification
 - canonical modular and uniqueness-gated signed decode paths

{rns_engine-0.6.0 → rns_engine-0.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "rns_engine"
-version = "0.6.0"
+version = "0.7.0"
 description = "Exact RNS engine with session/cache API."
 readme = "README.md"
 requires-python = ">=3.10"

{rns_engine-0.6.0 → rns_engine-0.7.0}/setup.py

@@ -39,19 +39,27 @@ def get_link_args():
     return []
 
 
-ext = Extension(
-    "rns_engine._core",
-    sources=["src/rns_engine/_core.cpp"],
-    include_dirs=[pybind11.get_include(), np.get_include()],
-    extra_compile_args=get_compile_args(),
-    extra_link_args=get_link_args(),
-    language="c++",
+def native_extension(name, source):
+    return Extension(
+        name,
+        sources=[source],
+        include_dirs=[pybind11.get_include(), np.get_include()],
+        extra_compile_args=get_compile_args(),
+        extra_link_args=get_link_args(),
+        language="c++",
+    )
+
+
+ext = native_extension("rns_engine._core", "src/rns_engine/_core.cpp")
+weighted_ext = native_extension(
+    "rns_engine._weighted",
+    "src/rns_engine/_weighted.cpp",
 )
 
 # Project metadata and package discovery live in pyproject.toml. Keeping them
 # out of setup.py prevents the two build entry points from drifting apart.
 setup(
-    ext_modules=[ext],
+    ext_modules=[ext, weighted_ext],
     include_package_data=True,
     zip_safe=False,
 )

rns_engine-0.7.0/src/rns_engine/_weighted.cpp

@@ -0,0 +1,141 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/numpy.h>
+#include <stdint.h>
+#include <stdexcept>
+#include <string>
+#include <cstring>
+
+namespace py = pybind11;
+
+using arr_i32 = py::array_t<int32_t, py::array::c_style>;
+using arr16 = py::array_t<uint16_t, py::array::c_style>;
+using arr32 = py::array_t<uint32_t, py::array::c_style>;
+using arr64 = py::array_t<uint64_t, py::array::c_style | py::array::forcecast>;
+
+static constexpr uint32_t M0      = 127;
+static constexpr uint32_t M1      = 8191;
+static constexpr uint32_t M2      = 65536;
+static constexpr uint32_t M3      = 524287;
+static constexpr uint32_t M3_MASK = 0x7FFFFu;
+static constexpr uint64_t BM      = (uint64_t)M0 * M1 * M2 * M3;
+
+static int64_t require_1d_len(const py::array& a, const char* name) {
+    if (a.ndim() != 1) {
+        throw std::invalid_argument(std::string(name) + " must be a 1D array");
+    }
+    return (int64_t)a.shape(0);
+}
+
+static inline uint16_t r127s(uint32_t x) {
+    x = (x & 0x7F) + (x >> 7);
+    x = (x & 0x7F) + (x >> 7);
+    return x >= M0 ? x - M0 : (uint16_t)x;
+}
+
+static inline uint16_t r8191s(uint32_t x) {
+    x = (x & 0x1FFF) + (x >> 13);
+    x = (x & 0x1FFF) + (x >> 13);
+    return x >= M1 ? x - M1 : (uint16_t)x;
+}
+
+static inline uint32_t fma524287s(uint32_t a, uint32_t b, uint32_t c) {
+    uint64_t x = (uint64_t)a * b + c;
+    x = (x & M3_MASK) + (x >> 19);
+    x = (x & M3_MASK) + (x >> 19);
+    x = (x & M3_MASK) + (x >> 19);
+    uint32_t r = (uint32_t)x;
+    return r >= M3 ? (r - M3) : r;
+}
+
+static inline uint32_t mod524287_u64(uint64_t x) {
+    x = (x & M3_MASK) + (x >> 19);
+    x = (x & M3_MASK) + (x >> 19);
+    x = (x & M3_MASK) + (x >> 19);
+    uint32_t r = (uint32_t)x;
+    return r >= M3 ? (r - M3) : r;
+}
+
+py::tuple weighted_int32(const arr_i32& partials, const arr64& weights) {
+    if (partials.ndim() != 2) {
+        throw std::invalid_argument("partials must be a 2D int32 array");
+    }
+
+    const int64_t terms = (int64_t)partials.shape(0);
+    const int64_t n = (int64_t)partials.shape(1);
+    const int64_t weight_count = require_1d_len(weights, "weights");
+    if (weight_count != terms) {
+        throw std::invalid_argument(
+            "weights length must match partial term count (" +
+            std::to_string(weight_count) + " != " + std::to_string(terms) + ")");
+    }
+
+    arr16 o0({n}), o1({n}), o2({n});
+    arr32 o3({n});
+    arr64 bounds({terms});
+
+    uint16_t* p0 = o0.mutable_data();
+    uint16_t* p1 = o1.mutable_data();
+    uint16_t* p2 = o2.mutable_data();
+    uint32_t* p3 = o3.mutable_data();
+    uint64_t* pb = bounds.mutable_data();
+
+    if (n > 0) {
+        std::memset(p0, 0, (size_t)n * sizeof(uint16_t));
+        std::memset(p1, 0, (size_t)n * sizeof(uint16_t));
+        std::memset(p2, 0, (size_t)n * sizeof(uint16_t));
+        std::memset(p3, 0, (size_t)n * sizeof(uint32_t));
+    }
+    if (terms > 0) {
+        std::memset(pb, 0, (size_t)terms * sizeof(uint64_t));
+    }
+
+    const int32_t* x = partials.data();
+    const uint64_t* w = weights.data();
+
+    {
+        py::gil_scoped_release release;
+        for (int64_t term = 0; term < terms; ++term) {
+            const uint64_t weight = w[term] % BM;
+            const uint16_t w0 = (uint16_t)(weight % M0);
+            const uint16_t w1 = (uint16_t)(weight % M1);
+            const uint16_t w2 = (uint16_t)weight;
+            const uint32_t w3 = mod524287_u64(weight);
+            const int32_t* row = x + term * n;
+            uint64_t max_abs = 0;
+
+            for (int64_t i = 0; i < n; ++i) {
+                const int32_t signed_value = row[i];
+                const uint64_t magnitude = signed_value < 0
+                    ? (uint64_t)(-(int64_t)signed_value)
+                    : (uint64_t)signed_value;
+                if (magnitude > max_abs) max_abs = magnitude;
+
+                if (weight == 0) continue;
+
+                const uint64_t canonical = signed_value < 0
+                    ? (uint64_t)((int64_t)BM + (int64_t)signed_value)
+                    : (uint64_t)signed_value;
+                const uint16_t x0 = (uint16_t)(canonical % M0);
+                const uint16_t x1 = (uint16_t)(canonical % M1);
+                const uint16_t x2 = (uint16_t)canonical;
+                const uint32_t x3 = mod524287_u64(canonical);
+
+                p0[i] = r127s((uint32_t)p0[i] + (uint32_t)x0 * w0);
+                p1[i] = r8191s((uint32_t)p1[i] + (uint32_t)x1 * w1);
+                p2[i] = (uint16_t)((uint32_t)p2[i] + (uint32_t)x2 * w2);
+                p3[i] = fma524287s(x3, w3, p3[i]);
+            }
+            pb[term] = max_abs;
+        }
+    }
+
+    return py::make_tuple(o0, o1, o2, o3, bounds);
+}
+
+PYBIND11_MODULE(_weighted, m) {
+    m.doc() = "Fused weighted signed INT32 accumulation for rns_engine.";
+    m.def(
+        "weighted_int32",
+        &weighted_int32,
+        "Fused signed int32 weighting and four-rail accumulation with per-term bounds.");
+}

{rns_engine-0.6.0 → rns_engine-0.7.0}/src/rns_engine/weighted.py

@@ -10,6 +10,7 @@ from ._core import M
 from ._core import add as _add
 from ._core import decode as _decode
 from ._core import mul_u64 as _mul_u64
+from ._weighted import weighted_int32 as _weighted_int32
 from .engine import EncodedArray
 from .signed import SignedRangeCertificate, certify_signed_bound, decode_signed, encode_signed
 
@@ -57,15 +58,7 @@ def certify_weighted_sum_bound(
     term_abs_bounds: Sequence[int] | Iterable[int],
     addend_abs_bound: int = 0,
 ) -> SignedRangeCertificate:
-    """Certify ``sum(weight[t] * term[t]) + addend`` from magnitude bounds.
-
-    The conservative exact bound is::
-
-        sum(abs(weight[t]) * term_abs_bound[t]) + addend_abs_bound
-
-    Weights are unrestricted Python integers. The certificate is unique only
-    when the resulting bound is strictly less than ``M/2``.
-    """
+    """Certify ``sum(weight[t] * term[t]) + addend`` from magnitude bounds."""
 
     exact_weights = _integer_tuple(weights, name="weights")
     exact_bounds = _bound_tuple(term_abs_bounds, name="term_abs_bounds")
@@ -105,38 +98,18 @@ class WeightedInt32Result:
         return int(np.prod(self.output_shape, dtype=np.int64)) if self.output_shape else 1
 
     def decode_modular(self) -> np.ndarray:
-        """Return the canonical unsigned residue in ``[0, M)``."""
-
         return _decode(*self.encoded.rails()).reshape(self.output_shape)
 
     def decode_signed(self, *, require_unique: bool = True) -> np.ndarray:
-        """Return the centered result, optionally requiring uniqueness proof."""
-
         if require_unique:
             self.certificate.require_unique()
         return decode_signed(*self.encoded.rails()).reshape(self.output_shape)
 
 
-def accumulate_weighted_int32(
+def _validate_weighted_inputs(
     partials: Any,
     weights: Sequence[int] | Iterable[int],
-    *,
-    require_unique: bool = False,
-) -> WeightedInt32Result:
-    """Combine signed INT32 partial outputs through native RNS kernels.
-
-    ``partials`` has shape ``(terms, *output_shape)``. Each term is encoded by
-    the native four-rail encoder, multiplied by its exact positional weight
-    modulo ``M`` through the native scalar-broadcast kernel, and accumulated by
-    the native rail-add kernel. Python orchestrates the terms; the arithmetic on
-    every output element remains in the compiled RNS body.
-
-    The returned range receipt uses the actual maximum absolute INT32 value in
-    every term and the full Python integer weights, not their reduced residues.
-    Therefore ``certificate.require_unique()`` is a valid no-wrap gate for the
-    represented weighted sum.
-    """
-
+) -> tuple[np.ndarray, tuple[int, ...], tuple[int, ...], int, np.ndarray]:
     raw = np.asarray(partials)
     if raw.ndim < 1:
         raise ValueError("partials must have shape (terms, *output_shape)")
@@ -155,6 +128,20 @@ def accumulate_weighted_int32(
     output_shape = tuple(int(dimension) for dimension in contiguous.shape[1:])
     output_size = int(np.prod(output_shape, dtype=np.int64)) if output_shape else 1
     flat = contiguous.reshape(term_count, output_size)
+    execution_weights = np.fromiter(
+        (weight % int(M) for weight in exact_weights),
+        dtype=np.uint64,
+        count=term_count,
+    )
+    return flat, exact_weights, output_shape, output_size, execution_weights
+
+
+def _accumulate_weighted_int32_staged(
+    flat: np.ndarray,
+    exact_weights: tuple[int, ...],
+    output_size: int,
+) -> tuple[tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray], tuple[int, ...]]:
+    """Pre-fusion reference body retained for correctness and A/B benchmarks."""
 
     term_abs_bounds: list[int] = []
     for term in flat:
@@ -164,14 +151,8 @@ def accumulate_weighted_int32(
         widened = term.astype(np.int64, copy=False)
         term_abs_bounds.append(int(np.max(np.abs(widened))))
 
-    bounds = tuple(term_abs_bounds)
-    certificate = certify_weighted_sum_bound(exact_weights, bounds)
-    if require_unique:
-        certificate.require_unique()
-
     accumulator = encode_signed(np.zeros(output_size, dtype=np.int64))
     modulus = int(M)
-
     for term, weight in zip(flat, exact_weights):
         if weight == 0 or output_size == 0:
             continue
@@ -179,8 +160,36 @@ def accumulate_weighted_int32(
         scaled = _mul_u64(*encoded, weight % modulus)
         accumulator = _add(*accumulator, *scaled)
 
+    return accumulator, tuple(term_abs_bounds)
+
+
+def accumulate_weighted_int32(
+    partials: Any,
+    weights: Sequence[int] | Iterable[int],
+    *,
+    require_unique: bool = False,
+) -> WeightedInt32Result:
+    """Fuse signed INT32 weighting, rail accumulation, and bound collection.
+
+    Python validates shape and preserves the original arbitrary-precision
+    weights for the proof receipt. The compiled kernel reads each INT32 term,
+    computes its actual maximum magnitude, reduces the execution weight modulo
+    ``M``, and updates all four rails without materializing encoded/scaled
+    intermediate arrays.
+    """
+
+    flat, exact_weights, output_shape, _, execution_weights = _validate_weighted_inputs(
+        partials,
+        weights,
+    )
+    r0, r1, r2, r3, native_bounds = _weighted_int32(flat, execution_weights)
+    bounds = tuple(int(value) for value in native_bounds)
+    certificate = certify_weighted_sum_bound(exact_weights, bounds)
+    if require_unique:
+        certificate.require_unique()
+
     return WeightedInt32Result(
-        encoded=EncodedArray(*accumulator),
+        encoded=EncodedArray(r0, r1, r2, r3),
         certificate=certificate,
         output_shape=output_shape,
         weights=exact_weights,

{rns_engine-0.6.0 → rns_engine-0.7.0/src/rns_engine.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rns_engine
-Version: 0.6.0
+Version: 0.7.0
 Summary: Exact RNS engine with session/cache API.
 Author: Evan Wesley
 License-Expression: AGPL-3.0-only
@@ -194,7 +194,7 @@ out = session.decode_signed(session.add(a, b))
 
 ## Weighted INT32 partial accumulation
 
-Version 0.6 adds the first direct bridge for digit-plane, chunked-GEMM, and Tensor Core pipelines.
+Version 0.7 provides the fused direct bridge for digit-plane, chunked-GEMM, and Tensor Core pipelines.
 
 Give the engine signed INT32 partial outputs with shape:
 
@@ -246,7 +246,7 @@ Important details:
 - `decode_modular()` always returns the canonical residue in `[0, M)`.
 - Empty term sets produce an exact zero result.
 
-The current implementation is an evidence-first baseline. Python schedules terms, while each per-element encode, scalar-weight multiply, and rail addition runs through the compiled native kernels. It is **not yet one fused C++ weighted-accumulation kernel**, and no fused-kernel speed claim is made.
+The current implementation uses one fused native `_weighted` call to read signed INT32 partials, collect exact per-term magnitude bounds, apply positional weights modulo `M`, and accumulate all four rails. The pre-fusion staged encode → scale → add body remains available internally as an exact reference for A/B tests. Local AVX2 diagnostics measured roughly 2.1×–2.9× speedup at one million outputs and larger gains on tiny many-term cases; those figures are hardware-specific CPU evidence, not CUDA, Tensor Core, or universal performance claims.
 
 A precomputed receipt can also be created without materializing partial arrays:
 
@@ -404,9 +404,11 @@ rns.HAS_AVX2
 
 ## Current release
 
-### v0.6.0
+### v0.7.0
 
-- weighted signed INT32 partial accumulation
+- fused native weighted signed INT32 partial accumulation
+- one compiled pass for magnitude collection, positional weighting, and four-rail accumulation
+- staged reference body retained for exact fused-versus-staged A/B benchmarking
 - exact arbitrary-precision positional weights
 - per-term magnitude receipts and strict no-wrap certification
 - canonical modular and uniqueness-gated signed decode paths

{rns_engine-0.6.0 → rns_engine-0.7.0}/src/rns_engine.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ pyproject.toml
 setup.py
 src/rns_engine/__init__.py
 src/rns_engine/_core.cpp
+src/rns_engine/_weighted.cpp
 src/rns_engine/engine.py
 src/rns_engine/signed.py
 src/rns_engine/weighted.py
@@ -17,4 +18,5 @@ tests/test_packaging.py
 tests/test_rns.py
 tests/test_session.py
 tests/test_signed.py
-tests/test_weighted.py
+tests/test_weighted.py
+tests/test_weighted_benchmark.py

{rns_engine-0.6.0 → rns_engine-0.7.0}/tests/test_weighted.py

@@ -157,3 +157,53 @@ def test_weighted_bound_validates_lengths_and_nonnegative_term_bounds():
 
     with pytest.raises(TypeError, match="addend_abs_bound"):
         rns.certify_weighted_sum_bound([1], [1], addend_abs_bound=1.5)
+
+
+def test_fused_weighted_kernel_matches_staged_reference_randomized():
+    from rns_engine.weighted import (
+        _accumulate_weighted_int32_staged,
+        _validate_weighted_inputs,
+    )
+
+    rng = np.random.default_rng(20260802)
+    for terms, outputs in [(0, 7), (1, 1), (2, 17), (5, 257), (9, 1024)]:
+        partials = rng.integers(
+            np.iinfo(np.int32).min,
+            np.iinfo(np.int32).max,
+            size=(terms, outputs),
+            dtype=np.int32,
+        )
+        weights = tuple(
+            ((-1) ** position) * (2 ** (13 * position) + 17)
+            for position in range(terms)
+        )
+
+        fused = rns.accumulate_weighted_int32(partials, weights)
+        flat, exact_weights, output_shape, output_size, _ = _validate_weighted_inputs(
+            partials,
+            weights,
+        )
+        staged_rails, staged_bounds = _accumulate_weighted_int32_staged(
+            flat,
+            exact_weights,
+            output_size,
+        )
+
+        assert fused.output_shape == output_shape
+        assert fused.term_abs_bounds == staged_bounds
+        for fused_rail, staged_rail in zip(fused.encoded.rails(), staged_rails):
+            np.testing.assert_array_equal(fused_rail, staged_rail)
+
+
+def test_fused_kernel_handles_noncontiguous_input_without_changing_result():
+    base = np.arange(4 * 20, dtype=np.int32).reshape(4, 20)
+    partials = base[:, ::2]
+    assert not partials.flags.c_contiguous
+
+    receipt = rns.accumulate_weighted_int32(partials, [1, -2, 3, -4])
+    expected = sum(
+        weight * term.astype(np.int64)
+        for weight, term in zip([1, -2, 3, -4], partials)
+    )
+
+    np.testing.assert_array_equal(receipt.decode_signed(), expected)

rns_engine-0.7.0/tests/test_weighted_benchmark.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+import importlib.util
+import sys
+from pathlib import Path
+
+import numpy as np
+
+
+BENCHMARK_PATH = (
+    Path(__file__).resolve().parents[1]
+    / "benchmarks"
+    / "weighted_int32_baseline.py"
+)
+
+
+def _load_benchmark_module():
+    spec = importlib.util.spec_from_file_location(
+        "weighted_int32_baseline",
+        BENCHMARK_PATH,
+    )
+    if spec is None or spec.loader is None:
+        raise RuntimeError("could not load weighted INT32 benchmark module")
+
+    module = importlib.util.module_from_spec(spec)
+    # Dataclasses with postponed annotations resolve their defining module
+    # through sys.modules while the class decorator executes.
+    sys.modules[spec.name] = module
+    try:
+        spec.loader.exec_module(module)
+    except Exception:
+        sys.modules.pop(spec.name, None)
+        raise
+    return module
+
+
+def test_weight_families_are_deterministic():
+    benchmark = _load_benchmark_module()
+
+    assert benchmark._weights(4, "unit", 128) == (1, 1, 1, 1)
+    assert benchmark._weights(4, "alternating", 128) == (1, -1, 1, -1)
+    assert benchmark._weights(4, "radix", 8) == (1, 8, 64, 512)
+    assert benchmark._weights(4, "centered-radix", 8) == (1, -8, 64, -512)
+
+
+def test_tiny_benchmark_case_runs_with_exact_witnesses():
+    benchmark = _load_benchmark_module()
+
+    result = benchmark.run_case(
+        terms=2,
+        outputs=8,
+        max_abs=7,
+        weight_mode="alternating",
+        radix=128,
+        repeats=1,
+        warmups=0,
+        sample_count=8,
+        rng=np.random.default_rng(12345),
+    )
+
+    assert result.terms == 2
+    assert result.outputs == 8
+    assert result.fused_native_calls == 1
+    assert result.staged_native_calls == 7
+    assert result.fused_speedup_over_staged > 0
+    assert result.max_abs_bound <= 14
+    assert result.unique_signed_result is True
+    assert result.fused_median_seconds >= 0
+    assert result.staged_median_seconds >= 0
+    assert result.decode_median_seconds >= 0
+    assert result.numpy_int64_control_median_seconds is not None