wavekit 0.7.1__tar.gz → 0.7.2__tar.gz

{wavekit-0.7.1 → wavekit-0.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wavekit
-Version: 0.7.1
+Version: 0.7.2
 Summary: a fundamental package for digital circuit waveform analysis
 License-File: LICENSE
 Author: cxzzzz
@@ -13,6 +13,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: lark (>=1.2,<2)
 Requires-Dist: numpy (>=2.0.0,<3.0.0)
 Requires-Dist: pylibfst (>=0.2.1,<0.3.0)
 Requires-Dist: pytest (>=8.2.2,<9.0.0)
@@ -294,7 +295,7 @@ Some tips for programmable patterns:
 
 | Method | Description |
 |--------|-------------|
-| `VcdReader(file)` / `FstReader(file)` / `FsdbReader(file)` | Open a waveform file. Use as a context manager. `FsdbReader` requires Verdi runtime (`WAVEKIT_NPI_LIB`, `VERDI_HOME`, or `LD_LIBRARY_PATH`). |
+| `VcdReader(file)` / `FstReader(file)` / `FsdbReader(file, *, quiet=True)` | Open a waveform file. Use as a context manager. `FsdbReader` requires Verdi runtime (`WAVEKIT_NPI_LIB`, `VERDI_HOME`, or `LD_LIBRARY_PATH`) and suppresses the NPI startup banner by default; pass `quiet=False` to keep it. |
 | `reader.load_waveform(signal, clock, ...)` | Load one signal sampled on every clock edge. Returns `Waveform`. |
 | `reader.load_unknown_mask(signal, clock, ...)` | **Experimental.** Load X/Z bit presence as an unsigned mask `Waveform`. |
 | `reader.load_matched_waveforms(signal_path, clock_path, ...)` | Batch-load matching signals. Returns `dict[CaptureKey, Waveform]`. |
@@ -319,9 +320,8 @@ Some tips for programmable patterns:
 | `$ModName` | `tb.$fifo_unit.ptr` | Match a direct-child scope by module/definition name (FSDB only) | `ExactCapture(path=..., definition=...)` |
 | `$$ModName` | `tb.$$fifo_unit.ptr` | Match any-depth descendant scope by module/definition name (FSDB only) | `ExactCapture(path=..., definition=...)` |
 
-`$` and `$$` are path-step modifiers: they can combine with exact names, brace
-expansion, regex, and a trailing range selector in the same query.
-For example: `tb.$/fifo_(in|out)/.data_{0..3}[7:0]`.
+`$` and `$$` are path-step modifiers that can combine with exact-name, brace,
+and regex matchers. For example: `tb.$/fifo_(in|out)/.data_{0..3}[7:0]`.
 
 Matched-reader and hierarchy query APIs return dictionaries keyed by
 `CaptureKey = tuple[Capture, ...]`. Exact-name components are omitted, so a

{wavekit-0.7.1 → wavekit-0.7.2}/README.md

@@ -272,7 +272,7 @@ Some tips for programmable patterns:
 
 | Method | Description |
 |--------|-------------|
-| `VcdReader(file)` / `FstReader(file)` / `FsdbReader(file)` | Open a waveform file. Use as a context manager. `FsdbReader` requires Verdi runtime (`WAVEKIT_NPI_LIB`, `VERDI_HOME`, or `LD_LIBRARY_PATH`). |
+| `VcdReader(file)` / `FstReader(file)` / `FsdbReader(file, *, quiet=True)` | Open a waveform file. Use as a context manager. `FsdbReader` requires Verdi runtime (`WAVEKIT_NPI_LIB`, `VERDI_HOME`, or `LD_LIBRARY_PATH`) and suppresses the NPI startup banner by default; pass `quiet=False` to keep it. |
 | `reader.load_waveform(signal, clock, ...)` | Load one signal sampled on every clock edge. Returns `Waveform`. |
 | `reader.load_unknown_mask(signal, clock, ...)` | **Experimental.** Load X/Z bit presence as an unsigned mask `Waveform`. |
 | `reader.load_matched_waveforms(signal_path, clock_path, ...)` | Batch-load matching signals. Returns `dict[CaptureKey, Waveform]`. |
@@ -297,9 +297,8 @@ Some tips for programmable patterns:
 | `$ModName` | `tb.$fifo_unit.ptr` | Match a direct-child scope by module/definition name (FSDB only) | `ExactCapture(path=..., definition=...)` |
 | `$$ModName` | `tb.$$fifo_unit.ptr` | Match any-depth descendant scope by module/definition name (FSDB only) | `ExactCapture(path=..., definition=...)` |
 
-`$` and `$$` are path-step modifiers: they can combine with exact names, brace
-expansion, regex, and a trailing range selector in the same query.
-For example: `tb.$/fifo_(in|out)/.data_{0..3}[7:0]`.
+`$` and `$$` are path-step modifiers that can combine with exact-name, brace,
+and regex matchers. For example: `tb.$/fifo_(in|out)/.data_{0..3}[7:0]`.
 
 Matched-reader and hierarchy query APIs return dictionaries keyed by
 `CaptureKey = tuple[Capture, ...]`. Exact-name components are omitted, so a

{wavekit-0.7.1 → wavekit-0.7.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "wavekit"
-version = "0.7.1"
+version = "0.7.2"
 description = "a fundamental package for digital circuit waveform analysis"
 authors = ["cxzzzz <cxz19961010@outlook.com>"]
 readme = "README.md"
@@ -16,6 +16,7 @@ numpy = "^2.0.0"
 vcdvcd = "^2.3.5"
 pylibfst = "^0.2.1"
 pytest = "^8.2.2"
+lark = ">=1.2,<2"
 
 [tool.poetry.group.dev.dependencies]
 ruff = "^0.6.2"

wavekit-0.7.2/src/wavekit/expression.py

@@ -0,0 +1,165 @@
+"""Parsing and evaluating WaveKit waveform expressions."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any
+
+from lark import Lark, Transformer
+
+_EXPRESSION_GRAMMAR = r"""
+?start: expr
+?expr: bit_or
+?bit_or: bit_xor | bit_or VBAR bit_xor
+?bit_xor: bit_and | bit_xor CIRCUMFLEX bit_and
+?bit_and: comparison | bit_and AMPERSAND comparison
+?comparison: shift
+           | comparison EQEQ shift
+           | comparison NEQ shift
+           | comparison LE shift
+           | comparison LT shift
+           | comparison GE shift
+           | comparison GT shift
+?shift: sum | shift LSHIFT sum | shift RSHIFT sum
+?sum: product | sum PLUS product | sum MINUS product
+?product: unary
+        | product STAR unary
+        | product SLASH unary
+        | product FLOOR unary
+        | product PERCENT unary
+        | product POWER unary
+?unary: TILDE unary | PLUS unary | MINUS unary | atom
+?atom: call | path | NUMBER | group
+group: LPAR expr RPAR
+call: NAME LPAR [expr (COMMA expr)*] RPAR
+path: segment (DOT segment)* SUBSCRIPT*
+segment: segment_text | WILDCARD
+segment_text: segment_piece+
+?segment_piece: NAME | MODULE | BRACE | REGEX
+
+MODULE: /\${1,2}/
+BRACE: /\{[^{}]*\}/
+WILDCARD.3: "**" | "*"
+REGEX: /\/(?:\\.|[^\/\\])*\//
+SUBSCRIPT: /\[\d+(?::\d+)?\]/
+NAME: /[A-Za-z_][A-Za-z0-9_]*/
+HEX_NUMBER.2: /0[xX][0-9a-fA-F](?:_?[0-9a-fA-F])*/
+BIN_NUMBER.2: /0[bB][01](?:_?[01])*/
+OCT_NUMBER.2: /0[oO][0-7](?:_?[0-7])*/
+DECIMAL_FLOAT_NUMBER.2: /(?:\d(?:_?\d)*)?\.(?:\d(?:_?\d)*)?(?:[eE][+-]?\d(?:_?\d)*)?/
+EXP_NUMBER.2: /\d(?:_?\d)*[eE][+-]?\d(?:_?\d)*/
+DEC_NUMBER.1: /\d(?:_?\d)*/
+NUMBER: HEX_NUMBER | BIN_NUMBER | OCT_NUMBER | DECIMAL_FLOAT_NUMBER | EXP_NUMBER | DEC_NUMBER
+
+VBAR: "|"
+CIRCUMFLEX: "^"
+AMPERSAND: "&"
+EQEQ: "=="
+NEQ: "!="
+LE: "<="
+LT: "<"
+GE: ">="
+GT: ">"
+LSHIFT: "<<"
+RSHIFT: ">>"
+PLUS: "+"
+MINUS: "-"
+STAR: "*"
+SLASH: "/"
+FLOOR: "//"
+PERCENT: "%"
+POWER: "**"
+TILDE: "~"
+LPAR: "("
+RPAR: ")"
+COMMA: ","
+DOT: "."
+
+%import common.WS_INLINE
+%ignore WS_INLINE
+"""
+
+_EXPRESSION_PARSER = Lark(
+    _EXPRESSION_GRAMMAR,
+    parser='lalr',
+    lexer='contextual',
+)
+_EXPRESSION_FUNCTIONS: dict[str, Callable[..., Any]] = {}
+
+
+def expression_function(func: Callable[..., Any]) -> Callable[..., Any]:
+    """Register a Waveform method as callable from an expression string."""
+    _EXPRESSION_FUNCTIONS[func.__name__] = func
+    return func
+
+
+class ExpressionTransformer(Transformer):
+    def __init__(self, *, function_names: set[str]):
+        super().__init__()
+        self.function_names = function_names
+        self.path_entries: list[tuple[str, str]] = []
+
+    @staticmethod
+    def join(items: list[Any]) -> str:
+        return ''.join(str(item) for item in items)
+
+    def call(self, items: list[Any]) -> str:
+        name = str(items[0])
+        if name not in self.function_names:
+            raise ValueError(f'unknown expression function {name!r}')
+        return self.join(items)
+
+    def path(self, items: list[Any]) -> str:
+        path = self.join(items)
+        placeholder = f'__wave_{len(self.path_entries)}__'
+        self.path_entries.append((placeholder, path))
+        return placeholder
+
+    def __default__(self, data: str, children: list[Any], meta: Any) -> Any:
+        return self.join(children)
+
+    def __default_token__(self, token: Any) -> str:
+        return str(token)
+
+
+def parse_expression(expr: str) -> tuple[str, list[tuple[str, str]]]:
+    """Parse an expression and replace each signal path with a placeholder.
+
+    Parameters
+    ----------
+    expr:
+        WaveKit expression containing physical signal paths.
+
+    Returns
+    -------
+    tuple[str, list[tuple[str, str]]]
+        The substituted expression and ordered ``(placeholder, path)`` entries.
+    """
+    tree = _EXPRESSION_PARSER.parse(expr)
+    transformer = ExpressionTransformer(
+        function_names=set(_EXPRESSION_FUNCTIONS),
+    )
+    result = transformer.transform(tree)
+    return str(result), transformer.path_entries
+
+
+def evaluate_expression(expr: str, namespace: dict[str, Any]) -> Any:
+    """Evaluate an already-parsed expression against preloaded Waveforms.
+
+    Parameters
+    ----------
+    expr:
+        The substituted expression returned by :func:`parse_expression`.
+        Physical paths must be resolved and replaced before calling this
+        function.
+    namespace:
+        Names available to the expression, normally Waveform objects.
+
+    Returns
+    -------
+    Any
+        The result produced by the Waveform expression.
+    """
+    evaluation_namespace = {**_EXPRESSION_FUNCTIONS, **namespace}
+    code = compile(expr, '<wavekit-expression>', 'eval')
+    return eval(code, {'__builtins__': {}}, evaluation_namespace)  # noqa: S307

{wavekit-0.7.1 → wavekit-0.7.2}/src/wavekit/readers/base.py

@@ -1,14 +1,13 @@
 from __future__ import annotations
 
-import ast
 from abc import abstractmethod
 from dataclasses import dataclass, field
 from typing import Any, Generic, Literal, TypeVar, cast
 
 import numpy as np
 
+from ..expression import evaluate_expression, parse_expression
 from ..waveform import Waveform
-from .expr_parser import extract_wave_paths
 from .hierarchy import Node, Scope, Signal
 from .matcher import CaptureKey
 from .value_change import value_change_to_value_array
@@ -684,35 +683,33 @@ class Reader(Generic[SignalT]):
         mode: Literal['single', 'zip'] = 'single',
         root_scope: Scope | None = None,
     ) -> Waveform | dict[CaptureKey, Waveform]:
-        """Evaluate a waveform expression string.
-
-        Wave signal paths embedded in *expr* are automatically extracted,
-        loaded, and substituted before evaluating the resulting Python
-        arithmetic expression.
+        """Evaluate a waveform expression containing physical signal paths.
 
         Parameters
         ----------
         expr:
-            Expression string.
-            Single mode example: ``"tb.dut.w_ptr[3:0] - tb.dut.r_ptr[3:0]"``.
-            Zip mode example: ``"tb.dut.fifo_{0..3}.w_ptr[3:0] - tb.dut.fifo_{0..3}.r_ptr[3:0]"``.
+            Expression string. Signal paths may be used as operands or as
+            arguments to registered expression functions.
         clock:
             Clock signal used for all waveform loads.
+        xz_value, signed, sample_on_posedge, begin_time, end_time, begin_cycle,
+        end_cycle:
+            Forwarded to :meth:`load_matched_waveforms` for every path.
         mode:
-            ``'single'`` (default) — every path must match exactly one
-            signal; returns a single :class:`Waveform`.
-            ``'zip'`` — paths matching multiple signals must all share the
-            same set of pattern keys; single-match paths are broadcast;
-            returns ``dict[CaptureKey, Waveform]``.
+            ``'single'`` requires every path to match one signal. ``'zip'``
+            evaluates once per shared multi-match key and broadcasts singleton
+            paths.
         root_scope:
-            If provided, all signal paths in *expr* are resolved within this
-            scope instead of the file's top-level scopes.
+            If provided, resolve paths within this scope.
+
+        Returns
+        -------
+        Waveform or dict[CaptureKey, Waveform]
+            The evaluated waveform, or one waveform per zip key.
         """
         self._validate_xz_value(xz_value)
-        substituted, path_entries = extract_wave_paths(expr)
-
+        substituted, path_entries = parse_expression(expr)
         load_kwargs: dict[str, Any] = dict(
-            clock=clock,
             xz_value=xz_value,
             signed=signed,
             sample_on_posedge=sample_on_posedge,
@@ -720,81 +717,84 @@ class Reader(Generic[SignalT]):
             end_time=end_time,
             begin_cycle=begin_cycle,
             end_cycle=end_cycle,
+            root_scope=root_scope,
         )
 
-        # Resolve each path to its matched signal(s)
-        matched_per_path: list[tuple[str, str, dict[CaptureKey, SignalT]]] = []
+        loaded_per_path: list[tuple[str, str, dict[CaptureKey, Waveform]]] = []
         for placeholder, path in path_entries:
-            matched = self.get_matched_signals(path, root_scope=root_scope)
+            matched = self.load_matched_waveforms(
+                signal_path=path,
+                clock_path=clock,
+                **load_kwargs,
+            )
             if not matched:
                 raise ValueError(f"path '{path}' matched no signals")
-            matched_per_path.append((placeholder, path, matched))
+            loaded_per_path.append((placeholder, path, matched))
 
         if mode == 'single':
-            for _placeholder, path, matched in matched_per_path:
+            for _placeholder, path, matched in loaded_per_path:
                 if len(matched) > 1:
+                    matched_names = [
+                        wave.signal.full_name if wave.signal is not None else None
+                        for wave in matched.values()
+                    ]
                     raise ValueError(
                         f"path '{path}' matched {len(matched)} signals in mode='single',"
-                        f" use mode='zip'. Matched: {[sig.full_name for sig in matched.values()]}"
+                        f" use mode='zip'. Matched: "
+                        f'{matched_names}'
                     )
-            ns: dict[str, Any] = {
-                placeholder: self.load_waveform(next(iter(matched.values())), **load_kwargs)
-                for placeholder, _, matched in matched_per_path
+            namespace = {
+                placeholder: next(iter(matched.values()))
+                for placeholder, _, matched in loaded_per_path
             }
             try:
-                code = compile(ast.parse(substituted, mode='eval'), '<eval_expr>', 'eval')
-                return eval(code, {'__builtins__': {}}, ns)  # noqa: S307
+                return evaluate_expression(substituted, namespace)
             except Exception as exc:
                 raise ValueError(
-                    f"failed to evaluate expression '{expr}' (substituted: '{substituted}')"
+                    f"failed to evaluate expression '{expr}' " f"(substituted: '{substituted}')"
                 ) from exc
 
-        elif mode == 'zip':
-            multi_paths = [(ph, p, m) for ph, p, m in matched_per_path if len(m) > 1]
-            single_paths = [(ph, p, m) for ph, p, m in matched_per_path if len(m) == 1]
+        if mode == 'zip':
+            multi_paths = [
+                (placeholder, path, matched)
+                for placeholder, path, matched in loaded_per_path
+                if len(matched) > 1
+            ]
+            single_paths = [
+                (placeholder, path, matched)
+                for placeholder, path, matched in loaded_per_path
+                if len(matched) == 1
+            ]
 
             if multi_paths:
-                # All multi-match paths must share identical key sets
-                ref_ph, ref_p, ref_matched = multi_paths[0]
-                ref_keys = set(ref_matched.keys())
-                for _ph, p, matched in multi_paths[1:]:
-                    if set(matched.keys()) != ref_keys:
+                _ref_placeholder, ref_path, ref_matched = multi_paths[0]
+                ref_keys = set(ref_matched)
+                for _placeholder, path, matched in multi_paths[1:]:
+                    if set(matched) != ref_keys:
                         raise ValueError(
-                            f'inconsistent match keys between paths: '
-                            f"'{ref_p}' has keys {ref_keys!r}, "
-                            f"'{p}' has keys {set(matched)!r}"
+                            'inconsistent match keys between paths: '
+                            f"'{ref_path}' has keys {ref_keys!r}, "
+                            f"'{path}' has keys {set(matched)!r}"
                         )
-                zip_keys: list[CaptureKey] = list(ref_keys)
+                zip_keys = list(ref_keys)
             else:
-                # All paths are single-match; degenerate to single behaviour
                 zip_keys = [()]
 
-            # Pre-load broadcast waveforms (single-match paths)
-            broadcast_ns: dict[str, Waveform] = {
-                placeholder: self.load_waveform(next(iter(matched.values())), **load_kwargs)
+            broadcast_namespace = {
+                placeholder: next(iter(matched.values()))
                 for placeholder, _, matched in single_paths
             }
-
             result: dict[CaptureKey, Waveform] = {}
-            try:
-                code = compile(ast.parse(substituted, mode='eval'), '<eval_expr>', 'eval')
-            except SyntaxError as exc:
-                raise ValueError(
-                    f"invalid expression '{expr}' (substituted: '{substituted}')"
-                ) from exc
-
             for key in zip_keys:
-                ns = dict(broadcast_ns)
-                for placeholder, _, matched in multi_paths:
-                    ns[placeholder] = self.load_waveform(matched[key], **load_kwargs)
+                namespace = dict(broadcast_namespace)
+                for placeholder, _path, matched in multi_paths:
+                    namespace[placeholder] = matched[key]
                 try:
-                    result[key] = eval(code, {'__builtins__': {}}, ns)  # noqa: S307
+                    result[key] = evaluate_expression(substituted, namespace)
                 except Exception as exc:
                     raise ValueError(
-                        f"failed to evaluate expression '{expr}' for key {key}"
+                        f'failed to evaluate expression {expr!r} for key {key!r}'
                     ) from exc
-
             return result
 
-        else:
-            raise ValueError(f"unknown mode '{mode}', expected 'single' or 'zip'")
+        raise ValueError(f"unknown mode '{mode}', expected 'single' or 'zip'")

{wavekit-0.7.1 → wavekit-0.7.2}/src/wavekit/waveform.py

@@ -5,6 +5,7 @@ from typing import Any, Callable, Literal, Union, cast
 import numpy as np
 import numpy.typing as npt
 
+from .expression import expression_function
 from .readers.hierarchy import Signal
 
 
@@ -276,6 +277,7 @@ class Waveform:
             value.astype(np.uint64) - offset,
         )
 
+    @expression_function
     def as_signed(self) -> Waveform:
         """Reinterpret the unsigned bit pattern as a two's-complement signed integer.
 
@@ -293,6 +295,7 @@ class Waveform:
     def _unsigned(value: np.ndarray, width: int):
         return value & ((1 << width) - 1)
 
+    @expression_function
     def as_unsigned(self) -> Waveform:
         """Reinterpret the signed value as an unsigned bit pattern.
 
@@ -308,10 +311,6 @@ class Waveform:
             lambda x: self._unsigned(x, width), width=self.width, signed=False
         )
 
-    @staticmethod
-    def _add(a, b):
-        return a + b
-
     def _check_sign(self, other: WaveformOrScalar):
         if isinstance(other, Waveform) and self.signed != other.signed:
             raise ValueError('signedness mismatch')
@@ -367,9 +366,10 @@ class Waveform:
             return max_width + 1
 
         new_width = self._infer_arithmetic_op_width(inferred_width)
+        other_value = self._get_value(other)
 
         return self.vectorized_map(
-            lambda x: self._add(x, self._get_value(other)),
+            lambda x: x + other_value,
             width=new_width,
             signed=self.signed,
         )
@@ -377,10 +377,6 @@ class Waveform:
     def __radd__(self, other: WaveformOrScalar) -> Waveform:
         return self.__add__(other)
 
-    @staticmethod
-    def _sub(a, b):
-        return a - b
-
     def __sub__(self, other: WaveformOrScalar) -> Waveform:
         self._check_sign(other)
 
@@ -388,9 +384,10 @@ class Waveform:
             return self._optional_max_width(other)
 
         new_width = self._infer_arithmetic_op_width(inferred_width)
+        other_value = self._get_value(other)
 
         return self.vectorized_map(
-            lambda x: self._sub(x, self._get_value(other)),
+            lambda x: x - other_value,
             width=new_width,
             signed=self.signed,
         )
@@ -402,17 +399,14 @@ class Waveform:
             return self._optional_max_width(other)
 
         new_width = self._infer_arithmetic_op_width(inferred_width)
+        other_value = self._get_value(other)
 
         return self.vectorized_map(
-            lambda x: self._sub(self._get_value(other), x),
+            lambda x: other_value - x,
             width=new_width,
             signed=self.signed,
         )
 
-    @staticmethod
-    def _mul(a, b):
-        return a * b
-
     def __mul__(self, other: WaveformOrScalar) -> Waveform:
         self._check_sign(other)
 
@@ -423,9 +417,10 @@ class Waveform:
             return self.width + other_width
 
         new_width = self._infer_arithmetic_op_width(inferred_width)
+        other_value = self._get_value(other)
 
         return self.vectorized_map(
-            lambda x: self._mul(x, self._get_value(other)),
+            lambda x: x * other_value,
             width=new_width,
             signed=self.signed,
         )
@@ -433,13 +428,9 @@ class Waveform:
     def __rmul__(self, other: WaveformOrScalar) -> Waveform:
         return self.__mul__(other)
 
-    @staticmethod
-    def _truediv(a, b):
-        return a / b
-
     def __truediv__(self, other: WaveformOrScalar) -> Waveform:
         self._check_sign(other)
-        new_value = self._truediv(self.value, self._get_value(other))
+        new_value = self.value / self._get_value(other)
 
         return Waveform(
             value=new_value,
@@ -451,7 +442,7 @@ class Waveform:
 
     def __rtruediv__(self, other: WaveformOrScalar) -> Waveform:
         self._check_sign(other)
-        new_value = self._truediv(self._get_value(other), self.value)
+        new_value = self._get_value(other) / self.value
 
         return Waveform(
             value=new_value,
@@ -461,14 +452,10 @@ class Waveform:
             signed=self.signed,
         )
 
-    @staticmethod
-    def _floordiv(a, b):
-        return a // b
-
     def __floordiv__(self, other: WaveformOrScalar) -> Waveform:
         self._check_sign(other)
         new_width = self._infer_arithmetic_op_width(lambda: self.width)
-        new_value = self._floordiv(self.value, self._get_value(other))
+        new_value = self.value // self._get_value(other)
 
         return Waveform(
             value=new_value,
@@ -481,7 +468,7 @@ class Waveform:
     def __rfloordiv__(self, other: WaveformOrScalar) -> Waveform:
         self._check_sign(other)
         new_width = self._infer_arithmetic_op_width(lambda: self._get_width(other))
-        new_value = self._floordiv(self._get_value(other), self.value)
+        new_value = self._get_value(other) // self.value
 
         return Waveform(
             value=new_value,
@@ -491,15 +478,11 @@ class Waveform:
             signed=self.signed,
         )
 
-    @staticmethod
-    def _mod(a, b):
-        return a % b
-
     def __mod__(self, other: WaveformOrScalar) -> Waveform:
         self._check_sign(other)
         new_width = self._infer_arithmetic_op_width(lambda: self.width)
 
-        new_value = self._mod(self.value, self._get_value(other))
+        new_value = self.value % self._get_value(other)
 
         return Waveform(
             value=new_value,
@@ -513,7 +496,7 @@ class Waveform:
         self._check_sign(other)
         new_width = self._infer_arithmetic_op_width(lambda: self._get_width(other))
 
-        new_value = self._mod(self._get_value(other), self.value)
+        new_value = self._get_value(other) % self.value
 
         return Waveform(
             value=new_value,
@@ -523,15 +506,11 @@ class Waveform:
             signed=self.signed,
         )
 
-    @staticmethod
-    def _pow(a, b):
-        return a**b
-
     def __pow__(self, other: WaveformOrScalar) -> Waveform:
         self._check_sign(other)
         new_width = self._infer_arithmetic_op_width(lambda: 64)
 
-        new_value = self._pow(self.value, self._get_value(other))
+        new_value = self.value ** self._get_value(other)
 
         return Waveform(
             value=new_value,
@@ -576,10 +555,6 @@ class Waveform:
             raise ValueError(f'width mismatch: {self.width} and {other}')
         return self.width
 
-    @staticmethod
-    def _lshift(a, b):
-        return a << b
-
     def __lshift__(self, other: WaveformOrScalar) -> Waveform:
         self._check_sign(other)
         self._check_logical_op_type(other)
@@ -597,10 +572,9 @@ class Waveform:
             inferred_width=base_width + shift_width,
         )
 
-        new_value = self._lshift(
-            self.value.astype(np.object_) if new_width > 64 else self.value,
-            self._get_value(other),
-        )
+        new_value = (
+            self.value.astype(np.object_) if new_width > 64 else self.value
+        ) << self._get_value(other)
 
         return Waveform(
             value=new_value,
@@ -613,10 +587,6 @@ class Waveform:
     def __rlshift__(self, other: WaveformOrScalar) -> Waveform:
         return self.__lshift__(other)
 
-    @staticmethod
-    def _rshift(a, b):
-        return a >> b
-
     def __rshift__(self, other: WaveformOrScalar) -> Waveform:
         self._check_sign(other)
         self._check_logical_op_type(other)
@@ -631,7 +601,7 @@ class Waveform:
                 inferred_width=max((self.width or 0) - other, 0),
             )
 
-        new_value = self._rshift(self.value, self._get_value(other))
+        new_value = self.value >> self._get_value(other)
 
         return Waveform(
             value=new_value,
@@ -655,7 +625,7 @@ class Waveform:
                 inferred_width=max((self.width or 0) - other, 0),
             )
 
-        new_value = self._rshift(self.value, self._get_value(other))
+        new_value = self.value >> self._get_value(other)
 
         return Waveform(
             value=new_value,
@@ -665,15 +635,12 @@ class Waveform:
             signed=self.signed,
         )
 
-    @staticmethod
-    def _and(a, b):
-        return a & b
-
     def __and__(self, other: WaveformOrScalar) -> Waveform:
         self._check_sign(other)
         new_width = self._infer_logical_op_width(other)
+        other_value = self._get_value(other)
         return self.vectorized_map(
-            lambda x: self._and(x, self._get_value(other)),
+            lambda x: x & other_value,
             width=new_width,
             signed=False,
         )
@@ -681,29 +648,21 @@ class Waveform:
     def __rand__(self, other: WaveformOrScalar) -> Waveform:
         return self.__and__(other)
 
-    @staticmethod
-    def _or(a, b):
-        return a | b
-
     def __or__(self, other: WaveformOrScalar, width: int = None) -> Waveform:
         self._check_sign(other)
         new_width = self._infer_logical_op_width(other)
-        return self.vectorized_map(
-            lambda x: self._or(x, self._get_value(other)), width=new_width, signed=False
-        )
+        other_value = self._get_value(other)
+        return self.vectorized_map(lambda x: x | other_value, width=new_width, signed=False)
 
     def __ror__(self, other: WaveformOrScalar, width: int = None) -> Waveform:
         return self.__or__(other, width)
 
-    @staticmethod
-    def _xor(a, b):
-        return a ^ b
-
     def __xor__(self, other: WaveformOrScalar, width: int = None) -> Waveform:
         self._check_sign(other)
         new_width = self._infer_logical_op_width(other)
+        other_value = self._get_value(other)
         return self.vectorized_map(
-            lambda x: self._xor(x, self._get_value(other)),
+            lambda x: x ^ other_value,
             width=new_width,
             signed=False,
         )
@@ -725,30 +684,50 @@ class Waveform:
             signed=False,
         )
 
-    @staticmethod
-    def _eq(a, b):
-        return a == b
+    def _compare(self, other: object, comparator: Callable[[Any, Any], Any]) -> Any:
+        if not isinstance(other, (Waveform, int, float)):
+            return NotImplemented
+        self._check_sign(other)
+        return self.vectorized_map(
+            lambda x: comparator(x, self._get_value(other)),
+            width=1,
+            signed=False,
+        )
+
+    def __lt__(self, other: object) -> Any:
+        """Return a 1-bit waveform for ``self < other``."""
+        return self._compare(other, lambda a, b: a < b)
+
+    def __le__(self, other: object) -> Any:
+        """Return a 1-bit waveform for ``self <= other``."""
+        return self._compare(other, lambda a, b: a <= b)
+
+    def __gt__(self, other: object) -> Any:
+        """Return a 1-bit waveform for ``self > other``."""
+        return self._compare(other, lambda a, b: a > b)
+
+    def __ge__(self, other: object) -> Any:
+        """Return a 1-bit waveform for ``self >= other``."""
+        return self._compare(other, lambda a, b: a >= b)
 
     def __eq__(self, other: object) -> Any:
         if not isinstance(other, (Waveform, int, float)):
             return NotImplemented
         self._check_sign(other)
+        other_value = self._get_value(other)
         return self.vectorized_map(
-            lambda x: self._eq(x, self._get_value(other)),
+            lambda x: x == other_value,
             width=1,
             signed=False,
         )
 
-    @staticmethod
-    def _ne(a, b):
-        return a != b
-
     def __ne__(self, other: object) -> Any:
         if not isinstance(other, (Waveform, int, float)):
             return NotImplemented
         self._check_sign(other)
+        other_value = self._get_value(other)
         return self.vectorized_map(
-            lambda x: self._ne(x, self._get_value(other)),
+            lambda x: x != other_value,
             width=1,
             signed=False,
         )
@@ -962,6 +941,7 @@ class Waveform:
         vectorized_func = np.vectorize(func)
         return self.vectorized_map(vectorized_func, width, signed)
 
+    @expression_function
     def falling_edge(self) -> Waveform:
         """Detect 1→0 transitions in a 1-bit waveform.
 
@@ -991,6 +971,7 @@ class Waveform:
             signed=False,
         )
 
+    @expression_function
     def rising_edge(self) -> Waveform:
         """Detect 0→1 transitions in a 1-bit waveform.
 
@@ -1020,6 +1001,7 @@ class Waveform:
             signed=False,
         )
 
+    @expression_function
     def bit_count(self) -> Waveform:
         """Count the number of set bits (population count) in each sample value.
 
@@ -1419,6 +1401,7 @@ class Waveform:
             signed=self.signed,
         )
 
+    @expression_function
     def ahead(
         self,
         n: int = 1,
@@ -1452,6 +1435,7 @@ class Waveform:
         """
         return self.relative(n, pad, pad_value)
 
+    @expression_function
     def back(
         self,
         n: int = 1,