waveforms 3.4.0__tar.gz → 3.5.1__tar.gz

{waveforms-3.4.0/waveforms.egg-info → waveforms-3.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: waveforms
-Version: 3.4.0
+Version: 3.5.1
 Summary: Edit waveforms used in experiment
 Author-email: feihoo87 <feihoo87@gmail.com>
 Maintainer-email: feihoo87 <feihoo87@gmail.com>
@@ -153,6 +153,71 @@ Real waveforms and stacks therefore avoid complex storage and arithmetic for
 the common real-valued case. `ComplexWaveform.real` and `.imag` expose the two
 real channel waveforms.
 
+### Post-sampling nonlinear calibration
+
+`NonlinearMap` compiles one monotone branch of calibration samples to a compact
+native lookup table.  A centered map is useful when a waveform describes a
+frequency excursion around an idle point:
+
+```python
+frequency = np.array([4.0e9, 4.5e9, 5.0e9, 5.5e9, 6.0e9])
+flux = np.array([0.31, 0.22, 0.08, -0.06, -0.16])
+
+frequency_to_flux = wf.NonlinearMap.from_samples(
+    frequency,
+    flux,
+    method="monotone_cubic",  # PCHIP compiled to uniform cubic segments
+    reference=5.0e9,          # map(0) == 0 around the idle frequency
+    dtype=np.float32,
+    extrapolate="error",
+)
+
+trajectory.start = 0
+trajectory.stop = 200e-9
+trajectory.sample_rate = 2_400_000_000
+trajectory.nonlinear = frequency_to_flux
+flux_samples = trajectory.sample(dtype=np.int16)
+```
+
+The sampling order is waveform accumulation, nonlinear mapping, optional SOS
+filtering/predistortion, output amplitude limits (`min`/`max`), and finally
+integer quantization or floating-point output. This is important for
+`WaveVStack`: the map is applied to the accumulated trajectory rather than to
+each pulse event independently. `method="linear"` selects the smaller and
+fastest two-point interpolation path. Maps serialize independently through
+`to_bytes()`/`from_bytes()` using the language-neutral `NLM1` format.
+
+Every waveform and stack has output limits, defaulting to `min=-np.inf` and
+`max=np.inf`. A stack ignores its child waveforms' limits and uses only its own:
+
+```python
+stack.min = -0.2
+stack.max = 0.3
+samples = stack.sample()  # limit after the complete calibration/filter chain
+```
+
+Limits apply to whole and chunked sampling, including `out=` buffers and
+integer output. Complex signals limit I and Q independently; `sample_iq()`
+uses the same final limits. The filter state continues from the unclipped
+filtered signal across chunks. DAC `full_scale` controls integer conversion
+and saturation separately from these amplitude limits.
+
+Real-coefficient SOS filters (`filters=(sos, initial)`) run in the C core for
+float64 and complex128 signals. This stage subtracts the baseline `initial`,
+applies the cascade, restores the baseline, and applies the final limits.
+Real int16/int32 output is quantized in the same stage, without allocating a
+full filtered floating-point buffer. Float output can reuse the sampled
+buffer. A small fixed scratch buffer keeps filtering and conversion local;
+waveform evaluation and nonlinear mapping still precede this stage. Complex
+coefficients and extended precision retain the SciPy implementation.
+`sample_iq()` still converts the filtered complex result into separate I/Q
+output arrays. See [the SOS benchmark](benchmarks/sos_filter.md).
+
+Calling `waveform(t)` directly evaluates with amplitude limits but without
+nonlinear calibration or filtering. Sampling evaluates the underlying signal
+without limits before applying its processing chain. Limits are sampling
+metadata preserved by pickle, not part of the raw WNF4/WNS4 binary blocks.
+
 ## Reporting Issues
 Please report all issues [on github](https://github.com/feihoo87/waveforms/issues).
 

{waveforms-3.4.0 → waveforms-3.5.1}/README.md

@@ -109,6 +109,71 @@ Real waveforms and stacks therefore avoid complex storage and arithmetic for
 the common real-valued case. `ComplexWaveform.real` and `.imag` expose the two
 real channel waveforms.
 
+### Post-sampling nonlinear calibration
+
+`NonlinearMap` compiles one monotone branch of calibration samples to a compact
+native lookup table.  A centered map is useful when a waveform describes a
+frequency excursion around an idle point:
+
+```python
+frequency = np.array([4.0e9, 4.5e9, 5.0e9, 5.5e9, 6.0e9])
+flux = np.array([0.31, 0.22, 0.08, -0.06, -0.16])
+
+frequency_to_flux = wf.NonlinearMap.from_samples(
+    frequency,
+    flux,
+    method="monotone_cubic",  # PCHIP compiled to uniform cubic segments
+    reference=5.0e9,          # map(0) == 0 around the idle frequency
+    dtype=np.float32,
+    extrapolate="error",
+)
+
+trajectory.start = 0
+trajectory.stop = 200e-9
+trajectory.sample_rate = 2_400_000_000
+trajectory.nonlinear = frequency_to_flux
+flux_samples = trajectory.sample(dtype=np.int16)
+```
+
+The sampling order is waveform accumulation, nonlinear mapping, optional SOS
+filtering/predistortion, output amplitude limits (`min`/`max`), and finally
+integer quantization or floating-point output. This is important for
+`WaveVStack`: the map is applied to the accumulated trajectory rather than to
+each pulse event independently. `method="linear"` selects the smaller and
+fastest two-point interpolation path. Maps serialize independently through
+`to_bytes()`/`from_bytes()` using the language-neutral `NLM1` format.
+
+Every waveform and stack has output limits, defaulting to `min=-np.inf` and
+`max=np.inf`. A stack ignores its child waveforms' limits and uses only its own:
+
+```python
+stack.min = -0.2
+stack.max = 0.3
+samples = stack.sample()  # limit after the complete calibration/filter chain
+```
+
+Limits apply to whole and chunked sampling, including `out=` buffers and
+integer output. Complex signals limit I and Q independently; `sample_iq()`
+uses the same final limits. The filter state continues from the unclipped
+filtered signal across chunks. DAC `full_scale` controls integer conversion
+and saturation separately from these amplitude limits.
+
+Real-coefficient SOS filters (`filters=(sos, initial)`) run in the C core for
+float64 and complex128 signals. This stage subtracts the baseline `initial`,
+applies the cascade, restores the baseline, and applies the final limits.
+Real int16/int32 output is quantized in the same stage, without allocating a
+full filtered floating-point buffer. Float output can reuse the sampled
+buffer. A small fixed scratch buffer keeps filtering and conversion local;
+waveform evaluation and nonlinear mapping still precede this stage. Complex
+coefficients and extended precision retain the SciPy implementation.
+`sample_iq()` still converts the filtered complex result into separate I/Q
+output arrays. See [the SOS benchmark](benchmarks/sos_filter.md).
+
+Calling `waveform(t)` directly evaluates with amplitude limits but without
+nonlinear calibration or filtering. Sampling evaluates the underlying signal
+without limits before applying its processing chain. Limits are sampling
+metadata preserved by pickle, not part of the raw WNF4/WNS4 binary blocks.
+
 ## Reporting Issues
 Please report all issues [on github](https://github.com/feihoo87/waveforms/issues).
 

waveforms-3.5.1/tests/test_native_sos.py

@@ -0,0 +1,176 @@
+"""Native SOS processing agrees with SciPy and keeps output limits out of state."""
+
+import numpy as np
+import pytest
+from scipy.signal import butter, sosfilt
+
+import waveforms as wf
+from waveforms._waveform import quantize_samples, sosfilt_samples
+
+
+def _clip(values, lower, upper):
+    if np.iscomplexobj(values):
+        return (np.clip(values.real, lower, upper)
+                + 1j * np.clip(values.imag, lower, upper))
+    return np.clip(values, lower, upper)
+
+
+@pytest.mark.parametrize("sections", [1, 2, 4, 8, 16])
+@pytest.mark.parametrize("complex_signal", [False, True])
+def test_scipy_equivalence_and_streaming(sections, complex_signal):
+    rng = np.random.default_rng(832)
+    sos = butter(2 * sections, .2, output="sos")
+    values = rng.normal(size=1031)
+    zi = rng.normal(size=(sections, 2)) * .001
+    initial = .07
+    if complex_signal:
+        values = values + 1j * rng.normal(size=len(values))
+        zi = zi + 1j * rng.normal(size=zi.shape) * .001
+        initial += .04j
+    original = values.copy()
+    initial_state = zi.copy()
+    filtered, expected_state = sosfilt(sos, values - initial, zi=zi)
+    expected = _clip(filtered + initial, -.17, .23)
+    result, state = sosfilt_samples(values, sos, initial, zi,
+                                    lower=-.17, upper=.23)
+    np.testing.assert_allclose(result, expected, rtol=3e-13, atol=3e-14)
+    np.testing.assert_allclose(state, expected_state, rtol=3e-13, atol=3e-14)
+    np.testing.assert_array_equal(zi, initial_state)
+    np.testing.assert_array_equal(values, original)
+
+    # Boundaries straddle the internal block size and include a one-sample chunk.
+    output = np.empty_like(values)
+    state = zi
+    start = 0
+    for stop in (1, 254, 511, 512, 1024, len(values)):
+        part, state = sosfilt_samples(values[start:stop], sos, initial, state,
+                                     lower=-.17, upper=.23,
+                                     out=output[start:stop])
+        assert np.shares_memory(part, output)
+        start = stop
+    np.testing.assert_array_equal(output, result)
+    np.testing.assert_allclose(state, expected_state, rtol=3e-13, atol=3e-14)
+
+
+@pytest.mark.parametrize("bits", [16, 32])
+@pytest.mark.parametrize("sections", [1, 4, 8])
+def test_direct_quantization_matches_scipy(bits, sections):
+    rng = np.random.default_rng(337)
+    values = rng.uniform(-2, 2, 5003)
+    sos = butter(sections * 2, .25, output="sos")
+    expected = quantize_samples(
+        np.clip(sosfilt(sos, values - .1) + .1, -.25, .35), bits, .7)
+    output = np.empty_like(expected)
+    result, _ = sosfilt_samples(values, sos, .1, bits=bits, full_scale=.7,
+                                lower=-.25, upper=.35, out=output)
+    assert result is output
+    np.testing.assert_array_equal(result, expected)
+
+
+@pytest.mark.parametrize("complex_signal", [False, True])
+@pytest.mark.parametrize("overlap", [False, True])
+def test_aliasing_and_readonly_inputs(complex_signal, overlap):
+    rng = np.random.default_rng(4)
+    storage = rng.normal(size=601)
+    if complex_signal:
+        storage = storage + 1j * rng.normal(size=len(storage))
+    values = storage[:-1]
+    output = storage[1:] if overlap else values
+    sos = butter(6, .3, output="sos")
+    sos.flags.writeable = False
+    # SciPy 1.13 requires a writable coefficient buffer.
+    expected = sosfilt(sos.copy(), values.copy())
+    result, _ = sosfilt_samples(values, sos, out=output)
+    assert result is output
+    np.testing.assert_allclose(result, expected, rtol=3e-13, atol=3e-14)
+    values.flags.writeable = False
+    expected = sosfilt(sos.copy(), values.copy())
+    result, _ = sosfilt_samples(values, sos)
+    np.testing.assert_allclose(result, expected, rtol=3e-13, atol=3e-14)
+
+
+def test_coefficients_may_overlap_output():
+    sos = butter(8, .3, output="sos")
+    values = np.linspace(-1, 1, sos.size)
+    expected = sosfilt(sos.copy(), values)
+    result, _ = sosfilt_samples(values, sos, out=sos.reshape(-1))
+    np.testing.assert_allclose(result, expected, rtol=3e-13, atol=3e-14)
+
+
+@pytest.mark.parametrize("dtype", [np.float64, np.complex128])
+def test_empty_input_preserves_state(dtype):
+    sos = butter(4, .3, output="sos")
+    zi = np.ones((2, 2), dtype=dtype)
+    result, state = sosfilt_samples(np.empty(0, dtype=dtype), sos, zi=zi)
+    assert result.shape == (0,)
+    assert result.dtype == dtype
+    np.testing.assert_array_equal(state, zi)
+
+
+@pytest.mark.parametrize("sos", [np.ones((2, 5)), np.ones((1, 2, 6)),
+                                  [[1, 0, 0, 2, 0, 0]]])
+def test_invalid_coefficients(sos):
+    with pytest.raises(ValueError, match="sos"):
+        sosfilt_samples(np.ones(3), sos)
+
+
+def test_invalid_state_and_output():
+    sos = butter(4, .3, output="sos")
+    values = np.ones(10)
+    with pytest.raises(ValueError, match="zi"):
+        sosfilt_samples(values, sos, zi=np.zeros((1, 2)))
+    with pytest.raises(ValueError, match="shape"):
+        sosfilt_samples(values, sos, out=np.empty(9))
+    with pytest.raises(TypeError, match="dtype"):
+        sosfilt_samples(values, sos, bits=16, out=np.empty(10))
+    with pytest.raises(ValueError, match="contiguous"):
+        sosfilt_samples(values, sos, bits=16, out=np.empty(20, dtype=np.int16)[::2])
+    with pytest.raises(TypeError, match="real signal"):
+        sosfilt_samples(values + 1j, sos, bits=16)
+    with pytest.raises(ValueError, match="full_scale"):
+        sosfilt_samples(values, sos, bits=16, full_scale=0)
+    with pytest.raises(ValueError, match="min and max"):
+        sosfilt_samples(values, sos, lower=np.nan)
+    with pytest.raises(ValueError, match="non-finite"):
+        sosfilt_samples(np.array([np.nan]), sos, bits=16)
+
+
+def _wave():
+    wave = .4 + .5 * wf.cos(6 * np.pi)
+    wave.start, wave.stop, wave.sample_rate = 0., 1., 1024
+    wave.min, wave.max = -.15, .27
+    return wave
+
+
+@pytest.mark.parametrize("coefficient_dtype", [np.complex128, np.longdouble])
+def test_scipy_fallback(coefficient_dtype):
+    wave = _wave()
+    sos = butter(4, .3, output="sos").astype(coefficient_dtype)
+    if coefficient_dtype == np.complex128:
+        sos[0, 0] += .1j
+    wave.filters = sos, .03
+    raw = .4 + .5 * np.cos(6 * np.pi * np.arange(1024) / 1024)
+    expected = _clip(sosfilt(sos, raw - .03) + .03, wave.min, wave.max)
+    np.testing.assert_allclose(wave.sample(), expected, rtol=3e-13, atol=3e-14)
+    np.testing.assert_allclose(np.concatenate(list(wave.sample(chunk_size=73))),
+                               expected, rtol=3e-13, atol=3e-14)
+
+
+def test_pipeline_output_casting_and_single_section_vector():
+    wave = _wave()
+    wave.filters = butter(2, .3, output="sos")[0], .03
+    expected = wave.sample()
+    for dtype in (None, np.float32, np.float64):
+        for stride in (1, 2):
+            output = np.empty(1024 * stride)[::stride]
+            result = wave.sample(dtype=dtype, out=output)
+            assert result is output
+            np.testing.assert_array_equal(result, expected.astype(dtype or np.float64))
+    expected_i16 = quantize_samples(expected, 16)
+    np.testing.assert_array_equal(wave.sample(dtype=np.int16), expected_i16)
+    np.testing.assert_allclose(np.concatenate(list(wave.sample(chunk_size=31))),
+                               expected, rtol=3e-13, atol=3e-14)
+    with pytest.raises(TypeError, match="dtype"):
+        wave.sample(dtype=np.int16, out=np.empty(1024))
+    with pytest.raises(ValueError, match="contiguous"):
+        wave.sample(out=np.empty(2048, dtype=np.int16)[::2])

waveforms-3.5.1/tests/test_nonlinear.py

@@ -0,0 +1,255 @@
+import pickle
+
+import numpy as np
+import pytest
+from scipy.interpolate import PchipInterpolator
+from scipy.signal import butter, sosfilt, tf2sos
+
+import waveforms as wf
+from waveforms._waveform import quantize_samples
+
+
+def test_linear_map_binary_roundtrip_clip_and_output():
+    x = np.linspace(-2.0, 2.0, 9)
+    y = 0.5 + 1.75 * x
+    mapping = wf.NonlinearMap.from_samples(
+        x, y, method="linear", table_size=9,
+    )
+    points = np.linspace(-2.0, 2.0, 1001)
+    expected = 0.5 + 1.75 * points
+    assert np.allclose(mapping(points), expected, rtol=0, atol=2e-15)
+
+    target = np.empty_like(points)
+    assert mapping(points, out=target) is target
+    assert np.array_equal(target, mapping(points))
+    assert mapping(0.25) == pytest.approx(0.9375)
+    assert mapping.method == "linear"
+    assert mapping.dtype == np.dtype(np.float64)
+    assert mapping.extrapolate == "error"
+    assert mapping.point_count == 9
+    assert mapping.domain == (-2.0, 2.0)
+
+    data = mapping.to_bytes()
+    assert data[:4] == b"NLM1"
+    restored = wf.NonlinearMap.from_bytes(data)
+    assert restored.to_bytes() is data
+    assert restored == mapping
+    assert hash(restored) == hash(mapping)
+    assert pickle.loads(pickle.dumps(mapping)) == mapping
+    assert np.array_equal(
+        mapping._apply_quantized(points, 16),
+        quantize_samples(mapping(points), 16),
+    )
+
+    malformed = bytearray(data)
+    malformed[9] = 1
+    with pytest.raises(ValueError, match="NLM1"):
+        wf.NonlinearMap.from_bytes(malformed)
+    with pytest.raises(ValueError, match="NLM1"):
+        wf.NonlinearMap.from_bytes(data[:-1])
+
+    with pytest.raises(ValueError, match="outside its domain"):
+        mapping(np.array([-2.1, 0.0]))
+    clipped = wf.NonlinearMap.from_samples(
+        x, y, method="linear", table_size=9, extrapolate="clip",
+    )
+    assert np.array_equal(clipped([-3.0, 3.0]), [y[0], y[-1]])
+
+
+def test_monotone_cubic_accuracy_storage_and_centering():
+    x = np.array([4.0, 4.15, 4.4, 4.9, 5.6, 6.0])
+    y = np.array([0.31, 0.27, 0.18, 0.02, -0.11, -0.16])
+    reference = 4.9
+    mapping = wf.NonlinearMap.from_samples(
+        x, y, table_size=1025, reference=reference,
+    )
+    relative = np.linspace(mapping.domain[0], mapping.domain[1], 10001)
+    reference_curve = PchipInterpolator(x, y)
+    expected = reference_curve(reference + relative) - reference_curve(reference)
+    assert np.max(np.abs(mapping(relative) - expected)) < 2e-7
+    assert mapping(0.0) == pytest.approx(0.0, abs=2e-15)
+    assert mapping.method == "monotone_cubic"
+    assert mapping.reference_input == reference
+    assert mapping.reference_output == pytest.approx(
+        reference_curve(reference), abs=2e-7)
+    assert np.all(np.diff(mapping(relative)) <= 0)
+
+    compact = wf.NonlinearMap.from_samples(
+        x, y, table_size=1025, reference=reference, dtype=np.float32,
+    )
+    assert compact.dtype == np.dtype(np.float32)
+    assert compact(0.0) == pytest.approx(0.0, abs=2e-7)
+    assert len(compact.to_bytes()) == 48 + 16 * (compact.point_count - 1)
+    assert len(mapping.to_bytes()) == 48 + 32 * (mapping.point_count - 1)
+    assert np.max(np.abs(compact(relative) - expected)) < 3e-7
+
+
+@pytest.mark.parametrize("x,y,message", [
+    ([0, 0, 1], [0, 1, 2], "increase strictly"),
+    ([0, 1, 2], [0, 2, 1], "one inverse branch"),
+    ([0, 1], [0, np.nan], "finite"),
+])
+def test_map_validation(x, y, message):
+    with pytest.raises(ValueError, match=message):
+        wf.NonlinearMap.from_samples(x, y)
+    with pytest.raises(ValueError, match="reference"):
+        wf.NonlinearMap.from_samples([0, 1], [0, 1], reference=2)
+    with pytest.raises(TypeError, match="float32 or float64"):
+        wf.NonlinearMap.from_samples([0, 1], [0, 1], dtype=np.int16)
+    with pytest.raises(ValueError, match="method"):
+        wf.NonlinearMap.from_samples([0, 1], [0, 1], method="bezier")
+    with pytest.raises(ValueError, match="NLM1"):
+        wf.NonlinearMap.from_bytes(b"not a map")
+
+
+def test_error_controlled_table_compilation():
+    x = np.array([0.0, 0.13, 0.41, 1.0])
+    y = np.array([0.0, 0.2, 0.75, 1.0])
+    mapping = wf.NonlinearMap.from_samples(
+        x, y, method="linear", table_size=5,
+        max_error=1e-3, max_table_size=4097,
+    )
+    assert mapping.point_count > 5
+    points = np.linspace(0.0, 1.0, 100_001)
+    assert np.max(np.abs(mapping(points) - np.interp(points, x, y))) < 1e-3
+
+    with pytest.raises(ValueError, match="requires more than"):
+        wf.NonlinearMap.from_samples(
+            x, y, method="linear", table_size=5,
+            max_error=1e-6, max_table_size=9,
+        )
+    with pytest.raises(ValueError, match="max_error"):
+        wf.NonlinearMap.from_samples(x, y, max_error=0)
+
+
+def test_waveform_sampling_order_chunking_quantization_and_pickle():
+    sample_rate = 1024
+    mapping = wf.NonlinearMap.from_samples(
+        [0.0, 0.25, 0.5, 0.75, 1.0],
+        [0.0, 0.0625, 0.25, 0.5625, 1.0],
+        table_size=257,
+    )
+    b, a = butter(3, 40.0, "lowpass", fs=sample_rate)
+    sos = tf2sos(b, a)
+    waveform = wf.t()
+    waveform.start = 0.0
+    waveform.stop = 1.0
+    waveform.sample_rate = sample_rate
+    waveform.nonlinear = mapping
+    waveform.filters = (sos, 0.0)
+
+    raw = np.arange(sample_rate, dtype=np.float64) / sample_rate
+    expected = sosfilt(sos, mapping(raw))
+    actual = waveform.sample()
+    assert np.allclose(actual, expected, rtol=3e-14, atol=3e-14)
+    chunks = np.concatenate(list(waveform.sample(chunk_size=73)))
+    assert np.allclose(chunks, expected, rtol=3e-14, atol=3e-14)
+
+    expected_int16 = quantize_samples(expected, 16)
+    output = np.empty(sample_rate, dtype=np.int16)
+    assert waveform.sample(dtype=np.int16, out=output) is output
+    assert np.array_equal(output, expected_int16)
+
+    restored = pickle.loads(pickle.dumps(waveform))
+    assert restored.nonlinear == mapping
+    assert np.array_equal(restored.sample(), actual)
+
+
+def test_stack_mapping_happens_after_event_accumulation():
+    pulse = 0.4 * wf.square(1.0)
+    stack = wf.WaveVStack([pulse, pulse])
+    stack.start = -0.25
+    stack.stop = 0.25
+    stack.sample_rate = 1000
+    stack.nonlinear = wf.NonlinearMap.from_samples(
+        [0.0, 0.4, 0.8], [0.0, 0.16, 0.64], table_size=257,
+    )
+    samples = stack.sample()
+    assert np.allclose(samples, 0.64, atol=2e-14)
+    assert not np.allclose(samples, 0.32)
+
+
+def test_complex_waveform_uses_explicit_component_maps():
+    real_map = wf.NonlinearMap.from_samples(
+        [0.0, 0.5, 1.0], [0.0, 0.25, 1.0], table_size=257,
+    )
+    imag_map = wf.NonlinearMap.from_samples(
+        [0.0, 0.5, 1.0], [0.0, 1.0, 2.0],
+        method="linear", table_size=257,
+    )
+    waveform = wf.ComplexWaveform(0.5, 0.25)
+    waveform.start = 0.0
+    waveform.stop = 1.0
+    waveform.sample_rate = 16
+    waveform.nonlinear = (real_map, imag_map)
+    expected = real_map(0.5) + 1j * imag_map(0.25)
+    assert np.allclose(waveform.sample(), expected)
+    i, q = waveform.sample_iq(dtype=np.int16)
+    assert np.array_equal(i, quantize_samples(
+        np.full(16, expected.real), 16))
+    assert np.array_equal(q, quantize_samples(
+        np.full(16, expected.imag), 16))
+
+    waveform.nonlinear = real_map
+    with pytest.raises(TypeError, match="complex waveforms require"):
+        waveform.sample()
+
+
+@pytest.mark.parametrize("method", ["linear", "monotone_cubic"])
+@pytest.mark.parametrize("storage", [np.float32, np.float64])
+def test_simd_batches_match_scalar_edges_aliasing_and_quantization(
+        method, storage):
+    mapping = wf.NonlinearMap.from_samples(
+        [-1.0, -0.6, -0.1, 0.35, 1.0],
+        [-0.8, -0.5, 0.05, 0.4, 0.9],
+        method=method, table_size=257, dtype=storage, extrapolate="clip",
+    )
+    source = np.linspace(-1.2, 1.2, 65)
+    source[0] = -1.0
+    source[-1] = 1.0
+    for count in (1, 7, 8, 9, 15, 16, 17, 31, 32, 33, 65):
+        values = source[:count].copy()
+        expected = np.array([mapping(float(value)) for value in values])
+        actual = mapping(values)
+        assert np.allclose(actual, expected, rtol=2e-15, atol=2e-15)
+
+        in_place = values.copy()
+        assert mapping(in_place, out=in_place) is in_place
+        assert np.allclose(in_place, expected, rtol=2e-15, atol=2e-15)
+
+        assert np.array_equal(
+            mapping._apply_quantized(values, 16),
+            quantize_samples(expected, 16),
+        )
+        assert np.array_equal(
+            mapping._apply_quantized(values, 32),
+            quantize_samples(expected, 32),
+        )
+
+
+def test_simd_batches_preserve_error_extrapolation_and_nonfinite_checks():
+    mapping = wf.NonlinearMap.from_samples(
+        [-1.0, 0.0, 1.0], [-0.5, 0.0, 0.5], table_size=257,
+    )
+    for bad_value in (-1.01, 1.01, np.nan, np.inf, -np.inf):
+        values = np.linspace(-0.9, 0.9, 32)
+        values[19] = bad_value
+        with pytest.raises(ValueError, match="outside its domain"):
+            mapping(values)
+
+
+def test_simd_quantized_pipeline_spans_multiple_cache_blocks():
+    mapping = wf.NonlinearMap.from_samples(
+        [-1.0, -0.25, 0.3, 1.0], [-0.9, -0.2, 0.4, 0.95],
+        table_size=1025,
+    )
+    values = 0.99 * np.sin(np.linspace(-70.0, 70.0, 12_345))
+    mapped = mapping(values)
+    assert np.array_equal(
+        mapping._apply_quantized(values, 16),
+        quantize_samples(mapped, 16),
+    )
+    assert np.array_equal(
+        mapping._apply_quantized(values, 32),
+        quantize_samples(mapped, 32),
+    )