waveforms 3.3.0__tar.gz → 3.4.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: waveforms
-Version: 3.3.0
+Version: 3.4.0
 Summary: Edit waveforms used in experiment
 Author-email: feihoo87 <feihoo87@gmail.com>
 Maintainer-email: feihoo87 <feihoo87@gmail.com>

{waveforms-3.3.0 → waveforms-3.4.0}/setup.py

@@ -39,15 +39,19 @@ def get_extensions():
                 sources = [os.path.join(dirpath, filename)]
                 include_dirs = []
                 extra_link_args = []
+                libraries = []
                 if filename == '_waveform.pyx':
                     sources.append(os.path.join(
                         'waveforms', '_cwaveform.c'))
                     include_dirs.append('waveforms')
                     if sys.platform == 'darwin':
                         extra_link_args.extend(['-framework', 'Accelerate'])
+                    elif sys.platform.startswith('linux'):
+                        libraries.append('m')
                 extensions.append(
                     Extension(module_name(dirpath, filename), sources,
                               include_dirs=include_dirs,
+                              libraries=libraries,
                               extra_link_args=extra_link_args))
 
     return extensions

{waveforms-3.3.0 → waveforms-3.4.0}/tests/test_core.py

@@ -80,6 +80,78 @@ def test_c_symbolic_frequency_filter():
     )
 
 
+def test_c_symbolic_filter_reduces_trigonometric_products_and_powers():
+    x = np.linspace(-1.0, 1.0, 4097)
+    envelope = wf.gaussian(2.0)
+    first_frequency = 9.0
+    second_frequency = 7.0
+    first_phase = 0.31
+    second_phase = -0.27
+    cutoff = 5.0
+
+    first_cos = wf.cos(first_frequency, first_phase)
+    first_sin = wf.sin(first_frequency, first_phase)
+    second_cos = wf.cos(second_frequency, second_phase)
+    second_sin = wf.sin(second_frequency, second_phase)
+    difference = first_frequency - second_frequency
+    phase_difference = first_phase - second_phase
+
+    assert np.allclose(
+        (2 * envelope * first_cos * second_cos).filter(high=cutoff)(x),
+        (envelope * wf.cos(difference, phase_difference))(x),
+        atol=2e-11,
+    )
+    assert np.allclose(
+        (2 * envelope * first_cos * second_sin).filter(high=cutoff)(x),
+        (-envelope * wf.sin(difference, phase_difference))(x),
+        atol=2e-11,
+    )
+    assert np.allclose(
+        (2 * envelope * first_sin * second_sin).filter(high=cutoff)(x),
+        (envelope * wf.cos(difference, phase_difference))(x),
+        atol=2e-11,
+    )
+
+    powered = wf.cos(first_frequency, first_phase) ** 2
+    assert np.allclose(powered.filter(high=cutoff)(x), 0.5, atol=2e-11)
+    assert np.allclose(
+        powered.filter(2 * first_frequency, np.inf)(x),
+        (0.5 * wf.cos(2 * first_frequency, 2 * first_phase))(x),
+        atol=2e-11,
+    )
+
+    retained = (1.5e-15 * first_cos).filter(eps=1e-15)
+    discarded = (0.5e-15 * first_cos).filter(eps=1e-15)
+    assert np.max(np.abs(retained(x))) > 1e-15
+    assert np.array_equal(discarded(x), np.zeros_like(x))
+
+
+def test_down_conversion_filter_matches_historic_symbolic_behavior():
+    x = np.linspace(-100.0, 100.0, 10001)
+    envelope = wf.gaussian(100.0)
+    radio_frequency = 92.0451
+    local_frequency = 92.0
+    phase = 0.32
+    rf, _ = wf.mixing(
+        envelope, freq=radio_frequency, phase=phase, DRAGScaling=0.0,
+    )
+
+    i = (2 * rf * wf.cos(-2 * np.pi * local_frequency)).filter(
+        high=2 * np.pi * local_frequency,
+    )
+    q = (2 * rf * wf.sin(-2 * np.pi * local_frequency)).filter(
+        high=2 * np.pi * local_frequency,
+    )
+    difference = 2 * np.pi * (radio_frequency - local_frequency)
+
+    assert np.allclose(
+        i(x), (envelope * wf.cos(difference, -phase))(x), atol=2e-9,
+    )
+    assert np.allclose(
+        q(x), (envelope * wf.sin(difference, -phase))(x), atol=2e-9,
+    )
+
+
 def test_wave_block_roundtrip_pickle_and_numerics():
     actual = _pulse()
     actual.start = -20e-9

{waveforms-3.3.0 → waveforms-3.4.0}/tests/test_waveform.py

@@ -22,8 +22,9 @@ PUBLIC_NAMES = {
     "exp", "function",
     "gaussian", "general_cosine", "get_time_resolution", "hanning", "interp", "mixing",
     "mollifier", "one", "poly", "registerBaseFunc", "registerDerivative",
-    "samplingPoints", "set_time_resolution", "sign", "sin", "sinc", "sinh", "square", "step",
-    "t", "wave_eval", "zero",
+    "quantize_time", "sample_clock", "sample_grid", "samplingPoints",
+    "set_time_resolution", "sign", "sin", "sinc", "sinh", "square",
+    "step", "t", "tick_to_time", "time_to_tick", "wave_eval", "zero",
 }
 
 
@@ -34,6 +35,9 @@ def test_public_api_and_basic_sampling():
     assert np.allclose(wf.sin(0.7)(x), np.sin(0.7 * x))
     assert np.allclose(wf.poly([1, -0.5, 0.25])(x),
                        1 - 0.5 * x + 0.25 * x**2)
+    assert wf.zero().is_zero()
+    assert (0 * wf.gaussian(1)).is_zero()
+    assert not wf.one().is_zero()
 
 
 def test_binary_roundtrip_is_zero_copy_for_bytes_input():
@@ -461,7 +465,7 @@ def test_device_sample_clocks_and_rational_fallback():
     assert np.all(np.diff(grid) > 0)
 
 
-def test_fixed_width_quantization_supported_sampling_and_fallback():
+def test_fixed_width_quantization_and_rational_sampling():
     values = np.array([-2, -1, -0.5, 0, 0.5, 1, 2.0])
     assert np.array_equal(
         quantize_samples(values, 16),
@@ -473,6 +477,15 @@ def test_fixed_width_quantization_supported_sampling_and_fallback():
          1073741824, 2147483647, 2147483647],
     )
 
+    # Exercise the fused SIMD path, including its historic half-away-from-zero
+    # rounding rule and multidimensional ``out`` handling.
+    half_steps = np.array([0.5, -0.5, 1.5, -1.5] * 8) / 32768.0
+    target = np.empty((8, 4), dtype=np.int16)
+    assert quantize_samples(half_steps.reshape(8, 4), 16, out=target) is target
+    assert np.array_equal(
+        target.reshape(-1), np.array([1, -1, 2, -2] * 8, dtype=np.int16)
+    )
+
     wav = 0.8 * wf.gaussian(20e-9)
     wav.start = -20e-9
     wav.stop = 20e-9
@@ -489,8 +502,28 @@ def test_fixed_width_quantization_supported_sampling_and_fallback():
     assert np.array_equal(chunks, whole)
 
     odd_rate = 7_000_000_000
-    legacy_grid = np.arange(wav.start, wav.stop, 1 / odd_rate)
-    assert np.array_equal(wav.sample(odd_rate), wav(legacy_grid))
+    rational_samples = wav.sample(odd_rate)
+    numerator, denominator = sample_clock(odd_rate)
+    rational_grid = sample_grid(
+        time_to_tick(wav.start), len(rational_samples),
+        numerator, denominator,
+    )
+    assert np.allclose(rational_samples, wav(rational_grid), rtol=0, atol=1e-15)
+
+
+def test_simd_node_evaluation_matches_scalar_boundaries():
+    positions = np.linspace(-2.0, 2.0, 513)
+    waves = (
+        wf.t(),
+        wf.exp(0.2),
+        wf.sinc(1.3),
+        wf.cosh(0.3),
+        wf.sinh(0.3),
+        (wf.gaussian(4.0, 1.5) * wf.cos(2.2)) ** 2,
+    )
+    for wave in waves:
+        expected = np.array([wave(float(position)) for position in positions])
+        assert np.allclose(wave(positions), expected, rtol=1e-12, atol=1e-13)
 
 
 def test_integer_sampling_fast_paths_are_bit_exact_and_pickle_safe():

{waveforms-3.3.0 → waveforms-3.4.0}/tests/test_wavevstack.py

@@ -3,7 +3,10 @@ import pickle
 import numpy as np
 from scipy.signal import butter, lfilter, lfiltic, tf2sos
 
-from waveforms import WaveVStack, cos, gaussian, pi, poly, sin, step, zero
+from waveforms import (
+    Waveform, WaveVStack, cos, gaussian, pi, poly, sin, step,
+    time_to_tick, zero,
+)
 
 
 def _waves():
@@ -59,3 +62,46 @@ def test_wavevstack_binary_template_sharing_and_pickle():
     restored = WaveVStack.from_bytes(stack.to_bytes())
     assert restored == stack
     assert pickle.loads(pickle.dumps(stack)) == stack
+
+
+def test_wavevstack_content_deduplication_and_constant_time_support():
+    base = gaussian(20e-9) * cos(2 * pi * 5e9)
+    waves = [
+        Waveform.from_bytes(base.to_bytes()) >> (index * 80e-9)
+        for index in range(100)
+    ]
+    stack = WaveVStack([zero(), *waves])
+
+    assert len(stack) == stack.event_count == 100
+    assert stack.template_count == 1
+    assert np.isclose(stack.begin, base.begin)
+    assert np.isclose(stack.end, base.end + 99 * 80e-9)
+
+    restored = WaveVStack.from_bytes(stack.to_bytes())
+    shifted = restored >> 2e-9
+    assert restored.template_count == 1
+    assert restored.event_count == 100
+    assert np.isclose(shifted.begin, stack.begin + 2e-9)
+    assert np.isclose(shifted.end, stack.end + 2e-9)
+
+    empty = WaveVStack()
+    assert empty.begin == -np.inf
+    assert empty.end == np.inf
+
+
+def test_wavevstack_compiler_event_columns():
+    template = gaussian(20e-9) * cos(2 * pi * 5e9)
+    delays = np.arange(100, dtype=np.int64) * time_to_tick(80e-9)
+    stack = WaveVStack.from_events(
+        (template,), np.zeros(100, dtype=np.uint32), delays,
+        np.full(100, 0.25),
+    )
+    expected = WaveVStack([
+        0.25 * template >> (index * 80e-9) for index in range(100)
+    ])
+
+    assert stack.template_count == 1
+    assert stack.event_count == 100
+    assert stack.to_bytes() == expected.to_bytes()
+    positions = np.linspace(-20e-9, 8e-6, 1000)
+    assert np.allclose(stack(positions), expected(positions))

{waveforms-3.3.0 → waveforms-3.4.0}/waveforms/__init__.py

@@ -30,9 +30,12 @@ from .waveform import (
     mollifier,
     one,
     poly,
+    quantize_time,
     registerBaseFunc,
     registerDerivative,
     samplingPoints,
+    sample_clock,
+    sample_grid,
     set_time_resolution,
     sign,
     sin,
@@ -41,6 +44,8 @@ from .waveform import (
     square,
     step,
     t,
+    tick_to_time,
+    time_to_tick,
     wave_eval,
     zero,
 )
@@ -53,7 +58,9 @@ __all__ = [
     "e", "exp", "function",
     "gaussian", "general_cosine", "get_time_resolution", "hanning",
     "interp", "mixing", "mollifier", "one", "pi", "poly",
-    "registerBaseFunc", "registerDerivative", "samplingPoints",
+    "quantize_time", "registerBaseFunc", "registerDerivative",
+    "sample_clock", "sample_grid", "samplingPoints",
     "set_time_resolution", "sign", "sin", "sinc", "sinh", "square",
-    "step", "t", "wave_eval", "zero", "__version__",
+    "step", "t", "tick_to_time", "time_to_tick", "wave_eval", "zero",
+    "__version__",
 ]