flode 0.63.0__tar.gz → 0.64.0__tar.gz

{flode-0.63.0 → flode-0.64.0}/CHANGELOG.md

@@ -5,6 +5,56 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.64.0] - 2026-09-21 — StateSpace 系のベクトルポート統一とソース系のベクトル値 (ADR-0079 Stage 3)
+
+### Changed (BREAKING: `StateSpace` 系のポートが変わります)
+
+- **`StateSpace` / `DiscreteStateSpace` / `MimoTransferFunction` の入出力がベクトルポート
+  1 本ずつになった** (ADR-0079 §(7) D-9)。入力は `m >= 2` なら shape `(m,)` の 1 ポート
+  (`m == 1` はスカラ)、出力も同様 (`p`)。m 本のスカラ信号は `Mux` で束ねて繋ぎ、出力は
+  `Demux` で分けるか、ベクトルのまま下流へ渡す。Python API では `sim.connect(src, ss,
+  dst_idx=i)` (i ≥ 1) / `src_idx=j` の配線が `PortIndexError` になる (共通 mixin
+  `flode.blocks._lti_utils.LtiVectorPortMixin`、SM-A の `output` / `derivative` /
+  `update` / `advance` は不変で結果は bit-identical)。`port_shapes_*` は行列次元から
+  一意なので JSON には書かない
+- **モデル schema `0.14 → 0.15`** (`_builtin_migrate_0_14_to_0_15`)。既存ファイルの
+  `m >= 2` / `p >= 2` の StateSpace 系ブロックには `Mux(n=m)` (`<id>__in_mux`) /
+  `Demux(n=p)` (`<id>__out_demux`) が挿入され、既存の結線・`branch_waypoints` が
+  付け替わる (数値等価、v0.63.0 で採取した基準 npz で固定)。挿入 ID は決定的
+  (衝突時のみ `_1`, `_2` …、64 code point 超は切詰め)、レイアウトは元ブロックから
+  水平に 120 px ずらした位置 (既存ブロックの座標は不変)、Subsystem 内部にも再帰。
+  SISO / SIMO (`m == p == 1`) は無変更。`linearize` の外部入出力ラベルは
+  `ss.in[0][i]` / `ss.out[0][j]` (1 ポートの flat index) になる
+- `TransferFunction` / `DiscreteTransferFunction` (SISO)、時間ソース (`Step` / `Sine` /
+  `Ramp` / `Clock` / `PulseGenerator`)、`TransportDelay` / `Relay`、`Fcn`、`XYGraph` は
+  スカラ専用のまま (D-10)。エラーメッセージを Stage 3 の実態に更新
+
+### Added
+
+- **ソース系のベクトル値** (SPEC-0031 #18): `Constant(value=[…])` は配列の shape の信号を
+  出力する (shape の起点、`_params["value"]` は入れ子リスト)。`RandomSource(shape=(n,))`
+  はサンプル境界ごとに `shape` 個の独立サンプルを 1 回で引く (`shape=()` の既定は
+  従来の乱数系列と bit-identical、非既定時のみ JSON に書く)
+- **lookup 5 クラスのベクトル入力** (`LookupTable1D` / `LookupTable2D` / `LookupTableND` /
+  `Prelookup` / `InterpolationUsingPrelookup`): 要素ごとにスカラ核 `_eval` を適用する
+  (`ElementwiseMixin`、`Demux → × n → Mux` 版と bit-identical、`extrapolation="error"` /
+  nan / ±inf の扱いも要素ごと)。2 入力以上はスカラ拡張を含む合流規則に従う
+- **新ブロック** (SPEC-0031 #19、Math カテゴリ): `Reduce(operation="sum" | "product" |
+  "min" | "max" | "mean")` (全要素を 1 スカラに縮約、スカラ入力は恒等)、`DotProduct`
+  (同 shape 2 入力の内積)、`MatrixMultiply` (`u0 @ u1`、numpy matmul 規則を build 時に検査、
+  片方だけスカラは `shape.mismatch`)。shape 規則 `reduce` / `matmul` を解決器に追加
+- GUI: Inspector の数値欄で **`[1, 2, 3]` を配列として受理** (`Constant.value` / `Gain.k` /
+  ベクトル状態 7 クラスの `x0`、frontend の表 `lib/arrayParams.ts`)、配列欄に数値 1 個を
+  書くとスカラに戻る。ブロック面の `Constant` は配列値を `[1, 2, 3]` / `[2×2]` と表示。
+  新ブロックの glyph (Σ / u·v / A×B) と `Reduce` の operation 表示
+
+### Fixed
+
+- **GUI で `Mux` → `Gain` / `Integrator` 等の要素ごとブロックを接続できなかった**
+  (v0.62.0 から)。接続前検証が registry 既定の `()` と Mux の `(n,)` を strict 比較して
+  拒否していた。`()` は「build 時に推論する」の意味なので、両端とも非 `()` の宣言で
+  食い違うときだけ拒否し、それ以外は backend の信号面解決器に委ねる (ADR-0079 D-3)
+
 ## [0.63.0] - 2026-09-21 — ベクトル状態と Subsystem 境界のテンソル化 (ADR-0079 Stage 2)
 
 ### Added

{flode-0.63.0/flode.egg-info → flode-0.64.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flode
-Version: 0.63.0
+Version: 0.64.0
 Summary: Block-diagram dynamic system simulator
 Author: aramoto99
 License-Expression: MIT

{flode-0.63.0 → flode-0.64.0}/flode/__init__.py

@@ -7,7 +7,7 @@
 # ADR-0044) は docked split と並存。Phase 6c (Workspace
 # convergence) Stage 1 として ADR-0040 §Amendments §(1) で位置付け、Stage 2 /
 # 3 (= activity bar + Launcher、drag-to-split-tab) は後続 ADR で順次着手。
-__version__ = "0.63.0"
+__version__ = "0.64.0"
 
 from .analysis import (
     BodeResponse,

{flode-0.63.0 → flode-0.64.0}/flode/blocks/__init__.py

@@ -30,10 +30,13 @@ from .mathops import (
     CompareToZero,
     DeadZone,
     Divide,
+    DotProduct,
     Gain,
     MathFunction,
+    MatrixMultiply,
     MinMax,
     Product,
+    Reduce,
     Saturation,
     Sign,
     Sum,
@@ -64,6 +67,7 @@ __all__ = [
     "DiscreteStateSpace",
     "DiscreteTransferFunction",
     "Divide",
+    "DotProduct",
     "Fcn",
     "From",
     "Gain",
@@ -75,6 +79,7 @@ __all__ = [
     "LookupTable2D",
     "LookupTableND",
     "MathFunction",
+    "MatrixMultiply",
     "Merge",
     "MimoTransferFunction",
     "MinMax",
@@ -88,6 +93,7 @@ __all__ = [
     "RandomSource",
     "RateLimiter",
     "RateTransition",
+    "Reduce",
     "RelationalOperator",
     "Relay",
     "Rounding",

{flode-0.63.0 → flode-0.64.0}/flode/blocks/_lti_utils.py

@@ -5,6 +5,7 @@
 
 from __future__ import annotations
 
+from collections.abc import Callable
 from typing import Any
 
 import numpy as np
@@ -15,6 +16,97 @@ from ..exceptions import BlockSpecError
 # ADR-0006 §(6): D 行列の最大絶対値がこの閾値を超えたら direct_feedthrough = True
 _DF_TOLERANCE = 1e-12
 
+Shape = tuple[int, ...]
+
+
+def lti_port_layout(n_signals: int) -> tuple[int, tuple[Shape, ...]]:
+    """信号数 ``n_signals`` を ADR-0079 D-9 のポート規則に写す。
+
+    ``StateSpace`` 系は入力 m 本 / 出力 p 本の信号を **ベクトルポート 1 本** で運ぶ:
+    ``n >= 2`` なら shape ``(n,)`` の 1 ポート、``n == 1`` なら ``()`` の 1 ポート
+    (SISO / SIMO は 0.14 以前と同じ配線)、``n == 0`` ならポートなし。
+
+    Returns:
+        ``(n_ports, port_shapes)``。
+    """
+    if n_signals <= 0:
+        return 0, ()
+    if n_signals == 1:
+        return 1, ((),)
+    return 1, ((n_signals,),)
+
+
+class LtiVectorPortMixin:
+    """``StateSpace`` 系の vector-port API (ADR-0079 §(7) D-9)。
+
+    SM-A の ``output`` / ``derivative`` / ``update`` / ``advance`` は 0.14 以前と同じ
+    「長さ m の 1-D ``u``」を受け取る契約のまま (1 バイトも変えない)。本 mixin の
+    ``*_v`` は 1 本のベクトルポート (``(m,)``、m == 1 なら rank-0) を flat にして
+    SM-A 版へ渡し、出力 ``(p,)`` を p == 1 なら rank-0 に整形する。m 本のスカラ
+    ポートから組み立てていた配列と同じ値が渡るため、結果は bit-identical。
+
+    MRO 上は ``Block`` の **前** に置く。leaf は SM-A メソッドだけを定義するので
+    dual-override 検査に掛からない。``port_shapes_*`` は行列次元から一意に決まるため
+    JSON には書かない。
+    """
+
+    _serialize_port_shapes = False
+
+    # Block が持つ属性 / SM-A メソッド (型ヒントのみ、mypy 用)
+    n_outputs: int
+    output: Callable[..., npt.NDArray[Any]]
+    derivative: Callable[..., npt.NDArray[Any]]
+    update: Callable[..., npt.NDArray[Any]]
+    advance: Callable[..., npt.NDArray[Any]]
+
+    @staticmethod
+    def _u_flat(u: tuple[npt.NDArray[Any], ...]) -> npt.NDArray[Any]:
+        """ベクトルポート 1 本 (または無し) を SM-A の 1-D ``u`` に戻す。"""
+        if not u:
+            return np.zeros(0, dtype=float)
+        return np.asarray(u[0], dtype=float).reshape(-1)
+
+    def _y_port(self, y: npt.NDArray[Any]) -> tuple[npt.NDArray[Any], ...]:
+        """SM-A の 1-D 出力 ``(p,)`` をベクトルポート 1 本 (p == 1 なら rank-0) にする。"""
+        if self.n_outputs == 0:
+            return ()
+        arr = np.asarray(y, dtype=float).reshape(-1)
+        if arr.shape[0] == 1:
+            return (arr.reshape(()),)
+        return (arr,)
+
+    def output_v(
+        self,
+        t: float,
+        x: npt.NDArray[Any],
+        u: tuple[npt.NDArray[Any], ...],
+    ) -> tuple[npt.NDArray[Any], ...]:
+        return self._y_port(self.output(t, x, self._u_flat(u)))
+
+    def derivative_v(
+        self,
+        t: float,
+        x: npt.NDArray[Any],
+        u: tuple[npt.NDArray[Any], ...],
+    ) -> npt.NDArray[Any]:
+        return np.asarray(self.derivative(t, x, self._u_flat(u)), dtype=float).ravel()
+
+    def update_v(
+        self,
+        t: float,
+        x: npt.NDArray[Any],
+        u: tuple[npt.NDArray[Any], ...],
+    ) -> npt.NDArray[Any]:
+        return np.asarray(self.update(t, x, self._u_flat(u)), dtype=float).ravel()
+
+    def advance_v(
+        self,
+        t: float,
+        x: npt.NDArray[Any],
+        u: tuple[npt.NDArray[Any], ...],
+    ) -> npt.NDArray[Any]:
+        return np.asarray(self.advance(t, x, self._u_flat(u)), dtype=float).ravel()
+
 
 def build_companion_form_siso(
     numerator: npt.NDArray[Any], denominator: npt.NDArray[Any]

{flode-0.63.0 → flode-0.64.0}/flode/blocks/continuous.py

@@ -16,7 +16,12 @@ import scipy.signal
 
 from ..core.block import Block
 from ..exceptions import BlockSpecError
-from ._lti_utils import _DF_TOLERANCE, build_companion_form_siso
+from ._lti_utils import (
+    _DF_TOLERANCE,
+    LtiVectorPortMixin,
+    build_companion_form_siso,
+    lti_port_layout,
+)
 from ._vector_state import VectorStateMixin, X0Like
 
 
@@ -73,16 +78,20 @@ class Integrator(VectorStateMixin, Block):
         return self._u_state(u[0])
 
 
-class StateSpace(Block):
+class StateSpace(LtiVectorPortMixin, Block):
     """連続 LTI 状態空間 ``x_dot = A x + B u``、``y = C x + D u``。
 
     ``direct_feedthrough`` は ``D`` 行列の最大絶対値が ``1e-12`` を超えるかで
     自動推論する (ADR-0006 §(6))。
 
+    ポート (ADR-0079 §(7) D-9、v0.64.0): 入力は **ベクトルポート 1 本** (``m >= 2`` なら
+    shape ``(m,)``、``m == 1`` なら スカラ)、出力も同様 (``p``)。m 本のスカラ信号は
+    ``Mux`` で束ねて繋ぐ (0.14 以前のファイルは load 時に自動変換される)。
+
     Args:
         A: システム行列 (shape ``(n, n)``)。
-        B: 入力行列 (shape ``(n, m)``)、``m = n_inputs``。
-        C: 出力行列 (shape ``(p, n)``)、``p = n_outputs``。
+        B: 入力行列 (shape ``(n, m)``)、``m`` = 入力ベクトルの次元。
+        C: 出力行列 (shape ``(p, n)``)、``p`` = 出力ベクトルの次元。
         D: 直達行列 (shape ``(p, m)``)。``None`` のときゼロ行列。
         x0: 初期状態 (shape ``(n,)``)。``None`` のときゼロ。
     """
@@ -131,13 +140,17 @@ class StateSpace(Block):
                 raise BlockSpecError(f"StateSpace: D must have shape ({p}, {m}), got {D_arr.shape}")
         df = bool(np.max(np.abs(D_arr)) > _DF_TOLERANCE) if D_arr.size else False
 
+        n_in, shapes_in = lti_port_layout(m)
+        n_out, shapes_out = lti_port_layout(p)
         super().__init__(
             id=id,
             name=name,
-            n_inputs=m,
-            n_outputs=p,
+            n_inputs=n_in,
+            n_outputs=n_out,
             n_states=n,
             direct_feedthrough=df,
+            port_shapes_in=shapes_in,
+            port_shapes_out=shapes_out,
         )
         self._A = A_arr
         self._B = B_arr
@@ -253,7 +266,7 @@ class TransferFunction(Block):
         return np.asarray(self._A @ x + self._B @ u, dtype=float).ravel()
 
 
-class MimoTransferFunction(Block):
+class MimoTransferFunction(LtiVectorPortMixin, Block):
     """連続 LTI MIMO 伝達関数 ``H(s) = N(s) / d(s)`` (共通分母版、ADR-0010 §(2)、ADR-0016)。
 
     入力 ``q`` 個 / 出力 ``p`` 個の伝達関数行列を扱う。共通分母 ``d(s)`` (1D) と、
@@ -280,8 +293,8 @@ class MimoTransferFunction(Block):
         - ``C``: shape ``(p, p*q*n)``、出力 i は ブロック (i, j) for all j の C を集約
         - ``D``: shape ``(p, q)``、各 (i, j) で biproper なら非ゼロ
 
-    SM-A 信号モデル (ADR-0010 §(1)) に従い、ポートは ``q`` 個のスカラー入力 +
-    ``p`` 個のスカラー出力。
+    ポート (ADR-0079 §(7) D-9、v0.64.0): 入力はベクトルポート 1 本 (``q >= 2`` なら
+    shape ``(q,)``、``q == 1`` ならスカラ)、出力も同様 (``p``)。
 
     Phase 3 では **共通分母版のみ** をサポート (各 (i, j) で異なる分母を許容する
     独立分母版は Phase 4+ で再検討、ADR-0010 §(2))。
@@ -397,13 +410,17 @@ class MimoTransferFunction(Block):
 
         df = bool(np.max(np.abs(D)) > _DF_TOLERANCE) if D.size else False
 
+        n_in, shapes_in = lti_port_layout(q)
+        n_out, shapes_out = lti_port_layout(p)
         super().__init__(
             id=id,
             name=name,
-            n_inputs=q,
-            n_outputs=p,
+            n_inputs=n_in,
+            n_outputs=n_out,
             n_states=n_total,
             direct_feedthrough=df,
+            port_shapes_in=shapes_in,
+            port_shapes_out=shapes_out,
         )
         self._A = A
         self._B = B

{flode-0.63.0 → flode-0.64.0}/flode/blocks/discrete.py

@@ -32,7 +32,7 @@ import scipy.signal
 
 from ..core.block import Block
 from ..exceptions import BlockSpecError
-from ._lti_utils import _DF_TOLERANCE
+from ._lti_utils import _DF_TOLERANCE, LtiVectorPortMixin, lti_port_layout
 from ._vector_state import VectorStateMixin, X0Like
 
 _zohd_logger = logging.getLogger("flode.blocks.discrete")
@@ -465,12 +465,15 @@ class ZeroOrderHoldDirect(VectorStateMixin, Block):
         return self._u_state(u[0])
 
 
-class DiscreteStateSpace(Block):
+class DiscreteStateSpace(LtiVectorPortMixin, Block):
     """離散 LTI 状態空間 ``x[k+1] = A x[k] + B u[k]``、``y[k] = C x[k] + D u[k]`` (リファレンスツール互換)。
 
     ADR-0006 §(5)、ADR-0015 §(3) で 2n-state augmentation。``direct_feedthrough`` は
     ``D`` の最大絶対値が ``1e-12`` を超えるかで自動推論。
 
+    ポート (ADR-0079 §(7) D-9、v0.64.0): 入力はベクトルポート 1 本 (``m >= 2`` なら
+    shape ``(m,)``、``m == 1`` ならスカラ)、出力も同様 (``p``)。
+
     Internal state (n_states=2n、ADR-0015 §(3)):
         x[0..n-1]   = output_curr — 現サンプル境界での状態 (前回 fire で確定)
         x[n..2n-1]  = next_x      — 次サンプル境界で前半にシフトされる buffer
@@ -537,14 +540,18 @@ class DiscreteStateSpace(Block):
         df = bool(np.max(np.abs(D_arr)) > _DF_TOLERANCE) if D_arr.size else False
 
         # ADR-0015 §(3): 2n-state augmentation で n_states = 2n
+        n_in, shapes_in = lti_port_layout(m)
+        n_out, shapes_out = lti_port_layout(p)
         super().__init__(
             id=id,
             name=name,
-            n_inputs=m,
-            n_outputs=p,
+            n_inputs=n_in,
+            n_outputs=n_out,
             n_states=2 * n,
             direct_feedthrough=df,
             sample_time=sample_time,
+            port_shapes_in=shapes_in,
+            port_shapes_out=shapes_out,
         )
         self._A = A_arr
         self._B = B_arr

{flode-0.63.0 → flode-0.64.0}/flode/blocks/lookup.py

@@ -23,6 +23,7 @@ from scipy.interpolate import RegularGridInterpolator, interp1d
 
 from ..core.block import Block
 from ..exceptions import BlockEvalError, BlockSpecError
+from ._elementwise import ElementwiseMixin
 
 _logger = logging.getLogger(__name__)
 
@@ -31,7 +32,25 @@ _logger = logging.getLogger(__name__)
 LOOKUP_ND_AXIS_WARNING_THRESHOLD = 6
 
 
-class LookupTable1D(Block):
+def _elementwise(
+    fn: Any, *arrays: npt.NDArray[Any], n_out: int = 1
+) -> tuple[npt.NDArray[Any], ...]:
+    """スカラ核 ``fn`` を要素ごとに適用する (ADR-0079 Stage 3、lookup 系のベクトル化)。
+
+    入力は解決器の合流規則 (完全一致 + rank-0 拡張) を満たすので ``np.broadcast_arrays``
+    で揃え、``np.vectorize`` で ``fn`` を各要素に呼ぶ。全入力が rank-0 なら各出力も
+    rank-0 で、SM-A ``output`` と同じスカラ核を通るため bit-identical。補間オブジェクトの
+    配列呼びは使わない (``extrapolation="error"`` / nan / ±inf の要素ごとの分岐を
+    スカラ核 1 箇所に保つため。性能より意味論の一致を優先、SPEC-0031 §非機能要件)。
+    """
+    vec = np.vectorize(fn, otypes=[float] * n_out)
+    out = vec(*np.broadcast_arrays(*arrays))
+    if n_out == 1:
+        return (np.asarray(out, dtype=float),)
+    return tuple(np.asarray(o, dtype=float) for o in out)
+
+
+class LookupTable1D(ElementwiseMixin, Block):
     """1 次元ルックアップテーブル ``y = f(u)``。
 
     ブレークポイント配列 ``breakpoints`` (厳密単調増加) と対応するテーブル値
@@ -237,14 +256,23 @@ class LookupTable1D(Block):
         return edge_y + slope * (val - edge_x)
 
     def output(self, t: float, x: npt.NDArray[Any], u: npt.NDArray[Any]) -> npt.NDArray[Any]:
-        val = float(np.asarray(u).reshape(-1)[0])
+        return np.array([self._eval(float(np.asarray(u).reshape(-1)[0]))])
+
+    def _kernel(
+        self, t: float, x: npt.NDArray[Any], u: tuple[npt.NDArray[Any], ...]
+    ) -> tuple[npt.NDArray[Any], ...]:
+        return _elementwise(self._eval, u[0])
+
+    def _eval(self, val: float) -> float:
+        """スカラ核 ``y = f(val)`` (SM-A ``output`` と SM-T ``_kernel`` が共有)。"""
+        val = float(val)
 
         # ±inf × linear 外挿: scipy 1.18+ の interp1d は外挿を lerp 形式
         # ``y_lo*(1-t) + y_hi*t`` で計算するため inf - inf = nan (+ RuntimeWarning)
         # になる (~1.17 は point-slope 形式で ±inf を返していた)。scipy を呼ばず
         # 全補間方式で端点 slope から極限値を直接計算する。
         if self.extrapolation == "linear" and np.isinf(val):
-            return np.array([self._extrapolate_from_edge(val)])
+            return self._extrapolate_from_edge(val)
 
         try:
             y = float(self._interp(val))
@@ -267,10 +295,10 @@ class LookupTable1D(Block):
         ):
             y = self._extrapolate_from_edge(val)
 
-        return np.array([y])
+        return y
 
 
-class LookupTable2D(Block):
+class LookupTable2D(ElementwiseMixin, Block):
     """2 次元ルックアップテーブル ``y = f(u[0], u[1])``。
 
     2 つのブレークポイント配列 (``breakpoints_row`` / ``breakpoints_col``、
@@ -496,8 +524,17 @@ class LookupTable2D(Block):
 
     def output(self, t: float, x: npt.NDArray[Any], u: npt.NDArray[Any]) -> npt.NDArray[Any]:
         u_arr = np.asarray(u).reshape(-1)
-        u0 = float(u_arr[0])
-        u1 = float(u_arr[1])
+        return np.array([self._eval(float(u_arr[0]), float(u_arr[1]))])
+
+    def _kernel(
+        self, t: float, x: npt.NDArray[Any], u: tuple[npt.NDArray[Any], ...]
+    ) -> tuple[npt.NDArray[Any], ...]:
+        return _elementwise(self._eval, u[0], u[1])
+
+    def _eval(self, u0: float, u1: float) -> float:
+        """スカラ核 ``y = f(u0, u1)`` (SM-A ``output`` と SM-T ``_kernel`` が共有)。"""
+        u0 = float(u0)
+        u1 = float(u1)
 
         # nan は比較が全て False になるため、in_row/in_col は False となり
         # extrapolation 経路に入る (== 1-D と同方針)。
@@ -516,8 +553,7 @@ class LookupTable2D(Block):
                 )
             if self.extrapolation == "linear":
                 # nan は伝播 (np.isnan で early return、interp1d が nan を返すため不要)
-                y = self._linear_extrapolate(u0, u1)
-                return np.array([y])
+                return self._linear_extrapolate(u0, u1)
             # extrapolation == "clip": 端点に飽和してから補間
             u0 = float(np.clip(u0, self._bp_row[0], self._bp_row[-1]))
             u1 = float(np.clip(u1, self._bp_col[0], self._bp_col[-1]))
@@ -525,16 +561,14 @@ class LookupTable2D(Block):
         if self.interpolation == "flat":
             # nan が clip 後に残るのは clip(nan)=nan の場合 (ありうる)
             if np.isnan(u0) or np.isnan(u1):
-                return np.array([float("nan")])
-            y = self._flat_lookup(u0, u1)
-        else:
-            # RegularGridInterpolator は shape (npts, ndim) を期待 → (1, 2) で渡す。
-            # 戻り値は shape (1,) なので .item() で scalar 抽出 (numpy 2.0 警告回避)。
-            y = float(self._interp(np.array([[u0, u1]])).item())
-        return np.array([y])
+                return float("nan")
+            return self._flat_lookup(u0, u1)
+        # RegularGridInterpolator は shape (npts, ndim) を期待 → (1, 2) で渡す。
+        # 戻り値は shape (1,) なので .item() で scalar 抽出 (numpy 2.0 警告回避)。
+        return float(self._interp(np.array([[u0, u1]])).item())
 
 
-class Prelookup(Block):
+class Prelookup(ElementwiseMixin, Block):
     """1-D Prelookup: 入力 ``u`` から ``(k, f)`` を分離出力する (SPEC-0019)。
 
     breakpoints 検索結果を `(k=index, f=fraction)` の 2 出力に分離することで、
@@ -612,13 +646,23 @@ class Prelookup(Block):
         }
 
     def output(self, t: float, x: npt.NDArray[Any], u: npt.NDArray[Any]) -> npt.NDArray[Any]:
-        val = float(np.asarray(u).reshape(-1)[0])
+        k, f = self._eval(float(np.asarray(u).reshape(-1)[0]))
+        return np.array([k, f])
+
+    def _kernel(
+        self, t: float, x: npt.NDArray[Any], u: tuple[npt.NDArray[Any], ...]
+    ) -> tuple[npt.NDArray[Any], ...]:
+        return _elementwise(self._eval, u[0], n_out=2)
+
+    def _eval(self, val: float) -> tuple[float, float]:
+        """スカラ核 ``(k, f) = g(val)`` (SM-A ``output`` と SM-T ``_kernel`` が共有)。"""
+        val = float(val)
         bp = self._breakpoints
         n = bp.size
 
         if np.isnan(val):
             # nan は 1-D LookupTable と同方針で伝播
-            return np.array([float("nan"), float("nan")])
+            return float("nan"), float("nan")
 
         in_domain = bool(bp[0] <= val <= bp[-1])
 
@@ -636,17 +680,17 @@ class Prelookup(Block):
                 else:  # val > bp[-1] (inf 含む)
                     k = n - 2
                 f = (val - float(bp[k])) / (float(bp[k + 1]) - float(bp[k]))
-                return np.array([float(k), f])
+                return float(k), f
             # extrapolation == "clip": 端点に飽和
             val = float(np.clip(val, bp[0], bp[-1]))
 
         # 定義域内 (or clip 後): 純 numpy 検索
         k = int(np.clip(np.searchsorted(bp, val, side="right") - 1, 0, n - 2))
         f = (val - float(bp[k])) / (float(bp[k + 1]) - float(bp[k]))
-        return np.array([float(k), f])
+        return float(k), f
 
 
-class InterpolationUsingPrelookup(Block):
+class InterpolationUsingPrelookup(ElementwiseMixin, Block):
     """1-D Prelookup を用いた補間 (SPEC-0019)。
 
     :class:`Prelookup` の出力 ``(k, f)`` を受け取り、内部 ``table`` から
@@ -726,30 +770,37 @@ class InterpolationUsingPrelookup(Block):
 
     def output(self, t: float, x: npt.NDArray[Any], u: npt.NDArray[Any]) -> npt.NDArray[Any]:
         u_arr = np.asarray(u).reshape(-1)
-        k_raw = float(u_arr[0])
-        f = float(u_arr[1])
+        return np.array([self._eval(float(u_arr[0]), float(u_arr[1]))])
+
+    def _kernel(
+        self, t: float, x: npt.NDArray[Any], u: tuple[npt.NDArray[Any], ...]
+    ) -> tuple[npt.NDArray[Any], ...]:
+        return _elementwise(self._eval, u[0], u[1])
+
+    def _eval(self, k_raw: float, f: float) -> float:
+        """スカラ核 ``y = h(k, f)`` (SM-A ``output`` と SM-T ``_kernel`` が共有)。"""
+        k_raw = float(k_raw)
+        f = float(f)
         tbl = self._table
         n = tbl.size
 
         # k / f の nan は伝播 (= nan 出力)。
         if np.isnan(k_raw) or np.isnan(f):
-            return np.array([float("nan")])
+            return float("nan")
         # k は黙って clip ([0, n-2])。Prelookup の出力域だが上流ブロック自由なので保険。
         # ``np.clip`` を ``int()`` より先に評価することで ``k_raw=±inf`` でも
         # OverflowError を避けて n-2 / 0 に飽和させる (ADR-0056 構造化エラー protocol)。
         k = int(np.clip(k_raw, 0, n - 2))
 
         if self.interpolation == "linear":
-            y = float(tbl[k]) + f * (float(tbl[k + 1]) - float(tbl[k]))
-        elif self.interpolation == "nearest":
-            y = float(tbl[k + 1]) if f >= 0.5 else float(tbl[k])
-        else:  # "flat"
-            y = float(tbl[k])
+            return float(tbl[k]) + f * (float(tbl[k + 1]) - float(tbl[k]))
+        if self.interpolation == "nearest":
+            return float(tbl[k + 1]) if f >= 0.5 else float(tbl[k])
+        # "flat"
+        return float(tbl[k])
 
-        return np.array([y])
 
-
-class LookupTableND(Block):
+class LookupTableND(ElementwiseMixin, Block):
     """n 次元ルックアップテーブル ``y = f(u[0], u[1], ..., u[n-1])`` (SPEC-0018)。
 
     軸数 n は ``len(breakpoints_axes)`` で動的に決まる。``LookupTable1D`` (n=1) /
@@ -978,6 +1029,16 @@ class LookupTableND(Block):
                 f"LookupTableND[{self.name}]: expected {self._n_axes} inputs, got {u_arr.size}",
                 block_id=self.id,
             )
+        return np.array([self._eval(*u_arr)])
+
+    def _kernel(
+        self, t: float, x: npt.NDArray[Any], u: tuple[npt.NDArray[Any], ...]
+    ) -> tuple[npt.NDArray[Any], ...]:
+        return _elementwise(self._eval, *u)
+
+    def _eval(self, *vals: float) -> float:
+        """スカラ核 ``y = f(u[0], …, u[n-1])`` (SM-A ``output`` と SM-T ``_kernel`` が共有)。"""
+        u_arr = np.asarray(vals, dtype=float)
 
         # 各軸の定義域内判定 (nan は <=/>= で False になり外挿経路へ)
         in_domain_flags = [
@@ -999,8 +1060,7 @@ class LookupTableND(Block):
                 )
             if self.extrapolation == "linear":
                 # nan 含むときは結果も nan (interp1d が nan 伝播)
-                y = self._linear_extrapolate(u_arr)
-                return np.array([y])
+                return self._linear_extrapolate(u_arr)
             # extrapolation == "clip": 各軸独立に端点飽和
             u_arr = np.array(
                 [
@@ -1017,9 +1077,7 @@ class LookupTableND(Block):
 
         if self.interpolation == "flat":
             if bool(np.any(np.isnan(u_arr))):
-                return np.array([float("nan")])
-            y = self._flat_lookup(u_arr)
-        else:
-            # RegularGridInterpolator は shape (npts, ndim) を期待 → (1, n_axes)。
-            y = float(self._interp(u_arr.reshape(1, -1)).item())
-        return np.array([y])
+                return float("nan")
+            return self._flat_lookup(u_arr)
+        # RegularGridInterpolator は shape (npts, ndim) を期待 → (1, n_axes)。
+        return float(self._interp(u_arr.reshape(1, -1)).item())