new changes for windows

Author: Vahid Tavanashad

dpnp/dpnp_iface_linearalgebra.py

@@ -1116,13 +1116,13 @@ def vdot(a, b):
         if b.size != 1:
             raise ValueError("The second array should be of size one.")
         a_conj = numpy.conj(a)
-        return dpnp.multiply(a_conj, b)
+        return _call_multiply(a_conj, b)
 
     if dpnp.isscalar(b):
         if a.size != 1:
             raise ValueError("The first array should be of size one.")
         a_conj = dpnp.conj(a)
-        return dpnp.multiply(a_conj, b)
+        return _call_multiply(a_conj, b)
 
     if a.ndim == 1 and b.ndim == 1:
         return dpnp_dot(a, b, out=None, conjugate=True)

dpnp/tests/test_indexing.py

@@ -652,16 +652,9 @@ def test_values(self, arr_dt, idx_dt, ndim, values):
         ia, iind = dpnp.array(a), dpnp.array(ind)
 
         for axis in range(ndim):
-            if ndim != 1 and numpy.issubdtype(idx_dt, numpy.uint64):
-                # For this special case, dpnp raises an error but NumPy works
-                # TODO: remove the workaround when dpctl-1936 is fixed
-                assert_raises(
-                    ValueError, dpnp.put_along_axis, ia, iind, values, axis
-                )
-            else:
-                numpy.put_along_axis(a, ind, values, axis)
-                dpnp.put_along_axis(ia, iind, values, axis)
-                assert_array_equal(ia, a)
+            numpy.put_along_axis(a, ind, values, axis)
+            dpnp.put_along_axis(ia, iind, values, axis)
+            assert_array_equal(ia, a)
 
     @pytest.mark.parametrize("xp", [numpy, dpnp])
     @pytest.mark.parametrize("dt", [bool, numpy.float32])
@@ -678,10 +671,6 @@ def test_broadcast(self, arr_dt, idx_dt):
         ia, iind = dpnp.array(a), dpnp.array(ind)
 
         if numpy.issubdtype(idx_dt, numpy.uint64):
-            # For this special case, dpnp raises an error but NumPy works
-            # TODO: remove the workaround when dpctl-1936 is fixed
-            assert_raises(ValueError, dpnp.put_along_axis, ia, iind, 20, axis=1)
-        else:
             numpy.put_along_axis(a, ind, 20, axis=1)
             dpnp.put_along_axis(ia, iind, 20, axis=1)
             assert_array_equal(ia, a)
@@ -732,10 +721,11 @@ def test_1d(self, a_dt, ind_dt, indices, mode):
             expected = numpy.take(a, ind, mode=mode)
             assert_array_equal(result, expected)
         elif numpy.issubdtype(ind_dt, numpy.uint64):
-            # For this special case, although casting `ind_dt`` to numpy.intp
-            # is not safe, NumPy and dpnp do not raise an error
+            # For this special case, although casting `ind_dt` to numpy.intp
+            # is not safe, dpnp do not raise an error
+            # NumPy only raises an error on Windows
             result = dpnp.take(ia, iind, mode=mode)
-            expected = numpy.take(a, ind, mode=mode)
+            expected = numpy.take(a, ind.astype(numpy.int64), mode=mode)
             assert_array_equal(result, expected)
         else:
             assert_raises(TypeError, ia.take, iind, mode=mode)
@@ -758,9 +748,15 @@ def test_2d(self, a_dt, ind_dt, indices, mode, axis):
         ind = numpy.array(indices, dtype=ind_dt)
         ia, iind = dpnp.array(a), dpnp.array(ind)
 
-        result = ia.take(iind, axis=axis, mode=mode)
-        expected = a.take(ind, axis=axis, mode=mode)
-        assert_array_equal(result, expected)
+        if numpy.issubdtype(ind_dt, numpy.uint64):
+            # For this special case, NumPy raises an error on Windows
+            result = ia.take(iind, axis=axis, mode=mode)
+            expected = a.take(ind.astype(numpy.int64), axis=axis, mode=mode)
+            assert_array_equal(result, expected)
+        else:
+            result = ia.take(iind, axis=axis, mode=mode)
+            expected = a.take(ind, axis=axis, mode=mode)
+            assert_array_equal(result, expected)
 
     @pytest.mark.parametrize("a_dt", get_all_dtypes(no_none=True))
     @pytest.mark.parametrize("mode", ["clip", "wrap"])
@@ -852,14 +848,9 @@ def test_multi_dimensions(self, arr_dt, idx_dt, ndim):
         ia, iind = dpnp.array(a), dpnp.array(ind)
 
         for axis in range(ndim):
-            if ndim != 1 and numpy.issubdtype(idx_dt, numpy.uint64):
-                # For this special case, dpnp raises an error but NumPy works
-                # TODO: remove the workaround when dpctl-1936 is fixed
-                assert_raises(ValueError, dpnp.take_along_axis, ia, iind, axis)
-            else:
-                result = dpnp.take_along_axis(ia, iind, axis)
-                expected = numpy.take_along_axis(a, ind, axis)
-                assert_array_equal(expected, result)
+            result = dpnp.take_along_axis(ia, iind, axis)
+            expected = numpy.take_along_axis(a, ind, axis)
+            assert_array_equal(expected, result)
 
     @pytest.mark.parametrize("xp", [numpy, dpnp])
     def test_not_enough_indices(self, xp):
@@ -892,14 +883,9 @@ def test_empty(self, a_dt, idx_dt):
         ind = numpy.ones((3, 0, 5), dtype=idx_dt)
         ia, iind = dpnp.array(a), dpnp.array(ind)
 
-        if numpy.issubdtype(idx_dt, numpy.uint64):
-            # For this special case, dpnp raises an error but NumPy works
-            # TODO: remove the workaround when dpctl-1936 is fixed
-            assert_raises(ValueError, dpnp.take_along_axis, ia, iind, axis=1)
-        else:
-            result = dpnp.take_along_axis(ia, iind, axis=1)
-            expected = numpy.take_along_axis(a, ind, axis=1)
-            assert_array_equal(expected, result)
+        result = dpnp.take_along_axis(ia, iind, axis=1)
+        expected = numpy.take_along_axis(a, ind, axis=1)
+        assert_array_equal(expected, result)
 
     @pytest.mark.parametrize("a_dt", get_all_dtypes(no_none=True))
     @pytest.mark.parametrize("idx_dt", get_integer_dtypes())
@@ -908,14 +894,9 @@ def test_broadcast(self, a_dt, idx_dt):
         ind = numpy.ones((1, 2, 5), dtype=idx_dt)
         ia, iind = dpnp.array(a), dpnp.array(ind)
 
-        if numpy.issubdtype(idx_dt, numpy.uint64):
-            # For this special case, dpnp raises an error but NumPy works
-            # TODO: remove the workaround when dpctl-1936 is fixed
-            assert_raises(ValueError, dpnp.take_along_axis, ia, iind, axis=1)
-        else:
-            result = dpnp.take_along_axis(ia, iind, axis=1)
-            expected = numpy.take_along_axis(a, ind, axis=1)
-            assert_array_equal(expected, result)
+        result = dpnp.take_along_axis(ia, iind, axis=1)
+        expected = numpy.take_along_axis(a, ind, axis=1)
+        assert_array_equal(expected, result)
 
     def test_mode_wrap(self):
         a = numpy.array([-2, -1, 0, 1, 2])

dpnp/tests/test_mathematical.py

@@ -1429,6 +1429,13 @@ def test_basic(self, mant_dt, exp_dt):
         if dpnp.issubdtype(exp_dt, dpnp.uint64):
             assert_raises(ValueError, dpnp.ldexp, imant, iexp)
             assert_raises(TypeError, numpy.ldexp, mant, exp)
+        elif dpnp.issubdtype(exp_dt, dpnp.uint32):
+            # For this special case, NumPy raises an error on Windows
+            # because it doesn't have a loop for the input types
+            # dpnp works fine
+            result = dpnp.ldexp(imant, iexp)
+            expected = numpy.ldexp(mant, exp.astype(numpy.int32))
+            assert_almost_equal(result, expected)
         else:
             result = dpnp.ldexp(imant, iexp)
             expected = numpy.ldexp(mant, exp)
@@ -3409,7 +3416,7 @@ def test_invalid_out(self, out):
 class TestPower:
     @pytest.mark.parametrize("val_type", get_all_dtypes(no_none=True))
     @pytest.mark.parametrize("data_type", get_all_dtypes())
-    @pytest.mark.parametrize("val", [1.5, 1, 5], ids=["1.5", "1", "5"])
+    @pytest.mark.parametrize("val", [1.5, 1, 3], ids=["1.5", "1", "3"])
     @pytest.mark.parametrize(
         "array",
         [

dpnp/tests/test_product.py

@@ -16,18 +16,6 @@
 from .third_party.cupy import testing
 
 
-def _assert_selective_dtype_allclose(result, expected, dtype):
-    # For numpy.dot, numpy.vdot, numpy.kron, numpy.inner, and numpy.tensordot,
-    # when inputs are an scalar (which has the default dtype of platform) and
-    # an array, the scalar dtype precision determines the output dtype
-    # precision. In dpnp, we rely on dpnp.multiply for scalar-array product
-    # and array (not scalar) determines output dtype precision of dpnp.multiply
-    if dtype in [numpy.int32, numpy.float32, numpy.complex64]:
-        assert_dtype_allclose(result, expected, check_only_type_kind=True)
-    else:
-        assert_dtype_allclose(result, expected)
-
-
 class TestCross:
     def setup_method(self):
         numpy.random.seed(42)
@@ -222,11 +210,11 @@ def test_scalar(self, dtype):
 
         result = dpnp.dot(a, ib)
         expected = numpy.dot(a, b)
-        _assert_selective_dtype_allclose(result, expected, dtype)
+        assert_dtype_allclose(result, expected)
 
         result = dpnp.dot(ib, a)
         expected = numpy.dot(b, a)
-        _assert_selective_dtype_allclose(result, expected, dtype)
+        assert_dtype_allclose(result, expected)
 
     @pytest.mark.parametrize("dtype", get_all_dtypes(no_none=True))
     @pytest.mark.parametrize(
@@ -297,7 +285,7 @@ def test_out_scalar(self, dtype):
         expected = numpy.dot(a, b, out=out)
 
         assert result is dp_out
-        _assert_selective_dtype_allclose(result, expected, dtype)
+        assert_dtype_allclose(result, expected)
 
     @pytest.mark.parametrize("dtype", get_all_dtypes())
     @pytest.mark.parametrize(
@@ -448,11 +436,11 @@ def test_scalar(self, dtype):
 
         result = dpnp.inner(a, ib)
         expected = numpy.inner(a, b)
-        _assert_selective_dtype_allclose(result, expected, dtype)
+        assert_dtype_allclose(result, expected)
 
         result = dpnp.inner(ib, a)
         expected = numpy.inner(b, a)
-        _assert_selective_dtype_allclose(result, expected, dtype)
+        assert_dtype_allclose(result, expected)
 
     @pytest.mark.parametrize("dtype", get_all_dtypes(no_none=True))
     @pytest.mark.parametrize(
@@ -516,11 +504,12 @@ def test_scalar(self, dtype):
 
         result = dpnp.kron(a, ib)
         expected = numpy.kron(a, b)
-        _assert_selective_dtype_allclose(result, expected, dtype)
+        assert_dtype_allclose(result, expected)
 
         result = dpnp.kron(ib, a)
         expected = numpy.kron(b, a)
-        _assert_selective_dtype_allclose(result, expected, dtype)
+        # NumPy returns incorrect dtype on Windows, so add check_type=False
+        assert_dtype_allclose(result, expected, check_type=False)
 
     @pytest.mark.parametrize("dtype", get_all_dtypes(no_none=True))
     @pytest.mark.parametrize(
@@ -768,11 +757,11 @@ def test_scalar(self, dtype):
 
         result = dpnp.tensordot(a, ib, axes=0)
         expected = numpy.tensordot(a, b, axes=0)
-        _assert_selective_dtype_allclose(result, expected, dtype)
+        assert_dtype_allclose(result, expected)
 
         result = dpnp.tensordot(ib, a, axes=0)
         expected = numpy.tensordot(b, a, axes=0)
-        _assert_selective_dtype_allclose(result, expected, dtype)
+        assert_dtype_allclose(result, expected)
 
     @pytest.mark.parametrize("dtype", get_all_dtypes(no_none=True))
     @pytest.mark.parametrize("axes", [0, 1, 2])
@@ -902,11 +891,11 @@ def test_scalar(self, dtype):
 
         result = dpnp.vdot(ia, b)
         expected = numpy.vdot(a, b)
-        _assert_selective_dtype_allclose(result, expected, dtype)
+        assert_dtype_allclose(result, expected)
 
         result = dpnp.vdot(b, ia)
         expected = numpy.vdot(b, a)
-        _assert_selective_dtype_allclose(result, expected, dtype)
+        assert_dtype_allclose(result, expected)
 
     @pytest.mark.parametrize("dtype", get_all_dtypes(no_none=True))
     @pytest.mark.parametrize(