Implement dpnp.nextafter

Author: antonwolfy

dpnp/dpnp_iface_mathematical.py

@@ -111,6 +111,7 @@
     "modf",
     "multiply",
     "negative",
+    "nextafter",
     "positive",
     "power",
     "prod",
@@ -2359,6 +2360,63 @@ def modf(x1, **kwargs):
 )
 
 
+_NEXTAFTER_DOCSTRING = """
+Return the next floating-point value after `x1` towards `x2`, element-wise.
+
+For full documentation refer to :obj:`numpy.nextafter`.
+
+Parameters
+----------
+x1 : {dpnp.ndarray, usm_ndarray, scalar}
+    Values to find the next representable value of.
+    Both inputs `x1` and `x2` can not be scalars at the same time.
+x2 : {dpnp.ndarray, usm_ndarray, scalar}
+    The direction where to look for the next representable value of `x1`.
+    Both inputs `x1` and `x2` can not be scalars at the same time.
+out : {None, dpnp.ndarray, usm_ndarray}, optional
+    Output array to populate. Array must have the correct shape and
+    the expected data type.
+    Default: ``None``.
+order : {"C", "F", "A", "K"}, optional
+    Output array, if parameter `out` is ``None``.
+    Default: ``"K"``.
+
+Returns
+-------
+out : dpnp.ndarray
+    The next representable values of `x1` in the direction of `x2`. The data
+    type of the returned array is determined by the Type Promotion Rules.
+
+Limitations
+-----------
+Parameters `where` and `subok` are supported with their default values.
+Keyword argument `kwargs` is currently unsupported.
+Otherwise ``NotImplementedError`` exception will be raised.
+
+Examples
+--------
+>>> import dpnp as np
+>>> eps = np.finfo(np.float64).eps
+>>> np.nextafter(np.array(1), 2) == eps + 1
+array(True)
+
+>>> a = np.array([1, 2])
+>>> b = np.array([2, 1])
+>>> c = np.array([eps + 1, 2 - eps])
+>>> np.nextafter(a, b) == c
+array([ True,  True])
+"""
+
+nextafter = DPNPBinaryFunc(
+    "nextafter",
+    ti._nextafter_result_type,
+    ti._nextafter,
+    _NEXTAFTER_DOCSTRING,
+    # mkl_fn_to_call=vmi._mkl_nextafter_to_call,
+    # mkl_impl_fn=vmi._nextafter,
+)
+
+
 _POSITIVE_DOCSTRING = """
 Computes the numerical positive for each element `x_i` of input array `x`.
 

tests/skipped_tests.tbl

@@ -57,8 +57,6 @@ tests/test_umath.py::test_umaths[('ldexp', 'di')]
 tests/test_umath.py::test_umaths[('ldexp', 'dl')]
 tests/test_umath.py::test_umaths[('logaddexp2', 'ff')]
 tests/test_umath.py::test_umaths[('logaddexp2', 'dd')]
-tests/test_umath.py::test_umaths[('nextafter', 'ff')]
-tests/test_umath.py::test_umaths[('nextafter', 'dd')]
 tests/test_umath.py::test_umaths[('spacing', 'f')]
 tests/test_umath.py::test_umaths[('spacing', 'd')]
 
@@ -217,11 +215,6 @@ tests/third_party/cupy/manipulation_tests/test_dims.py::TestInvalidBroadcast_par
 tests/third_party/cupy/math_tests/test_explog.py::TestExplog::test_logaddexp2
 tests/third_party/cupy/math_tests/test_explog.py::TestExplog::test_logaddexp2_infinities
 
-tests/third_party/cupy/math_tests/test_floating.py::TestFloating::test_frexp
-tests/third_party/cupy/math_tests/test_floating.py::TestFloating::test_ldexp
-tests/third_party/cupy/math_tests/test_floating.py::TestFloating::test_nextafter_combination
-tests/third_party/cupy/math_tests/test_floating.py::TestFloating::test_nextafter_float
-
 tests/third_party/cupy/math_tests/test_misc.py::TestMisc::test_nan_to_num
 tests/third_party/cupy/math_tests/test_misc.py::TestMisc::test_nan_to_num_negative
 tests/third_party/cupy/math_tests/test_misc.py::TestMisc::test_nan_to_num_for_old_numpy

tests/skipped_tests_gpu.tbl

@@ -37,8 +37,6 @@ tests/test_umath.py::test_umaths[('ldexp', 'di')]
 tests/test_umath.py::test_umaths[('ldexp', 'dl')]
 tests/test_umath.py::test_umaths[('logaddexp2', 'ff')]
 tests/test_umath.py::test_umaths[('logaddexp2', 'dd')]
-tests/test_umath.py::test_umaths[('nextafter', 'ff')]
-tests/test_umath.py::test_umaths[('nextafter', 'dd')]
 tests/test_umath.py::test_umaths[('spacing', 'f')]
 tests/test_umath.py::test_umaths[('spacing', 'd')]
 
@@ -268,11 +266,6 @@ tests/third_party/cupy/manipulation_tests/test_dims.py::TestInvalidBroadcast_par
 tests/third_party/cupy/math_tests/test_explog.py::TestExplog::test_logaddexp2
 tests/third_party/cupy/math_tests/test_explog.py::TestExplog::test_logaddexp2_infinities
 
-tests/third_party/cupy/math_tests/test_floating.py::TestFloating::test_frexp
-tests/third_party/cupy/math_tests/test_floating.py::TestFloating::test_ldexp
-tests/third_party/cupy/math_tests/test_floating.py::TestFloating::test_nextafter_combination
-tests/third_party/cupy/math_tests/test_floating.py::TestFloating::test_nextafter_float
-
 tests/third_party/cupy/math_tests/test_misc.py::TestMisc::test_nan_to_num
 tests/third_party/cupy/math_tests/test_misc.py::TestMisc::test_nan_to_num_negative
 tests/third_party/cupy/math_tests/test_misc.py::TestMisc::test_nan_to_num_for_old_numpy

tests/test_mathematical.py

@@ -1113,6 +1113,139 @@ def test_power(self, dtype, lhs, rhs):
     def test_subtract(self, dtype, lhs, rhs):
         self._test_mathematical("subtract", dtype, lhs, rhs, check_type=False)
 
+class TestNextafter:
+    @pytest.mark.parametrize("dt", get_float_dtypes())
+    @pytest.mark.parametrize(
+        "val1, val2",
+        [
+            pytest.param(1, 2),
+            pytest.param(1, 0),
+            pytest.param(1, 1),
+        ],
+    )
+    def test_float(self, val1, val2, dt):
+        v1 = numpy.array(val1, dtype=dt)
+        v2 = numpy.array(val2, dtype=dt)
+        iv1, iv2 = dpnp.array(v1), dpnp.array(v2)
+
+        result = dpnp.nextafter(iv1, iv2)
+        expected = numpy.nextafter(v1, v2)
+        assert_equal(result, expected)
+
+    @pytest.mark.parametrize("dt", get_float_dtypes())
+    def test_float_nan(self, dt):
+        a = numpy.array(1, dtype=dt)
+        ia = dpnp.array(a)
+
+        result = dpnp.nextafter(ia, dpnp.nan)
+        expected = numpy.nextafter(numpy.nan, a)
+        assert_equal(result, expected)
+
+        result = dpnp.nextafter(dpnp.nan, ia)
+        expected = numpy.nextafter(a, numpy.nan)
+        assert_equal(result, expected)
+
+    @pytest.mark.parametrize("val", [0x7c00, 0x8000], ids=["val1", "val2"])
+    def test_f16_strides(self, val):
+        a = numpy.arange(val, dtype=numpy.uint16).astype(numpy.float16)
+        hinf = numpy.array((numpy.inf,), dtype=numpy.float16)
+        ia, ihinf = dpnp.array(a), dpnp.array(hinf)
+
+        result = dpnp.nextafter(ia[:-1], ihinf)
+        expected = numpy.nextafter(a[:-1], hinf)
+        assert_equal(result, expected)
+
+        result = dpnp.nextafter(ia[0], -ihinf)
+        expected = numpy.nextafter(a[0], -hinf)
+        assert_equal(result, expected)
+
+        result = dpnp.nextafter(ia[1:], -ihinf)
+        expected = numpy.nextafter(a[1:], -hinf)
+        assert_equal(result, expected)
+
+    @pytest.mark.parametrize("val", [0x7c00, 0x8000], ids=["val1", "val2"])
+    def test_f16_array_inf(self, val):
+        a = numpy.arange(val, dtype=numpy.uint16).astype(numpy.float16)
+        hinf = numpy.array((numpy.inf,), dtype=numpy.float16)
+        ia, ihinf = dpnp.array(a), dpnp.array(hinf)
+
+        result = dpnp.nextafter(ihinf, ia)
+        expected = numpy.nextafter(hinf, a)
+        assert_equal(result, expected)
+
+        result = dpnp.nextafter(-ihinf, ia)
+        expected = numpy.nextafter(-hinf, a)
+        assert_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "sign1, sign2",
+        [
+            pytest.param(1, 1),
+            pytest.param(1, -1),
+            pytest.param(-1, 1),
+            pytest.param(-1, -1),
+        ],
+    )
+    def test_f16_inf(self, sign1, sign2):
+        hinf1 = numpy.array((sign1 * numpy.inf,), dtype=numpy.float16)
+        hinf2 = numpy.array((sign2 * numpy.inf,), dtype=numpy.float16)
+        ihinf1, ihinf2 = dpnp.array(hinf1), dpnp.array(hinf2)
+
+        result = dpnp.nextafter(ihinf1, ihinf2)
+        expected = numpy.nextafter(hinf1, hinf2)
+        assert_equal(result, expected)
+
+    @pytest.mark.parametrize("val", [0x7c00, 0x8000], ids=["val1", "val2"])
+    def test_f16_array_nan(self, val):
+        a = numpy.arange(val, dtype=numpy.uint16).astype(numpy.float16)
+        nan = numpy.array((numpy.nan,), dtype=numpy.float16)
+        ia, inan = dpnp.array(a), dpnp.array(nan)
+
+        result = dpnp.nextafter(ia, inan)
+        expected = numpy.nextafter(a, nan)
+        assert_equal(result, expected)
+
+        result = dpnp.nextafter(inan, ia)
+        expected = numpy.nextafter(nan, a)
+        assert_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "val1, val2",
+        [
+            pytest.param(numpy.nan, numpy.nan),
+            pytest.param(numpy.inf, numpy.nan),
+            pytest.param(numpy.nan, numpy.inf),
+        ],
+    )
+    def test_f16_inf_nan(self, val1, val2):
+        v1 = numpy.array((val1,), dtype=numpy.float16)
+        v2 = numpy.array((val2,), dtype=numpy.float16)
+        iv1, iv2 =dpnp.array(v1), dpnp.array(v2)
+
+        result = dpnp.nextafter(iv1, iv2)
+        expected = numpy.nextafter(v1, v2)
+        assert_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "val, scalar",
+        [
+            pytest.param(65504, -numpy.inf),
+            pytest.param(-65504, numpy.inf),
+            pytest.param(numpy.inf, 0),
+            pytest.param(-numpy.inf, 0),
+            pytest.param(0, numpy.nan),
+            pytest.param(numpy.nan, 0),
+        ],
+    )
+    def test_f16_corner_values_with_scalar(self, val, scalar):
+        a = numpy.array(val, dtype=numpy.float16)
+        ia = dpnp.array(a)
+        scalar = numpy.float16(scalar)
+
+        result = dpnp.nextafter(ia, scalar)
+        expected = numpy.nextafter(a, scalar)
+        assert_equal(result, expected)
+
 
 @pytest.mark.usefixtures("suppress_divide_invalid_numpy_warnings")
 @pytest.mark.parametrize(

tests/test_sycl_queue.py

@@ -686,6 +686,7 @@ def test_reduce_hypot(device):
             [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0],
             [0.0, 1.0, 2.0, 0.0, 1.0, 2.0, 0.0, 1.0, 2.0],
         ),
+        pytest.param("nextafter", [1, 2], [2, 1]),
         pytest.param(
             "outer", [0.0, 1.0, 2.0, 3.0, 4.0, 5.0], [0.0, 1.0, 2.0, 0.0]
         ),

tests/test_usm_type.py

@@ -655,6 +655,7 @@ def test_1in_1out(func, data, usm_type):
         pytest.param("logaddexp", [[-1, 2, 5, 9]], [[4, -3, 2, -8]]),
         pytest.param("maximum", [0.0, 1.0, 2.0], [3.0, 4.0, 5.0]),
         pytest.param("minimum", [0.0, 1.0, 2.0], [3.0, 4.0, 5.0]),
+        pytest.param("nextafter", [1, 2], [2, 1]),
         pytest.param("searchsorted", [11, 12, 13, 14, 15], [-10, 20, 12, 13]),
         pytest.param(
             "tensordot",

tests/third_party/cupy/math_tests/test_floating.py

@@ -1,4 +1,5 @@
 import unittest
+import pytest
 
 import numpy
 
@@ -28,6 +29,7 @@ def test_copysign_float(self, xp, dtype):
         b = xp.array([-xp.inf, -3, -0.0, 0, 3, xp.inf], dtype=dtype)[None, :]
         return xp.copysign(a, b)
 
+    @pytest.mark.skip("ldexp() is not implemented yet")
     @testing.for_float_dtypes(name="ftype")
     @testing.for_dtypes(["i", "l"], name="itype")
     @testing.numpy_cupy_array_equal()
@@ -36,6 +38,7 @@ def test_ldexp(self, xp, ftype, itype):
         b = xp.array([-3, -2, -1, 0, 1, 2, 3], dtype=itype)
         return xp.ldexp(a, b)
 
+    @pytest.mark.skip("frexp() is not implemented yet")
     @testing.for_float_dtypes()
     def test_frexp(self, dtype):
         numpy_a = numpy.array(