waveforms 2.2.2__tar.gz → 2.3.0__tar.gz

waveforms-2.3.0/MANIFEST.in

@@ -0,0 +1,4 @@
+include src/*.h
+include waveforms/_waveform.pyx
+include waveforms/Waveform.g4
+include MANIFEST.in

{waveforms-2.2.2 → waveforms-2.3.0}/PKG-INFO

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

{waveforms-2.2.2 → waveforms-2.3.0}/pyproject.toml

@@ -68,5 +68,8 @@ content-type = "text/markdown"
 license-files = ["LICENSE"]
 include-package-data = true
 
+[tool.setuptools.package-data]
+waveforms = ["WaveformLexer.py", "WaveformParser.py", "WaveformListener.py"]
+
 [tool.setuptools.dynamic]
 version = {attr = "waveforms.version.__version__"}

{waveforms-2.2.2 → waveforms-2.3.0}/tests/test_waveform.py

@@ -138,6 +138,44 @@ def test_chirp():
     assert np.allclose(wav3(t), _chirp(t, 1, 2, 10, 4, 'hyperbolic'))
 
 
+def test_gaussian_derivative_and_mollifier():
+    x = np.linspace(-1.999, 1.999, 4097)
+
+    width = 4.0
+    std_sq2 = width / 3.3302184446307908
+    n = 8
+    expected = ((-1)**n / std_sq2**n
+                * special.eval_hermite(n, x / std_sq2)
+                * np.exp(-(x / std_sq2)**2))
+    assert np.allclose(gaussian(width, d=n)(x), expected)
+
+    d = 6
+    r = width / 2
+    scaled = x / r
+    xx_1 = scaled * scaled - 1
+    p = np.poly1d([-2, 0])
+    for order in range(1, d):
+        p = (np.poly1d([1, 0, -2, 0, 1]) * p.deriv()
+             + np.poly1d([-4 * order, 0, 4 * order - 2, 0]) * p)
+    expected = (np.exp(1 / xx_1 + 1) / (-xx_1)**(2 * d)
+                * p(scaled) / r**d)
+    assert np.allclose(mollifier(width, d=d)(x), expected)
+
+
+def test_sampling_points_and_clipping():
+    x = np.linspace(-2.0, 2.0, 4096, endpoint=False)
+    points = tuple(np.sin(np.linspace(0.0, 3.0, 65)))
+    wav = samplingPoints(-2.0, 2.0, points)
+    assert np.allclose(wav(x), np.interp(x, np.linspace(-2.0, 2.0, 65),
+                                        points))
+
+    wav = 2.0 * cos(2.1) + 0.3 * sin(0.7)
+    wav.min = -0.4
+    wav.max = 0.6
+    assert np.allclose(wav(x), np.clip(2.0 * np.cos(2.1 * x)
+                                      + 0.3 * np.sin(0.7 * x), -0.4, 0.6))
+
+
 def test_parser():
     assert wave_eval("one()") == one()
     assert wave_eval("zero()") == zero()

{waveforms-2.2.2 → waveforms-2.3.0}/tests/test_wavevstack.py

@@ -141,3 +141,13 @@ def test_wave_sum():
     assert wave_sum([((-1.0, np.inf), (((), ()), ((((), ()), ), (0.02, )))),
                      ((-1.0, np.inf), (((), ()), ((((), ()), ), (-0.02, ))))
                      ]) == ((np.inf, ), (((), ()), ))
+
+
+def test_wave_sum_preserves_value_before_a_new_earliest_bound():
+    source = (square(1.0) >> 5.0, const(2.0), square(1.0))
+    waves = [(wav.bounds, wav.seq) for wav in source]
+    combined = Waveform(*wave_sum(waves))
+    x = np.array([-10.0, 0.0, 2.0, 5.0, 10.0])
+    expected = sum(wav(x) for wav in source)
+
+    assert np.allclose(combined(x), expected)

waveforms-2.3.0/waveforms/Waveform.g4

@@ -0,0 +1,68 @@
+grammar Waveform;
+
+// 主规则
+expr: assignment | expression ;
+
+assignment: ID '=' expression ;
+
+expression
+    : expression op=('**' | '^') expression                    # PowerExpression
+    | expression op=('*' | '/') expression                     # MultiplyDivideExpression
+    | expression op=('+' | '-') expression                     # AddSubtractExpression
+    | expression op=('<<' | '>>') expression                   # ShiftExpression
+    | '(' expression ')'                                       # ParenthesesExpression
+    | '-' expression                                           # UnaryMinusExpression
+    | functionCall                                             # FunctionCallExpression
+    | CONSTANT                                                 # ConstantExpression
+    | NUMBER                                                   # NumberExpression
+    | STRING                                                   # StringExpression
+    | list                                                     # ListExpression
+    | tuple                                                    # TupleExpression
+    | ID                                                       # IdentifierExpression
+    ;
+
+functionCall
+    : ID '(' ')'                                               # NoArgFunction
+    | ID '(' args ')'                                          # ArgsFunction  
+    | ID '(' kwargs ')'                                        # KwargsFunction
+    | ID '(' args ',' kwargs ')'                               # ArgsKwargsFunction
+    ;
+
+args: expression (',' expression)* ;
+
+kwargs: kwarg (',' kwarg)* ;
+
+kwarg: ID '=' expression ;
+
+list: '[' ']' | '[' expression (',' expression)* ']' ;
+
+tuple: '(' expression ',' ')' | '(' expression (',' expression)+ ')' ;
+
+// 词法规则
+NUMBER
+    : REAL
+    | INT
+    | IMAG
+    ;
+
+REAL: (DIGIT+ ('.' DIGIT*)? | '.' DIGIT+) ([eE] [+-]? DIGIT+)? ;
+
+INT: DIGIT+ ;
+
+IMAG: (REAL | INT) 'j' ;
+
+STRING: '"' (~["\r\n])* '"' | '\'' (~['\r\n])* '\'' ;
+
+CONSTANT: 'pi' | 'e' | 'inf' ;
+
+ID: [a-zA-Z_][a-zA-Z0-9_]* ;
+
+// 运算符
+POW: '**' ;
+LSHIFT: '<<' ;
+RSHIFT: '>>' ;
+
+// 忽略空白字符
+WS: [ \t\r\n]+ -> skip ;
+
+fragment DIGIT: [0-9] ; 

{waveforms-2.2.2 → waveforms-2.3.0}/waveforms/_waveform.pyx

@@ -1,5 +1,6 @@
 import pickle
 from bisect import bisect_left
+from functools import lru_cache
 from itertools import chain, product
 
 import numpy as np
@@ -127,90 +128,174 @@ def pow(x, n):
         return ret
 
 
-def _apply(function_lib, func_id, x, shift, *args):
-    return function_lib[func_id](x - shift, *args)
+cdef object _calc_impl(object wav, object x, object function_lib):
+    cdef dict value_cache = {}
+    cdef object term_list = wav[0]
+    cdef object coefficient_list = wav[1]
+    cdef object monomial
+    cdef object base_list
+    cdef object power_list
+    cdef object base
+    cdef object value
+    cdef object product_value
+    cdef object term_value
+    cdef object total = None
+    cdef object coefficient
+    cdef object func
+    cdef object shift
+    cdef object args
+    cdef Py_ssize_t i, j
+    cdef Py_ssize_t term_count = len(term_list)
+    cdef Py_ssize_t base_count
+
+    for i in range(term_count):
+        monomial = term_list[i]
+        base_list = monomial[0]
+        power_list = monomial[1]
+        coefficient = coefficient_list[i]
+        product_value = None
+        base_count = len(base_list)
+
+        for j in range(base_count):
+            base = base_list[j]
+            if base in value_cache:
+                value = value_cache[base]
+            else:
+                func = function_lib[base[0]]
+                shift = base[-1]
+                args = base[1:-1]
+                if shift == 0:
+                    value = func(x, *args)
+                else:
+                    value = func(x - shift, *args)
+                value_cache[base] = value
 
+            if power_list[j] != 1:
+                value = value**power_list[j]
 
-def _calc(wav, x, function_lib):
-    lru_cache = {}
-
-    def _calc_m(t, x):
-        ret = 1
-        for mt, n in zip(*t):
-            if mt not in lru_cache:
-                func_id, *args, shift = mt
-                lru_cache[mt] = _apply(function_lib, func_id, x, shift, *args)
-            if n == 1:
-                ret = ret * lru_cache[mt]
+            if product_value is None:
+                product_value = value
             else:
-                ret = ret * lru_cache[mt]**n
-        return ret
+                product_value = product_value * value
+
+        if product_value is None:
+            term_value = coefficient
+        elif coefficient == 1:
+            term_value = product_value
+        else:
+            term_value = coefficient * product_value
+
+        if total is None:
+            total = term_value
+        else:
+            total = total + term_value
+
+    if total is None:
+        return 0
+    return total
 
-    ret = 0
-    for t, v in zip(*wav):
-        ret = ret + v * _calc_m(t, x)
-    return ret
+
+def _calc(wav, x, function_lib):
+    return _calc_impl(wav, x, function_lib)
 
 
 def calc_parts(bounds, seq, x, function_lib, min=-inf, max=inf):
-    range_list = np.searchsorted(x, bounds)
-    parts = []
-    start, stop = 0, 0
-    dtype = float
-    for i, stop in enumerate(range_list):
+    cdef object range_list = np.searchsorted(x, bounds)
+    cdef list parts = []
+    cdef object part
+    cdef object dtype = float
+    cdef Py_ssize_t i
+    cdef Py_ssize_t start = 0
+    cdef Py_ssize_t stop
+    cdef Py_ssize_t count = len(range_list)
+    cdef bint should_clip = min != -inf or max != inf
+
+    for i in range(count):
+        stop = range_list[i]
         if start < stop and seq[i] != _zero:
-            part = np.clip(_calc(seq[i], x[start:stop], function_lib), min,
-                           max)
-            if (isinstance(part, complex) or isinstance(part, np.ndarray)
-                    and isinstance(part[0], complex)):
+            part = _calc_impl(seq[i], x[start:stop], function_lib)
+            if should_clip:
+                part = np.clip(part, min, max)
+            if np.iscomplexobj(part):
                 dtype = complex
             parts.append((start, stop, part))
         start = stop
     return parts, dtype
 
 
-def wave_sum(waves):
-    if not waves:
-        return ((+inf, ), (_zero, ))
-
-    bounds, seq = waves[0]
-    if not waves[1:]:
-        return bounds, seq
-    bounds, seq = list(bounds), list(seq)
-
-    for bounds_, seq_ in waves[1:]:
-        if len(bounds_) == 1:
-            for i, s in enumerate(seq):
-                seq[i] = add(s, seq_[0])
-        elif len(bounds) == 1:
-            bounds = list(bounds_)
-            seq = [add(seq[0], s) for s in seq_]
-        else:
-            lo = 0
-            for b, s in zip(bounds_, seq_):
-                i = bisect_left(bounds, b, lo=lo)
-                if bounds[i] > b:
-                    bounds.insert(i, b)
-                    if i == 0:
-                        seq.insert(i, s)
-                    else:
-                        seq.insert(i, add(s, seq[i]))
-                    up = i - 1
-                else:
-                    up = i
-                for j in range(lo + 1, up + 1):
-                    seq[j] = add(seq[j], s)
-                lo = i
-
-    i = 0
-    while i < len(bounds) - 1:
-        if seq[i] == seq[i + 1]:
-            del seq[i]
-            del bounds[i]
+cdef void _accumulate_expr(dict accumulator, object expr, int sign):
+    cdef object term_list = expr[0]
+    cdef object value_list = expr[1]
+    cdef object term
+    cdef object value
+    cdef Py_ssize_t i
+    cdef Py_ssize_t count = len(term_list)
+
+    for i in range(count):
+        term = term_list[i]
+        value = accumulator.get(term, 0) + sign * value_list[i]
+        if value == 0:
+            accumulator.pop(term, None)
         else:
-            i += 1
+            accumulator[term] = value
 
-    return tuple(bounds), tuple(seq)
+
+cdef object _snapshot_expr(dict accumulator):
+    cdef list items
+    if not accumulator:
+        return _zero
+    items = sorted(accumulator.items())
+    return (tuple(item[0] for item in items),
+            tuple(item[1] for item in items))
+
+
+def wave_sum(waves):
+    cdef dict accumulator = {}
+    cdef dict events = {}
+    cdef list output_bounds = []
+    cdef list output_seq
+    cdef object bounds
+    cdef object seq
+    cdef object changes
+    cdef object old_expr
+    cdef object new_expr
+    cdef object expr
+    cdef object boundary
+    cdef Py_ssize_t i, j
+    cdef Py_ssize_t wave_count
+    cdef Py_ssize_t bound_count
+
+    if not waves:
+        return ((inf, ), (_zero, ))
+    if len(waves) == 1:
+        return waves[0]
+
+    wave_count = len(waves)
+    for i in range(wave_count):
+        bounds, seq = waves[i]
+        _accumulate_expr(accumulator, seq[0], 1)
+        bound_count = len(bounds)
+        for j in range(bound_count - 1):
+            boundary = bounds[j]
+            changes = events.get(boundary)
+            if changes is None:
+                changes = []
+                events[boundary] = changes
+            changes.append((seq[j], seq[j + 1]))
+
+    output_seq = [_snapshot_expr(accumulator)]
+    for boundary in sorted(events):
+        changes = events[boundary]
+        for old_expr, new_expr in changes:
+            _accumulate_expr(accumulator, old_expr, -1)
+            _accumulate_expr(accumulator, new_expr, 1)
+        expr = _snapshot_expr(accumulator)
+        if expr != output_seq[-1]:
+            output_bounds.append(boundary)
+            output_seq.append(expr)
+
+    output_bounds.append(inf)
+    return tuple(output_bounds), tuple(output_seq)
 
 
 def merge_waveform(b1, s1, b2, s2, oper):
@@ -296,8 +381,9 @@ def _GAUSSIAN(t, std_sq2):
 
 
 def _D_GAUSSIAN(t, std_sq2, n):
-    return (-1)**n / std_sq2**n * special.hermite(n)(
-        t / std_sq2) * np.exp(-(t / std_sq2)**2)
+    x = t / std_sq2
+    return ((-1)**n / std_sq2**n * special.eval_hermite(n, x)
+            * np.exp(-(x**2)))
 
 
 def _ERF(t, std_sq2):
@@ -316,8 +402,13 @@ def _EXP(t, alpha):
     return np.exp(alpha * t)
 
 
+@lru_cache(maxsize=256)
+def _interp_grid(start, stop, size):
+    return np.linspace(start, stop, size)
+
+
 def _INTERP(t, start, stop, points):
-    return np.interp(t, np.linspace(start, stop, len(points)), points)
+    return np.interp(t, _interp_grid(start, stop, len(points)), points)
 
 
 def _LINEARCHIRP(t, f0, f1, T, phi0):
@@ -356,19 +447,24 @@ def _drag(t: np.ndarray, t0: float, freq: float, width: float, delta: float,
     return Omega_x * np.cos(wt) + Omega_y * np.sin(wt)
 
 
+@lru_cache(maxsize=64)
+def _mollifier_poly(d):
+    p = np.poly1d([-2, 0])
+    for n in range(1, d):
+        p = (np.poly1d([1, 0, -2, 0, 1]) * p.deriv()
+             + np.poly1d([-4 * n, 0, 4 * n - 2, 0]) * p)
+    return p
+
+
 def _mollifier(t: np.ndarray, r: float, d: int):
     x = t / r
-    xx_1 = np.abs(x)**2 - 1
+    xx_1 = x * x - 1
     if d == 0:
-        return np.where(xx_1 == 0, 0, np.exp(1 / xx_1 + 1))
-    else:
-        p = np.poly1d([-2, 0])
-        for n in range(1, d):
-            p = np.poly1d([1, 0, -2, 0, 1]) * p.deriv() + np.poly1d(
-                [-4 * n, 0, 4 * n - 2, 0]) * p
-        return np.where(xx_1 == 0, 0,
-                        np.exp(1 / xx_1 + 1) /
-                        (-xx_1)**(2 * d)) * p(x) / r**d
+        return np.where(xx_1 >= 0, 0, np.exp(1 / xx_1 + 1))
+    p = _mollifier_poly(d)
+    return (np.where(xx_1 >= 0, 0,
+                     np.exp(1 / xx_1 + 1) / (-xx_1)**(2 * d))
+            * p(x) / r**d)
 
 
 LINEAR = registerBaseFunc(_LINEAR)

{waveforms-2.2.2 → waveforms-2.3.0}/waveforms/distortion.py

@@ -135,8 +135,18 @@ def exp_decay_filter(
             poles (p) and gain (k). See scipy.signal.lfilter for more.
 
     Returns:
-        tuple: (b, a) array like, numerator (b) and denominator (a)
+        if output is 'ba', return (b, a) array like, numerator (b) and denominator (a)
         polynomials of the IIR filter. See scipy.signal.lfilter for more.
+        if output is 'sos', return array of second-order filter coefficients with shape
+        (n_sections, 6). See scipy.signal.sosfilt for more.
+        if output is 'zpk', return (z, p, k) array like, zeros (z), poles (p) and gain (k).
+        See scipy.signal.zpk2tf for more.
+    
+    Raises:
+        ValueError: if output is not 'ba', 'sos', or 'zpk'
+    
+    Notes:
+        The filter is stable if all poles are inside the unit circle.
     """
 
     if isinstance(amp, (int, float, complex)):
@@ -155,11 +165,14 @@ def exp_decay_filter(
     numerator = numerator + denominator
 
     z = cast(NDArray[np.float64], np.exp(-numerator.roots / sample_rate))
-    p = cast(NDArray[np.float64], np.exp(-denominator.roots / sample_rate))
+    # p = cast(NDArray[np.float64], np.exp(-denominator.roots / sample_rate))
+    p = np.exp(-1 / (np.asarray(tau) * sample_rate))
+
     if inv:
         z, p = p, z
-    k = cast(float,
-             numerator(0) / denominator(0) * np.prod(1 - p) / np.prod(1 - z))
+    # remove poles outside the unit circle to make the filter stable
+    p = p[np.abs(p) < 1]
+    k = cast(float, (np.prod(1 - p) / np.prod(1 - z)).real)
 
     if output == 'sos':
         return cast(NDArray[np.float64], zpk2sos(z, p, k))

{waveforms-2.2.2 → waveforms-2.3.0}/waveforms/version.py

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

{waveforms-2.2.2 → waveforms-2.3.0}/waveforms/waveform.py

@@ -28,6 +28,14 @@ def _test_spec_num(num, spec):
     return False, x, 0
 
 
+def _exp_num(s):
+    if "e" in s:
+        a, n = s.split("e")
+        n = float(n)
+        s = f"{a} \\times 10^{{{n:g}}}"
+    return s
+
+
 def _spec_num_latex(num):
     for spec, spec_latex in [(1, ''), (np.sqrt(2), '\\sqrt{2}'),
                              (np.sqrt(3), '\\sqrt{3}'),
@@ -44,13 +52,14 @@ def _spec_num_latex(num):
                 if x.numerator == 1:
                     return f"{spec_latex}"
                 else:
-                    return f"{x.numerator:g}{spec_latex}"
+                    s = _exp_num(f"{x.numerator:g}")
+                    return f"{s}{spec_latex}"
             else:
                 if x.numerator < 0:
                     return f"-\\frac{{{-x.numerator}}}{{{x.denominator}}}{spec_latex}"
                 else:
                     return f"\\frac{{{x.numerator}}}{{{x.denominator}}}{spec_latex}"
-    return f"{num:g}"
+    return _exp_num(f"{num:g}")
 
 
 def _num_latex(num):
@@ -65,10 +74,6 @@ def _num_latex(num):
     s = _spec_num_latex(num.real)
     if s == '' and round(num.real) == 1:
         return '1'
-    if "e" in s:
-        a, n = s.split("e")
-        n = float(n)
-        s = f"{a} \\times 10^{{{n:g}}}"
     return s
 
 

{waveforms-2.2.2 → waveforms-2.3.0}/waveforms.egg-info/PKG-INFO

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

{waveforms-2.2.2 → waveforms-2.3.0}/waveforms.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ src/waveform.h
 tests/test_multi_drag.py
 tests/test_waveform.py
 tests/test_wavevstack.py
+waveforms/Waveform.g4
 waveforms/WaveformLexer.py
 waveforms/WaveformListener.py
 waveforms/WaveformParser.py

waveforms-2.2.2/MANIFEST.in

@@ -1,3 +0,0 @@
-include src/*.h
-include waveforms/_waveform.pyx
-include MANIFEST.in