Add tests

Author: antonwolfy

dpnp/backend/kernels/dpnp_krnl_elemwise.cpp

@@ -1276,14 +1276,11 @@ static constexpr DPNPFuncType get_divide_res_type()
 template <DPNPFuncType FT1, DPNPFuncType FT2>
 static constexpr DPNPFuncType get_fmod_res_type()
 {
-    constexpr auto widest_type = populate_func_types<FT1, FT2>();
-    constexpr auto shortes_type = (widest_type == FT1) ? FT2 : FT1;
-
-    if constexpr (shortes_type == DPNPFuncType::DPNP_FT_BOOL)
+    if constexpr ((FT1 == DPNPFuncType::DPNP_FT_BOOL) && (FT2 == DPNPFuncType::DPNP_FT_BOOL))
     {
         return DPNPFuncType::DPNP_FT_INT;
     }
-    return widest_type;
+    return populate_func_types<FT1, FT2>();
 }
 
 template <DPNPFuncType FT1, DPNPFuncType... FTs>

tests/skipped_tests.tbl

@@ -715,19 +715,15 @@ tests/third_party/cupy/manipulation_tests/test_tiling.py::TestTile_param_5_{reps
 tests/third_party/cupy/manipulation_tests/test_transpose.py::TestTranspose::test_moveaxis_invalid5_2
 tests/third_party/cupy/manipulation_tests/test_transpose.py::TestTranspose::test_moveaxis_invalid5_3
 tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_455_{arg1=array([[1, 2, 3],       [4, 5, 6]], dtype=int32), arg2=array([[0, 1, 2],       [3, 4, 5]], dtype=int32), dtype=float64, name='floor_divide', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_457_{arg1=array([[1, 2, 3],       [4, 5, 6]], dtype=int32), arg2=array([[0, 1, 2],       [3, 4, 5]], dtype=int32), dtype=float64, name='fmod', use_dtype=False}::test_binary
 tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_459_{arg1=array([[1, 2, 3],       [4, 5, 6]], dtype=int32), arg2=array([[0, 1, 2],       [3, 4, 5]], dtype=int32), dtype=float64, name='remainder', use_dtype=False}::test_binary
 tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_461_{arg1=array([[1, 2, 3],       [4, 5, 6]], dtype=int32), arg2=array([[0, 1, 2],       [3, 4, 5]], dtype=int32), dtype=float64, name='mod', use_dtype=False}::test_binary
 tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_463_{arg1=array([[1, 2, 3],       [4, 5, 6]], dtype=int32), arg2=array([[0, 1, 2],       [3, 4, 5]]), dtype=float64, name='floor_divide', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_465_{arg1=array([[1, 2, 3],       [4, 5, 6]], dtype=int32), arg2=array([[0, 1, 2],       [3, 4, 5]]), dtype=float64, name='fmod', use_dtype=False}::test_binary
 tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_467_{arg1=array([[1, 2, 3],       [4, 5, 6]], dtype=int32), arg2=array([[0, 1, 2],       [3, 4, 5]]), dtype=float64, name='remainder', use_dtype=False}::test_binary
 tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_469_{arg1=array([[1, 2, 3],       [4, 5, 6]], dtype=int32), arg2=array([[0, 1, 2],       [3, 4, 5]]), dtype=float64, name='mod', use_dtype=False}::test_binary
 tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_535_{arg1=array([[1, 2, 3],       [4, 5, 6]]), arg2=array([[0, 1, 2],       [3, 4, 5]], dtype=int32), dtype=float64, name='floor_divide', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_537_{arg1=array([[1, 2, 3],       [4, 5, 6]]), arg2=array([[0, 1, 2],       [3, 4, 5]], dtype=int32), dtype=float64, name='fmod', use_dtype=False}::test_binary
 tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_539_{arg1=array([[1, 2, 3],       [4, 5, 6]]), arg2=array([[0, 1, 2],       [3, 4, 5]], dtype=int32), dtype=float64, name='remainder', use_dtype=False}::test_binary
 tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_541_{arg1=array([[1, 2, 3],       [4, 5, 6]]), arg2=array([[0, 1, 2],       [3, 4, 5]], dtype=int32), dtype=float64, name='mod', use_dtype=False}::test_binary
 tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_543_{arg1=array([[1, 2, 3],       [4, 5, 6]]), arg2=array([[0, 1, 2],       [3, 4, 5]]), dtype=float64, name='floor_divide', use_dtype=False}::test_binary
-tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_545_{arg1=array([[1, 2, 3],       [4, 5, 6]]), arg2=array([[0, 1, 2],       [3, 4, 5]]), dtype=float64, name='fmod', use_dtype=False}::test_binary
 tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_547_{arg1=array([[1, 2, 3],       [4, 5, 6]]), arg2=array([[0, 1, 2],       [3, 4, 5]]), dtype=float64, name='remainder', use_dtype=False}::test_binary
 tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticBinary2_param_549_{arg1=array([[1, 2, 3],       [4, 5, 6]]), arg2=array([[0, 1, 2],       [3, 4, 5]]), dtype=float64, name='mod', use_dtype=False}::test_binary
 tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticModf::test_modf

tests/test_mathematical.py

@@ -71,11 +71,14 @@ def test_diff(array):
 @pytest.mark.parametrize("dtype1", get_all_dtypes())
 @pytest.mark.parametrize("dtype2", get_all_dtypes())
 @pytest.mark.parametrize("func",
-                         ['add', 'divide', 'multiply', 'power', 'subtract'])
+                         ['add', 'divide', 'fmod', 'multiply', 'power', 'subtract'])
 @pytest.mark.parametrize("data",
                          [[[1, 2], [3, 4]]],
                          ids=['[[1, 2], [3, 4]]'])
 def test_op_multiple_dtypes(dtype1, func, dtype2, data):
+    if func == 'fmod' and (dpnp.issubdtype(dtype1, dpnp.complexfloating) or dpnp.issubdtype(dtype2, dpnp.complexfloating)):
+        pytest.skip("no support of fmod for complex")
+
     np_a = numpy.array(data, dtype=dtype1)
     dpnp_a = dpnp.array(data, dtype=dtype1)
 
@@ -141,9 +144,18 @@ def test_copysign(self, dtype, lhs, rhs):
     def test_divide(self, dtype, lhs, rhs):
         self._test_mathematical('divide', dtype, lhs, rhs)
 
-    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     @pytest.mark.parametrize("dtype", get_all_dtypes(no_bool=True, no_complex=True))
     def test_fmod(self, dtype, lhs, rhs):
+        if dtype == dpnp.float32 and rhs == 0.3:
+            """
+            Due to some reason NumPy behaves incorrectly, when:
+                >>> numpy.fmod(numpy.array([3.9], dtype=numpy.float32), 0.3)
+                array([0.29999995], dtype=float32)
+            while dpnp returns something around zero which is expected:
+                >>> dpnp.fmod(dpnp.array([3.9], dtype=dpnp.float32), 0.3)
+                array([9.53674318e-08])
+            """
+            pytest.skip("missaligned with numpy results")
         self._test_mathematical('fmod', dtype, lhs, rhs)
 
     @pytest.mark.usefixtures("allow_fall_back_on_numpy")
@@ -216,6 +228,9 @@ def test_op_with_scalar(array, val, func, data_type, val_type):
         elif is_cpu_device() and data_type == dpnp.complex128:
             # TODO: discuss the bahavior with OneMKL team
             pytest.skip("(0j ** 5) is different: (NaN + NaNj) in dpnp and (0j) in numpy")
+    elif func == 'fmod' and ((data_type is None or not dpnp.issubdtype(data_type, dpnp.floating)) and
+                             (val_type != float or dpnp.issubdtype(data_type, dpnp.complexfloating))):
+        pytest.skip("dpnp.fmod(a, 0) != 0 for integer a, like it's in numpy")
 
     if func == 'subtract' and val_type == bool and data_type == dpnp.bool:
         with pytest.raises(TypeError):

tests/test_strides.py

@@ -203,14 +203,14 @@ def test_strides_fmod(dtype, shape):
 @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)

tests/test_usm_type.py

@@ -180,6 +180,9 @@ def test_meshgrid(usm_type_x, usm_type_y):
         pytest.param("dot",
                      [[0., 1., 2.], [3., 4., 5.]],
                      [[4., 4.], [4., 4.], [4., 4.]]),
+        pytest.param("fmod",
+                     [-3., -2., -1., 1., 2., 3.],
+                     [2., 2., 2., 2., 2., 2.]),
     ],
 )
 @pytest.mark.parametrize("usm_type_x", list_of_usm_types, ids=list_of_usm_types)

tests/third_party/cupy/math_tests/test_arithmetic.py

@@ -145,6 +145,14 @@ def check_binary(self, xp):
             if dtype1 in (numpy.float16, numpy.float32):
                 y = y.astype(numpy.complex64)
 
+        if xp is cupy and not xp.isscalar(y) and not self.use_dtype:
+            if self.name == 'fmod':
+                # TODO: Fix this: fmod(a, 0)
+                #     numpy => 0
+                #     cupy => 2147483647
+                if not (dtype1 in float_types or dtype2 in float_types) and (np2 == 0).any():
+                    y[xp.broadcast_to(xp.array(arg2), y.shape) == 0] = 0
+
         # NumPy returns an output array of another type than DPNP when input ones have diffrent types.
         if xp is cupy and dtype1 != dtype2 and not self.use_dtype:
             is_array_arg1 = not xp.isscalar(arg1)
@@ -153,7 +161,7 @@ def check_binary(self, xp):
             is_int_float = lambda _x, _y: numpy.issubdtype(_x, numpy.integer) and numpy.issubdtype(_y, numpy.floating)
             is_same_type = lambda _x, _y, _type: numpy.issubdtype(_x, _type) and numpy.issubdtype(_y, _type)
 
-            if self.name in ('add', 'multiply', 'power', 'subtract'):
+            if self.name in ('add', 'fmod', 'multiply', 'power', 'subtract'):
                 if is_array_arg1 and is_array_arg2:
                     # If both inputs are arrays where one is of floating type and another - integer,
                     # NumPy will return an output array of always "float64" type,