Fix reflected operators bug. Add test coverage for the rest of the arithmetic operators

Author: roaffix

arrayfire/array_api/_array_object.py

@@ -19,7 +19,7 @@
 from ._dtypes import int64 as af_int64
 from ._dtypes import supported_dtypes
 from ._dtypes import uint64 as af_uint64
-from ._utils import PointerSource, is_number, to_str
+from ._utils import PointerSource, to_str
 
 ShapeType = tuple[int, ...]
 _bcast_var = False  # HACK, TODO replace for actual bcast_var after refactoring
@@ -286,25 +286,25 @@ def __radd__(self, other: Array, /) -> Array:
         """
         Return other + self.
         """
-        return _process_c_function(self, other, backend.get().af_add)
+        return _process_c_function(other, self, backend.get().af_add)
 
     def __rsub__(self, other: Array, /) -> Array:
         """
         Return other - self.
         """
-        return _process_c_function(self, other, backend.get().af_sub)
+        return _process_c_function(other, self, backend.get().af_sub)
 
     def __rmul__(self, other: Array, /) -> Array:
         """
         Return other * self.
         """
-        return _process_c_function(self, other, backend.get().af_mul)
+        return _process_c_function(other, self, backend.get().af_mul)
 
     def __rtruediv__(self, other: Array, /) -> Array:
         """
         Return other / self.
         """
-        return _process_c_function(self, other, backend.get().af_div)
+        return _process_c_function(other, self, backend.get().af_div)
 
     def __rfloordiv__(self, other:  Array, /) -> Array:
         # TODO
@@ -314,13 +314,13 @@ def __rmod__(self, other: Array, /) -> Array:
         """
         Return other / self.
         """
-        return _process_c_function(self, other, backend.get().af_mod)
+        return _process_c_function(other, self, backend.get().af_mod)
 
     def __rpow__(self, other: Array, /) -> Array:
         """
         Return other ** self.
         """
-        return _process_c_function(self, other, backend.get().af_pow)
+        return _process_c_function(other, self, backend.get().af_pow)
 
     # Reflected Array Operators
 
@@ -334,31 +334,31 @@ def __rand__(self, other: Array, /) -> Array:
         """
         Return other & self.
         """
-        return _process_c_function(self, other, backend.get().af_bitand)
+        return _process_c_function(other, self, backend.get().af_bitand)
 
     def __ror__(self, other: Array, /) -> Array:
         """
         Return other & self.
         """
-        return _process_c_function(self, other, backend.get().af_bitor)
+        return _process_c_function(other, self, backend.get().af_bitor)
 
     def __rxor__(self, other: Array, /) -> Array:
         """
         Return other ^ self.
         """
-        return _process_c_function(self, other, backend.get().af_bitxor)
+        return _process_c_function(other, self, backend.get().af_bitxor)
 
     def __rlshift__(self, other: Array, /) -> Array:
         """
         Return other << self.
         """
-        return _process_c_function(self, other, backend.get().af_bitshiftl)
+        return _process_c_function(other, self, backend.get().af_bitshiftl)
 
     def __rrshift__(self, other: Array, /) -> Array:
         """
         Return other >> self.
         """
-        return _process_c_function(self, other, backend.get().af_bitshiftr)
+        return _process_c_function(other, self, backend.get().af_bitshiftr)
 
     # In-place Arithmetic Operators
 
@@ -614,20 +614,32 @@ def _str_to_dtype(value: int) -> Dtype:
 
 
 def _process_c_function(
-        target: Array, other: int | float | bool | complex | Array, c_function: Any) -> Array:
+        lhs: int | float | bool | complex | Array, rhs: int | float | bool | complex | Array,
+        c_function: Any) -> Array:
     out = Array()
 
-    # TODO discuss the difference between binary_func and binary_funcr
-    # because implementation looks like exectly the same.
-    # consider chaging to __iadd__ = __radd__ = __add__ interfce if no difference
-    if isinstance(other, Array):
-        safe_call(c_function(ctypes.pointer(out.arr), target.arr, other.arr, _bcast_var))
-    elif is_number(other):
-        other_dtype = _implicit_dtype(other, target.dtype)
-        other_array = _constant_array(other, CShape(*target.shape), other_dtype)
-        safe_call(c_function(ctypes.pointer(out.arr), target.arr, other_array.arr, _bcast_var))
+    if isinstance(lhs, Array) and isinstance(rhs, Array):
+        lhs_array = lhs.arr
+        rhs_array = rhs.arr
+
+    elif isinstance(lhs, Array) and isinstance(rhs, int | float | bool | complex):
+        rhs_dtype = _implicit_dtype(rhs, lhs.dtype)
+        rhs_constant_array = _constant_array(rhs, CShape(*lhs.shape), rhs_dtype)
+
+        lhs_array = lhs.arr
+        rhs_array = rhs_constant_array.arr
+
+    elif isinstance(lhs, int | float | bool | complex) and isinstance(rhs, Array):
+        lhs_dtype = _implicit_dtype(lhs, rhs.dtype)
+        lhs_constant_array = _constant_array(lhs, CShape(*rhs.shape), lhs_dtype)
+
+        lhs_array = lhs_constant_array.arr
+        rhs_array = rhs.arr
+
     else:
-        raise TypeError(f"{type(other)} is not supported and can not be passed to C binary function.")
+        raise TypeError(f"{type(rhs)} is not supported and can not be passed to C binary function.")
+
+    safe_call(c_function(ctypes.pointer(out.arr), lhs_array, rhs_array, _bcast_var))
 
     return out
 

arrayfire/array_api/_utils.py

@@ -1,6 +1,5 @@
 import ctypes
 import enum
-import numbers
 
 
 class PointerSource(enum.Enum):
@@ -14,7 +13,3 @@ class PointerSource(enum.Enum):
 
 def to_str(c_str: ctypes.c_char_p) -> str:
     return str(c_str.value.decode("utf-8"))  # type: ignore[union-attr]
-
-
-def is_number(number: int | float | bool | complex) -> bool:
-    return isinstance(number, numbers.Number)

arrayfire/array_api/tests/test_array_object.py

@@ -179,9 +179,6 @@ def setup_method(self, method: Any) -> None:
         self.tuple = (1, 2, 3)
         self.const_str = "15"
 
-    def teardown_method(self, method: Any) -> None:
-        self.array = Array(self.list)
-
     def test_add_int(self) -> None:
         res = self.array + self.const_int
         assert res[0].scalar() == 3
@@ -220,10 +217,10 @@ def test_add_inplace_and_reflected(self) -> None:
 
     def test_add_raises_type_error(self) -> None:
         with pytest.raises(TypeError):
-            Array([1, 2, 3]) + self.const_str  # type: ignore[operator]
+            self.array + self.const_str  # type: ignore[operator]
 
         with pytest.raises(TypeError):
-            Array([1, 2, 3]) + self.tuple  # type: ignore[operator]
+            self.array + self.tuple  # type: ignore[operator]
 
     # Test __sub__, __isub__, __rsub__
 
@@ -251,9 +248,13 @@ def test_sub_inplace_and_reflected(self) -> None:
         ires -= self.const_int
         rres = self.const_int - self.array  # type: ignore[operator]
 
-        assert res[0].scalar() == ires[0].scalar() == rres[0].scalar() == -1
-        assert res[1].scalar() == ires[1].scalar() == rres[1].scalar() == 0
-        assert res[2].scalar() == ires[2].scalar() == rres[2].scalar() == 1
+        assert res[0].scalar() == ires[0].scalar() == -1
+        assert res[1].scalar() == ires[1].scalar() == 0
+        assert res[2].scalar() == ires[2].scalar() == 1
+
+        assert rres[0].scalar() == 1
+        assert rres[1].scalar() == 0
+        assert rres[2].scalar() == -1
 
         assert res.dtype == ires.dtype == rres.dtype
         assert res.ndim == ires.ndim == rres.ndim