address comments

Author: vtavana

dpnp/dpnp_iface_manipulation.py

@@ -39,6 +39,7 @@
 
 
 import math
+import operator
 
 import dpctl.tensor as dpt
 import numpy
@@ -1524,6 +1525,7 @@ def fliplr(m):
     --------
     :obj:`dpnp.flipud` : Flip an array vertically (axis=0).
     :obj:`dpnp.flip` : Flip array in one or more dimensions.
+    :obj:`dpnp.rot90` : Rotate array counterclockwise.
 
     Examples
     --------
@@ -1574,6 +1576,7 @@ def flipud(m):
     --------
     :obj:`dpnp.fliplr` : Flip array in the left/right direction.
     :obj:`dpnp.flip` : Flip array in one or more dimensions.
+    :obj:`dpnp.rot90` : Rotate array counterclockwise.
 
     Examples
     --------
@@ -2056,12 +2059,12 @@ def resize(a, new_shape):
     -------
     out : dpnp.ndarray
         The new array is formed from the data in the old array, repeated
-        if necessary to fill out the required number of elements.  The
+        if necessary to fill out the required number of elements. The
         data are repeated iterating over the array in C-order.
 
     See Also
     --------
-    :obj:`dpnp.ndarray.reshape` : Resize an array in-place.
+    :obj:`dpnp.ndarray.resize` : Resize an array in-place.
     :obj:`dpnp.reshape` : Reshape an array without changing the total size.
     :obj:`dpnp.pad` : Enlarge and pad an array.
     :obj:`dpnp.repeat` : Repeat elements of an array.
@@ -2083,8 +2086,8 @@ def resize(a, new_shape):
     Examples
     --------
     >>> import dpnp as np
-    >>> a=np.array([[0, 1], [2, 3]])
-    >>> np.resize(a, (2 ,3))
+    >>> a = np.array([[0, 1], [2, 3]])
+    >>> np.resize(a, (2, 3))
     array([[0, 1, 2],
            [3, 0, 1]])
     >>> np.resize(a, (1, 4))
@@ -2097,24 +2100,24 @@ def resize(a, new_shape):
 
     dpnp.check_supported_arrays_type(a)
     if a.ndim == 0:
-        return dpnp.full(new_shape, a)
+        return dpnp.full_like(a, a, shape=new_shape)
 
     if isinstance(new_shape, (int, numpy.integer)):
         new_shape = (new_shape,)
 
-    a = dpnp.ravel(a)
     new_size = 1
     for dim_length in new_shape:
         if dim_length < 0:
             raise ValueError("all elements of `new_shape` must be non-negative")
         new_size *= dim_length
 
-    if a.size == 0 or new_size == 0:
+    a_size = a.size
+    if a_size == 0 or new_size == 0:
         # First case must zero fill. The second would have repeats == 0.
         return dpnp.zeros_like(a, shape=new_shape)
 
-    repeats = -(-new_size // a.size)  # ceil division
-    a = dpnp.concatenate((a,) * repeats)[:new_size]
+    repeats = -(-new_size // a_size)  # ceil division
+    a = dpnp.concatenate((dpnp.ravel(a),) * repeats)[:new_size]
 
     return a.reshape(new_shape)
 
@@ -2324,7 +2327,7 @@ def rot90(m, k=1, axes=(0, 1)):
 
     Notes
     -----
-    ``rot90(m, k=1, axes=(1,0))``  is the reverse of
+    ``rot90(m, k=1, axes=(1,0))`` is the reverse of
     ``rot90(m, k=1, axes=(0,1))``.
 
     ``rot90(m, k=1, axes=(1,0))`` is equivalent to
@@ -2353,8 +2356,7 @@ def rot90(m, k=1, axes=(0, 1)):
     """
 
     dpnp.check_supported_arrays_type(m)
-    if not isinstance(k, (int, dpnp.integer)):
-        raise TypeError("k must be an integer.")
+    k = operator.index(k)
 
     m_ndim = m.ndim
     if m_ndim < 2:
@@ -2384,7 +2386,7 @@ def rot90(m, k=1, axes=(0, 1)):
     )
 
     if k == 1:
-        return dpnp.transpose(flip(m, axes[1]), axes_list)
+        return dpnp.transpose(dpnp.flip(m, axes[1]), axes_list)
 
     # k == 3
     return dpnp.flip(dpnp.transpose(m, axes_list), axes[1])

tests/test_manipulation.py

@@ -666,37 +666,37 @@ def test_minimum_signed_integers(self, data, dtype):
 
 
 class TestResize:
-    def test_copies(self):
-        a = numpy.array([[1, 2], [3, 4]])
-        ia = dpnp.array(a)
-        assert_equal(dpnp.resize(ia, (2, 4)), numpy.resize(a, (2, 4)))
-
-        a = numpy.array([[1, 2], [3, 4], [1, 2], [3, 4]])
-        ia = dpnp.array(a)
-        assert_equal(dpnp.resize(ia, (4, 2)), numpy.resize(a, (4, 2)))
-
-        a = numpy.array([[1, 2, 3], [4, 1, 2], [3, 4, 1], [2, 3, 4]])
+    @pytest.mark.parametrize(
+        "data, shape",
+        [
+            pytest.param([[1, 2], [3, 4]], (2, 4)),
+            pytest.param([[1, 2], [3, 4], [1, 2], [3, 4]], (4, 2)),
+            pytest.param([[1, 2, 3], [4, 1, 2], [3, 4, 1], [2, 3, 4]], (4, 3)),
+        ],
+    )
+    def test_copies(self, data, shape):
+        a = numpy.array(data)
         ia = dpnp.array(a)
-        assert_equal(dpnp.resize(ia, (4, 3)), numpy.resize(a, (4, 3)))
+        assert_equal(dpnp.resize(ia, shape), numpy.resize(a, shape))
 
     @pytest.mark.parametrize("newshape", [(2, 4), [2, 4], (10,), 10])
     def test_newshape_type(self, newshape):
         a = numpy.array([[1, 2], [3, 4]])
         ia = dpnp.array(a)
         assert_equal(dpnp.resize(ia, newshape), numpy.resize(a, newshape))
 
-    def test_repeats(self):
-        a = numpy.array([1, 2, 3])
-        ia = dpnp.array(a)
-        assert_equal(dpnp.resize(ia, (2, 4)), numpy.resize(a, (2, 4)))
-
-        a = numpy.array([[1, 2], [3, 1], [2, 3], [1, 2]])
-        ia = dpnp.array(a)
-        assert_equal(dpnp.resize(ia, (4, 2)), numpy.resize(a, (4, 2)))
-
-        a = numpy.array([[1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3]])
+    @pytest.mark.parametrize(
+        "data, shape",
+        [
+            pytest.param([1, 2, 3], (2, 4)),
+            pytest.param([[1, 2], [3, 1], [2, 3], [1, 2]], (4, 2)),
+            pytest.param([[1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3]], (4, 3)),
+        ],
+    )
+    def test_repeats(self, data, shape):
+        a = numpy.array(data)
         ia = dpnp.array(a)
-        assert_equal(dpnp.resize(ia, (4, 3)), numpy.resize(a, (4, 3)))
+        assert_equal(dpnp.resize(ia, shape), numpy.resize(a, shape))
 
     def test_zeroresize(self):
         a = numpy.array([[1, 2], [3, 4]])
@@ -729,9 +729,9 @@ def test_error(self, xp):
         assert_raises(ValueError, xp.rot90, xp.ones((2, 2)), axes=(0, 2))
         assert_raises(ValueError, xp.rot90, xp.ones((2, 2)), axes=(1, 1))
         assert_raises(ValueError, xp.rot90, xp.ones((2, 2, 2)), axes=(-2, 1))
-        if xp == dpnp:
-            # NumPy return result of k=3 incorrectly when k is float
-            assert_raises(TypeError, xp.rot90, xp.ones((2, 2)), k=2.5)
+
+    def test_error_float_k(self):
+        assert_raises(TypeError, dpnp.rot90, dpnp.ones((2, 2)), k=2.5)
 
     def test_basic(self):
         a = numpy.array([[0, 1, 2], [3, 4, 5]])

tests/test_sycl_queue.py

@@ -495,6 +495,7 @@ def test_meshgrid(device):
         ),
         pytest.param("real_if_close", [2.1 + 4e-15j, 5.2 + 3e-16j]),
         pytest.param("reciprocal", [1.0, 2.0, 4.0, 7.0]),
+        pytest.param("rot90", [[1, 2], [3, 4]]),
         pytest.param("sign", [-5.0, 0.0, 4.5]),
         pytest.param("signbit", [-5.0, 0.0, 4.5]),
         pytest.param(
@@ -1298,20 +1299,6 @@ def test_resize(device):
     assert_sycl_queue_equal(result_queue, expected_queue)
 
 
-@pytest.mark.parametrize(
-    "device",
-    valid_devices,
-    ids=[device.filter_string for device in valid_devices],
-)
-def test_rot90(device):
-    dpnp_data = dpnp.array([[1, 2], [3, 4]], device=device)
-    result = dpnp.rot90(dpnp_data)
-
-    expected_queue = dpnp_data.sycl_queue
-    result_queue = result.sycl_queue
-    assert_sycl_queue_equal(result_queue, expected_queue)
-
-
 class TestFft:
     @pytest.mark.parametrize(
         "func", ["fft", "ifft", "rfft", "irfft", "hfft", "ihfft"]

tests/test_usm_type.py

@@ -622,6 +622,7 @@ def test_norm(usm_type, ord, axis):
         pytest.param("real_if_close", [2.1 + 4e-15j, 5.2 + 3e-16j]),
         pytest.param("reciprocal", [1.0, 2.0, 4.0, 7.0]),
         pytest.param("reduce_hypot", [1.0, 2.0, 4.0, 7.0]),
+        pytest.param("rot90", [[1, 2], [3, 4]]),
         pytest.param("rsqrt", [1, 8, 27]),
         pytest.param("sign", [-5.0, 0.0, 4.5]),
         pytest.param("signbit", [-5.0, 0.0, 4.5]),
@@ -1021,15 +1022,6 @@ def test_resize(usm_type):
     assert result.usm_type == usm_type
 
 
-@pytest.mark.parametrize("usm_type", list_of_usm_types, ids=list_of_usm_types)
-def test_rot90(usm_type):
-    dpnp_data = dp.array([[1, 2], [3, 4]], usm_type=usm_type)
-    result = dp.rot90(dpnp_data)
-
-    assert dpnp_data.usm_type == usm_type
-    assert result.usm_type == usm_type
-
-
 class TestFft:
     @pytest.mark.parametrize(
         "func", ["fft", "ifft", "rfft", "irfft", "hfft", "ihfft"]