update dpnp.ravel

Author: vtavana

dpnp/dpnp_iface_manipulation.py

@@ -1849,23 +1849,50 @@ def ravel(a, order="C"):
     x : {dpnp.ndarray, usm_ndarray}
         Input array. The elements in `a` are read in the order specified by
         order, and packed as a 1-D array.
-    order : {"C", "F"}, optional
+    order : {None, "C", "F", "A"}, optional
         The elements of `a` are read using this index order. ``"C"`` means to
         index the elements in row-major, C-style order, with the last axis
         index changing fastest, back to the first axis index changing slowest.
         ``"F"`` means to index the elements in column-major, Fortran-style
         order, with the first index changing fastest, and the last index
-        changing slowest. By default, ``"C"`` index order is used.
+        changing slowest. Note that the "C" and "F" options take no account of
+        the memory layout of the underlying array, and only refer to
+        the order of axis indexing. "A" means to read the elements in
+        Fortran-like index order if `a` is Fortran *contiguous* in
+        memory, C-like order otherwise. ``order=None`` is an alias for
+        ``order="C"``.
+        Default: ``"C"``.
 
     Returns
     -------
     out : dpnp.ndarray
         A contiguous 1-D array of the same subtype as `a`, with shape (a.size,).
 
+    Limitations
+    -----------
+    `order="K"` is not supported and the function raises `NotImplementedError`
+    exception.
+
     See Also
     --------
-    :obj:`dpnp.reshape` : Change the shape of an array without changing its
-                          data.
+    :obj:`dpnp.ndarray.flat` : 1-D iterator over an array.
+    :obj:`dpnp.ndarray.flatten` : 1-D array copy of the elements of an array
+                    in row-major order.
+    :obj:`dpnp.ndarray.reshape` : Change the shape of an array without
+                    changing its data.
+    :obj:`dpnp.reshape` : The same as :obj:`dpnp.ndarray.reshape`.
+
+    Notes
+    -----
+    In row-major, C-style order, in two dimensions, the row index
+    varies the slowest, and the column index the quickest.  This can
+    be generalized to multiple dimensions, where row-major order
+    implies that the index along the first axis varies slowest, and
+    the index along the last quickest. The opposite holds for
+    column-major, Fortran-style index ordering.
+
+    When a view is desired in as many cases as possible, ``arr.reshape(-1)``
+    may be preferable.
 
     Examples
     --------
@@ -1880,9 +1907,26 @@ def ravel(a, order="C"):
     >>> np.ravel(x, order='F')
     array([1, 4, 2, 5, 3, 6])
 
+    When ``order`` is 'A', it will preserve the array's 'C' or 'F' ordering:
+
+    >>> np.ravel(x.T)
+    array([1, 4, 2, 5, 3, 6])
+    >>> np.ravel(x.T, order='A')
+    array([1, 2, 3, 4, 5, 6])
+
     """
 
-    return dpnp.reshape(a, -1, order=order)
+    if order in "kK":
+        raise NotImplementedError(
+            "Keyword argument `order` is supported only with "
+            f"values None, 'C', 'F', and 'A', but got '{order}'"
+        )
+
+    result = dpnp.reshape(a, -1, order=order)
+    if result.flags.c_contiguous:
+        return result
+
+    return dpnp.ascontiguousarray(result)
 
 
 def repeat(a, repeats, axis=None):
@@ -2071,8 +2115,6 @@ def reshape(a, /, shape=None, order="C", *, newshape=None, copy=None):
         an integer, then the result will be a 1-D array of that length.
         One shape dimension can be -1. In this case, the value is
         inferred from the length of the array and remaining dimensions.
-    newshape : int or tuple of ints
-        Replaced by `shape` argument. Retained for backward compatibility.
     order : {None, "C", "F", "A"}, optional
         Read the elements of `a` using this index order, and place the
         elements into the reshaped array using this index order. ``"C"``
@@ -2087,6 +2129,8 @@ def reshape(a, /, shape=None, order="C", *, newshape=None, copy=None):
         read / write the elements in Fortran-like index order if ``a`` is
         Fortran *contiguous* in memory, C-like order otherwise.
         Default: ``"C"``.
+    newshape : int or tuple of ints
+        Replaced by `shape` argument. Retained for backward compatibility.
     copy : {None, bool}, optional
         If ``True``, then the array data is copied. If ``None``, a copy will
         only be made if it's required by ``order``. For ``False`` it raises
@@ -2109,7 +2153,7 @@ def reshape(a, /, shape=None, order="C", *, newshape=None, copy=None):
     It is not always possible to change the shape of an array without copying
     the data.
 
-    The ``order`` keyword gives the index ordering both for *fetching*
+    The `order` keyword gives the index ordering both for *fetching*
     the values from ``a``, and then *placing* the values into the output
     array. For example, let's say you have an array:
 

tests/test_manipulation.py

@@ -448,6 +448,22 @@ def test_no_copy(self):
         assert_array_equal(b, a)
 
 
+class TestRavel:
+    def test_error(self):
+        ia = dpnp.arange(10).reshape(2, 5)
+        assert_raises(NotImplementedError, dpnp.ravel, ia, order="K")
+
+    @pytest.mark.parametrize("order", ["C", "F", "A"])
+    def test_non_contiguous(self, order):
+        a = numpy.arange(10)[::2]
+        ia = dpnp.arange(10)[::2]
+        expected = numpy.ravel(a, order=order)
+        result = dpnp.ravel(ia, order=order)
+        assert result.flags.c_contiguous == expected.flags.c_contiguous
+        assert result.flags.f_contiguous == expected.flags.f_contiguous
+        assert_array_equal(result, expected)
+
+
 class TestRepeat:
     @pytest.mark.parametrize(
         "data",

tests/third_party/cupy/manipulation_tests/test_shape.py

@@ -142,29 +142,80 @@ def test_ndim_limit2(self, dtype, order):
 
 
 class TestRavel:
-    @testing.for_orders("CF")
-    # order = 'A' is out of support currently
+    @testing.for_orders("CFA")
+    # order = 'K' is not supported currently
     @testing.numpy_cupy_array_equal()
     def test_ravel(self, xp, order):
         a = testing.shaped_arange((2, 3, 4), xp)
         a = a.transpose(2, 0, 1)
         return a.ravel(order)
 
-    @testing.for_orders("CF")
-    # order = 'A' is out of support currently
+    @testing.for_orders("CFA")
+    # order = 'K' is not supported currently
     @testing.numpy_cupy_array_equal()
     def test_ravel2(self, xp, order):
         a = testing.shaped_arange((2, 3, 4), xp)
         return a.ravel(order)
 
-    @testing.for_orders("CF")
-    # order = 'A' is out of support currently
+    @testing.for_orders("CFA")
+    # order = 'K' is not supported currently
     @testing.numpy_cupy_array_equal()
     def test_ravel3(self, xp, order):
         a = testing.shaped_arange((2, 3, 4), xp)
         a = xp.asfortranarray(a)
         return a.ravel(order)
 
+    @testing.for_orders("CFA")
+    # order = 'K' is not supported currently
+    @testing.numpy_cupy_array_equal()
+    def test_ravel4(self, xp, order):
+        a = testing.shaped_arange((2, 3, 4), xp)
+        a = a.transpose(0, 2, 1)[:, ::-2]
+        return a.ravel(order)
+
+    @testing.for_orders("CFA")
+    # order = 'K' is not supported currently
+    @testing.numpy_cupy_array_equal()
+    def test_ravel_non_contiguous(self, xp, order):
+        a = xp.arange(10)[::2]
+        assert not a.flags.c_contiguous and not a.flags.f_contiguous
+        b = a.ravel(order)
+        assert b.flags.c_contiguous
+        return b
+
+    @testing.for_orders("CFA")
+    # order = 'K' is not supported currently
+    @testing.numpy_cupy_array_equal()
+    def test_ravel_broadcasted(self, xp, order):
+        a = xp.array([1])
+        b = xp.broadcast_to(a, (10,))
+        assert not b.flags.c_contiguous and not b.flags.f_contiguous
+        b = b.ravel(order)
+        assert b.flags.c_contiguous
+        return b
+
+    @testing.for_orders("CFA")
+    # order = 'K' is not supported currently
+    @testing.numpy_cupy_array_equal()
+    def test_ravel_broadcasted2(self, xp, order):
+        a = testing.shaped_arange((2, 1), xp)
+        b = xp.broadcast_to(a, (3, 2, 4))
+        assert not b.flags.c_contiguous and not b.flags.f_contiguous
+        b = b.ravel(order)
+        assert b.flags.c_contiguous
+        return b
+
+    @testing.for_orders("CFA")
+    # order = 'K' is not supported currently
+    @testing.for_orders("CF", name="a_order")
+    @testing.numpy_cupy_array_equal()
+    def test_ravel_broadcasted3(self, xp, order, a_order):
+        a = testing.shaped_arange((2, 1, 3), xp, order=a_order)
+        b = xp.broadcast_to(a, (2, 4, 3))
+        b = b.ravel(order)
+        assert b.flags.c_contiguous
+        return b
+
     @testing.numpy_cupy_array_equal()
     def test_external_ravel(self, xp):
         a = testing.shaped_arange((2, 3, 4), xp)