address comments

Author: vtavana

dpnp/dpnp_array.py

@@ -1026,9 +1026,7 @@ def prod(
         """
         Returns the prod along a given axis.
 
-        .. seealso::
-           :obj:`dpnp.prod` for full documentation,
-           :meth:`dpnp.dparray.sum`
+        For full documentation refer to :obj:`dpnp.prod`.
 
         """
 

dpnp/dpnp_iface_mathematical.py

@@ -1761,16 +1761,19 @@ def nanprod(
     where=True,
 ):
     """
-    Calculate prod() function treating 'Not a Numbers' (NaN) as ones.
+    Return the product of array elements over a given axis treating Not a Numbers (NaNs) as ones.
 
     For full documentation refer to :obj:`numpy.nanprod`.
 
     Returns
     -------
     out : dpnp.ndarray
-        Return the product of array elements over a given axis treating Not a Numbers (NaNs) as ones.
+        A new array holding the result is returned unless `out` is specified, in which case it is returned.
 
-    .. seealso:: :obj:`dpnp.prod` : Returns product across array propagating NaNs.
+    See Also
+    --------
+    :obj:`dpnp.prod` : Returns product across array propagating NaNs.
+    :obj:`dpnp.isnan` : Test element-wise for NaN and return result as a boolean array.
 
     Limitations
     -----------
@@ -1796,8 +1799,14 @@ def nanprod(
 
     """
 
-    mask = dpnp.isnan(a)
-    dpnp.copyto(a, 1, where=mask)
+    if issubclass(a.dtype.type, dpnp.inexact):
+        mask = dpnp.isnan(a)
+    else:
+        mask = None
+
+    if mask is not None:
+        a = dpnp.array(a, copy=True)
+        dpnp.copyto(a, 1, where=mask)
 
     return dpnp.prod(
         a,
@@ -2069,14 +2078,14 @@ def prod(
     where=True,
 ):
     """
-    Calculate product of array elements over a given axis.
+    Return the product of array elements over a given axis.
 
     For full documentation refer to :obj:`numpy.prod`.
 
     Returns
     -------
     out : dpnp.ndarray
-        Return the product of array elements over a given axis.
+        A new array holding the result is returned unless `out` is specified, in which case it is returned.
 
     Limitations
     -----------
@@ -2085,7 +2094,9 @@ def prod(
     Otherwise the function will be executed sequentially on CPU.
     Input array data types are limited by DPNP :ref:`Data types`.
 
-    .. seealso:: :obj:`dpnp.nanprod` : Return the product of array elements over a given axis treating Not a Numbers (NaNs) as ones.
+    See Also
+    --------
+    :obj:`dpnp.nanprod` : Return the product of array elements over a given axis treating Not a Numbers (NaNs) as ones.
 
     Examples
     --------
@@ -2116,7 +2127,7 @@ def prod(
         )
     _dtypes = (a.dtype, dtype)
     _any_complex = any(
-        dpt.isdtype(dpnp.dtype(dt), "complex floating") for dt in _dtypes
+        dpnp.issubdtype(dt, dpnp.complexfloating) for dt in _dtypes
     )
     device_mask = (
         du.intel_device_info(a.sycl_device).get("device_id", 0) & 0xFF00
@@ -2132,10 +2143,14 @@ def prod(
             initial=initial,
             where=where,
         )
-    if initial is not None:
-        pass
+    elif initial is not None:
+        raise NotImplementedError(
+            "initial keyword argument is only supported by its default value."
+        )
     elif where is not True:
-        pass
+        raise NotImplementedError(
+            "where keyword argument is only supported by its default value."
+        )
     else:
         dpt_array = dpnp.get_usm_ndarray(a)
         result = dpnp_array._create_from_usm_ndarray(
@@ -2163,17 +2178,6 @@ def prod(
 
             return out
 
-    return call_origin(
-        numpy.prod,
-        a,
-        axis=axis,
-        dtype=dtype,
-        out=out,
-        keepdims=keepdims,
-        initial=initial,
-        where=where,
-    )
-
 
 def proj(
     x,

tests/skipped_tests.tbl

@@ -616,10 +616,6 @@ tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodAxes_param_2
 tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodAxes_param_3_{axis=(0, 2, 3), shape=(20, 30, 40, 50)}::test_nansum_axes
 tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodExtra_param_0_{shape=(2, 3, 4)}::test_nansum_out
 tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodExtra_param_1_{shape=(20, 30, 40)}::test_nansum_out
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_11_{axis=0, func='nanprod', keepdims=True, shape=(20, 30, 40), transpose_axes=False}::test_nansum_all
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_11_{axis=0, func='nanprod', keepdims=True, shape=(20, 30, 40), transpose_axes=False}::test_nansum_axis_transposed
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_15_{axis=0, func='nanprod', keepdims=False, shape=(20, 30, 40), transpose_axes=False}::test_nansum_all
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_15_{axis=0, func='nanprod', keepdims=False, shape=(20, 30, 40), transpose_axes=False}::test_nansum_axis_transposed
 
 tests/third_party/cupy/math_tests/test_trigonometric.py::TestUnwrap::test_unwrap_1dim
 tests/third_party/cupy/math_tests/test_trigonometric.py::TestUnwrap::test_unwrap_1dim_with_discont

tests/skipped_tests_gpu.tbl

@@ -711,10 +711,6 @@ tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodAxes_param_2
 tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodAxes_param_3_{axis=(0, 2, 3), shape=(20, 30, 40, 50)}::test_nansum_axes
 tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodExtra_param_0_{shape=(2, 3, 4)}::test_nansum_out
 tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodExtra_param_1_{shape=(20, 30, 40)}::test_nansum_out
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_11_{axis=0, func='nanprod', keepdims=True, shape=(20, 30, 40), transpose_axes=False}::test_nansum_all
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_11_{axis=0, func='nanprod', keepdims=True, shape=(20, 30, 40), transpose_axes=False}::test_nansum_axis_transposed
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_15_{axis=0, func='nanprod', keepdims=False, shape=(20, 30, 40), transpose_axes=False}::test_nansum_all
-tests/third_party/cupy/math_tests/test_sumprod.py::TestNansumNanprodLong_param_15_{axis=0, func='nanprod', keepdims=False, shape=(20, 30, 40), transpose_axes=False}::test_nansum_axis_transposed
 
 tests/third_party/cupy/math_tests/test_trigonometric.py::TestUnwrap::test_unwrap_1dim
 tests/third_party/cupy/math_tests/test_trigonometric.py::TestUnwrap::test_unwrap_1dim_with_discont

tests/test_mathematical.py

@@ -461,15 +461,18 @@ def test_positive_boolean():
         dpnp.positive(dpnp_a)
 
 
+@pytest.mark.parametrize("func", ["prod", "nanprod"])
 @pytest.mark.parametrize("axis", [None, 0, 1, -1, 2, -2, (1, 2), (0, -2)])
 @pytest.mark.parametrize("keepdims", [False, True])
 @pytest.mark.parametrize("dtype", get_all_dtypes(no_bool=True))
-def test_prod(axis, keepdims, dtype):
+def test_prod_nanprod(func, axis, keepdims, dtype):
     a = numpy.arange(1, 13, dtype=dtype).reshape((2, 2, 3))
+    if func == "nanprod" and issubclass(a.dtype.type, dpnp.inexact):
+        a[1:2:] = numpy.nan
     ia = dpnp.array(a)
 
-    np_res = numpy.prod(a, axis=axis, keepdims=keepdims)
-    dpnp_res = dpnp.prod(ia, axis=axis, keepdims=keepdims)
+    np_res = getattr(numpy, func)(a, axis=axis, keepdims=keepdims)
+    dpnp_res = getattr(dpnp, func)(ia, axis=axis, keepdims=keepdims)
 
     assert dpnp_res.shape == np_res.shape
     assert_allclose(dpnp_res, np_res)
@@ -487,107 +490,74 @@ def test_prod_zero_size(axis):
     assert_allclose(dpnp_res, np_res)
 
 
-@pytest.mark.parametrize("axis", [None, 0, 1, -1, 2, -2, (1, 2), (0, -2)])
-@pytest.mark.parametrize("keepdims", [False, True])
-@pytest.mark.parametrize("dtype", get_float_complex_dtypes())
-def test_nanprod(axis, keepdims, dtype):
-    a = numpy.arange(1, 13, dtype=dtype).reshape((2, 2, 3))
-    a[1:2:] = numpy.nan
-    ia = dpnp.array(a)
-
-    np_res = numpy.nanprod(a, axis=axis, keepdims=keepdims)
-    dpnp_res = dpnp.nanprod(ia, axis=axis, keepdims=keepdims)
-
-    assert dpnp_res.shape == np_res.shape
-    assert_allclose(dpnp_res, np_res)
-
-
+@pytest.mark.parametrize("func", ["prod", "nanprod"])
 @pytest.mark.parametrize("axis", [None, 0, 1, -1])
 @pytest.mark.parametrize("keepdims", [False, True])
-def test_prod_bool(axis, keepdims):
+def test_prod_nanprod_bool(func, axis, keepdims):
     a = numpy.arange(2, dtype=dpnp.bool)
     a = numpy.tile(a, (2, 2))
     ia = dpnp.array(a)
 
-    np_res = numpy.prod(a, axis=axis, keepdims=keepdims)
-    dpnp_res = dpnp.prod(ia, axis=axis, keepdims=keepdims)
+    np_res = getattr(numpy, func)(a, axis=axis, keepdims=keepdims)
+    dpnp_res = getattr(dpnp, func)(ia, axis=axis, keepdims=keepdims)
 
     assert dpnp_res.shape == np_res.shape
     assert_allclose(dpnp_res, np_res)
 
 
+@pytest.mark.usefixtures("suppress_complex_warning")
+@pytest.mark.usefixtures("suppress_invalid_numpy_warnings")
+@pytest.mark.parametrize("func", ["prod", "nanprod"])
 @pytest.mark.parametrize("in_dtype", get_all_dtypes(no_bool=True))
 @pytest.mark.parametrize("out_dtype", get_all_dtypes(no_bool=True))
-def test_prod_dtype(in_dtype, out_dtype):
+def test_prod_nanprod_dtype(func, in_dtype, out_dtype):
     a = numpy.arange(1, 13, dtype=in_dtype).reshape((2, 2, 3))
+    if func == "nanprod" and issubclass(a.dtype.type, dpnp.inexact):
+        a[1:2:] = numpy.nan
     ia = dpnp.array(a)
 
-    np_res = numpy.prod(a, dtype=out_dtype)
-    dpnp_res = dpnp.prod(ia, dtype=out_dtype)
+    np_res = getattr(numpy, func)(a, dtype=out_dtype)
+    dpnp_res = getattr(dpnp, func)(ia, dtype=out_dtype)
 
     if out_dtype is not None:
         assert dpnp_res.dtype == out_dtype
     assert_allclose(dpnp_res, np_res)
 
 
-@pytest.mark.parametrize("in_dtype", get_float_complex_dtypes())
-@pytest.mark.parametrize("out_dtype", get_float_complex_dtypes())
-def test_nanprod_dtype(in_dtype, out_dtype):
-    a = numpy.arange(1, 13, dtype=in_dtype).reshape((2, 2, 3))
-    a[1:2:] = numpy.nan
-    ia = dpnp.array(a)
-
-    np_res = numpy.nanprod(a, dtype=out_dtype)
-    dpnp_res = dpnp.nanprod(ia, dtype=out_dtype)
-
-    if out_dtype is not None:
-        assert dpnp_res.dtype == out_dtype
-    assert_allclose(dpnp_res, np_res)
-
-
-def test_prod_out():
+@pytest.mark.parametrize("func", ["prod", "nanprod"])
+def test_prod_nanprod_out(func):
     a = numpy.arange(1, 7).reshape((2, 3))
+    if func == "nanprod" and issubclass(a.dtype.type, dpnp.inexact):
+        a[1:2:] = numpy.nan
     ia = dpnp.array(a)
 
-    np_res = numpy.prod(a, axis=0)
+    np_res = getattr(numpy, func)(a, axis=0)
     dpnp_res = dpnp.array(numpy.empty_like(np_res))
-    dpnp.prod(ia, axis=0, out=dpnp_res)
+    getattr(dpnp, func)(ia, axis=0, out=dpnp_res)
     assert_allclose(dpnp_res, np_res)
 
     dpnp_res = dpt.asarray(numpy.empty_like(np_res))
-    dpnp.prod(ia, axis=0, out=dpnp_res)
+    getattr(dpnp, func)(ia, axis=0, out=dpnp_res)
     assert_allclose(dpnp_res, np_res)
 
     dpnp_res = numpy.empty_like(np_res)
     with pytest.raises(TypeError):
-        dpnp.prod(ia, axis=0, out=dpnp_res)
+        getattr(dpnp, func)(ia, axis=0, out=dpnp_res)
 
     dpnp_res = dpnp.array(numpy.empty((2, 3)))
     with pytest.raises(ValueError):
-        dpnp.prod(ia, axis=0, out=dpnp_res)
+        getattr(dpnp, func)(ia, axis=0, out=dpnp_res)
 
 
-def test_nanprod_out():
-    a = numpy.arange(1, 7, dtype=float).reshape((2, 3))
-    a[1:2:] = numpy.nan
-    ia = dpnp.array(a)
-
-    np_res = numpy.prod(a, axis=0)
-    dpnp_res = dpnp.array(numpy.empty_like(np_res))
-    dpnp.prod(ia, axis=0, out=dpnp_res)
-    assert_allclose(dpnp_res, np_res)
+def test_prod_Error():
+    ia = dpnp.arange(5)
 
-    dpnp_res = dpt.asarray(numpy.empty_like(np_res))
-    dpnp.prod(ia, axis=0, out=dpnp_res)
-    assert_allclose(dpnp_res, np_res)
-
-    dpnp_res = numpy.empty_like(np_res)
     with pytest.raises(TypeError):
-        dpnp.prod(ia, axis=0, out=dpnp_res)
-
-    dpnp_res = dpnp.array(numpy.empty((2, 3)))
-    with pytest.raises(ValueError):
-        dpnp.prod(ia, axis=0, out=dpnp_res)
+        dpnp.prod(dpnp.asnumpy(ia))
+    with pytest.raises(NotImplementedError):
+        dpnp.prod(ia, where=False)
+    with pytest.raises(NotImplementedError):
+        dpnp.prod(ia, initial=6)
 
 
 @pytest.mark.parametrize(

tests/test_usm_type.py

@@ -348,6 +348,7 @@ def test_meshgrid(usm_type_x, usm_type_y):
         pytest.param("log10", [1.0, 2.0, 4.0, 7.0]),
         pytest.param("log1p", [1.0e-10, 1.0, 2.0, 4.0, 7.0]),
         pytest.param("log2", [1.0, 2.0, 4.0, 7.0]),
+        pytest.param("nanprod", [1.0, 2.0, dp.nan]),
         pytest.param("negative", [1.0, 0.0, -1.0]),
         pytest.param("positive", [1.0, 0.0, -1.0]),
         pytest.param("prod", [1.0, 2.0]),

tests/third_party/cupy/math_tests/test_sumprod.py

@@ -267,6 +267,17 @@ def _numpy_nanprod_implemented(self):
         )
 
     def _test(self, xp, dtype):
+        if (
+            self.func == "nanprod"
+            and self.shape == (20, 30, 40)
+            and has_support_aspect64()
+        ):
+            # If input type is float, NumPy returns the same data type but
+            # dpctl (and dpnp) returns default platform float following array api.
+            # When input is `float32` and output is a very large number, dpnp returns
+            # the number because it is `float64` but NumPy returns `inf` since it is `float32`.
+            pytest.skip("Output is a very large number.")
+
         a = testing.shaped_arange(self.shape, xp, dtype)
         if self.transpose_axes:
             a = a.transpose(2, 0, 1)