expr/arith: add type-generic max()/min()

Add a single type-generic max()/min() in expr/arith.py, modeled on
cutlass.max/min. Accepts any DSL numeric type (Float32/Int32/Int64/unsigned
...) and Python scalars, any number of args (max(a,b), max(a,b,c),
max([a,b,...]), max(a,[x,y])). Return type follows the operands' static types.

Dispatch reuses the shared numeric coercion (as_numeric + _coerce_operands)
and the resulting type:
  float         -> maximumf / minimumf  (NaN-propagating, matches cutlass)
  int signed    -> maxsi / minsi
  int unsigned  -> maxui / minui
Float fastmath follows the fast_fp_math compile hint. The maximum-vs-maxnum
choice is not exposed (matches cutlass). Registered in __all__ (fx.max/fx.min);
decorated with dsl_loc_tracing like the other builders.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: xudoyuan

python/flydsl/expr/arith.py

@@ -31,13 +31,16 @@
     "xori",
     "cmpi",
     "cmpf",
+    "max",
+    "min",
 ]
 
 # Override star-import cmpi/cmpf to accept Numeric types (Int32, etc.)
 from .._mlir.dialects import arith as _mlir_arith
 from .meta import dsl_loc_tracing
 from .utils.arith import (  # noqa: F401
     ArithValue,
+    _default_fastmath,
     _to_raw,
     andi,
     constant,
@@ -82,3 +85,63 @@ def cmpf(predicate, lhs, rhs, **kwargs):
         An ``i1`` comparison result.
     """
     return _mlir_arith.cmpf(predicate, _to_raw(lhs), _to_raw(rhs), **kwargs)
+
+
+# ── Type-generic max / min ──────────────────────────────────────────────────
+# One entry point for any DSL numeric type (Float32/Int32/Int64/unsigned/...) and
+# Python scalars, any number of args. Reuses the shared numeric coercion
+# (as_numeric + _coerce_operands) and dispatches by the resulting type:
+#   float          -> maximumf / minimumf   (NaN-propagating, matches cutlass.max)
+#   int, signed    -> maxsi / minsi
+#   int, unsigned  -> maxui / minui
+# The maximum-vs-maxnum choice is NOT exposed (matches cutlass). Return type
+# follows the operands' static type.
+
+
+def _minmax_pair(is_max, a, b):
+    from .numeric import _coerce_operands, as_numeric
+
+    a, b, out_ty = _coerce_operands(as_numeric(a), as_numeric(b))
+    lv, rv = a.ir_value(), b.ir_value()
+    if out_ty.is_float:
+        fn = _mlir_arith.maximumf if is_max else _mlir_arith.minimumf
+        res = fn(lv, rv, fastmath=_default_fastmath())
+    elif out_ty.signed:
+        fn = _mlir_arith.maxsi if is_max else _mlir_arith.minsi
+        res = fn(lv, rv)
+    else:
+        fn = _mlir_arith.maxui if is_max else _mlir_arith.minui
+        res = fn(lv, rv)
+    return out_ty(res)
+
+
+def _minmax(is_max, args):
+    flat = []
+    for a in args:
+        if isinstance(a, (list, tuple)):
+            flat.extend(a)
+        else:
+            flat.append(a)
+    if not flat:
+        raise ValueError("max()/min() requires at least one argument")
+    acc = flat[0]
+    for x in flat[1:]:
+        acc = _minmax_pair(is_max, acc, x)
+    return acc
+
+
+@dsl_loc_tracing
+def max(*args):
+    """Type-generic maximum over any number of DSL numeric args (and Python scalars).
+
+    Return type follows the operands' static types (not values). Accepts
+    ``max(a, b)``, ``max(a, b, c, ...)``, ``max([a, b, ...])``, ``max(a, [x, y])``.
+    Float uses NaN-propagating ``maximumf``; signed/unsigned int use ``maxsi``/``maxui``.
+    """
+    return _minmax(True, args)
+
+
+@dsl_loc_tracing
+def min(*args):
+    """Type-generic minimum. See :func:`max`."""
+    return _minmax(False, args)