Style changes and adding logical_or.reduce() functionality with Unary…

…RedCode.ANY Signed-off-by: Joseph Guman <[email protected]>

cunumeric/_ufunc/comparison.py

@@ -73,14 +73,15 @@
     "logical_and",
     BinaryOpCode.LOGICAL_AND,
     relation_types_of(all_dtypes),
-    red_code=UnaryRedCode.PROD,
+    red_code=UnaryRedCode.ALL,
 )
 
 logical_or = create_binary_ufunc(
     "Compute the truth value of x1 OR x2 element-wise.",
     "logical_or",
     BinaryOpCode.LOGICAL_OR,
     relation_types_of(all_dtypes),
+    red_code=UnaryRedCode.ANY,
 )
 
 logical_xor = create_binary_ufunc(

cunumeric/_ufunc/ufunc.py

@@ -756,9 +756,12 @@ def reduce(
         if self._op_code in [
             BinaryOpCode.LOGICAL_AND,
             BinaryOpCode.LOGICAL_OR,
-            BinaryOpCode.LOGICAL_XOR,
         ]:
-            array = array._astype(bool, temporary=True)
+            res_dtype = bool
+            if dtype is not None:
+                raise TypeError("Cannot set dtype on a logical reduction")
+        else:
+            res_dtype = None
 
         # NumPy seems to be using None as the default axis value for scalars
         if array.ndim == 0 and axis == 0:
@@ -774,6 +777,7 @@ def reduce(
             keepdims=keepdims,
             initial=initial,
             where=where,
+            res_dtype=res_dtype,
         )
 
 

tests/integration/test_fallback.py

@@ -28,8 +28,15 @@ def test_ufunc():
     in_num = num.array([0, 1, 2, 3])
     in_np = in_num.__array__()
 
-    out_num = np.logical_or.reduce(in_num)
-    out_np = np.logical_or.reduce(in_np)
+    # This test uses logical_xor.reduce because it is currently unimplemented,
+    # and we want to verify a behaviour of unimplemented ufunc methods. If
+    # logical_xor.reduce becomes implemented in the future, this assertion will
+    # start to fail, and a new (unimplemented) ufunc method should be found to
+    # replace it
+    assert not num.logical_and.accumulate._cunumeric.implemented
+
+    out_num = np.logical_and.accumulate(in_num)
+    out_np = np.logical_and.accumulate(in_np)
     assert np.array_equal(out_num, out_np)
 
 

tests/integration/test_logical_reduction.py

@@ -1,20 +1,22 @@
 import numpy as np
 import pytest
-from utils.comparisons import allclose
 
 import cunumeric as num
 
 
-def test_logical_and_reduce():
+@pytest.mark.parametrize("axis", [None, 0, 1, 2, (0, 1, 2)])
+def test_logical_reductions(axis):
     input = [[[12, 0, 1, 2], [9, 0, 0, 1]], [[0, 0, 0, 5], [1, 1, 1, 1]]]
     in_num = num.array(input)
     in_np = np.array(input)
 
-    axes = [None, 0, 1, 2, (0, 1, 2)]
-    for axis in axes:
-        out_num = num.logical_and.reduce(in_num, axis=axis)
-        out_np = np.logical_and.reduce(in_np, axis=axis)
-        assert allclose(out_num, out_np, check_dtype=True)
+    out_num = num.logical_and.reduce(in_num, axis=axis)
+    out_np = np.logical_and.reduce(in_np, axis=axis)
+    assert num.array_equal(out_num, out_np)
+
+    out_num = num.logical_or.reduce(in_num, axis=axis)
+    out_np = np.logical_or.reduce(in_np, axis=axis)
+    assert num.array_equal(out_num, out_np)
 
 
 if __name__ == "__main__":