Remove floatMAX and update some tests

Author: vlad-perevezentsev

tests/conftest.py

@@ -29,7 +29,6 @@
 import dpnp
 import numpy
 import pytest
-from .helper import check_support_float64
 
 
 skip_mark = pytest.mark.skip(reason='Skipping test.')
@@ -78,6 +77,3 @@ def pytest_collection_modifyitems(config, items):
 @pytest.fixture
 def allow_fall_back_on_numpy(monkeypatch):
     monkeypatch.setattr(dpnp.config, '__DPNP_RAISE_EXCEPION_ON_NUMPY_FALLBACK__', 0)
-
-def pytest_configure():
-    pytest.floatMAX = "float64" if check_support_float64() else "float32"

tests/helper.py

@@ -37,11 +37,3 @@ def get_all_dtypes(no_bool=False,
     if not no_none:
         dtypes.append(None)
     return dtypes
-
-def check_support_float64():
-    """
-    Returns True if the default device supports 64-bit precision floating
-    point operations, False otherwise.
-    """
-
-    return dpctl.select_default_device().has_aspect_fp64

tests/test_absolute.py

@@ -1,51 +1,46 @@
 import pytest
+from .helper import get_all_dtypes
 
 import dpnp as inp
 
 import numpy
 
 
-@pytest.mark.parametrize("type", [numpy.int64], ids=["int64"])
-def test_abs_int(type):
-    a = numpy.array([1, 0, 2, -3, -1, 2, 21, -9])
+@pytest.mark.parametrize(
+    "dtype", get_all_dtypes(no_bool=True, no_none=True, no_complex=True)
+)
+def test_abs(dtype):
+    a = numpy.array([1, 0, 2, -3, -1, 2, 21, -9], dtype=dtype)
     ia = inp.array(a)
 
     result = inp.abs(ia)
     expected = numpy.abs(a)
     numpy.testing.assert_array_equal(expected, result)
 
 
-@pytest.mark.parametrize("type", [numpy.int64], ids=["int64"])
-def test_absolute_int(type):
-    a = numpy.array([1, 0, 2, -3, -1, 2, 21, -9])
+@pytest.mark.parametrize(
+    "dtype", get_all_dtypes(no_bool=True, no_none=True, no_complex=True)
+)
+def test_absolute(dtype):
+    a = numpy.array([[-2.0, 3.0, 9.1], [-2.0, 5.0, -2], [1.0, -2.0, 5.0]], dtype=dtype)
     ia = inp.array(a)
 
     result = inp.absolute(ia)
     expected = numpy.absolute(a)
     numpy.testing.assert_array_equal(expected, result)
 
 
-@pytest.mark.parametrize("type", [numpy.float64], ids=[pytest.floatMAX])
-def test_absolute_float(type):
-    a = numpy.array(
-        [[-2.0, 3.0, 9.1], [-2.0, 5.0, -2], [1.0, -2.0, 5.0]], dtype=pytest.floatMAX
-    )
-    ia = inp.array(a)
-
-    result = inp.absolute(ia)
-    expected = numpy.absolute(a)
-    numpy.testing.assert_array_equal(expected, result)
-
-
-@pytest.mark.parametrize("type", [numpy.float64], ids=[pytest.floatMAX])
-def test_absolute_float_3(type):
+@pytest.mark.parametrize(
+    "dtype", get_all_dtypes(no_bool=True, no_none=True, no_complex=True)
+)
+def test_absolute_3d(dtype):
     a = numpy.array(
         [
             [[-2.0, 3.0], [9.1, 0.2]],
             [[-2.0, 5.0], [-2, -1.2]],
             [[1.0, -2.0], [5.0, -1.1]],
         ],
-        dtype=pytest.floatMAX,
+        dtype=dtype,
     )
     ia = inp.array(a)
 

tests/test_amin_amax.py

@@ -1,19 +1,22 @@
 import pytest
+from .helper import get_all_dtypes
 
 import dpnp
 
 import numpy
 
 
-@pytest.mark.parametrize("type", [numpy.float64], ids=[pytest.floatMAX])
-def test_amax_float(type):
+@pytest.mark.parametrize(
+    "dtype", get_all_dtypes(no_bool=True, no_none=True, no_complex=True)
+)
+def test_amax(dtype):
     a = numpy.array(
         [
             [[-2.0, 3.0], [9.1, 0.2]],
             [[-2.0, 5.0], [-2, -1.2]],
             [[1.0, -2.0], [5.0, -1.1]],
         ],
-        dtype=pytest.floatMAX,
+        dtype=dtype,
     )
     ia = dpnp.array(a)
 
@@ -23,25 +26,17 @@ def test_amax_float(type):
         numpy.testing.assert_array_equal(expected, result)
 
 
-@pytest.mark.parametrize("type", [numpy.int64], ids=["int64"])
-def test_amax_int(type):
-    a = numpy.array([1, 0, 2, -3, -1, 2, 21, -9])
-    ia = dpnp.array(a)
-
-    result = dpnp.amax(ia)
-    expected = numpy.amax(a)
-    numpy.testing.assert_array_equal(expected, result)
-
-
-@pytest.mark.parametrize("type", [numpy.float64], ids=[pytest.floatMAX])
-def test_amin_float(type):
+@pytest.mark.parametrize(
+    "dtype", get_all_dtypes(no_bool=True, no_none=True, no_complex=True)
+)
+def test_amin(dtype):
     a = numpy.array(
         [
             [[-2.0, 3.0], [9.1, 0.2]],
             [[-2.0, 5.0], [-2, -1.2]],
             [[1.0, -2.0], [5.0, -1.1]],
         ],
-        dtype=pytest.floatMAX,
+        dtype=dtype,
     )
     ia = dpnp.array(a)
 
@@ -51,16 +46,6 @@ def test_amin_float(type):
         numpy.testing.assert_array_equal(expected, result)
 
 
-@pytest.mark.parametrize("type", [numpy.int64], ids=["int64"])
-def test_amin_int(type):
-    a = numpy.array([1, 0, 2, -3, -1, 2, 21, -9])
-    ia = dpnp.array(a)
-
-    result = dpnp.amin(ia)
-    expected = numpy.amin(a)
-    numpy.testing.assert_array_equal(expected, result)
-
-
 def _get_min_max_input(type, shape):
     size = 1
     for i in range(len(shape)):
@@ -75,25 +60,13 @@ def _get_min_max_input(type, shape):
 
 @pytest.mark.usefixtures("allow_fall_back_on_numpy")
 @pytest.mark.parametrize(
-    "type",
-    [
-        pytest.param(
-            numpy.float64,
-            marks=pytest.mark.skipif(
-                pytest.floatMAX != "float64", reason="No float64 support on this device"
-            ),
-        ),
-        numpy.float32,
-        numpy.int64,
-        numpy.int32,
-    ],
-    ids=["float64", "float32", "int64", "int32"],
+    "dtype", get_all_dtypes(no_bool=True, no_none=True, no_complex=True)
 )
 @pytest.mark.parametrize(
     "shape", [(4,), (2, 3), (4, 5, 6)], ids=["(4,)", "(2,3)", "(4,5,6)"]
 )
-def test_amax(type, shape):
-    a = _get_min_max_input(type, shape)
+def test_amax_with_shape(dtype, shape):
+    a = _get_min_max_input(dtype, shape)
 
     ia = dpnp.array(a)
 
@@ -108,25 +81,13 @@ def test_amax(type, shape):
 
 @pytest.mark.usefixtures("allow_fall_back_on_numpy")
 @pytest.mark.parametrize(
-    "type",
-    [
-        pytest.param(
-            numpy.float64,
-            marks=pytest.mark.skipif(
-                pytest.floatMAX != "float64", reason="No float64 support on this device"
-            ),
-        ),
-        numpy.float32,
-        numpy.int64,
-        numpy.int32,
-    ],
-    ids=["float64", "float32", "int64", "int32"],
+    "dtype", get_all_dtypes(no_bool=True, no_none=True, no_complex=True)
 )
 @pytest.mark.parametrize(
     "shape", [(4,), (2, 3), (4, 5, 6)], ids=["(4,)", "(2,3)", "(4,5,6)"]
 )
-def test_amin(type, shape):
-    a = _get_min_max_input(type, shape)
+def test_amin_with_shape(dtype, shape):
+    a = _get_min_max_input(dtype, shape)
 
     ia = dpnp.array(a)
 

tests/test_bitwise.py

@@ -5,11 +5,20 @@
 import numpy
 
 
-@pytest.mark.parametrize("lhs", [[[-7, -6, -5, -4, -3, -2, -1], [0, 1, 2, 3, 4, 5, 6]], [-3, -2, -1, 0, 1, 2, 3], 0])
-@pytest.mark.parametrize("rhs", [[[0, 1, 2, 3, 4, 5, 6], [7, 8, 9, 10, 11, 12, 13]], [0, 1, 2, 3, 4, 5, 6], 3])
+@pytest.mark.parametrize(
+    "lhs",
+    [
+        [[-7, -6, -5, -4, -3, -2, -1], [0, 1, 2, 3, 4, 5, 6]],
+        [-3, -2, -1, 0, 1, 2, 3],
+        0,
+    ],
+)
+@pytest.mark.parametrize(
+    "rhs",
+    [[[0, 1, 2, 3, 4, 5, 6], [7, 8, 9, 10, 11, 12, 13]], [0, 1, 2, 3, 4, 5, 6], 3],
+)
 @pytest.mark.parametrize("dtype", [numpy.int32, numpy.int64])
 class TestBitwise:
-
     @staticmethod
     def array_or_scalar(xp, data, dtype=None):
         if numpy.isscalar(data):
@@ -39,24 +48,24 @@ def _test_binary_int(self, name, lhs, rhs, dtype):
 
     @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     def test_bitwise_and(self, lhs, rhs, dtype):
-        self._test_binary_int('bitwise_and', lhs, rhs, dtype)
+        self._test_binary_int("bitwise_and", lhs, rhs, dtype)
 
     @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     def test_bitwise_or(self, lhs, rhs, dtype):
-        self._test_binary_int('bitwise_or', lhs, rhs, dtype)
+        self._test_binary_int("bitwise_or", lhs, rhs, dtype)
 
     @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     def test_bitwise_xor(self, lhs, rhs, dtype):
-        self._test_binary_int('bitwise_xor', lhs, rhs, dtype)
+        self._test_binary_int("bitwise_xor", lhs, rhs, dtype)
 
     @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     def test_invert(self, lhs, rhs, dtype):
-        self._test_unary_int('invert', lhs, dtype)
+        self._test_unary_int("invert", lhs, dtype)
 
     @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     def test_left_shift(self, lhs, rhs, dtype):
-        self._test_binary_int('left_shift', lhs, rhs, dtype)
+        self._test_binary_int("left_shift", lhs, rhs, dtype)
 
     @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     def test_right_shift(self, lhs, rhs, dtype):
-        self._test_binary_int('right_shift', lhs, rhs, dtype)
+        self._test_binary_int("right_shift", lhs, rhs, dtype)

tests/test_counting.py

@@ -1,17 +1,17 @@
 import pytest
+from .helper import get_all_dtypes
 
 import dpnp
 
 import numpy
 
 
-@pytest.mark.parametrize("type",
-                         [numpy.float64, numpy.float32, numpy.int64, numpy.int32],
-                         ids=['float64', 'float32', 'int64', 'int32'])
-@pytest.mark.parametrize("size",
-                         [2, 4, 8, 16, 3, 9, 27, 81])
-def test_count_nonzero(type, size):
-    a = numpy.arange(size, dtype=type)
+@pytest.mark.parametrize(
+    "dtype", get_all_dtypes(no_bool=True, no_none=True, no_complex=True)
+)
+@pytest.mark.parametrize("size", [2, 4, 8, 16, 3, 9, 27, 81])
+def test_count_nonzero(dtype, size):
+    a = numpy.arange(size, dtype=dtype)
     for i in range(int(size / 2)):
         a[(i * (int(size / 3) - 1)) % size] = 0
 

tests/test_dot.py

@@ -1,17 +1,18 @@
 import pytest
+from .helper import get_all_dtypes
 
 import dpnp as inp
 
 import numpy
 
 
-@pytest.mark.parametrize("type",
-                         [numpy.float64, numpy.float32, numpy.int64, numpy.int32],
-                         ids=['float64', 'float32', 'int64', 'int32'])
-def test_dot_ones(type):
+@pytest.mark.parametrize(
+    "dtype", get_all_dtypes(no_bool=True, no_none=True, no_complex=True)
+)
+def test_dot_ones(dtype):
     n = 10**5
-    a = numpy.ones(n, dtype=type)
-    b = numpy.ones(n, dtype=type)
+    a = numpy.ones(n, dtype=dtype)
+    b = numpy.ones(n, dtype=dtype)
     ia = inp.array(a)
     ib = inp.array(b)
 
@@ -20,13 +21,13 @@ def test_dot_ones(type):
     numpy.testing.assert_array_equal(expected, result)
 
 
-@pytest.mark.parametrize("type",
-                         [numpy.float64, numpy.float32, numpy.int64, numpy.int32],
-                         ids=['float64', 'float32', 'int64', 'int32'])
-def test_dot_arange(type):
+@pytest.mark.parametrize(
+    "dtype", get_all_dtypes(no_bool=True, no_none=True, no_complex=True)
+)
+def test_dot_arange(dtype):
     n = 10**2
     m = 10**3
-    a = numpy.hstack((numpy.arange(n, dtype=type),) * m)
+    a = numpy.hstack((numpy.arange(n, dtype=dtype),) * m)
     b = numpy.flipud(a)
     ia = inp.array(a)
     ib = inp.array(b)
@@ -36,20 +37,20 @@ def test_dot_arange(type):
     numpy.testing.assert_allclose(expected, result)
 
 
-@pytest.mark.parametrize("type",
-                         [numpy.float64, numpy.float32, numpy.int64, numpy.int32],
-                         ids=['float64', 'float32', 'int64', 'int32'])
-def test_multi_dot(type):
+@pytest.mark.parametrize(
+    "dtype", get_all_dtypes(no_bool=True, no_none=True, no_complex=True)
+)
+def test_multi_dot(dtype):
     n = 16
-    a = inp.reshape(inp.arange(n, dtype=type), (4, 4))
-    b = inp.reshape(inp.arange(n, dtype=type), (4, 4))
-    c = inp.reshape(inp.arange(n, dtype=type), (4, 4))
-    d = inp.reshape(inp.arange(n, dtype=type), (4, 4))
-
-    a1 = numpy.arange(n, dtype=type).reshape((4, 4))
-    b1 = numpy.arange(n, dtype=type).reshape((4, 4))
-    c1 = numpy.arange(n, dtype=type).reshape((4, 4))
-    d1 = numpy.arange(n, dtype=type).reshape((4, 4))
+    a = inp.reshape(inp.arange(n, dtype=dtype), (4, 4))
+    b = inp.reshape(inp.arange(n, dtype=dtype), (4, 4))
+    c = inp.reshape(inp.arange(n, dtype=dtype), (4, 4))
+    d = inp.reshape(inp.arange(n, dtype=dtype), (4, 4))
+
+    a1 = numpy.arange(n, dtype=dtype).reshape((4, 4))
+    b1 = numpy.arange(n, dtype=dtype).reshape((4, 4))
+    c1 = numpy.arange(n, dtype=dtype).reshape((4, 4))
+    d1 = numpy.arange(n, dtype=dtype).reshape((4, 4))
 
     result = inp.linalg.multi_dot([a, b, c, d])
     expected = numpy.linalg.multi_dot([a1, b1, c1, d1])