address reviewer's comments

Author: Vahid Tavanashad

dpnp/dpnp_algo/dpnp_elementwise_common.py

@@ -979,19 +979,23 @@ def dpnp_not_equal(x1, x2, out=None, order="K"):
 """
 
 
+remainder_func = BinaryElementwiseFunc(
+    "remainder",
+    ti._remainder_result_type,
+    ti._remainder,
+    _remainder_docstring_,
+)
+
+
 def dpnp_remainder(x1, x2, out=None, order="K"):
     # dpctl.tensor only works with usm_ndarray or scalar
     x1_usm_or_scalar = dpnp.get_usm_ndarray_or_scalar(x1)
     x2_usm_or_scalar = dpnp.get_usm_ndarray_or_scalar(x2)
     out_usm = None if out is None else dpnp.get_usm_ndarray(out)
 
-    func = BinaryElementwiseFunc(
-        "remainder",
-        ti._remainder_result_type,
-        ti._remainder,
-        _remainder_docstring_,
+    res_usm = remainder_func(
+        x1_usm_or_scalar, x2_usm_or_scalar, out=out_usm, order=order
     )
-    res_usm = func(x1_usm_or_scalar, x2_usm_or_scalar, out=out_usm, order=order)
     return dpnp_array._create_from_usm_ndarray(res_usm)
 
 

dpnp/dpnp_iface_mathematical.py

@@ -220,7 +220,7 @@ def add(
     Parameters `x1` and `x2` are supported as either scalar, :class:`dpnp.ndarray`
     or :class:`dpctl.tensor.usm_ndarray`, but both `x1` and `x2` can not be scalars at the same time.
     Parameters `where`, `dtype` and `subok` are supported with their default values.
-    Keyword arguments ``kwargs`` are currently unsupported.
+    Keyword arguments `kwargs` are currently unsupported.
     Otherwise the function will be executed sequentially on CPU.
     Input array data types are limited by supported DPNP :ref:`Data types`.
 
@@ -626,14 +626,14 @@ def divide(
     Returns
     -------
     y : dpnp.ndarray
-        The quotient ``x1/x2``, element-wise.
+        The quotient `x1/x2`, element-wise.
 
     Limitations
     -----------
     Parameters `x1` and `x2` are supported as either scalar, :class:`dpnp.ndarray`
     or :class:`dpctl.tensor.usm_ndarray`, but both `x1` and `x2` can not be scalars at the same time.
-    Parameters `out`, `where`, `dtype` and `subok` are supported with their default values.
-    Keyword arguments ``kwargs`` are currently unsupported.
+    Parameters `where`, `dtype` and `subok` are supported with their default values.
+    Keyword arguments `kwargs` are currently unsupported.
     Otherwise the function will be executed sequentially on CPU.
     Input array data types are limited by supported DPNP :ref:`Data types`.
 
@@ -823,7 +823,7 @@ def floor_divide(
 
     See Also
     --------
-    :obj:`dpnp.reminder` : Remainder complementary to floor_divide.
+    :obj:`dpnp.remainder` : Remainder complementary to floor_divide.
     :obj:`dpnp.divide` : Standard division.
     :obj:`dpnp.floor` : Round a number to the nearest integer toward minus infinity.
     :obj:`dpnp.ceil` : Round a number to the nearest integer toward infinity.
@@ -910,7 +910,7 @@ def fmod(x1, x2, dtype=None, out=None, where=True, **kwargs):
 
     See Also
     --------
-    :obj:`dpnp.reminder` : Remainder complementary to floor_divide.
+    :obj:`dpnp.remainder` : Remainder complementary to floor_divide.
     :obj:`dpnp.divide` : Standard division.
 
     Examples
@@ -1137,16 +1137,36 @@ def minimum(x1, x2, dtype=None, out=None, where=True, **kwargs):
     )
 
 
-def mod(*args, **kwargs):
+def mod(
+    x1,
+    x2,
+    /,
+    out=None,
+    *,
+    where=True,
+    order="K",
+    dtype=None,
+    subok=True,
+    **kwargs,
+):
     """
     Compute element-wise remainder of division.
 
     For full documentation refer to :obj:`numpy.mod`.
 
+    Limitations
+    -----------
+    Parameters `x1` and `x2` are supported as either scalar, :class:`dpnp.ndarray`
+    or :class:`dpctl.tensor.usm_ndarray`, but both `x1` and `x2` can not be scalars at the same time.
+    Parameters `where`, `dtype` and `subok` are supported with their default values.
+    Keyword arguments `kwargs` are currently unsupported.
+    Otherwise the function will be executed sequentially on CPU.
+    Input array data types are limited by supported DPNP :ref:`Data types`.
+
     See Also
     --------
     :obj:`dpnp.fmod` : Calculate the element-wise remainder of division
-    :obj:`dpnp.reminder` : Remainder complementary to floor_divide.
+    :obj:`dpnp.remainder` : Remainder complementary to floor_divide.
     :obj:`dpnp.divide` : Standard division.
 
     Notes
@@ -1155,7 +1175,16 @@ def mod(*args, **kwargs):
 
     """
 
-    return dpnp.remainder(*args, **kwargs)
+    return dpnp.remainder(
+        x1,
+        x2,
+        out=out,
+        where=where,
+        order=order,
+        dtype=dtype,
+        subok=subok,
+        **kwargs,
+    )
 
 
 def modf(x1, **kwargs):
@@ -1602,18 +1631,20 @@ def remainder(
 
     Limitations
     -----------
-        Parameters ``x1`` and ``x2`` are supported as either :obj:`dpnp.ndarray`,
-        :class:`dpctl.tensor.usm_ndarray` or scalar.
-        Parameters `where`, `dtype` and `subok` are supported with their default values.
-        Keyword arguments `kwargs` are currently unsupported.
-        Otherwise the functions will be executed sequentially on CPU.
-        Input array data types are limited by supported DPNP :ref:`Data types`.
+    Parameters `x1` and `x2` are supported as either scalar, :class:`dpnp.ndarray`
+    or :class:`dpctl.tensor.usm_ndarray`, but both `x1` and `x2` can not be scalars at the same time.
+    Parameters `where`, `dtype` and `subok` are supported with their default values.
+    Keyword arguments `kwargs` are currently unsupported.
+    Otherwise the function will be executed sequentially on CPU.
+    Input array data types are limited by supported DPNP :ref:`Data types`.
 
     See Also
     --------
-        :obj:`dpnp.fmod` : Calculate the element-wise remainder of division.
-        :obj:`dpnp.divide` : Standard division.
-        :obj:`dpnp.floor` : Round a number to the nearest integer toward minus infinity.
+    :obj:`dpnp.fmod` : Calculate the element-wise remainder of division.
+    :obj:`dpnp.divide` : Standard division.
+    :obj:`dpnp.floor` : Round a number to the nearest integer toward minus infinity.
+    :obj:`dpnp.floor_divide` : Compute the largest integer smaller or equal to the division of the inputs.
+    :obj:`dpnp.mod` : Calculate the element-wise remainder of division.
 
     Example
     -------
@@ -1718,8 +1749,8 @@ def subtract(
     -----------
     Parameters `x1` and `x2` are supported as either scalar, :class:`dpnp.ndarray`
     or :class:`dpctl.tensor.usm_ndarray`, but both `x1` and `x2` can not be scalars at the same time.
-    Parameters `out`, `where`, `dtype` and `subok` are supported with their default values.
-    Keyword arguments ``kwargs`` are currently unsupported.
+    Parameters `where`, `dtype` and `subok` are supported with their default values.
+    Keyword arguments `kwargs` are currently unsupported.
     Otherwise the function will be executed sequentially on CPU.
     Input array data types are limited by supported DPNP :ref:`Data types`.
 

tests/test_mathematical.py

@@ -136,6 +136,12 @@ def _test_mathematical(self, name, dtype, lhs, rhs):
         else:
             result = getattr(dpnp, name)(a_dpnp, b_dpnp)
             expected = getattr(numpy, name)(a_np, b_np)
+            if (
+                name == "remainder"
+                and result.dtype != expected.dtype
+                and not has_support_aspect64()
+            ):
+                pytest.skip("skipping since output is promoted differently")
             assert_allclose(result, expected, rtol=1e-6)
 
     @pytest.mark.parametrize("dtype", get_all_dtypes())
@@ -210,9 +216,7 @@ def test_minimum(self, dtype, lhs, rhs):
     def test_multiply(self, dtype, lhs, rhs):
         self._test_mathematical("multiply", dtype, lhs, rhs)
 
-    @pytest.mark.parametrize(
-        "dtype", get_all_dtypes(no_bool=True, no_complex=True)
-    )
+    @pytest.mark.parametrize("dtype", get_all_dtypes(no_complex=True))
     def test_remainder(self, dtype, lhs, rhs):
         self._test_mathematical("remainder", dtype, lhs, rhs)
 

tests/test_strides.py

@@ -233,15 +233,30 @@ def test_strides_fmod(dtype, shape):
 
 @pytest.mark.parametrize("dtype", get_all_dtypes(no_bool=True, no_complex=True))
 @pytest.mark.parametrize("shape", [(3, 3)], ids=["(3, 3)"])
-def test_strides_true_devide(dtype, shape):
+def test_strides_true_divide(dtype, shape):
     a = numpy.arange(numpy.prod(shape), dtype=dtype).reshape(shape)
     b = a.T + 1
 
     dpa = dpnp.reshape(dpnp.arange(numpy.prod(shape), dtype=dtype), shape)
     dpb = dpa.T + 1
 
-    result = dpnp.fmod(dpa, dpb)
-    expected = numpy.fmod(a, b)
+    result = dpnp.true_divide(dpa, dpb)
+    expected = numpy.true_divide(a, b)
+
+    assert_allclose(result, expected, atol=1e-08)
+
+
+@pytest.mark.parametrize("dtype", get_all_dtypes(no_bool=True, no_complex=True))
+@pytest.mark.parametrize("shape", [(3, 3)], ids=["(3, 3)"])
+def test_strides_remainder(dtype, shape):
+    a = numpy.arange(numpy.prod(shape), dtype=dtype).reshape(shape)
+    b = a.T + 1
+
+    dpa = dpnp.reshape(dpnp.arange(numpy.prod(shape), dtype=dtype), shape)
+    dpb = dpa.T + 1
+
+    result = dpnp.remainder(dpa, dpb)
+    expected = numpy.remainder(a, b)
 
     assert_allclose(result, expected)
 

tests/test_usm_type.py

@@ -74,6 +74,20 @@ def test_coerced_usm_types_divide(usm_type_x, usm_type_y):
     assert z.usm_type == du.get_coerced_usm_type([usm_type_x, usm_type_y])
 
 
+@pytest.mark.parametrize("usm_type_x", list_of_usm_types, ids=list_of_usm_types)
+@pytest.mark.parametrize("usm_type_y", list_of_usm_types, ids=list_of_usm_types)
+def test_coerced_usm_types_remainder(usm_type_x, usm_type_y):
+    x = dp.arange(100, usm_type=usm_type_x).reshape(10, 10)
+    y = dp.arange(100, usm_type=usm_type_y).reshape(10, 10)
+    y = y.T + 1
+
+    z = x % y
+
+    assert x.usm_type == usm_type_x
+    assert y.usm_type == usm_type_y
+    assert z.usm_type == du.get_coerced_usm_type([usm_type_x, usm_type_y])
+
+
 @pytest.mark.parametrize("usm_type_x", list_of_usm_types, ids=list_of_usm_types)
 @pytest.mark.parametrize("usm_type_y", list_of_usm_types, ids=list_of_usm_types)
 def test_coerced_usm_types_power(usm_type_x, usm_type_y):

tests/third_party/cupy/math_tests/test_arithmetic.py

@@ -199,16 +199,6 @@ def check_binary(self, xp):
                     elif is_array_arg2 and not is_array_arg1:
                         y = y.astype(dtype2)
 
-        # NumPy returns different values (nan/inf) on division by zero
-        # depending on the architecture.
-        # As it is not possible for CuPy to replicate this behavior, we ignore
-        # the difference here.
-        # if self.name in ('floor_divide', 'remainder', 'mod'):
-        #     if y.dtype in (float_types + complex_types) and (np2 == 0).any():
-        #         y = xp.asarray(y)
-        #         y[y == numpy.inf] = numpy.nan
-        #        y[y == -numpy.inf] = numpy.nan
-
         return y