update dpnp.result_type tests

Author: Vahid Tavanashad

.github/workflows/conda-package.yml

@@ -63,6 +63,7 @@ env:
       third_party/cupy/statistics_tests/test_histogram.py
       third_party/cupy/statistics_tests/test_meanvar.py
       third_party/cupy/test_ndim.py
+      third_party/cupy/test_type_routines.py
   VER_JSON_NAME: 'version.json'
   VER_SCRIPT1: "import json; f = open('version.json', 'r'); j = json.load(f); f.close(); "
   VER_SCRIPT2: "d = j['dpnp'][0]; print('='.join((d[s] for s in ('version', 'build'))))"

dpnp/dpnp_iface_manipulation.py

@@ -2388,6 +2388,7 @@ def result_type(*arrays_and_dtypes):
     ----------
     arrays_and_dtypes : list of {dpnp.ndarray, usm_ndarray, dtype}
         An arbitrary length sequence of arrays or dtypes.
+        There should be at least one array in the input.
 
     Returns
     -------
@@ -2402,9 +2403,6 @@ def result_type(*arrays_and_dtypes):
     >>> np.result_type(a, b)
     dtype('int64')
 
-    >>> np.result_type(np.int64, np.complex128)
-    dtype('complex128')
-
     >>> np.result_type(np.ones(10, dtype=np.float32), np.float64)
     dtype('float64')
 

tests/test_manipulation.py

@@ -87,9 +87,8 @@ def test_result_type():
 
 def test_result_type_only_dtypes():
     X = [dpnp.int64, dpnp.int32, dpnp.bool, dpnp.float32]
-    X_np = [numpy.int64, numpy.int32, numpy.bool_, numpy.float32]
-
-    assert dpnp.result_type(*X) == numpy.result_type(*X_np)
+    with pytest.raises(ValueError):
+        dpnp.result_type(*X)
 
 
 def test_result_type_only_arrays():

tests/third_party/cupy/test_type_routines.py

@@ -34,11 +34,13 @@ class TestCanCast(unittest.TestCase):
     @testing.for_all_dtypes_combination(names=("from_dtype", "to_dtype"))
     @testing.numpy_cupy_equal()
     def test_can_cast(self, xp, from_dtype, to_dtype):
-        if self.obj_type == "scalar":
+        if (
+            self.obj_type == "scalar"
+            and numpy.lib.NumpyVersion(numpy.__version__) < "2.0.0"
+        ):
             pytest.skip("to be aligned with NEP-50")
 
         from_obj = _generate_type_routines_input(xp, from_dtype, self.obj_type)
-
         ret = xp.can_cast(from_obj, to_dtype)
         assert isinstance(ret, bool)
         return ret
@@ -83,7 +85,9 @@ def test_common_type_bool(self, dtype):
 @testing.parameterize(
     *testing.product(
         {
-            "obj_type1": ["dtype", "specifier", "scalar", "array", "primitive"],
+            # obj_type1 is modified since at least one input should be an
+            # array for dpnp.result_dtype
+            "obj_type1": ["array"],
             "obj_type2": ["dtype", "specifier", "scalar", "array", "primitive"],
         }
     )
@@ -92,37 +96,35 @@ class TestResultType(unittest.TestCase):
     @testing.for_all_dtypes_combination(names=("dtype1", "dtype2"))
     @testing.numpy_cupy_equal()
     def test_result_type(self, xp, dtype1, dtype2):
-        if "scalar" in {self.obj_type1, self.obj_type2}:
+        if (
+            self.obj_type2 == "scalar"
+            and numpy.lib.NumpyVersion(numpy.__version__) < "2.0.0"
+        ):
             pytest.skip("to be aligned with NEP-50")
 
         input1 = _generate_type_routines_input(xp, dtype1, self.obj_type1)
-
         input2 = _generate_type_routines_input(xp, dtype2, self.obj_type2)
 
-        flag1 = isinstance(input1, (numpy.ndarray, cupy.ndarray))
-        flag2 = isinstance(input2, (numpy.ndarray, cupy.ndarray))
-        dt1 = cupy.dtype(input1) if not flag1 else None
-        dt2 = cupy.dtype(input2) if not flag2 else None
-        # dpnp takes into account device capabilities only if one of the
-        # inputs is an array, for such a case, if the other dtype is not
-        # supported by device, dpnp raise ValueError. So, we skip the test.
-        if flag1 or flag2:
-            if (
-                dt1 in [cupy.float64, cupy.complex128]
-                or dt2 in [cupy.float64, cupy.complex128]
-            ) and not has_support_aspect64():
-                pytest.skip("No fp64 support by device.")
+        # dpnp.result_type only takes into account device capabilities. If
+        # dtype2 is `float32` and the object is primitive, the `input2` variable
+        # is `float` which needs a device with double precision support.
+        # so we skip the test for such a case on a device that does not support fp64
+        flag = self.obj_type2 == "primitive" and input2 == float
+        if flag and not has_support_aspect64():
+            pytest.skip("No fp64 support by device.")
 
         ret = xp.result_type(input1, input2)
 
-        # dpnp takes into account device capabilities if one of the inputs
-        # is an array, for such a case, we have to modify the results for
-        # NumPy to align it with device capabilities.
-        if (flag1 or flag2) and xp == numpy and not has_support_aspect64():
-            ret = numpy.dtype(numpy.float32) if ret == numpy.float64 else ret
-            ret = (
-                numpy.dtype(numpy.complex64) if ret == numpy.complex128 else ret
-            )
+        # dpnp.result_type takes into account device capabilities.
+        # So, we have to modify the results for NumPy to align it with
+        # device capabilities.
+        flag1 = isinstance(input1, numpy.ndarray)
+        flag2 = isinstance(input2, numpy.ndarray)
+        if (flag1 or flag2) and not has_support_aspect64():
+            if ret == numpy.float64:
+                ret = numpy.dtype(numpy.float32)
+            elif ret == numpy.complex128:
+                ret = numpy.dtype(numpy.complex64)
 
         assert isinstance(ret, numpy.dtype)
         return ret