waveforms 3.3.2__tar.gz → 3.4.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: waveforms
-Version: 3.3.2
+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.2 → 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),
@@ -498,8 +502,13 @@ 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():

{waveforms-3.3.2 → 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.2 → 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__",
 ]

{waveforms-3.3.2 → waveforms-3.4.0}/waveforms/_cwaveform.c

@@ -87,6 +87,18 @@ typedef struct wf_node {
     int64_t upper;
 } wf_node;
 
+typedef struct wf_drag_sin_kernel {
+    size_t order;
+    size_t power;
+    size_t basis_count;
+    double angular;
+    double normalization;
+    double *transform;
+    double *derivatives;
+    double *left_polynomial;
+    double *right_polynomial;
+} wf_drag_sin_kernel;
+
 struct cwaveform_wave {
     uint32_t references;
     uint32_t node_count;
@@ -97,6 +109,7 @@ struct cwaveform_wave {
     wf_node *nodes;
     double *parameters;
     size_t parameter_count;
+    wf_drag_sin_kernel **drag_sin_kernels;
 };
 
 struct cwaveform_stack {
@@ -107,6 +120,8 @@ struct cwaveform_stack {
     uint32_t *template_ids;
     int64_t *delays;
     double *scales;
+    int64_t lower_tick;
+    int64_t upper_tick;
     uint64_t hash;
     size_t data_size;
     uint8_t *data;
@@ -147,6 +162,8 @@ struct cwaveform_sample_plan {
 
 static double wf_node_parameter(const cwaveform_wave *wave,
                                 const wf_node *node, size_t index);
+static int wf_wave_prepare_drag_sin_kernels(cwaveform_wave *wave);
+static void wf_wave_clear_drag_sin_kernels(cwaveform_wave *wave);
 
 static double wf_hypot(double x, double y) {
     double high = fabs(x);
@@ -474,6 +491,10 @@ static cwaveform_wave *wf_wave_from_parts(const wf_node *nodes,
                    + (size_t)index * sizeof(double), parameters[index]);
     }
     wave->hash = wf_hash_bytes(wave->data, size);
+    if (wf_wave_prepare_drag_sin_kernels(wave) != 0) {
+        cwaveform_wave_release(wave);
+        return NULL;
+    }
     return wave;
 }
 
@@ -1716,6 +1737,10 @@ cwaveform_wave *cwaveform_wave_from_bytes(const uint8_t *data, size_t size) {
     wave->parameter_count = parameter_count;
     wave->data_size = size;
     wave->hash = wf_hash_bytes(data, size);
+    if (wf_wave_prepare_drag_sin_kernels(wave) != 0) {
+        cwaveform_wave_release(wave);
+        return NULL;
+    }
     return wave;
 }
 
@@ -1957,6 +1982,7 @@ void cwaveform_wave_release(cwaveform_wave *wave) {
     free(wave->data);
     free(wave->nodes);
     free(wave->parameters);
+    wf_wave_clear_drag_sin_kernels(wave);
     free(wave);
 }
 
@@ -2172,198 +2198,272 @@ static double wf_polynomial_derivative_value(const double *coefficients,
     return value;
 }
 
-static double wf_drag_sin_value(const cwaveform_wave *wave,
-                                const wf_node *node, double local,
-                                int sinx) {
+static void wf_drag_sin_kernel_free(wf_drag_sin_kernel *kernel) {
+    if (kernel == NULL) return;
+    free(kernel->transform);
+    free(kernel->derivatives);
+    free(kernel->left_polynomial);
+    free(kernel->right_polynomial);
+    free(kernel);
+}
+
+static wf_drag_sin_kernel *wf_drag_sin_kernel_create(
+    const cwaveform_wave *wave, const wf_node *node, int sinx) {
     size_t total = (size_t)node->parameter_count + 1;
     size_t block_count = total - 7;
     size_t order = block_count + 1;
     size_t power = ((block_count + 2) >> 1) << 1;
     size_t basis_count;
-    double t0 = wf_node_parameter(wave, node, 0);
-    double frequency = wf_node_parameter(wave, node, 1);
     double width = wf_node_parameter(wave, node, 2);
     double delta = wf_node_parameter(wave, node, 3);
-    double phase = wf_node_parameter(wave, node, 4);
-    double plateau = wf_node_parameter(wave, node, 5);
     double tab = wf_node_parameter(wave, node, 6);
-    double angular;
-    double *transform;
-    double *derivatives;
-    double *basis;
-    double *values;
-    double components[2] = {0.0, 0.0};
-    double normalization = 1.0;
+    wf_drag_sin_kernel *kernel;
+    double basis[67];
+    double values[65];
     size_t index;
-    if (!(width > 0.0) || block_count > 64) return NAN;
+    if (!(width > 0.0) || block_count > 64) return NULL;
     if (power < 2) power = 2;
     basis_count = power + 1;
-    angular = 3.14159265358979323846 / width;
-    transform = (double *)calloc(order * 4, sizeof(double));
-    derivatives = (double *)calloc(order * basis_count, sizeof(double));
-    basis = (double *)calloc(basis_count, sizeof(double));
-    values = (double *)calloc(order, sizeof(double));
-    if (transform == NULL || derivatives == NULL || basis == NULL
-            || values == NULL) {
-        free(transform); free(derivatives); free(basis); free(values);
-        return NAN;
-    }
-    transform[0] = 1.0;
-    transform[3] = 1.0;
+    kernel = (wf_drag_sin_kernel *)calloc(1, sizeof(*kernel));
+    if (kernel == NULL) return NULL;
+    kernel->order = order;
+    kernel->power = power;
+    kernel->basis_count = basis_count;
+    kernel->angular = 3.14159265358979323846 / width;
+    kernel->normalization = 1.0;
+    kernel->transform = (double *)calloc(order * 4, sizeof(double));
+    kernel->derivatives = (double *)calloc(
+        order * basis_count, sizeof(double));
+    if (sinx) {
+        kernel->left_polynomial = (double *)calloc(
+            2 * order, sizeof(double));
+        kernel->right_polynomial = (double *)calloc(
+            2 * order, sizeof(double));
+    }
+    if (kernel->transform == NULL || kernel->derivatives == NULL
+            || (sinx && (kernel->left_polynomial == NULL
+                         || kernel->right_polynomial == NULL))) {
+        wf_drag_sin_kernel_free(kernel);
+        return NULL;
+    }
+    kernel->transform[0] = 1.0;
+    kernel->transform[3] = 1.0;
     for (index = 0; index < block_count; ++index) {
         double block_frequency = wf_node_parameter(wave, node, 7 + index);
         double coefficient = 1.0 / (2.0 * 3.14159265358979323846
                                     * (block_frequency - delta));
         size_t row = index + 1;
         while (row-- != 0) {
-            double *target = transform + (row + 1) * 4;
-            const double *source = transform + row * 4;
+            double *target = kernel->transform + (row + 1) * 4;
+            const double *source = kernel->transform + row * 4;
             target[0] += -coefficient * source[1];
             target[1] += coefficient * source[0];
             target[2] += -coefficient * source[3];
             target[3] += coefficient * source[2];
         }
     }
-    derivatives[power] = 1.0;
+    kernel->derivatives[power] = 1.0;
     for (index = 1; index < order; ++index) {
         size_t exponent;
         if (index & 1) {
             for (exponent = 0; exponent < power; ++exponent)
-                derivatives[index * basis_count + exponent] =
-                    derivatives[(index - 1) * basis_count + exponent + 1]
-                    * (double)(exponent + 1) * angular;
+                kernel->derivatives[index * basis_count + exponent] =
+                    kernel->derivatives[
+                        (index - 1) * basis_count + exponent + 1]
+                    * (double)(exponent + 1) * kernel->angular;
         } else {
             for (exponent = 0; exponent + 2 <= power; ++exponent)
-                derivatives[index * basis_count + exponent] =
-                    derivatives[(index - 2) * basis_count + exponent + 2]
+                kernel->derivatives[index * basis_count + exponent] =
+                    kernel->derivatives[
+                        (index - 2) * basis_count + exponent + 2]
                     * (double)(exponent + 1) * (double)(exponent + 2);
             for (exponent = 0; exponent <= power; ++exponent)
-                derivatives[index * basis_count + exponent] -=
-                    derivatives[(index - 2) * basis_count + exponent]
+                kernel->derivatives[index * basis_count + exponent] -=
+                    kernel->derivatives[
+                        (index - 2) * basis_count + exponent]
                     * (double)(exponent * exponent);
             for (exponent = 0; exponent <= power; ++exponent)
-                derivatives[index * basis_count + exponent]
-                    *= angular * angular;
+                kernel->derivatives[index * basis_count + exponent]
+                    *= kernel->angular * kernel->angular;
         }
     }
-    {
-        double midpoint = t0 + width / 2.0;
-        double plateau_stop = midpoint + plateau;
-        double adjusted = local >= plateau_stop ? local - plateau : local;
-        double angle = angular * (adjusted - t0);
-        double sine = sin(angle);
-        double cosine = cos(angle);
-        int in_plateau = local > midpoint && local < plateau_stop;
-        size_t exponent;
-        for (exponent = 0; exponent <= power; ++exponent) {
-            basis[exponent] = pow(sine, (double)exponent);
-            if (exponent & 1) basis[exponent] *= cosine;
-            if (in_plateau) basis[exponent] = 0.0;
-        }
-        for (index = 0; index < order; ++index) {
-            for (exponent = 0; exponent <= power; ++exponent)
-                values[index] += derivatives[index * basis_count + exponent]
-                    * basis[exponent];
-        }
-        if (in_plateau) values[0] = 1.0;
-        if (sinx) {
-            int left = local >= midpoint - tab * width / 2.0
-                && local <= midpoint;
-            int right = local >= plateau_stop
-                && local <= plateau_stop + tab * width / 2.0;
-            if (left || right) {
-                double boundary_angle = angular
-                    * ((left ? (1.0 - tab) : (1.0 + tab)) * width / 2.0);
-                double boundary_sine = sin(boundary_angle);
-                double boundary_cosine = cos(boundary_angle);
-                double *boundary_basis = basis;
-                double *edge_values = (double *)calloc(order, sizeof(double));
-                double *polynomial = (double *)calloc(2 * order, sizeof(double));
-                double edge_x = (left ? -tab : tab) * width / 2.0;
-                double x = left ? local - midpoint : local - plateau_stop;
-                if (edge_values == NULL || polynomial == NULL) {
-                    free(edge_values); free(polynomial);
-                    free(transform); free(derivatives); free(basis); free(values);
-                    return NAN;
-                }
-                for (exponent = 0; exponent <= power; ++exponent) {
-                    boundary_basis[exponent] = pow(boundary_sine,
-                                                    (double)exponent);
-                    if (exponent & 1) boundary_basis[exponent]
-                        *= boundary_cosine;
-                }
-                for (index = 0; index < order; ++index)
-                    for (exponent = 0; exponent <= power; ++exponent)
-                        edge_values[index] +=
-                            derivatives[index * basis_count + exponent]
-                            * boundary_basis[exponent];
-                if (wf_edge_polynomial(edge_values, order, edge_x,
-                                       polynomial) != 0) {
-                    free(edge_values); free(polynomial);
-                    free(transform); free(derivatives); free(basis); free(values);
-                    return NAN;
-                }
-                for (index = 0; index < order; ++index)
-                    values[index] = wf_polynomial_derivative_value(
-                        polynomial, 2 * order, index, x);
-                free(edge_values);
-                free(polynomial);
+
+    if (sinx) {
+        int side;
+        for (side = 0; side < 2; ++side) {
+            double boundary_angle = kernel->angular
+                * ((side == 0 ? (1.0 - tab) : (1.0 + tab))
+                   * width / 2.0);
+            double boundary_sine = sin(boundary_angle);
+            double boundary_cosine = cos(boundary_angle);
+            double edge_x = (side == 0 ? -tab : tab) * width / 2.0;
+            double *polynomial = side == 0
+                ? kernel->left_polynomial : kernel->right_polynomial;
+            double sine_power = 1.0;
+            size_t exponent;
+            memset(values, 0, order * sizeof(double));
+            for (exponent = 0; exponent <= power; ++exponent) {
+                basis[exponent] = sine_power;
+                if (exponent & 1) basis[exponent] *= boundary_cosine;
+                sine_power *= boundary_sine;
+            }
+            for (index = 0; index < order; ++index)
+                for (exponent = 0; exponent <= power; ++exponent)
+                    values[index] += kernel->derivatives[
+                        index * basis_count + exponent] * basis[exponent];
+            if (wf_edge_polynomial(
+                    values, order, edge_x, polynomial) != 0) {
+                wf_drag_sin_kernel_free(kernel);
+                return NULL;
             }
         }
-    }
-    if (!sinx) {
-        double peak_components[2] = {0.0, 0.0};
+    } else {
+        double components[2] = {0.0, 0.0};
         size_t exponent;
         memset(basis, 0, basis_count * sizeof(double));
+        memset(values, 0, order * sizeof(double));
         for (exponent = 0; exponent <= power; exponent += 2)
             basis[exponent] = 1.0;
-        memset(values, 0, order * sizeof(double));
         for (index = 0; index < order; ++index)
             for (exponent = 0; exponent <= power; ++exponent)
-                values[index] += derivatives[index * basis_count + exponent]
-                    * basis[exponent];
+                values[index] += kernel->derivatives[
+                    index * basis_count + exponent] * basis[exponent];
         for (index = 0; index < order; ++index) {
-            peak_components[0] += transform[index * 4 + 0] * values[index];
-            peak_components[1] += transform[index * 4 + 2] * values[index];
+            components[0] += kernel->transform[index * 4] * values[index];
+            components[1] += kernel->transform[index * 4 + 2]
+                * values[index];
         }
-        normalization = wf_hypot(peak_components[0], peak_components[1]);
-        /* Restore the actual derivatives after the peak calculation. */
-        {
-            double midpoint = t0 + width / 2.0;
-            double plateau_stop = midpoint + plateau;
-            double adjusted = local >= plateau_stop ? local - plateau : local;
-            double angle = angular * (adjusted - t0);
-            double sine = sin(angle), cosine = cos(angle);
+        kernel->normalization = wf_hypot(components[0], components[1]);
+    }
+    return kernel;
+}
+
+static int wf_wave_prepare_drag_sin_kernels(cwaveform_wave *wave) {
+    uint32_t index;
+    int needed = 0;
+    for (index = 0; index < wave->node_count; ++index) {
+        uint8_t op = wave->nodes[index].op;
+        if (op == WF_OP_DRAG_SIN || op == WF_OP_DRAG_SINX) {
+            needed = 1;
+            break;
+        }
+    }
+    if (!needed) return 0;
+    wave->drag_sin_kernels = (wf_drag_sin_kernel **)calloc(
+        wave->node_count, sizeof(*wave->drag_sin_kernels));
+    if (wave->drag_sin_kernels == NULL) return -1;
+    for (index = 0; index < wave->node_count; ++index) {
+        const wf_node *node = wave->nodes + index;
+        if (node->op != WF_OP_DRAG_SIN && node->op != WF_OP_DRAG_SINX)
+            continue;
+        wave->drag_sin_kernels[index] = wf_drag_sin_kernel_create(
+            wave, node, node->op == WF_OP_DRAG_SINX);
+        if (wave->drag_sin_kernels[index] == NULL) {
+            wf_wave_clear_drag_sin_kernels(wave);
+            return -1;
+        }
+    }
+    return 0;
+}
+
+static void wf_wave_clear_drag_sin_kernels(cwaveform_wave *wave) {
+    uint32_t index;
+    if (wave->drag_sin_kernels == NULL) return;
+    for (index = 0; index < wave->node_count; ++index)
+        wf_drag_sin_kernel_free(wave->drag_sin_kernels[index]);
+    free(wave->drag_sin_kernels);
+    wave->drag_sin_kernels = NULL;
+}
+
+static double wf_drag_sin_value(const cwaveform_wave *wave,
+                                uint32_t node_index,
+                                const wf_node *node, double local,
+                                int sinx) {
+    const wf_drag_sin_kernel *kernel = wave->drag_sin_kernels == NULL
+        ? NULL : wave->drag_sin_kernels[node_index];
+    double t0 = wf_node_parameter(wave, node, 0);
+    double frequency = wf_node_parameter(wave, node, 1);
+    double width = wf_node_parameter(wave, node, 2);
+    double delta = wf_node_parameter(wave, node, 3);
+    double phase = wf_node_parameter(wave, node, 4);
+    double plateau = wf_node_parameter(wave, node, 5);
+    double tab = wf_node_parameter(wave, node, 6);
+    double basis[67];
+    double values[65];
+    double components[2] = {0.0, 0.0};
+    double midpoint;
+    double plateau_stop;
+    size_t index;
+    if (kernel == NULL) return NAN;
+    midpoint = t0 + width / 2.0;
+    plateau_stop = midpoint + plateau;
+    memset(values, 0, kernel->order * sizeof(double));
+    if (sinx) {
+        int left = local >= midpoint - tab * width / 2.0
+            && local <= midpoint;
+        int right = local >= plateau_stop
+            && local <= plateau_stop + tab * width / 2.0;
+        if (left || right) {
+            double x = left ? local - midpoint : local - plateau_stop;
+            const double *polynomial = left
+                ? kernel->left_polynomial : kernel->right_polynomial;
+            for (index = 0; index < kernel->order; ++index)
+                values[index] = wf_polynomial_derivative_value(
+                    polynomial, 2 * kernel->order, index, x);
+        } else {
+            double adjusted = local >= plateau_stop
+                ? local - plateau : local;
+            double angle = kernel->angular * (adjusted - t0);
+            double sine = sin(angle);
+            double cosine = cos(angle);
+            double sine_power = 1.0;
             int in_plateau = local > midpoint && local < plateau_stop;
-            memset(values, 0, order * sizeof(double));
-            for (index = 0; index <= power; ++index) {
-                basis[index] = pow(sine, (double)index);
-                if (index & 1) basis[index] *= cosine;
-                if (in_plateau) basis[index] = 0.0;
+            size_t exponent;
+            for (exponent = 0; exponent <= kernel->power; ++exponent) {
+                basis[exponent] = sine_power;
+                if (exponent & 1) basis[exponent] *= cosine;
+                if (in_plateau) basis[exponent] = 0.0;
+                sine_power *= sine;
             }
-            for (index = 0; index < order; ++index) {
-                size_t exponent;
-                for (exponent = 0; exponent <= power; ++exponent)
-                    values[index] += derivatives[index * basis_count + exponent]
+            for (index = 0; index < kernel->order; ++index)
+                for (exponent = 0; exponent <= kernel->power; ++exponent)
+                    values[index] += kernel->derivatives[
+                        index * kernel->basis_count + exponent]
                         * basis[exponent];
-            }
             if (in_plateau) values[0] = 1.0;
         }
+    } else {
+        double adjusted = local >= plateau_stop ? local - plateau : local;
+        double angle = kernel->angular * (adjusted - t0);
+        double sine = sin(angle);
+        double cosine = cos(angle);
+        double sine_power = 1.0;
+        int in_plateau = local > midpoint && local < plateau_stop;
+        size_t exponent;
+        for (exponent = 0; exponent <= kernel->power; ++exponent) {
+            basis[exponent] = sine_power;
+            if (exponent & 1) basis[exponent] *= cosine;
+            if (in_plateau) basis[exponent] = 0.0;
+            sine_power *= sine;
+        }
+        for (index = 0; index < kernel->order; ++index)
+            for (exponent = 0; exponent <= kernel->power; ++exponent)
+                values[index] += kernel->derivatives[
+                    index * kernel->basis_count + exponent]
+                    * basis[exponent];
+        if (in_plateau) values[0] = 1.0;
     }
-    for (index = 0; index < order; ++index) {
-        components[0] += transform[index * 4 + 0] * values[index];
-        components[1] += transform[index * 4 + 2] * values[index];
+    for (index = 0; index < kernel->order; ++index) {
+        components[0] += kernel->transform[index * 4] * values[index];
+        components[1] += kernel->transform[index * 4 + 2] * values[index];
     }
-    components[0] /= normalization;
-    components[1] /= normalization;
+    components[0] /= kernel->normalization;
+    components[1] /= kernel->normalization;
     {
         double carrier = 2.0 * 3.14159265358979323846
             * (frequency + delta) * local
             - (2.0 * 3.14159265358979323846 * delta * t0 + phase);
-        double result = components[0] * cos(carrier)
-            + components[1] * sin(carrier);
-        free(transform); free(derivatives); free(basis); free(values);
-        return result;
+        return components[0] * cos(carrier) + components[1] * sin(carrier);
     }
 }
 
@@ -2521,11 +2621,13 @@ static double wf_evaluate_one(const cwaveform_wave *wave, double position,
             }
             case WF_OP_DRAG_SIN:
                 local = position - (double)node->shift / ticks;
-                values[index] = wf_drag_sin_value(wave, node, local, 0);
+                values[index] = wf_drag_sin_value(
+                    wave, index, node, local, 0);
                 break;
             case WF_OP_DRAG_SINX:
                 local = position - (double)node->shift / ticks;
-                values[index] = wf_drag_sin_value(wave, node, local, 1);
+                values[index] = wf_drag_sin_value(
+                    wave, index, node, local, 1);
                 break;
             case WF_OP_ADD:
                 values[index] = values[node->left] + values[node->right];
@@ -3405,6 +3507,8 @@ cwaveform_stack *cwaveform_stack_create(
     stack = (cwaveform_stack *)calloc(1, sizeof(*stack));
     if (stack == NULL) return NULL;
     stack->references = 1;
+    stack->lower_tick = INT64_MIN;
+    stack->upper_tick = INT64_MAX;
     stack->template_count = template_count;
     stack->event_count = event_count;
     stack->templates = (cwaveform_wave **)calloc(template_count,
@@ -3435,6 +3539,26 @@ cwaveform_stack *cwaveform_stack_create(
         stack->delays[index] = delay_ticks[index];
         stack->scales[index] = scales[index];
     }
+    if (event_count != 0) {
+        int have_support = 0;
+        int64_t lower_tick = INT64_MAX;
+        int64_t upper_tick = INT64_MIN;
+        for (index = 0; index < event_count; ++index) {
+            cwaveform_wave *wave = stack->templates[stack->template_ids[index]];
+            int64_t lower = wf_add_tick(
+                wave->nodes[wave->root].lower, stack->delays[index]);
+            int64_t upper = wf_add_tick(
+                wave->nodes[wave->root].upper, stack->delays[index]);
+            if (lower >= upper) continue;
+            if (!have_support || lower < lower_tick) lower_tick = lower;
+            if (!have_support || upper > upper_tick) upper_tick = upper;
+            have_support = 1;
+        }
+        if (have_support) {
+            stack->lower_tick = lower_tick;
+            stack->upper_tick = upper_tick;
+        }
+    }
     if (wf_stack_encode(stack) != 0) {
         cwaveform_stack_release(stack);
         return NULL;
@@ -3727,6 +3851,14 @@ size_t cwaveform_stack_template_count(const cwaveform_stack *stack) {
     return stack == NULL ? 0 : stack->template_count;
 }
 
+int64_t cwaveform_stack_lower_tick(const cwaveform_stack *stack) {
+    return stack == NULL ? INT64_MIN : stack->lower_tick;
+}
+
+int64_t cwaveform_stack_upper_tick(const cwaveform_stack *stack) {
+    return stack == NULL ? INT64_MAX : stack->upper_tick;
+}
+
 static size_t wf_lower_bound(const double *values, size_t count, double target) {
     size_t first = 0;
     while (count != 0) {

{waveforms-3.3.2 → waveforms-3.4.0}/waveforms/_cwaveform.h

@@ -145,6 +145,8 @@ CWAVEFORM_API const uint8_t *cwaveform_stack_bytes(const cwaveform_stack *stack,
 CWAVEFORM_API uint64_t cwaveform_stack_hash(const cwaveform_stack *stack);
 CWAVEFORM_API size_t cwaveform_stack_event_count(const cwaveform_stack *stack);
 CWAVEFORM_API size_t cwaveform_stack_template_count(const cwaveform_stack *stack);
+CWAVEFORM_API int64_t cwaveform_stack_lower_tick(const cwaveform_stack *stack);
+CWAVEFORM_API int64_t cwaveform_stack_upper_tick(const cwaveform_stack *stack);
 CWAVEFORM_API int cwaveform_stack_evaluate(
     const cwaveform_stack *stack, const double *positions, size_t count,
     int64_t global_shift, double offset, double *output);

{waveforms-3.3.2 → waveforms-3.4.0}/waveforms/_waveform.pyx

@@ -521,6 +521,8 @@ cdef extern from "_cwaveform.h":
     uint64_t cwaveform_stack_hash(const cwaveform_stack *) noexcept nogil
     size_t cwaveform_stack_event_count(const cwaveform_stack *) noexcept nogil
     size_t cwaveform_stack_template_count(const cwaveform_stack *) noexcept nogil
+    int64_t cwaveform_stack_lower_tick(const cwaveform_stack *) noexcept nogil
+    int64_t cwaveform_stack_upper_tick(const cwaveform_stack *) noexcept nogil
     int cwaveform_stack_evaluate(
         const cwaveform_stack *, const double *, size_t, int64_t, double,
         double *) noexcept nogil
@@ -1040,6 +1042,16 @@ cdef class CWaveformStackCore:
         self._ensure_pointer()
         return cwaveform_stack_template_count(self._pointer)
 
+    @property
+    def lower_tick(self):
+        self._ensure_pointer()
+        return cwaveform_stack_lower_tick(self._pointer)
+
+    @property
+    def upper_tick(self):
+        self._ensure_pointer()
+        return cwaveform_stack_upper_tick(self._pointer)
+
     @property
     def hash64(self):
         self._ensure_pointer()

{waveforms-3.3.2 → waveforms-3.4.0}/waveforms/version.py

@@ -1,2 +1,2 @@
 """Define version number here and read it from setup.py automatically"""
-__version__ = "3.3.2"
+__version__ = "3.4.0"

{waveforms-3.3.2 → waveforms-3.4.0}/waveforms/waveform.py

@@ -39,18 +39,6 @@ _ONE_EXPR = ((((), ()),), (1.0,))
 _COMPLEX_WAVE_MAGIC = b"CWF1"
 _COMPLEX_STACK_MAGIC = b"CWS1"
 _COMPLEX_HEADER = struct.Struct("<4sII")
-_SUPPORTED_SAMPLE_RATES = frozenset({
-    500_000_000,
-    1_000_000_000,
-    1_200_000_000,
-    2_000_000_000,
-    2_400_000_000,
-    2_500_000_000,
-    4_000_000_000,
-    6_000_000_000,
-    8_000_000_000,
-    10_000_000_000,
-})
 _INF_TICK = np.iinfo(np.int64).max
 _C_CLOCK_ACTIVE = get_time_resolution() == 1 / _CORE_TICKS_PER_SECOND
 _C_CLOCK_LOCKED = False
@@ -206,12 +194,12 @@ def _is_tick_aligned(value, tick):
 
 
 def _sampling_plan(start, stop, sample_rate):
-    """Return an integer/rational tick plan for a supported device rate."""
+    """Return an integer/rational tick plan for an integral-Hz device rate."""
     rate = float(sample_rate)
     if not np.isfinite(rate) or rate <= 0:
         raise ValueError("sample_rate must be a finite positive number")
     integer_rate = int(rate)
-    if rate != integer_rate or integer_rate not in _SUPPORTED_SAMPLE_RATES:
+    if rate != integer_rate:
         return None
     start_tick = time_to_tick(start)
     stop_tick = time_to_tick(stop)
@@ -357,6 +345,10 @@ class Waveform(metaclass=_WaveformMeta):
     sample_rate: float | None
     filters: tuple[np.ndarray, float] | None
 
+    def is_zero(self):
+        """Return whether this object has no non-zero waveform support."""
+        return self.begin >= self.end
+
     @classmethod
     def from_bytes(cls, data):
         """Restore any waveform kind from its canonical binary block."""
@@ -809,6 +801,17 @@ class WaveVStack(Waveform, metaclass=_WaveVStackMeta):
             return RealWaveVStack.from_bytes(data)
         return RealWaveVStack.from_bytes(data)
 
+    @classmethod
+    def from_events(cls, templates, template_ids, delay_ticks, scales):
+        """Build a real stack from compiler-native event columns.
+
+        ``delay_ticks`` uses the process-wide integer clock.  This entry point
+        avoids constructing one temporary Python waveform per event.
+        """
+        return RealWaveVStack.from_events(
+            templates, template_ids, delay_ticks, scales
+        )
+
 
 class _RealWaveVStackBase(WaveVStack):
     """Common real-stack type; concrete storage is provided by the C core."""
@@ -1160,6 +1163,9 @@ class RealWaveform(_RealWaveformBase):
         return (self._scale == 0.0
                 or self._core.lower_tick >= self._core.upper_tick)
 
+    def is_zero(self):
+        return self._is_zero()
+
     @property
     def bounds(self):
         lower = self.begin
@@ -1468,19 +1474,28 @@ class RealWaveVStack(_RealWaveVStackBase):
             ids = []
             delays = []
             scales = []
+            event_waves = []
             for wave in waves:
                 if not isinstance(wave, RealWaveform):
                     raise TypeError("RealWaveVStack accepts RealWaveform objects")
-                key = id(wave._core)
-                template_id = template_map.get(key)
+                if wave._is_zero():
+                    continue
+                key = wave._core.hash64
+                template_id = None
+                for candidate in template_map.get(key, ()):
+                    if templates[candidate] == wave._core:
+                        template_id = candidate
+                        break
                 if template_id is None:
                     template_id = len(templates)
-                    template_map[key] = template_id
+                    template_map.setdefault(key, []).append(template_id)
                     templates.append(wave._core)
                 ids.append(template_id)
                 delays.append(wave._delay_tick)
                 scales.append(wave._scale)
+                event_waves.append(wave)
             _core = _CWaveformStackCore.from_events(templates, ids, delays, scales)
+            waves = tuple(event_waves)
         self._core = _core
         self.start = None
         self.stop = None
@@ -1494,6 +1509,19 @@ class RealWaveVStack(_RealWaveVStackBase):
         self._waves_cache = tuple(waves) if waves else None
         self._eval_core_cache = None
 
+    @classmethod
+    def from_events(cls, templates, template_ids, delay_ticks, scales):
+        _ensure_c_clock_locked()
+        templates = tuple(templates)
+        if not all(isinstance(template, RealWaveform)
+                   for template in templates):
+            raise TypeError("templates must contain RealWaveform objects")
+        cores = [template._materialized_core() for template in templates]
+        core = _CWaveformStackCore.from_events(
+            cores, template_ids, delay_ticks, scales
+        )
+        return cls(_core=core)
+
     @property
     def shift(self):
         return _c_tick_to_time(self._shift_tick)
@@ -1510,20 +1538,29 @@ class RealWaveVStack(_RealWaveVStackBase):
 
     @property
     def begin(self):
-        if self.wlist:
-            value = min((wave >> self.shift).begin for wave in self.wlist)
-        else:
-            value = -inf
+        tick = self._core.lower_tick
+        value = (-inf if tick == np.iinfo(np.int64).min
+                 else _c_tick_to_time(tick + self._shift_tick))
         return value if self.start is None else max(self.start, value)
 
     @property
     def end(self):
-        if self.wlist:
-            value = max((wave >> self.shift).end for wave in self.wlist)
-        else:
-            value = inf
+        tick = self._core.upper_tick
+        value = (inf if tick == np.iinfo(np.int64).max
+                 else _c_tick_to_time(tick + self._shift_tick))
         return value if self.stop is None else min(self.stop, value)
 
+    @property
+    def event_count(self):
+        return self._core.event_count
+
+    @property
+    def template_count(self):
+        return self._core.template_count
+
+    def __len__(self):
+        return self._core.event_count
+
     def __call__(self, x, out=None, accumulate=False, **kwargs):
         scalar = isinstance(x, (int, float, np.number))
         raw_positions = np.asarray([x] if scalar else x)
@@ -1962,9 +1999,8 @@ def sinh(w):
     return RealWaveform._from_core(_scalar(SINH, w))
 
 
-def coshPulse(width, eps=1.0, plateau=0.0):
-    if width <= 0 and plateau <= 0:
-        return zero()
+@lru_cache(maxsize=1024)
+def _cosh_pulse_core(width, eps, plateau):
     w = eps / width
     amplitude = np.cosh(eps / 2)
     scale = -1 / (amplitude - 1)
@@ -1975,12 +2011,25 @@ def coshPulse(width, eps=1.0, plateau=0.0):
             offset=amplitude / (amplitude - 1),
         )
 
-    if plateau == 0 or quantize_time(-plateau / 2) == quantize_time(plateau / 2):
-        return _piecewise((-width / 2, width / 2, inf), 0, edge(0), 0)
-    return _piecewise(
-        (-width / 2 - plateau / 2, -plateau / 2, plateau / 2,
-         width / 2 + plateau / 2, inf),
-        0, edge(-plateau / 2), 1, edge(plateau / 2), 0,
+    if (plateau == 0
+            or quantize_time(-plateau / 2) == quantize_time(plateau / 2)):
+        waveform = _piecewise(
+            (-width / 2, width / 2, inf), 0, edge(0), 0
+        )
+    else:
+        waveform = _piecewise(
+            (-width / 2 - plateau / 2, -plateau / 2, plateau / 2,
+             width / 2 + plateau / 2, inf),
+            0, edge(-plateau / 2), 1, edge(plateau / 2), 0,
+        )
+    return waveform._materialized_core()
+
+
+def coshPulse(width, eps=1.0, plateau=0.0):
+    if width <= 0 and plateau <= 0:
+        return zero()
+    return RealWaveform._from_core(
+        _cosh_pulse_core(float(width), float(eps), float(plateau))
     )
 
 
@@ -2236,6 +2285,8 @@ __all__ = [
     "gaussian", "general_cosine", "get_time_resolution", "hanning",
     "interp", "mixing", "mollifier", "one", "play", "poly",
     "registerBaseFunc", "registerDerivative", "samplingPoints",
-    "set_time_resolution", "sign", "sin", "sinc", "sinh", "slepian",
+    "sample_clock", "sample_grid", "quantize_time", "time_to_tick",
+    "tick_to_time", "set_time_resolution", "sign", "sin", "sinc",
+    "sinh", "slepian",
     "square", "step", "t", "wave_eval", "zero", "e", "inf", "pi",
 ]

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

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