Revised any, all, min, max interfaces according to the recent review comments.

- Fixed return_type registration for above 4
- Fixed init_value registration for any, all
- Adjusted min, max init_value registration in algebra.py

Author: siyi-hu

src/finch/algebra/algebra.py

@@ -179,6 +179,8 @@ def return_type(op: Any, *args: Any) -> Any:
     operator.and_: ("__and__", "__rand__"),
     operator.xor: ("__xor__", "__rxor__"),
     operator.or_: ("__or__", "__ror__"),
+    min: ("__add__", "__radd__"),
+    max: ("__sub__", "__rsub__"),
 }
 
 
@@ -211,21 +213,6 @@ def _return_type_closure(a, b):
         register_property(T, meth, "return_type", _return_type_reflexive(meth))
         register_property(T, rmeth, "return_type", _return_type_reflexive(rmeth))
 
-register_property(
-    min,
-    "__call__",
-    "return_type",
-    lambda op, a, b: query_property(a, "__add__", "return_type", b),
-)
-register_property(
-    max,
-    "__call__",
-    "return_type",
-    lambda op, a, b: query_property(a, "__add__", "return_type", b),
-)
-register_property(any, "__call__", "return_type", lambda op, a, b: bool)
-register_property(all, "__call__", "return_type", lambda op, a, b: bool)
-
 
 _unary_operators: dict[Callable, str] = {
     operator.abs: "__abs__",
@@ -421,34 +408,6 @@ def init_value(op, arg) -> Any:
     register_property(T, "__or__", "init_value", lambda a, b: a(False))
 
 
-def _min_init(arg):
-    dtype = np.dtype(arg) if isinstance(arg, np.ndarray) else np.dtype(arg)
-    if np.issubdtype(dtype, np.floating):
-        return math.inf
-    if np.issubdtype(dtype, np.integer):
-        return np.iinfo(dtype).max
-    if np.issubdtype(dtype, np.bool_):
-        return True
-    raise TypeError("Unsupported dtype for min")
-
-
-def _max_init(arg):
-    dtype = np.dtype(arg) if isinstance(arg, np.ndarray) else np.dtype(arg)
-    if np.issubdtype(dtype, np.floating):
-        return -math.inf
-    if np.issubdtype(dtype, np.integer):
-        return np.iinfo(dtype).min
-    if np.issubdtype(dtype, np.bool_):
-        return False
-    raise TypeError("Unsupported dtype for max")
-
-
-register_property(
-    min, "__call__", "init_value", lambda op, arg: _min_init(element_type(arg))
-)
-register_property(
-    max, "__call__", "init_value", lambda op, arg: _max_init(element_type(arg))
-)
-register_property(any, "__call__", "init_value", lambda op, arg: False)
-register_property(all, "__call__", "init_value", lambda op, arg: True)
+register_property(min, "__call__", "init_value", lambda op, arg: math.inf)
+register_property(max, "__call__", "init_value", lambda op, arg: -math.inf)
 register_property(operator.truth, "__call__", "init_value", lambda op, arg: True)

src/finch/interface/lazy.py

@@ -496,8 +496,7 @@ def any(
     """
     Test whether any element of input array ``x`` along given axis is True.
     """
-    if init is None:
-        init = init_value(builtins.any, x)
+    x = defer(x)
     return reduce(
         operator.or_,
         elementwise(operator.truth, x),
@@ -518,8 +517,7 @@ def all(
     """
     Test whether all elements of input array ``x`` along given axis are True.
     """
-    if init is None:
-        init = init_value(builtins.all, x)
+    x = defer(x)
     return reduce(
         operator.and_,
         elementwise(operator.truth, x),
@@ -540,8 +538,7 @@ def min(
     """
     Return the minimum of input array ``arr`` along given axis.
     """
-    if init is None:
-        init = init_value(builtins.min, x)
+    x = defer(x)
     return reduce(builtins.min, x, axis=axis, keepdims=keepdims, init=init)
 
 
@@ -556,6 +553,5 @@ def max(
     """
     Return the maximum of input array ``arr`` along given axis.
     """
-    if init is None:
-        init = init_value(builtins.max, x)
+    x = defer(x)
     return reduce(builtins.max, x, axis=axis, keepdims=keepdims, init=init)

tests/test_reduce_api_funcs.py

@@ -26,8 +26,6 @@ def output_term(args):
 @pytest.mark.parametrize(
     "finch_op, np_op",
     [
-        (finch.prod, np.prod),
-        # (finch.sum,  np.sum),
         (finch.any, np.any),
         (finch.all, np.all),
         (finch.min, np.min),
@@ -43,7 +41,7 @@ def output_term(args):
         (0, 1),
     ],
 )
-def test_reduction_api_bitwise(a, finch_op, np_op, axis):
+def test_reduction_api_boolean(a, finch_op, np_op, axis):
     result = finch_op(a, axis=axis)
     expected = np_op(a, axis=axis)
     assert_equal(result, expected)
@@ -52,10 +50,10 @@ def test_reduction_api_bitwise(a, finch_op, np_op, axis):
 @pytest.mark.parametrize(
     "a",
     [
-        (np.array([[2, 0], [1, 3]])),
-        (np.array([[2, 3, 4], [5, 6, 7]])),
+        (np.array([[2, 0], [-1, 3]])),
+        (np.array([[2, 3, 4], [5, -6, 7]])),
         (np.array([[1, 0, 3, 8], [0, 0, 10, 0]])),
-        (np.array([[100, 14, 9, 78], [44, 3, 5, 10]])),
+        (np.array([[100, -14, 9, 78], [-44, 3, 5, 10]])),
     ],
 )
 @pytest.mark.parametrize(
@@ -82,8 +80,9 @@ def test_reduction_api_integer(a, finch_op, np_op, axis):
 @pytest.mark.parametrize(
     "a",
     [
+        (np.array([[1.00002, -12.618, 0, 0.001], [-1.414, -5.01, 0, 0]])),
         (np.array([[0, 0.618, 0, 0.001], [0, 0.01, 0, 0]])),
-        (np.array([[10000.0, 1.0, 89.0, 78], [401.0, 3, 5, 10.2]])),
+        (np.array([[10000.0, 1.0, -89.0, 78], [401.0, 3, 5, 10.2]])),
     ],
 )
 @pytest.mark.parametrize(