emx-onnx-cgen 0.3.3__py3-none-any.whl → 0.3.5__py3-none-any.whl

emx_onnx_cgen/_build_info.py

@@ -1,3 +1,3 @@
 """Auto-generated by build backend. Do not edit."""
-BUILD_DATE = '2026-01-23T06:14:26Z'
+BUILD_DATE = '2026-01-23T07:18:06Z'
 GIT_VERSION = 'unknown'

emx_onnx_cgen/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.3.3'
-__version_tuple__ = version_tuple = (0, 3, 3)
+__version__ = version = '0.3.5'
+__version_tuple__ = version_tuple = (0, 3, 5)
 
 __commit_id__ = commit_id = None

emx_onnx_cgen/codegen/c_emitter.py

@@ -954,13 +954,13 @@ class CEmitter:
             )
         if isinstance(op, MultiInputBinaryOp):
             return MultiInputBinaryOp(
+                op_type=op.op_type,
                 inputs=tuple(name_map.get(name, name) for name in op.inputs),
                 output=name_map.get(op.output, op.output),
                 function=op.function,
                 operator_kind=op.operator_kind,
-                shape=op.shape,
-                dtype=op.dtype,
-                input_dtype=op.input_dtype,
+                min_inputs=op.min_inputs,
+                max_inputs=op.max_inputs,
             )
         if isinstance(op, WhereOp):
             return WhereOp(
@@ -1554,12 +1554,7 @@ class CEmitter:
                 data=name_map.get(op.data, op.data),
                 indices=name_map.get(op.indices, op.indices),
                 output=name_map.get(op.output, op.output),
-                data_shape=op.data_shape,
-                indices_shape=op.indices_shape,
-                output_shape=op.output_shape,
                 axis=op.axis,
-                dtype=op.dtype,
-                indices_dtype=op.indices_dtype,
             )
         if isinstance(op, GatherNDOp):
             return GatherNDOp(
@@ -1896,13 +1891,8 @@ class CEmitter:
         if isinstance(op, ExpandOp):
             return ExpandOp(
                 input0=name_map.get(op.input0, op.input0),
-                output=name_map.get(op.output, op.output),
                 input_shape=op.input_shape,
-                output_shape=op.output_shape,
-                input_shape_padded=op.input_shape_padded,
-                input_strides=op.input_strides,
-                dtype=op.dtype,
-                input_dtype=op.input_dtype,
+                output=name_map.get(op.output, op.output),
             )
         if isinstance(op, CumSumOp):
             return CumSumOp(
@@ -2233,8 +2223,8 @@ class CEmitter:
         ):
             testbench_math_include.add("#include <math.h>")
         includes = self._collect_includes(
-            model,
-            resolved_ops,
+            original_model,
+            list(original_model.ops),
             emit_testbench=emit_testbench,
             extra_includes=scalar_includes | testbench_math_include,
             needs_weight_loader=bool(large_constants),
@@ -2380,8 +2370,8 @@ class CEmitter:
         ):
             testbench_math_include.add("#include <math.h>")
         includes = self._collect_includes(
-            model,
-            resolved_ops,
+            original_model,
+            list(original_model.ops),
             emit_testbench=emit_testbench,
             extra_includes=scalar_includes | testbench_math_include,
             needs_weight_loader=bool(large_constants),
@@ -2790,8 +2780,17 @@ class CEmitter:
             *(const.dtype for const in model.constants),
             *constant_of_shape_inputs,
         }
+        def _resolved_output_dtype(op: OpBase) -> ScalarType:
+            if isinstance(op, MultiInputBinaryOp):
+                return model.op_context.dtype(op.inputs[0])
+            if isinstance(op, GatherOp):
+                return model.op_context.dtype(op.data)
+            if isinstance(op, ExpandOp):
+                return model.op_context.dtype(op.input0)
+            return op.dtype
+
         model_dtypes.update(
-            op.dtype
+            _resolved_output_dtype(op)
             for op in resolved_ops
             if not isinstance(op, (ArgReduceOp, TopKOp))
         )
@@ -3875,13 +3874,13 @@ class CEmitter:
             )
         if isinstance(op, MultiInputBinaryOp):
             return MultiInputBinaryOp(
+                op_type=op.op_type,
                 inputs=tuple(temp_map.get(name, name) for name in op.inputs),
                 output=temp_map.get(op.output, op.output),
                 function=op.function,
                 operator_kind=op.operator_kind,
-                shape=op.shape,
-                dtype=op.dtype,
-                input_dtype=op.input_dtype,
+                min_inputs=op.min_inputs,
+                max_inputs=op.max_inputs,
             )
         if isinstance(op, WhereOp):
             return WhereOp(
@@ -4545,11 +4544,6 @@ class CEmitter:
                 indices=temp_map.get(op.indices, op.indices),
                 output=temp_map.get(op.output, op.output),
                 axis=op.axis,
-                data_shape=op.data_shape,
-                indices_shape=op.indices_shape,
-                output_shape=op.output_shape,
-                dtype=op.dtype,
-                indices_dtype=op.indices_dtype,
             )
         if isinstance(op, GatherNDOp):
             return GatherNDOp(
@@ -4674,13 +4668,8 @@ class CEmitter:
         if isinstance(op, ExpandOp):
             return ExpandOp(
                 input0=temp_map.get(op.input0, op.input0),
-                output=temp_map.get(op.output, op.output),
                 input_shape=op.input_shape,
-                output_shape=op.output_shape,
-                input_shape_padded=op.input_shape_padded,
-                input_strides=op.input_strides,
-                dtype=op.dtype,
-                input_dtype=op.input_dtype,
+                output=temp_map.get(op.output, op.output),
             )
         if isinstance(op, CumSumOp):
             return CumSumOp(
@@ -7446,30 +7435,34 @@ class CEmitter:
                     ("output", op.output),
                 ]
             )
-            output_shape = CEmitter._codegen_shape(op.output_shape)
-            loop_vars = CEmitter._loop_vars(output_shape)
-            output_loop_vars = loop_vars if op.output_shape else ()
-            indices_rank = len(op.indices_shape)
+            output_shape_raw = self._ctx_shape(op.output)
+            output_shape = CEmitter._codegen_shape(output_shape_raw)
+            loop_vars = CEmitter._loop_vars(output_shape_raw)
+            output_loop_vars = loop_vars if output_shape_raw else ()
+            indices_shape = self._ctx_shape(op.indices)
+            indices_rank = len(indices_shape)
             if indices_rank == 0:
                 indices_indices = ("0",)
             else:
-                indices_indices = output_loop_vars[
-                    op.axis : op.axis + indices_rank
-                ]
+                axis = int(self._derived(op, "axis"))
+                indices_indices = output_loop_vars[axis : axis + indices_rank]
+            axis = int(self._derived(op, "axis"))
             data_indices = [
-                *output_loop_vars[: op.axis],
+                *output_loop_vars[:axis],
                 "gather_index",
-                *output_loop_vars[op.axis + indices_rank :],
+                *output_loop_vars[axis + indices_rank :],
             ]
-            data_suffix = self._param_array_suffix(op.data_shape)
-            indices_suffix = self._param_array_suffix(op.indices_shape)
-            output_suffix = self._param_array_suffix(op.output_shape)
+            data_shape = self._ctx_shape(op.data)
+            data_suffix = self._param_array_suffix(data_shape)
+            indices_suffix = self._param_array_suffix(indices_shape)
+            output_suffix = self._param_array_suffix(output_shape_raw)
+            indices_dtype = self._ctx_dtype(op.indices)
             param_decls = self._build_param_decls(
                 [
                     (params["data"], c_type, data_suffix, True),
                     (
                         params["indices"],
-                        op.indices_dtype.c_type,
+                        indices_dtype.c_type,
                         indices_suffix,
                         True,
                     ),
@@ -7484,7 +7477,7 @@ class CEmitter:
                 output=params["output"],
                 params=param_decls,
                 c_type=c_type,
-                indices_c_type=op.indices_dtype.c_type,
+                indices_c_type=indices_dtype.c_type,
                 data_suffix=data_suffix,
                 indices_suffix=indices_suffix,
                 output_suffix=output_suffix,
@@ -7492,7 +7485,7 @@ class CEmitter:
                 loop_vars=loop_vars,
                 indices_indices=indices_indices,
                 data_indices=data_indices,
-                axis_dim=op.data_shape[op.axis],
+                axis_dim=data_shape[axis],
             ).rstrip()
             return with_node_comment(rendered)
         if isinstance(op, GatherNDOp):
@@ -9139,15 +9132,17 @@ class CEmitter:
                 [("input0", op.input0), ("output", op.output)]
             )
             output_dim_names = _dim_names_for(op.output)
+            output_shape_raw = self._ctx_shape(op.output)
             output_shape = CEmitter._shape_dim_exprs(
-                op.output_shape, output_dim_names
+                output_shape_raw, output_dim_names
             )
-            loop_vars = CEmitter._loop_vars(op.output_shape)
+            loop_vars = CEmitter._loop_vars(output_shape_raw)
+            input_shape = self._ctx_shape(op.input0)
             input_suffix = self._param_array_suffix(
-                op.input_shape, _dim_names_for(op.input0)
+                input_shape, _dim_names_for(op.input0)
             )
             output_suffix = self._param_array_suffix(
-                op.output_shape, output_dim_names
+                output_shape_raw, output_dim_names
             )
             param_decls = self._build_param_decls(
                 [
@@ -9155,10 +9150,12 @@ class CEmitter:
                     (params["output"], c_type, output_suffix, False),
                 ]
             )
+            input_shape_padded = self._derived(op, "input_shape_padded")
+            input_strides = self._derived(op, "input_strides")
             input_index_terms = [
                 f"{loop_var} * {stride}"
                 for loop_var, input_dim, stride in zip(
-                    loop_vars, op.input_shape_padded, op.input_strides
+                    loop_vars, input_shape_padded, input_strides
                 )
                 if input_dim != 1
             ]
@@ -10442,7 +10439,13 @@ class CEmitter:
             )
         if isinstance(op, NonMaxSuppressionOp):
             return ((op.output, op.output_shape, op.output_dtype),)
-        return ((op.output, self._op_output_shape(op), op.dtype),)
+        return (
+            (
+                op.output,
+                self._op_output_shape(op),
+                self._op_output_dtype(op),
+            ),
+        )
 
     def _op_output_shape(
         self,
@@ -10566,7 +10569,7 @@ class CEmitter:
         if isinstance(op, GatherElementsOp):
             return op.output_shape
         if isinstance(op, GatherOp):
-            return op.output_shape
+            return self._ctx_shape(op.output)
         if isinstance(op, GatherNDOp):
             return op.output_shape
         if isinstance(op, ScatterNDOp):
@@ -10614,7 +10617,7 @@ class CEmitter:
         if isinstance(op, NonMaxSuppressionOp):
             return op.output_shape
         if isinstance(op, ExpandOp):
-            return op.output_shape
+            return self._ctx_shape(op.output)
         if isinstance(op, CumSumOp):
             return op.input_shape
         if isinstance(op, RangeOp):
@@ -10700,10 +10703,12 @@ class CEmitter:
                 SoftmaxOp,
                 LogSoftmaxOp,
                 HardmaxOp,
+                GatherOp,
                 TransposeOp,
                 ReshapeOp,
                 IdentityOp,
                 ReduceOp,
+                ExpandOp,
             ),
         ):
             return self._ctx_dtype(op.output)

emx_onnx_cgen/compiler.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from dataclasses import dataclass
+from dataclasses import dataclass, fields
 import hashlib
 from pathlib import Path
 from typing import Mapping
@@ -24,6 +24,7 @@ from .ir.context import GraphContext
 from .ir.model import Graph, TensorType, Value
 from .ir.op_base import OpBase
 from .ir.op_context import OpContext
+from .ir.ops import ExpandOp, GatherOp, MultiInputBinaryOp
 from .lowering import load_lowering_registry
 from .lowering.common import ensure_supported_dtype, shape_product, value_dtype
 from .lowering.registry import get_lowering_registry
@@ -172,6 +173,43 @@ class Compiler:
         ) = self._collect_io_specs(graph)
         ops, node_infos = self._lower_nodes(ctx)
         op_ctx = OpContext(ctx)
+        for op, node_info in zip(ops, node_infos):
+            field_names = {field.name for field in fields(op)}
+            if "dtype" in field_names:
+                dtype = getattr(op, "dtype")
+                for field in fields(op):
+                    if not field.name.startswith("output"):
+                        continue
+                    value = getattr(op, field.name)
+                    if isinstance(value, str):
+                        op_ctx.set_dtype(value, dtype)
+                for name in node_info.outputs:
+                    op_ctx.set_dtype(name, dtype)
+            if "outputs" in field_names:
+                dtype = getattr(op, "dtype", None)
+                if dtype is not None:
+                    for name in getattr(op, "outputs"):
+                        op_ctx.set_dtype(name, dtype)
+            if "output_dtype" in field_names and "output" in field_names:
+                output_name = getattr(op, "output")
+                if isinstance(output_name, str):
+                    op_ctx.set_dtype(output_name, getattr(op, "output_dtype"))
+            if "output_values_dtype" in field_names:
+                op_ctx.set_dtype(
+                    getattr(op, "output_values"),
+                    getattr(op, "output_values_dtype"),
+                )
+            if "output_indices_dtype" in field_names:
+                op_ctx.set_dtype(
+                    getattr(op, "output_indices"),
+                    getattr(op, "output_indices_dtype"),
+                )
+            if isinstance(op, MultiInputBinaryOp) and op.inputs:
+                op_ctx.set_dtype(op.output, op_ctx.dtype(op.inputs[0]))
+            if isinstance(op, GatherOp):
+                op_ctx.set_dtype(op.output, op_ctx.dtype(op.data))
+            if isinstance(op, ExpandOp):
+                op_ctx.set_dtype(op.output, op_ctx.dtype(op.input0))
         for op in ops:
             op.validate(op_ctx)
         for op in ops:

emx_onnx_cgen/ir/op_base.py

@@ -88,7 +88,10 @@ class ElementwiseOpBase(RenderableOpBase):
             raise UnsupportedOpError(
                 f"{self.kind} expects matching input dtypes, got {dtype_names}"
             )
-        output_dtype = ctx.dtype(self._elementwise_output())
+        try:
+            output_dtype = ctx.dtype(self._elementwise_output())
+        except ShapeInferenceError:
+            return None
         if self._elementwise_compare():
             if output_dtype != ScalarType.BOOL:
                 raise UnsupportedOpError(
@@ -107,7 +110,25 @@ class ElementwiseOpBase(RenderableOpBase):
         output_name = self._elementwise_output()
         for name in input_names:
             ctx.dtype(name)
-        ctx.dtype(output_name)
+        desired_dtype = (
+            ScalarType.BOOL if self._elementwise_compare() else None
+        )
+        if desired_dtype is None:
+            data_inputs = self._elementwise_data_inputs()
+            if data_inputs:
+                desired_dtype = ctx.dtype(data_inputs[0])
+        try:
+            output_dtype = ctx.dtype(output_name)
+        except ShapeInferenceError:
+            if desired_dtype is not None:
+                ctx.set_dtype(output_name, desired_dtype)
+                return None
+            raise
+        if desired_dtype is not None and output_dtype != desired_dtype:
+            raise UnsupportedOpError(
+                f"{self.kind} expects output dtype {desired_dtype.onnx_name}, "
+                f"got {output_dtype.onnx_name}"
+            )
 
     def infer_shapes(self, ctx: OpContext) -> None:
         input_names = self._elementwise_inputs()
@@ -121,6 +142,295 @@ class ElementwiseOpBase(RenderableOpBase):
         return None
 
 
+class GatherLikeOpBase(RenderableOpBase):
+    def _gather_data(self) -> str:
+        raise NotImplementedError
+
+    def _gather_indices(self) -> str:
+        raise NotImplementedError
+
+    def _gather_output(self) -> str:
+        raise NotImplementedError
+
+    def _gather_axis(self) -> int:
+        raise NotImplementedError
+
+    def _gather_mode(self) -> str:
+        raise NotImplementedError
+
+    def validate(self, ctx: OpContext) -> None:
+        indices_dtype = ctx.dtype(self._gather_indices())
+        if indices_dtype not in {ScalarType.I64, ScalarType.I32}:
+            raise UnsupportedOpError(
+                f"{self.kind} indices must be int32 or int64, "
+                f"got {indices_dtype.onnx_name}"
+            )
+        data_shape = ctx.shape(self._gather_data())
+        if self._gather_mode() in {"gather", "gather_elements"}:
+            if not data_shape:
+                raise ShapeInferenceError(
+                    f"{self.kind} does not support scalar inputs"
+                )
+            axis = self._gather_axis()
+            if axis < 0:
+                axis += len(data_shape)
+            if axis < 0 or axis >= len(data_shape):
+                raise ShapeInferenceError(
+                    f"{self.kind} axis {axis} is out of range for rank "
+                    f"{len(data_shape)}"
+                )
+        return None
+
+    def infer_types(self, ctx: OpContext) -> None:
+        data_dtype = ctx.dtype(self._gather_data())
+        try:
+            output_dtype = ctx.dtype(self._gather_output())
+        except ShapeInferenceError:
+            ctx.set_dtype(self._gather_output(), data_dtype)
+            output_dtype = data_dtype
+        if output_dtype != data_dtype:
+            raise UnsupportedOpError(
+                f"{self.kind} expects output dtype {data_dtype.onnx_name}, "
+                f"got {output_dtype.onnx_name}"
+            )
+
+    def infer_shapes(self, ctx: OpContext) -> None:
+        data_shape = ctx.shape(self._gather_data())
+        indices_shape = ctx.shape(self._gather_indices())
+        axis = self._gather_axis()
+        if axis < 0:
+            axis += len(data_shape)
+        if axis < 0 or axis >= len(data_shape):
+            raise ShapeInferenceError(
+                f"{self.kind} axis {axis} is out of range for rank "
+                f"{len(data_shape)}"
+            )
+        if self._gather_mode() == "gather":
+            output_shape = (
+                data_shape[:axis] + indices_shape + data_shape[axis + 1 :]
+            )
+        else:
+            raise UnsupportedOpError(
+                f"{self.kind} does not support gather mode "
+                f"{self._gather_mode()}"
+            )
+        try:
+            expected = ctx.shape(self._gather_output())
+        except ShapeInferenceError:
+            expected = None
+        if expected is not None and expected != output_shape:
+            raise ShapeInferenceError(
+                f"{self.kind} output shape must be {output_shape}, got {expected}"
+            )
+        ctx.set_shape(self._gather_output(), output_shape)
+        ctx.set_derived(self, "axis", axis)
+
+
+class ShapeLikeOpBase(RenderableOpBase):
+    def _shape_data(self) -> str:
+        raise NotImplementedError
+
+    def _shape_output(self) -> str:
+        raise NotImplementedError
+
+    def _shape_spec(self, ctx: OpContext) -> tuple[int, ...]:
+        raise NotImplementedError
+
+    def _shape_mode(self) -> str:
+        raise NotImplementedError
+
+    def _shape_derived(
+        self,
+        ctx: OpContext,
+        *,
+        data_shape: tuple[int, ...],
+        target_shape: tuple[int, ...],
+        output_shape: tuple[int, ...],
+    ) -> None:
+        return None
+
+    @staticmethod
+    def _validate_static_dims(shape: tuple[int, ...], kind: str) -> None:
+        if any(dim < 0 for dim in shape):
+            raise ShapeInferenceError(
+                f"{kind} does not support dynamic dims"
+            )
+
+    @staticmethod
+    def _broadcast_shape(
+        input_shape: tuple[int, ...],
+        target_shape: tuple[int, ...],
+        *,
+        kind: str,
+    ) -> tuple[int, ...]:
+        ShapeLikeOpBase._validate_static_dims(input_shape, kind)
+        ShapeLikeOpBase._validate_static_dims(target_shape, kind)
+        output_rank = max(len(input_shape), len(target_shape))
+        input_padded = (1,) * (output_rank - len(input_shape)) + input_shape
+        target_padded = (1,) * (output_rank - len(target_shape)) + target_shape
+        result: list[int] = []
+        for input_dim, target_dim in zip(input_padded, target_padded):
+            if input_dim == 1:
+                result.append(target_dim)
+            elif target_dim == 1:
+                result.append(input_dim)
+            elif input_dim == target_dim:
+                result.append(input_dim)
+            else:
+                raise ShapeInferenceError(
+                    f"{kind} input shape {input_shape} is not "
+                    f"broadcastable to {target_shape}"
+                )
+        return tuple(result)
+
+    def validate(self, ctx: OpContext) -> None:
+        data_shape = ctx.shape(self._shape_data())
+        target_shape = self._shape_spec(ctx)
+        if self._shape_mode() == "expand":
+            self._broadcast_shape(
+                data_shape, target_shape, kind=self.kind
+            )
+        return None
+
+    def infer_types(self, ctx: OpContext) -> None:
+        input_dtype = ctx.dtype(self._shape_data())
+        try:
+            output_dtype = ctx.dtype(self._shape_output())
+        except ShapeInferenceError:
+            ctx.set_dtype(self._shape_output(), input_dtype)
+            output_dtype = input_dtype
+        if output_dtype != input_dtype:
+            raise UnsupportedOpError(
+                f"{self.kind} expects output dtype {input_dtype.onnx_name}, "
+                f"got {output_dtype.onnx_name}"
+            )
+
+    def infer_shapes(self, ctx: OpContext) -> None:
+        data_shape = ctx.shape(self._shape_data())
+        target_shape = self._shape_spec(ctx)
+        if self._shape_mode() == "expand":
+            output_shape = self._broadcast_shape(
+                data_shape, target_shape, kind=self.kind
+            )
+        else:
+            output_shape = target_shape
+        try:
+            expected = ctx.shape(self._shape_output())
+        except ShapeInferenceError:
+            expected = None
+        if expected is not None and expected != output_shape:
+            raise ShapeInferenceError(
+                f"{self.kind} output shape must be {output_shape}, got {expected}"
+            )
+        ctx.set_shape(self._shape_output(), output_shape)
+        self._shape_derived(
+            ctx,
+            data_shape=data_shape,
+            target_shape=target_shape,
+            output_shape=output_shape,
+        )
+
+
+class VariadicLikeOpBase(RenderableOpBase):
+    def _variadic_inputs(self) -> tuple[str, ...]:
+        raise NotImplementedError
+
+    def _variadic_output(self) -> str:
+        raise NotImplementedError
+
+    def _variadic_kind(self) -> str:
+        return self.kind
+
+    def _variadic_min_inputs(self) -> int:
+        return 2
+
+    def _variadic_max_inputs(self) -> int | None:
+        return None
+
+    def _variadic_compare(self) -> bool:
+        return False
+
+    def _variadic_supports_dtype(self, dtype: ScalarType) -> bool:
+        return True
+
+    def validate(self, ctx: OpContext) -> None:
+        inputs = self._variadic_inputs()
+        if any(not name for name in inputs):
+            raise UnsupportedOpError(
+                f"{self._variadic_kind()} input must be provided"
+            )
+        min_inputs = self._variadic_min_inputs()
+        max_inputs = self._variadic_max_inputs()
+        if len(inputs) < min_inputs:
+            raise UnsupportedOpError(
+                f"{self._variadic_kind()} must have at least {min_inputs} inputs"
+            )
+        if max_inputs is not None and len(inputs) != max_inputs:
+            raise UnsupportedOpError(
+                f"{self._variadic_kind()} must have exactly {max_inputs} inputs"
+            )
+        input_dtypes = tuple(ctx.dtype(name) for name in inputs)
+        if any(dtype != input_dtypes[0] for dtype in input_dtypes[1:]):
+            dtype_names = ", ".join(
+                dtype.onnx_name for dtype in input_dtypes
+            )
+            raise UnsupportedOpError(
+                f"{self._variadic_kind()} expects matching input dtypes, "
+                f"got {dtype_names}"
+            )
+        try:
+            output_dtype = ctx.dtype(self._variadic_output())
+        except ShapeInferenceError:
+            output_dtype = None
+        if output_dtype is not None:
+            if self._variadic_compare():
+                if output_dtype != ScalarType.BOOL:
+                    raise UnsupportedOpError(
+                        f"{self._variadic_kind()} expects bool output, "
+                        f"got {output_dtype.onnx_name}"
+                    )
+            elif output_dtype != input_dtypes[0]:
+                raise UnsupportedOpError(
+                    f"{self._variadic_kind()} expects output dtype "
+                    f"{input_dtypes[0].onnx_name}, got {output_dtype.onnx_name}"
+                )
+        if not self._variadic_supports_dtype(input_dtypes[0]):
+            raise UnsupportedOpError(
+                f"{self._variadic_kind()} does not support dtype "
+                f"{input_dtypes[0].onnx_name}"
+            )
+        return None
+
+    def infer_types(self, ctx: OpContext) -> None:
+        for name in self._variadic_inputs():
+            ctx.dtype(name)
+        try:
+            ctx.dtype(self._variadic_output())
+        except ShapeInferenceError:
+            ctx.set_dtype(
+                self._variadic_output(),
+                ctx.dtype(self._variadic_inputs()[0]),
+            )
+
+    def infer_shapes(self, ctx: OpContext) -> None:
+        input_shapes = tuple(ctx.shape(name) for name in self._variadic_inputs())
+        output_shape = BroadcastingOpBase.broadcast_shapes(*input_shapes)
+        for shape in input_shapes:
+            if shape != output_shape:
+                raise UnsupportedOpError(
+                    f"{self._variadic_kind()} expects identical input/output shapes"
+                )
+        try:
+            expected = ctx.shape(self._variadic_output())
+        except ShapeInferenceError:
+            expected = None
+        if expected is not None and expected != output_shape:
+            raise UnsupportedOpError(
+                f"{self._variadic_kind()} expects identical input/output shapes"
+            )
+        ctx.set_shape(self._variadic_output(), output_shape)
+
+
 class ReduceOpBase(RenderableOpBase):
     @staticmethod
     def normalize_axes(

emx_onnx_cgen/ir/ops/__init__.py

@@ -1,4 +1,12 @@
-from .elementwise import BinaryOp, ClipOp, IdentityOp, MultiInputBinaryOp, UnaryOp, WhereOp
+from .elementwise import (
+    BinaryOp,
+    ClipOp,
+    IdentityOp,
+    MultiInputBinaryOp,
+    UnaryOp,
+    VariadicOp,
+    WhereOp,
+)
 from .misc import (
     CastOp,
     ConcatOp,
@@ -126,5 +134,6 @@ __all__ = [
     "TransposeOp",
     "TriluOp",
     "UnaryOp",
+    "VariadicOp",
     "WhereOp",
 ]

emx_onnx_cgen/ir/ops/elementwise.py

@@ -5,8 +5,8 @@ from dataclasses import dataclass
 from shared.scalar_functions import ScalarFunction
 from shared.scalar_types import ScalarType
 
-from ...ops import COMPARE_FUNCTIONS, OperatorKind
-from ..op_base import ElementwiseOpBase
+from ...ops import COMPARE_FUNCTIONS, OperatorKind, binary_op_symbol
+from ..op_base import ElementwiseOpBase, VariadicLikeOpBase
 from ..op_context import OpContext
 
 
@@ -34,24 +34,45 @@ class BinaryOp(ElementwiseOpBase):
 
 
 @dataclass(frozen=True)
-class MultiInputBinaryOp(ElementwiseOpBase):
+class VariadicOp(VariadicLikeOpBase):
+    op_type: str
     inputs: tuple[str, ...]
     output: str
     function: ScalarFunction
     operator_kind: OperatorKind
-    shape: tuple[int, ...]
-    dtype: ScalarType
-    input_dtype: ScalarType
+    min_inputs: int = 2
+    max_inputs: int | None = None
 
-    def _elementwise_inputs(self) -> tuple[str, ...]:
+    def _variadic_inputs(self) -> tuple[str, ...]:
         return self.inputs
 
-    def _elementwise_output(self) -> str:
+    def _variadic_output(self) -> str:
         return self.output
 
-    def _elementwise_compare(self) -> bool:
+    def _variadic_kind(self) -> str:
+        return self.op_type
+
+    def _variadic_compare(self) -> bool:
         return self.function in COMPARE_FUNCTIONS
 
+    def _variadic_min_inputs(self) -> int:
+        return self.min_inputs
+
+    def _variadic_max_inputs(self) -> int | None:
+        return self.max_inputs
+
+    def _variadic_supports_dtype(self, dtype: ScalarType) -> bool:
+        return (
+            binary_op_symbol(
+                self.function, dtype=dtype, validate_attrs=False
+            )
+            is not None
+        )
+
+
+class MultiInputBinaryOp(VariadicOp):
+    pass
+
 
 @dataclass(frozen=True)
 class WhereOp(ElementwiseOpBase):

emx_onnx_cgen/ir/ops/misc.py

@@ -2,13 +2,29 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 
+import numpy as np
+
 from shared.scalar_types import ScalarType
 
-from ...errors import ShapeInferenceError
-from ..op_base import BroadcastingOpBase, RenderableOpBase
+from ...errors import ShapeInferenceError, UnsupportedOpError
+from ..op_base import (
+    BroadcastingOpBase,
+    GatherLikeOpBase,
+    RenderableOpBase,
+    ShapeLikeOpBase,
+)
 from ..op_context import OpContext
 
 
+def _compute_strides(shape: tuple[int, ...]) -> tuple[int, ...]:
+    strides: list[int] = []
+    stride = 1
+    for dim in reversed(shape):
+        strides.append(stride)
+        stride *= dim
+    return tuple(reversed(strides))
+
+
 @dataclass(frozen=True)
 class CastOp(RenderableOpBase):
     input0: str
@@ -59,16 +75,26 @@ class GatherElementsOp(RenderableOpBase):
     indices_dtype: ScalarType
 
 @dataclass(frozen=True)
-class GatherOp(RenderableOpBase):
+class GatherOp(GatherLikeOpBase):
     data: str
     indices: str
     output: str
     axis: int
-    data_shape: tuple[int, ...]
-    indices_shape: tuple[int, ...]
-    output_shape: tuple[int, ...]
-    dtype: ScalarType
-    indices_dtype: ScalarType
+
+    def _gather_data(self) -> str:
+        return self.data
+
+    def _gather_indices(self) -> str:
+        return self.indices
+
+    def _gather_output(self) -> str:
+        return self.output
+
+    def _gather_axis(self) -> int:
+        return self.axis
+
+    def _gather_mode(self) -> str:
+        return "gather"
 
 @dataclass(frozen=True)
 class GatherNDOp(RenderableOpBase):
@@ -360,15 +386,72 @@ class NonMaxSuppressionOp(RenderableOpBase):
     score_threshold_shape: tuple[int, ...] | None
 
 @dataclass(frozen=True)
-class ExpandOp(BroadcastingOpBase):
+class ExpandOp(ShapeLikeOpBase):
     input0: str
+    input_shape: str
     output: str
-    input_shape: tuple[int, ...]
-    output_shape: tuple[int, ...]
-    input_shape_padded: tuple[int, ...]
-    input_strides: tuple[int, ...]
-    dtype: ScalarType
-    input_dtype: ScalarType
+
+    def _shape_data(self) -> str:
+        return self.input0
+
+    def _shape_output(self) -> str:
+        return self.output
+
+    def _shape_mode(self) -> str:
+        return "expand"
+
+    def _shape_spec(self, ctx: OpContext) -> tuple[int, ...]:
+        initializer = ctx.initializer(self.input_shape)
+        if initializer is not None:
+            if initializer.type.dtype not in {ScalarType.I64, ScalarType.I32}:
+                raise UnsupportedOpError(
+                    f"{self.kind} shape input must be int64 or int32"
+                )
+            if len(initializer.type.shape) != 1:
+                raise UnsupportedOpError(
+                    f"{self.kind} shape input must be a 1D tensor"
+                )
+            values = np.array(initializer.data, dtype=np.int64).reshape(-1)
+            if values.size == 0:
+                raise ShapeInferenceError(
+                    f"{self.kind} shape input cannot be empty"
+                )
+            return tuple(int(value) for value in values)
+        dtype = ctx.dtype(self.input_shape)
+        if dtype not in {ScalarType.I64, ScalarType.I32}:
+            raise UnsupportedOpError(
+                f"{self.kind} shape input must be int64 or int32"
+            )
+        shape = ctx.shape(self.input_shape)
+        if len(shape) != 1:
+            raise UnsupportedOpError(
+                f"{self.kind} shape input must be a 1D tensor"
+            )
+        if shape[0] <= 0:
+            raise ShapeInferenceError(
+                f"{self.kind} shape input cannot be empty"
+            )
+        output_shape = ctx.shape(self.output)
+        if not output_shape:
+            raise ShapeInferenceError(
+                f"{self.kind} output shape must be specified"
+            )
+        return output_shape
+
+    def _shape_derived(
+        self,
+        ctx: OpContext,
+        *,
+        data_shape: tuple[int, ...],
+        target_shape: tuple[int, ...],
+        output_shape: tuple[int, ...],
+    ) -> None:
+        input_shape_padded = (
+            (1,) * (len(output_shape) - len(data_shape)) + data_shape
+        )
+        input_strides = _compute_strides(input_shape_padded)
+        ctx.set_derived(self, "input_shape_padded", input_shape_padded)
+        ctx.set_derived(self, "input_strides", input_strides)
 
 @dataclass(frozen=True)
 class CumSumOp(RenderableOpBase):

emx_onnx_cgen/lowering/expand.py

@@ -1,151 +1,17 @@
 from __future__ import annotations
 
-import numpy as np
-
-from shared.scalar_types import ScalarType
-
+from ..errors import UnsupportedOpError
+from ..ir.model import Graph, Node
 from ..ir.ops import ExpandOp
-from ..errors import ShapeInferenceError, UnsupportedOpError
-from ..ir.model import Graph, Initializer, Node
-from ..lowering.common import value_dtype, value_shape
 from .registry import register_lowering
 
 
-def _find_initializer(graph: Graph, name: str) -> Initializer | None:
-    for initializer in graph.initializers:
-        if initializer.name == name:
-            return initializer
-    return None
-
-
-def _read_shape_values(graph: Graph, name: str, node: Node) -> list[int] | None:
-    initializer = _find_initializer(graph, name)
-    if initializer is None:
-        return None
-    if initializer.type.dtype not in {ScalarType.I64, ScalarType.I32}:
-        raise UnsupportedOpError(
-            f"{node.op_type} shape input must be int64 or int32"
-        )
-    if len(initializer.type.shape) != 1:
-        raise UnsupportedOpError(
-            f"{node.op_type} shape input must be a 1D tensor"
-        )
-    values = np.array(initializer.data, dtype=np.int64).reshape(-1)
-    if values.size == 0:
-        raise ShapeInferenceError(
-            f"{node.op_type} shape input cannot be empty"
-        )
-    return [int(value) for value in values]
-
-
-def _validate_shape_input(graph: Graph, name: str, node: Node) -> None:
-    dtype = value_dtype(graph, name, node)
-    if dtype not in {ScalarType.I64, ScalarType.I32}:
-        raise UnsupportedOpError(
-            f"{node.op_type} shape input must be int64 or int32"
-        )
-    shape = value_shape(graph, name, node)
-    if len(shape) != 1:
-        raise UnsupportedOpError(
-            f"{node.op_type} shape input must be a 1D tensor"
-        )
-    if shape[0] <= 0:
-        raise ShapeInferenceError(
-            f"{node.op_type} shape input cannot be empty"
-        )
-
-
-def _validate_static_dims(shape: tuple[int, ...], node: Node) -> None:
-    if any(dim < 0 for dim in shape):
-        raise ShapeInferenceError(
-            f"{node.op_type} does not support dynamic dims"
-        )
-
-
-def _broadcast_shape(
-    input_shape: tuple[int, ...], shape_values: list[int], node: Node
-) -> tuple[int, ...]:
-    _validate_static_dims(input_shape, node)
-    for dim in shape_values:
-        if dim < 0:
-            raise ShapeInferenceError(
-                f"{node.op_type} does not support dynamic dims"
-            )
-    output_rank = max(len(input_shape), len(shape_values))
-    input_padded = (1,) * (output_rank - len(input_shape)) + input_shape
-    shape_padded = (1,) * (output_rank - len(shape_values)) + tuple(shape_values)
-    result: list[int] = []
-    for input_dim, shape_dim in zip(input_padded, shape_padded):
-        if input_dim == 1:
-            result.append(shape_dim)
-        elif shape_dim == 1:
-            result.append(input_dim)
-        elif input_dim == shape_dim:
-            result.append(input_dim)
-        else:
-            raise ShapeInferenceError(
-                f"{node.op_type} input shape {input_shape} is not "
-                f"broadcastable to {shape_values}"
-            )
-    return tuple(result)
-
-
-def _compute_strides(shape: tuple[int, ...]) -> tuple[int, ...]:
-    strides: list[int] = []
-    stride = 1
-    for dim in reversed(shape):
-        strides.append(stride)
-        stride *= dim
-    return tuple(reversed(strides))
-
-
 @register_lowering("Expand")
 def lower_expand(graph: Graph, node: Node) -> ExpandOp:
     if len(node.inputs) != 2 or len(node.outputs) != 1:
         raise UnsupportedOpError("Expand must have 2 inputs and 1 output")
-    input_shape = value_shape(graph, node.inputs[0], node)
-    output_shape = value_shape(graph, node.outputs[0], node)
-    input_dtype = value_dtype(graph, node.inputs[0], node)
-    output_dtype = value_dtype(graph, node.outputs[0], node)
-    if input_dtype != output_dtype:
-        raise UnsupportedOpError(
-            f"{node.op_type} expects matching input/output dtypes, "
-            f"got {input_dtype} and {output_dtype}"
-        )
-    shape_values = _read_shape_values(graph, node.inputs[1], node)
-    if shape_values is not None:
-        expected_output_shape = _broadcast_shape(input_shape, shape_values, node)
-        _validate_static_dims(expected_output_shape, node)
-        if output_shape and output_shape != expected_output_shape:
-            raise ShapeInferenceError(
-                f"{node.op_type} output shape must be {expected_output_shape}, "
-                f"got {output_shape}"
-            )
-    else:
-        _validate_shape_input(graph, node.inputs[1], node)
-        if not output_shape:
-            raise ShapeInferenceError(
-                f"{node.op_type} output shape must be specified"
-            )
-        expected_output_shape = _broadcast_shape(
-            input_shape, list(output_shape), node
-        )
-        if expected_output_shape != output_shape:
-            raise ShapeInferenceError(
-                f"{node.op_type} output shape must be {expected_output_shape}, "
-                f"got {output_shape}"
-            )
-    input_shape_padded = (
-        (1,) * (len(expected_output_shape) - len(input_shape)) + input_shape
-    )
-    input_strides = _compute_strides(input_shape_padded)
     return ExpandOp(
         input0=node.inputs[0],
+        input_shape=node.inputs[1],
         output=node.outputs[0],
-        input_shape=input_shape,
-        output_shape=expected_output_shape,
-        input_shape_padded=input_shape_padded,
-        input_strides=input_strides,
-        dtype=input_dtype,
-        input_dtype=input_dtype,
     )

emx_onnx_cgen/lowering/gather.py

@@ -1,13 +1,8 @@
 from __future__ import annotations
 
-from shared.scalar_types import ScalarType
-
 from ..ir.ops import GatherOp
-from ..errors import ShapeInferenceError, UnsupportedOpError
+from ..errors import UnsupportedOpError
 from ..ir.model import Graph, Node
-from ..validation import normalize_axis
-from .common import value_dtype as _value_dtype
-from .common import value_shape as _value_shape
 from .registry import register_lowering
 
 
@@ -16,33 +11,9 @@ def lower_gather(graph: Graph, node: Node) -> GatherOp:
     if len(node.inputs) != 2 or len(node.outputs) != 1:
         raise UnsupportedOpError("Gather must have 2 inputs and 1 output")
     data_name, indices_name = node.inputs
-    data_shape = _value_shape(graph, data_name, node)
-    indices_shape = _value_shape(graph, indices_name, node)
-    output_shape = _value_shape(graph, node.outputs[0], node)
-    axis = normalize_axis(int(node.attrs.get("axis", 0)), data_shape, node)
-    expected_output_shape = (
-        data_shape[:axis] + indices_shape + data_shape[axis + 1 :]
-    )
-    if output_shape != expected_output_shape:
-        raise ShapeInferenceError(
-            "Gather output shape must be "
-            f"{expected_output_shape}, got {output_shape}"
-        )
-    op_dtype = _value_dtype(graph, data_name, node)
-    indices_dtype = _value_dtype(graph, indices_name, node)
-    if indices_dtype not in {ScalarType.I64, ScalarType.I32}:
-        raise UnsupportedOpError(
-            "Gather indices must be int32 or int64, "
-            f"got {indices_dtype.onnx_name}"
-        )
     return GatherOp(
         data=data_name,
         indices=indices_name,
         output=node.outputs[0],
-        axis=axis,
-        data_shape=data_shape,
-        indices_shape=indices_shape,
-        output_shape=output_shape,
-        dtype=op_dtype,
-        indices_dtype=indices_dtype,
+        axis=int(node.attrs.get("axis", 0)),
     )

emx_onnx_cgen/lowering/variadic.py

@@ -1,14 +1,12 @@
 from __future__ import annotations
 
 from shared.scalar_functions import ScalarFunction
-from shared.scalar_types import ScalarType
 
-from ..ir.ops import MultiInputBinaryOp
 from ..errors import UnsupportedOpError
 from ..ir.model import Graph, Node
-from ..lowering.common import node_dtype, value_dtype, value_shape
+from ..ir.ops import MultiInputBinaryOp
 from ..lowering.registry import register_lowering
-from ..ops import binary_op_symbol
+from ..ops import OperatorKind
 
 VARIADIC_OP_FUNCTIONS: dict[str, ScalarFunction] = {
     "Sum": ScalarFunction.ADD,
@@ -32,62 +30,31 @@ BINARY_ONLY_OPS = {
     "BitwiseXor",
 }
 
-
-def _validate_inputs(
-    graph: Graph, node: Node, *, function: ScalarFunction
-) -> tuple[ScalarType, tuple[int, ...]]:
-    if len(node.outputs) != 1:
-        raise UnsupportedOpError(f"{node.op_type} must have 1 output")
-    if node.op_type in BINARY_ONLY_OPS:
-        if len(node.inputs) != 2:
-            raise UnsupportedOpError(
-                f"{node.op_type} must have exactly 2 inputs"
-            )
-    elif len(node.inputs) < 2:
-        raise UnsupportedOpError(
-            f"{node.op_type} must have at least 2 inputs"
-        )
-    for name in node.inputs:
-        if not name:
-            raise UnsupportedOpError(f"{node.op_type} input must be provided")
-    op_dtype = node_dtype(graph, node, *node.inputs, *node.outputs)
-    output_dtype = value_dtype(graph, node.outputs[0], node)
-    if op_dtype != output_dtype:
-        raise UnsupportedOpError(
-            f"{node.op_type} expects matching input/output dtypes, "
-            f"got {op_dtype.onnx_name} and {output_dtype.onnx_name}"
-        )
-    output_shape = value_shape(graph, node.outputs[0], node)
-    for name in node.inputs:
-        input_shape = value_shape(graph, name, node)
-        if input_shape != output_shape:
-            raise UnsupportedOpError(
-                f"{node.op_type} expects identical input/output shapes"
-            )
-    op_spec = binary_op_symbol(function, dtype=op_dtype, validate_attrs=False)
-    if op_spec is None:
-        raise UnsupportedOpError(
-            f"{node.op_type} does not support dtype {op_dtype.onnx_name}"
-        )
-    return op_dtype, output_shape
+VARIADIC_OP_OPERATOR_KINDS: dict[str, OperatorKind] = {
+    "Sum": OperatorKind.INFIX,
+    "Mean": OperatorKind.EXPR,
+    "Max": OperatorKind.FUNC,
+    "Min": OperatorKind.FUNC,
+    "And": OperatorKind.INFIX,
+    "Or": OperatorKind.INFIX,
+    "Xor": OperatorKind.INFIX,
+    "BitwiseAnd": OperatorKind.INFIX,
+    "BitwiseOr": OperatorKind.INFIX,
+    "BitwiseXor": OperatorKind.INFIX,
+}
 
 
 def _lower_variadic(graph: Graph, node: Node) -> MultiInputBinaryOp:
-    function = VARIADIC_OP_FUNCTIONS[node.op_type]
-    op_dtype, output_shape = _validate_inputs(graph, node, function=function)
-    op_spec = binary_op_symbol(function, dtype=op_dtype, validate_attrs=False)
-    if op_spec is None:
-        raise UnsupportedOpError(
-            f"{node.op_type} does not support dtype {op_dtype.onnx_name}"
-        )
+    if len(node.outputs) != 1:
+        raise UnsupportedOpError(f"{node.op_type} must have 1 output")
     return MultiInputBinaryOp(
+        op_type=node.op_type,
         inputs=tuple(node.inputs),
         output=node.outputs[0],
-        function=function,
-        operator_kind=op_spec.kind,
-        shape=output_shape,
-        dtype=op_dtype,
-        input_dtype=op_dtype,
+        function=VARIADIC_OP_FUNCTIONS[node.op_type],
+        operator_kind=VARIADIC_OP_OPERATOR_KINDS[node.op_type],
+        min_inputs=2,
+        max_inputs=2 if node.op_type in BINARY_ONLY_OPS else None,
     )
 
 

emx_onnx_cgen/runtime/evaluator.py

@@ -7,7 +7,9 @@ import numpy as np
 
 from shared.scalar_types import ScalarType
 from ..errors import ShapeInferenceError, UnsupportedOpError
+from ..ir.context import GraphContext
 from ..ir.model import Graph, Node
+from ..ir.op_context import OpContext
 from ..lowering.attention import resolve_attention_spec
 from ..lowering.average_pool import lower_average_pool, lower_global_average_pool
 from ..lowering.adagrad import lower_adagrad
@@ -2021,8 +2023,13 @@ def _eval_nonzero(evaluator: Evaluator, node: Node) -> None:
 def _eval_expand(evaluator: Evaluator, node: Node) -> None:
     op = lower_expand(evaluator.graph, node)
     value = evaluator.values[op.input0]
+    op_ctx = OpContext(GraphContext(evaluator.graph))
+    op.validate(op_ctx)
+    op.infer_types(op_ctx)
+    op.infer_shapes(op_ctx)
+    output_shape = op_ctx.shape(op.output)
     evaluator.values[op.output] = np.broadcast_to(
-        value, op.output_shape
+        value, output_shape
     ).copy()
 
 

{emx_onnx_cgen-0.3.3.dist-info → emx_onnx_cgen-0.3.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: emx-onnx-cgen
-Version: 0.3.3
+Version: 0.3.5
 Summary: emmtrix ONNX-to-C Code Generator
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{emx_onnx_cgen-0.3.3.dist-info → emx_onnx_cgen-0.3.5.dist-info}/RECORD

@@ -1,9 +1,9 @@
 emx_onnx_cgen/__init__.py,sha256=jUSbu1kJ0krzVTYEcph3jCprBhD7tWNtiSdL6r29KrM,221
 emx_onnx_cgen/__main__.py,sha256=iC1lLVtR6-TmpL6OxXcy3oIntExUtajn9-q627R1XyI,140
-emx_onnx_cgen/_build_info.py,sha256=W-LMY90LuY6_m3BNDTItdi_pO01vSSb1j-UK-NFUge0,112
-emx_onnx_cgen/_version.py,sha256=lemL_4Kl75FgrO6lVuFrrtw6-Dcf9wtXBalKkXuzkO4,704
+emx_onnx_cgen/_build_info.py,sha256=H1wVqVfVhPbohtf1JhkEW7F4rM6RzR1WlU9jrNMVYlE,112
+emx_onnx_cgen/_version.py,sha256=UAb2Toi6SAdScDfq1uKRRv5QpMUuRtJqqwNxTMGe5Q4,704
 emx_onnx_cgen/cli.py,sha256=7Y9JW-t1PLg25zOizuqyMqwsXbbG9ok99DsYeFSiOFQ,21685
-emx_onnx_cgen/compiler.py,sha256=qXKUQedaQY6A2jX-twte4qVA263T3UtCDlPjvoM5vYU,16513
+emx_onnx_cgen/compiler.py,sha256=v1-EzVUxZv5Kfn81kCDVuferRxvXFXEeRaNbQ4w6xss,18437
 emx_onnx_cgen/dtypes.py,sha256=jRx3BBvk0qFW14bngoL1B7L_IRasyNJ4jqhpM5YhcOM,1335
 emx_onnx_cgen/errors.py,sha256=HpOv95mTgr9ZX2gYe1RtwVMbPskh7zkqjU_FgAD-uIM,363
 emx_onnx_cgen/onnx_import.py,sha256=IF7KZGfEP9H4H1fHYjobGbB_381fqD_67KtqZYs9AZ4,9168
@@ -13,16 +13,16 @@ emx_onnx_cgen/testbench.py,sha256=-NbqD1aC7OXvFMLiLzd2IPObenQdHFH85cNxNSB1GeY,64
 emx_onnx_cgen/validation.py,sha256=KFdUdGjQbzTj1szCJcjxnTi8f5l6ywNgCB9abbBpTbM,2360
 emx_onnx_cgen/verification.py,sha256=IrhIMm29R2vEkW1Q8gtoQtscMGxfJRavNRSMJHBAJ5g,1041
 emx_onnx_cgen/codegen/__init__.py,sha256=H_kBdc_w_W-3qdUZJHwKBDns1AeP_Un3-46LW20yLV0,406
-emx_onnx_cgen/codegen/c_emitter.py,sha256=dS-vjjuWT0GHETbV3ipoYedvuvcJB0yGwMZgoQuJe-g,452931
+emx_onnx_cgen/codegen/c_emitter.py,sha256=JdDJGv1HptINaLLZxlxNfo1R7VM9v680EyiDMpeReds,453199
 emx_onnx_cgen/codegen/emitter.py,sha256=udcsqJNr46TFHiyVv5I4wdVH8ll6Bi4VqcR1VvofbnY,92
 emx_onnx_cgen/ir/__init__.py,sha256=fD2D8qxlGoCFJb0m9v6u3XTgzSxDOhB4cfLBiCLovzg,102
 emx_onnx_cgen/ir/context.py,sha256=cM3V6G3zs6VCsABP6TnZ8vvQ7VGwOF1iKtb1hq0WO3g,3356
 emx_onnx_cgen/ir/model.py,sha256=SZ3K8t4dKUqWuXWe5ozApofXx4bdcf4p0WYCdeU-mFA,1265
-emx_onnx_cgen/ir/op_base.py,sha256=mHvp0VD55JIrwQI2MFEmSILi22kuurBX085aamcjQ0g,6160
+emx_onnx_cgen/ir/op_base.py,sha256=_iPeVkLPR3jsRASrvXEWk-k3BJboPHtZY6jnB0HdLvk,17611
 emx_onnx_cgen/ir/op_context.py,sha256=9CZCUNJLsV4cJsYmJqWbaDrwQd4sr-9Ot1PmPSqGAto,2103
-emx_onnx_cgen/ir/ops/__init__.py,sha256=IcllGXB4T3TCrpBq9cy3jR_edS_IJ_qXac37K_rIZcA,2440
-emx_onnx_cgen/ir/ops/elementwise.py,sha256=sZ1S6X_fagNDevN6dXHBy75g_z-WP_dHFAVmPGnmeaU,3721
-emx_onnx_cgen/ir/ops/misc.py,sha256=1ekAgV5j6Stc1Yw8e-0EPD5t8mI1YJxmyIkAn9Zr4h8,10920
+emx_onnx_cgen/ir/ops/__init__.py,sha256=Zk7QzNiB4CHcixZlA1thA78mcudXdTvCfKlxUTRrX24,2503
+emx_onnx_cgen/ir/ops/elementwise.py,sha256=TXbyayj3UnfLe4tUYBEwBDr7ZFyFi1i8HdVdCjtvLCc,4241
+emx_onnx_cgen/ir/ops/misc.py,sha256=vN4OpW5gsryQ0aiVNBFiYlZMxwg8Z9wUOBM7w3f4ZFE,13522
 emx_onnx_cgen/ir/ops/nn.py,sha256=-4ZqDkcu7zgci3YVfMzCDzokqpZHgOYZaq_C1GclBZQ,14365
 emx_onnx_cgen/ir/ops/reduce.py,sha256=-aA4bwOMppd9pnWQwhl6hOxryh0G2xRaHqeNwQ97AdY,2756
 emx_onnx_cgen/lowering/__init__.py,sha256=AxnUfmpf5Teos1ms3zE6r0EBxxPYznGSOICDEFWH_pk,1535
@@ -42,10 +42,10 @@ emx_onnx_cgen/lowering/depth_space.py,sha256=i7INioNkofBxFlZW9y0W_qA6mp67_FAXouh
 emx_onnx_cgen/lowering/dropout.py,sha256=MZ4YrB-jvUFXpIKE5kOLyrEF5uy5dh0yjJH6Rj8KlMs,1764
 emx_onnx_cgen/lowering/einsum.py,sha256=MWAgWVOzP38RSOxJABwvYU6ykD9odmhrmddXinmFs7s,6117
 emx_onnx_cgen/lowering/elementwise.py,sha256=q9X3qTll7gLp39NTTdzuLs9RBsONssw50l1hWo8wby0,12229
-emx_onnx_cgen/lowering/expand.py,sha256=GmYJZWXXcBV42hMGUgbKKbLjeCxpbcMSoG9OU1ZkFFY,5518
+emx_onnx_cgen/lowering/expand.py,sha256=y0h1x2xh6Oqtblm6TbELB6_I4fsquU3YuZoB4mZJeTo,525
 emx_onnx_cgen/lowering/eye_like.py,sha256=QBiHWYZbgK4uiUYWuS7WHCMBGMSG0paNZM84OYmGb7c,1723
 emx_onnx_cgen/lowering/flatten.py,sha256=6h-TQNy9iq5hfXR9h2clUrc2eHmZP9gAb9KbCSJdV20,2131
-emx_onnx_cgen/lowering/gather.py,sha256=PCER36AjmpxzAM4wuL7En3XR1RKZCdSzjxualDCUHAI,1803
+emx_onnx_cgen/lowering/gather.py,sha256=3sxrld5GIS4OO3hRVp8QdbMtyLQUHbdCXL8vmZvh67c,599
 emx_onnx_cgen/lowering/gather_elements.py,sha256=cCp2UFOjktgEfS9s9npMS_BXklBkpMpD7UhIIMhQ-_Y,2318
 emx_onnx_cgen/lowering/gather_nd.py,sha256=rmr_ijeSeCrZ_R_QPwdoHPQUCe8nE0YRSv2NjUiiFjY,3090
 emx_onnx_cgen/lowering/gemm.py,sha256=qBaZ-6FZAAMEaZ4uifo58tJI8SoBsJvkZTCg7jvq288,4579
@@ -92,16 +92,16 @@ emx_onnx_cgen/lowering/topk.py,sha256=Dqx7qMr4HbXhVGN-wJf_D4dPTvYMVT6S82A2M3f9Dw
 emx_onnx_cgen/lowering/transpose.py,sha256=oNFRjkH63KqnO2Q4oJengEAUEYC1M3PW12AauWwebzI,1751
 emx_onnx_cgen/lowering/trilu.py,sha256=OjJjyo2ZRcfo9UGH8Zfq4o0PR6YDeoHSj8DzMu0w318,3266
 emx_onnx_cgen/lowering/unsqueeze.py,sha256=9y-OM-oY6ln1-R6duRRemeRrwBIpX2TZs_nRtlYQMYE,5985
-emx_onnx_cgen/lowering/variadic.py,sha256=etIWA7jVqWrWH3NkNvpF5opVGgvb0ZS4iLo4L3euWDs,3287
+emx_onnx_cgen/lowering/variadic.py,sha256=OrC3rwM3-SNewYRs7YA7DwwS8XW1ucxUobTEjZdEs4s,1823
 emx_onnx_cgen/lowering/where.py,sha256=K2RUDvLg0uTvi6Z_uTOXM5jgc3PXRj0cTZ4u58GEGko,2644
 emx_onnx_cgen/runtime/__init__.py,sha256=88xGpAs1IEBlzlWL_e9tnKUlaSRdc7pQUeVCu5LC4DY,50
-emx_onnx_cgen/runtime/evaluator.py,sha256=yqsBpAIlBky-rby7J5z7i1SvDaK6PjObxH-wQSdZ2G0,114732
+emx_onnx_cgen/runtime/evaluator.py,sha256=8d9GOzhYNs2XX5q4vjaTM-wxkf8_rE4QEf5e1USWGd8,114981
 shared/__init__.py,sha256=bmP79AVZdY_1aNULJap9pm76Q41Rabrza6X-0A8lDzw,45
 shared/scalar_functions.py,sha256=CErro1Du2Ri3uqX6Dgd18DzNbxduckAvsmLJ6oHGx9A,91123
 shared/scalar_types.py,sha256=kEpsl5T-NVFxCcTzXqPJbtpvDiCgKHfz91dphLLZxZA,4912
 shared/ulp.py,sha256=DpeovCFijmP8_M7zyTZWsNyfOtJ1AjNSdxf5jGsdfJo,1856
-emx_onnx_cgen-0.3.3.dist-info/METADATA,sha256=0joVoW9rki1TEClARZ0z235N-2ruM8R3mZ00zXGmR34,6266
-emx_onnx_cgen-0.3.3.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
-emx_onnx_cgen-0.3.3.dist-info/entry_points.txt,sha256=b7Rvmz_Bi9kWyn7QayQC_FEXiRpt4cS1RnluKh49yoo,57
-emx_onnx_cgen-0.3.3.dist-info/top_level.txt,sha256=g39fo-blEbgiVcC_GRqAnBzN234w3LXbcVdLUoItSLk,21
-emx_onnx_cgen-0.3.3.dist-info/RECORD,,
+emx_onnx_cgen-0.3.5.dist-info/METADATA,sha256=XwhvHTOcBPst7LPvgjPnR9hnVV8Jj0RtHtMITPMpAsA,6266
+emx_onnx_cgen-0.3.5.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+emx_onnx_cgen-0.3.5.dist-info/entry_points.txt,sha256=b7Rvmz_Bi9kWyn7QayQC_FEXiRpt4cS1RnluKh49yoo,57
+emx_onnx_cgen-0.3.5.dist-info/top_level.txt,sha256=g39fo-blEbgiVcC_GRqAnBzN234w3LXbcVdLUoItSLk,21
+emx_onnx_cgen-0.3.5.dist-info/RECORD,,