waveforms 3.0.0__tar.gz → 3.2.0__tar.gz

{waveforms-3.0.0 → waveforms-3.2.0}/MANIFEST.in

@@ -1,4 +1,8 @@
 include src/*.h
+include src/*.c
+include waveforms/_cwaveform.h
+include waveforms/_cwaveform.c
+include waveforms/_cwaveform.md
 include waveforms/_waveform.pyx
 include waveforms/_waveform.pyi
 include waveforms/Waveform.g4

{waveforms-3.0.0 → waveforms-3.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: waveforms
-Version: 3.0.0
+Version: 3.2.0
 Summary: Edit waveforms used in experiment
 Author-email: feihoo87 <feihoo87@gmail.com>
 Maintainer-email: feihoo87 <feihoo87@gmail.com>
@@ -107,8 +107,9 @@ serialization.
 ```python
 import waveforms as wf
 
-# Optional; call this once, before constructing or loading waveform objects.
-wf.set_time_resolution(1e-12)
+# The default tick is already the period of 120 GHz (1 / 120e9 seconds).
+# To use another global tick, override it before constructing/loading waveforms:
+# wf.set_time_resolution(1e-12)
 
 pulse = (wf.gaussian(12e-9) >> 20e-9) * wf.cos(2 * wf.pi * 5e9)
 data = pulse.to_bytes()
@@ -120,6 +121,31 @@ process loading a block must therefore use the same resolution as the process
 that created it. The setting is locked when the first waveform object is
 created or loaded.
 
+`sample()` has integer-grid fast paths for 500 MHz, 1 GHz, 1.2 GHz, 2 GHz,
+2.4 GHz, 2.5 GHz, 4 GHz, 6 GHz, 8 GHz, and 10 GHz. Real waveforms can be
+quantized directly to signed DAC buffers:
+
+```python
+pulse.start = 0
+pulse.stop = 100e-9
+dac16 = pulse.sample(2_400_000_000, dtype=np.int16, full_scale=1.0)
+```
+
+The packed core stores and evaluates real-valued signals only. Complex signals
+are represented in Python as independent real and imaginary channels:
+
+```python
+z = (1 + 0.25j) * wf.gaussian(12e-9)
+assert isinstance(z, wf.ComplexWaveform)
+
+stack = wf.ComplexWaveVStack([z, z >> 20e-9])
+samples = stack(t)  # complex NumPy array
+```
+
+`Waveform` and `WaveVStack` therefore avoid complex storage and arithmetic for
+the common real-valued case. `ComplexWaveform.real` and `.imag` expose the two
+real channel waveforms.
+
 ## Reporting Issues
 Please report all issues [on github](https://github.com/feihoo87/waveforms/issues).
 

{waveforms-3.0.0 → waveforms-3.2.0}/README.md

@@ -63,8 +63,9 @@ serialization.
 ```python
 import waveforms as wf
 
-# Optional; call this once, before constructing or loading waveform objects.
-wf.set_time_resolution(1e-12)
+# The default tick is already the period of 120 GHz (1 / 120e9 seconds).
+# To use another global tick, override it before constructing/loading waveforms:
+# wf.set_time_resolution(1e-12)
 
 pulse = (wf.gaussian(12e-9) >> 20e-9) * wf.cos(2 * wf.pi * 5e9)
 data = pulse.to_bytes()
@@ -76,6 +77,31 @@ process loading a block must therefore use the same resolution as the process
 that created it. The setting is locked when the first waveform object is
 created or loaded.
 
+`sample()` has integer-grid fast paths for 500 MHz, 1 GHz, 1.2 GHz, 2 GHz,
+2.4 GHz, 2.5 GHz, 4 GHz, 6 GHz, 8 GHz, and 10 GHz. Real waveforms can be
+quantized directly to signed DAC buffers:
+
+```python
+pulse.start = 0
+pulse.stop = 100e-9
+dac16 = pulse.sample(2_400_000_000, dtype=np.int16, full_scale=1.0)
+```
+
+The packed core stores and evaluates real-valued signals only. Complex signals
+are represented in Python as independent real and imaginary channels:
+
+```python
+z = (1 + 0.25j) * wf.gaussian(12e-9)
+assert isinstance(z, wf.ComplexWaveform)
+
+stack = wf.ComplexWaveVStack([z, z >> 20e-9])
+samples = stack(t)  # complex NumPy array
+```
+
+`Waveform` and `WaveVStack` therefore avoid complex storage and arithmetic for
+the common real-valued case. `ComplexWaveform.real` and `.imag` expose the two
+real channel waveforms.
+
 ## Reporting Issues
 Please report all issues [on github](https://github.com/feihoo87/waveforms/issues).
 

{waveforms-3.0.0 → waveforms-3.2.0}/pyproject.toml

@@ -71,7 +71,15 @@ license-files = ["LICENSE"]
 include-package-data = true
 
 [tool.setuptools.package-data]
-waveforms = ["WaveformLexer.py", "WaveformParser.py", "WaveformListener.py", "*.pyi"]
+waveforms = [
+    "WaveformLexer.py",
+    "WaveformParser.py",
+    "WaveformListener.py",
+    "*.pyi",
+    "_cwaveform.h",
+    "_cwaveform.c",
+    "_cwaveform.md",
+]
 
 [tool.setuptools.dynamic]
 version = {attr = "waveforms.version.__version__"}

{waveforms-3.0.0 → waveforms-3.2.0}/setup.py

@@ -1,4 +1,5 @@
 import os
+import sys
 
 from Cython.Build import cythonize
 from setuptools import Extension, find_packages, setup
@@ -35,9 +36,19 @@ def get_extensions():
     for dirpath, dirnames, filenames in os.walk('waveforms'):
         for filename in filenames:
             if filename.endswith('.pyx'):
+                sources = [os.path.join(dirpath, filename)]
+                include_dirs = []
+                extra_link_args = []
+                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'])
                 extensions.append(
-                    Extension(module_name(dirpath, filename),
-                              [os.path.join(dirpath, filename)]))
+                    Extension(module_name(dirpath, filename), sources,
+                              include_dirs=include_dirs,
+                              extra_link_args=extra_link_args))
 
     return extensions
 

waveforms-3.2.0/src/waveform.c

@@ -0,0 +1,248 @@
+#include <Python.h>
+#include <stdlib.h>
+#include <math.h>
+#include <stdint.h>
+#include "waveform.h"
+
+#define FUNC_TAB_SIZE 128
+
+static size_t wave_func_count = 0;
+FuncPtr wave_function_table[FUNC_TAB_SIZE];
+
+static inline size_t bisect_left(const void *array, const void *const value,
+                                 size_t lo, size_t hi,
+                                 size_t type_size, int (*cmp)(const void *, const void *))
+{
+    while (lo < hi)
+    {
+        size_t mid = (lo + hi) / 2;
+        void *p = (uint8_t *)array + mid * type_size;
+        if (cmp(p, value) < 0)
+        {
+            lo = mid + 1;
+        }
+        else
+        {
+            hi = mid;
+        }
+    }
+    return lo;
+}
+
+static int cmp_basic_fun(uint32_t func, const Wave1 *a, const Wave1 *b)
+{
+    return 1;
+}
+
+static int cmp_wav1(const void *a, const void *b)
+{
+    Wave1 *wa = (Wave1 *)a;
+    Wave1 *wb = (Wave1 *)b;
+    if (wa->func > wb->func)
+    {
+        return 1;
+    }
+    else if (wa->func < wb->func)
+    {
+        return -1;
+    }
+    return cmp_basic_fun(wa->func, wa, wb);
+}
+
+static int cmp_wav2(const void *a, const void *b)
+{
+    Wave2 *wa = (Wave2 *)a;
+    Wave2 *wb = (Wave2 *)b;
+    for (size_t i = 0; i < wa->size && i < wb->size; i++)
+    {
+        if (wa->waves[i].func > wb->waves[i].func)
+        {
+            return 1;
+        }
+        else if (wa->waves[i].func < wb->waves[i].func)
+        {
+            return -1;
+        }
+    }
+    return wa->size > wb->size ? 1 : wa->size < wb->size ? -1
+                                                         : 0;
+}
+
+static int cmp_wav3(const void *a, const void *b)
+{
+    Wave3 *wa = (Wave3 *)a;
+    Wave3 *wb = (Wave3 *)b;
+    return wa->upper_bound > wb->upper_bound ? 1 : wa->upper_bound < wb->upper_bound ? -1
+                                                                                     : 0;
+}
+
+static double wave_basic_func_linear(double t, size_t argc, const Number *argv)
+{
+    return t;
+}
+
+static double wave_basic_func_gaussian(double t, size_t argc, const Number *argv)
+{
+    double x = t / argv[0].real;
+    return exp(-x * x);
+}
+
+static double wave_basic_func_erf(double t, size_t argc, const Number *argv)
+{
+    double x = t / argv[0].real;
+    return erf(x);
+}
+
+static double wave_basic_func_cos(double t, size_t argc, const Number *argv)
+{
+    double x = t * argv[0].real;
+    return cos(x);
+}
+
+static double wave_basic_func_sinc(double t, size_t argc, const Number *argv)
+{
+    double x = t * argv[0].real;
+    if (x == 0.0)
+    {
+        return 0.0;
+    }
+    return sin(x) / x;
+}
+
+static double wave_basic_func_exp(double t, size_t argc, const Number *argv)
+{
+    double x = t * argv[0].real;
+    return exp(x);
+}
+
+static double wave_apply_wave1(Time t, const Wave1 *wave)
+{
+    double x = time_2_double(t - wave->shift);
+    double y = wave_function_table[wave->func](x, wave->argc, wave->argv);
+    if (wave->n != 1 || wave->d != 1)
+    {
+        y = pow(y, (double)wave->n / wave->d);
+    }
+    return y;
+}
+
+static double wave_apply_wave2(Time t, const Wave2 *wave)
+{
+    double y = wave->amplitude;
+    for (size_t i = 0; i < wave->size; i++)
+    {
+        y *= wave_apply_wave1(t, wave->waves + i);
+    }
+    return y;
+}
+
+static double wave_apply_wave3(Time t, const Wave3 *wave)
+{
+    double y = 0.0;
+    for (size_t i = 0; i < wave->size; i++)
+    {
+        y += wave_apply_wave2(t, wave->waves + i);
+    }
+    return y;
+}
+
+static double wave_apply_waveform(Time t, const Waveform *wave)
+{
+    size_t i = bisect_left(wave->waves, &t, 0, wave->size, sizeof(Wave3), cmp_wav3);
+    if (i == wave->size)
+    {
+        return 0.0;
+    }
+    return wave_apply_wave3(t, wave->waves + i);
+}
+
+static void wave_sample_waveform(const Waveform *wave, double *samples, size_t size, Time start, Time dt)
+{
+    Time t = start;
+    size_t i = 0;
+    for (size_t j = 0; j < size; j++)
+    {
+        i = bisect_left(wave->waves, &t, i, wave->size, sizeof(Wave3), cmp_wav3);
+        if (i == wave->size)
+        {
+            for (; j < size; j++)
+            {
+                samples[j] = 0.0;
+            }
+            break;
+        }
+        samples[j] = wave_apply_wave3(t, wave->waves + i);
+        t += dt;
+    }
+}
+
+static void wave_sample_waveform_tlist(const Waveform *wave, size_t size, const Time *tlist, double *samples)
+{
+    Time t = tlist[0];
+    size_t i = 0;
+    for (size_t j = 0; j < size; j++)
+    {
+        i = bisect_left(wave->waves, &t, i, wave->size, sizeof(Wave3), cmp_wav3);
+        if (i == wave->size)
+        {
+            for (; j < size; j++)
+            {
+                samples[j] = 0.0;
+            }
+            break;
+        }
+        samples[j] = wave_apply_wave3(t, wave->waves + i);
+        t = tlist[j + 1];
+    }
+}
+
+static size_t wave_register_basic_func(FuncPtr func)
+{
+    wave_function_table[wave_func_count] = func;
+    return wave_func_count++;
+}
+
+static void wave_init_basic_func_table()
+{
+    wave_register_basic_func(wave_basic_func_linear);
+    wave_register_basic_func(wave_basic_func_gaussian);
+    wave_register_basic_func(wave_basic_func_erf);
+    wave_register_basic_func(wave_basic_func_cos);
+    wave_register_basic_func(wave_basic_func_sinc);
+    wave_register_basic_func(wave_basic_func_exp);
+}
+
+static PyObject *method_fputs(PyObject *self, PyObject *args)
+{
+    char *str, *filename = NULL;
+    int bytes_copied = -1;
+
+    /* Parse arguments */
+    if (!PyArg_ParseTuple(args, "ss", &str, &filename))
+    {
+        return NULL;
+    }
+
+    // FILE *fp = fopen(filename, "w");
+    // bytes_copied = fputs(str, fp);
+    // fclose(fp);
+
+    return PyLong_FromLong(bytes_copied);
+}
+
+static PyMethodDef Methods[] = {
+    {"fputs", method_fputs, METH_VARARGS, "Python interface for fputs C library function"},
+    {NULL, NULL, 0, NULL}};
+
+static struct PyModuleDef module = {
+    PyModuleDef_HEAD_INIT,
+    "_waveform",
+    "Python interface for the _waveform C library",
+    -1,
+    Methods};
+
+PyMODINIT_FUNC PyInit__waveform(void)
+{
+    wave_init_basic_func_table();
+    return PyModule_Create(&module);
+}

waveforms-3.2.0/tests/test_native.py

@@ -0,0 +1,242 @@
+import pickle
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+import waveforms as wf
+
+
+RATE = 2_400_000_000
+
+
+def _pulse(native=False):
+    gaussian = wf.native_gaussian if native else wf.gaussian
+    cosine = wf.native_cos if native else wf.cos
+    sine = wf.native_sin if native else wf.sin
+    square = wf.native_square if native else wf.square
+    return (
+        0.8 * gaussian(20e-9) * cosine(2 * np.pi * 100e6)
+        + 0.15 * gaussian(12e-9) * sine(2 * np.pi * 180e6, 0.2)
+        + 0.05 * square(6e-9)
+    )
+
+
+def _stack(count, native=False, spacing=40e-9):
+    pulse = (0.8 * (wf.native_gaussian(20e-9)
+                    if native else wf.gaussian(20e-9))
+             * (wf.native_cos(2 * np.pi * 100e6)
+                if native else wf.cos(2 * np.pi * 100e6)))
+    stack_type = wf.NativeWaveVStack if native else wf.WaveVStack
+    stack = stack_type([pulse >> (index * spacing) for index in range(count)])
+    stack.start = -20e-9
+    stack.stop = count * spacing
+    stack.sample_rate = RATE
+    return stack
+
+
+def test_native_wave_block_roundtrip_pickle_and_numerics():
+    expected = _pulse()
+    actual = _pulse(native=True)
+    expected.start = actual.start = -20e-9
+    expected.stop = actual.stop = 20e-9
+    expected.sample_rate = actual.sample_rate = RATE
+    actual.label = "native-pulse"
+
+    data = actual.to_bytes()
+    restored = wf.NativeWaveform.from_bytes(data)
+    x = np.linspace(-20e-9, 20e-9, 200_000, endpoint=False)
+
+    assert data[:4] == b"WNF4"
+    assert actual.to_bytes() is data
+    assert restored.to_bytes() is data
+    assert restored == wf.NativeWaveform.from_bytes(data)
+    assert np.allclose(actual(x), expected(x), rtol=2e-15, atol=2e-15)
+    assert np.array_equal(restored(x), actual(x))
+    assert len(data) < len(expected.to_bytes())
+
+    unpickled = pickle.loads(pickle.dumps(actual, protocol=5))
+    assert unpickled == actual
+    assert unpickled.start == actual.start
+    assert unpickled.stop == actual.stop
+    assert unpickled.sample_rate == actual.sample_rate
+    assert unpickled.label == actual.label
+
+
+@pytest.mark.parametrize("dtype", [np.float64, np.int16, np.int32])
+def test_native_device_grid_sampling_matches_packed_backend(dtype):
+    expected = _pulse()
+    actual = _pulse(native=True)
+    expected.start = actual.start = -20e-9
+    expected.stop = actual.stop = 20e-9
+    expected.sample_rate = actual.sample_rate = RATE
+
+    reference = expected.sample(dtype=dtype)
+    result = actual.sample(dtype=dtype)
+    if dtype == np.float64:
+        assert np.allclose(result, reference, rtol=2e-15, atol=2e-15)
+    else:
+        assert np.array_equal(result, reference)
+
+    target = np.empty_like(result)
+    returned = actual.sample(dtype=dtype, out=target)
+    assert returned is target
+    assert np.array_equal(target, result)
+
+
+def test_native_complex_block_roundtrip_and_pickle():
+    pulse = _pulse(native=True)
+    complex_wave = pulse + 0.5j * (pulse >> 2e-9)
+    complex_wave.start = -20e-9
+    complex_wave.stop = 20e-9
+    complex_wave.sample_rate = RATE
+    complex_wave.label = "iq"
+    x = np.linspace(-20e-9, 20e-9, 8192, endpoint=False)
+    expected = pulse(x) + 0.5j * (pulse >> 2e-9)(x)
+
+    data = complex_wave.to_bytes()
+    restored = wf.NativeComplexWaveform.from_bytes(data)
+    assert data[:4] == b"WNC4"
+    assert np.allclose(restored(x), expected, rtol=2e-15, atol=2e-15)
+    unpickled = pickle.loads(pickle.dumps(complex_wave, protocol=5))
+    assert np.allclose(unpickled(x), expected, rtol=2e-15, atol=2e-15)
+    assert unpickled.start == complex_wave.start
+    assert unpickled.stop == complex_wave.stop
+    assert unpickled.sample_rate == complex_wave.sample_rate
+    assert unpickled.label == complex_wave.label
+
+
+def test_native_stack_sampling_lazy_roundtrip_shift_offset_and_pickle():
+    expected = _stack(100)
+    actual = _stack(100, native=True)
+
+    assert np.allclose(actual.sample(), expected.sample(),
+                       rtol=2e-15, atol=2e-15)
+    assert np.array_equal(actual.sample(dtype=np.int16),
+                          expected.sample(dtype=np.int16))
+
+    data = actual.to_bytes()
+    restored = wf.NativeWaveVStack.from_bytes(data)
+    restored.start = actual.start
+    restored.stop = actual.stop
+    restored.sample_rate = actual.sample_rate
+    assert data[:4] == b"WNS4"
+    assert restored.to_bytes() is data
+    assert np.array_equal(restored.sample(), actual.sample())
+
+    transformed = (actual >> 5e-9) + 0.125
+    transformed_data = transformed.to_bytes()
+    transformed_restored = wf.NativeWaveVStack.from_bytes(transformed_data)
+    x = np.linspace(-20e-9, 4e-6, 10_000, endpoint=False)
+    assert transformed_data[:4] == b"WNS4"
+    assert np.allclose(transformed_restored(x), transformed(x),
+                       rtol=2e-15, atol=2e-15)
+
+    actual.label = "events"
+    unpickled = pickle.loads(pickle.dumps(actual, protocol=5))
+    assert unpickled == actual
+    assert unpickled.sample_rate == actual.sample_rate
+    assert unpickled.label == actual.label
+
+
+@pytest.mark.parametrize("dtype,bits", [
+    (np.float64, 0),
+    (np.int16, 16),
+    (np.int32, 32),
+])
+def test_native_stack_sample_plan_matches_direct_sampler(dtype, bits):
+    pulse = (wf.native_gaussian(20e-9)
+             * wf.native_cos(2 * np.pi * 100e6))
+    scales = (0.25, 0.5, 1.0)
+    actual = wf.NativeWaveVStack([
+        scales[index % len(scales)] * pulse >> (index * 40e-9)
+        for index in range(75)
+    ])
+    actual.start = -20e-9
+    actual.stop = 75 * 40e-9
+    actual.sample_rate = RATE
+    actual.offset = 0.071
+
+    assert actual._sample_plan_cache is None
+    first = actual.sample(dtype=dtype)
+    cache_key, sample_plan = actual._sample_plan_cache
+    target = np.empty_like(first)
+    result = actual.sample(dtype=dtype, out=target)
+    direct = actual._core.sample(
+        cache_key[0], cache_key[1], cache_key[2], cache_key[3],
+        cache_key[4], actual.offset, bits, 1.0,
+    )
+
+    assert result is target
+    assert sample_plan.count == len(result)
+    assert sample_plan.group_count == 1
+    assert sample_plan.non_overlapping
+    assert np.array_equal(result, direct)
+    assert actual._sample_plan_cache[1] is sample_plan
+
+
+def test_native_sample_plan_overlaps_and_rational_fallback():
+    actual = _stack(50, native=True, spacing=10e-9)
+    result = actual.sample(dtype=np.int16)
+    cache_key, sample_plan = actual._sample_plan_cache
+    expected = actual._core.sample(
+        cache_key[0], cache_key[1], cache_key[2], cache_key[3],
+        cache_key[4], actual.offset, 16, 1.0,
+    )
+
+    assert np.array_equal(result, expected)
+    assert not sample_plan.non_overlapping
+    assert actual._core.prepare_sample(0, 64, 1200, 11, 0) is None
+
+
+def test_native_overlapping_stack_quantization_and_empty_stack():
+    expected = _stack(50, spacing=10e-9)
+    actual = _stack(50, native=True, spacing=10e-9)
+    assert np.array_equal(actual.sample(dtype=np.int16),
+                          expected.sample(dtype=np.int16))
+    assert np.array_equal(actual.sample(dtype=np.int32),
+                          expected.sample(dtype=np.int32))
+
+    empty = wf.NativeWaveVStack([])
+    empty.start = -1e-9
+    empty.stop = 1e-9
+    empty.sample_rate = RATE
+    assert empty.to_bytes() == b"WNS4\x01\x00\x00\x00" + b"\x00" * 8
+    assert not np.any(empty.sample())
+    assert not np.any(wf.NativeWaveVStack.from_bytes(empty.to_bytes())(
+        np.linspace(-1e-9, 1e-9, 17)
+    ))
+
+
+def test_native_blocks_reject_malformed_layouts():
+    wave_data = bytearray(_pulse(native=True).to_bytes())
+    with pytest.raises(ValueError):
+        wf.NativeWaveform.from_bytes(wave_data[:20])
+    wave_data[0] = 0
+    with pytest.raises(ValueError):
+        wf.NativeWaveform.from_bytes(wave_data)
+
+    wave_data = bytearray(_pulse(native=True).to_bytes())
+    wave_data[24] = 255
+    with pytest.raises(ValueError):
+        wf.NativeWaveform.from_bytes(wave_data)
+
+    stack_data = bytearray(_stack(2, native=True).to_bytes())
+    with pytest.raises(ValueError):
+        wf.NativeWaveVStack.from_bytes(stack_data[:-1])
+    event_offset = len(stack_data) - 40
+    stack_data[event_offset:event_offset + 4] = (99).to_bytes(4, "little")
+    malformed = wf.NativeWaveVStack.from_bytes(stack_data)
+    with pytest.raises(ValueError):
+        _ = malformed._core.event_count
+
+
+def test_native_format_is_language_neutral_and_self_describing():
+    description = wf.native_format_description()
+    assert "little-endian" in description
+    assert "120 GHz" in description
+    assert "ABI 1" in description
+    assert type(_pulse(native=True)._core).__module__ == "waveforms._waveform"
+    package_dir = Path(wf.__file__).resolve().parent
+    assert (package_dir / "_cwaveform.c").is_file()
+    assert (package_dir / "_cwaveform.h").is_file()