Added dpt.copy, and dpt.asnumpy (alias of dpt.to_numpy)

dpctl/tensor/__init__.py

@@ -29,16 +29,19 @@
 
 """
 
-from dpctl.tensor._copy_utils import astype
+from dpctl.tensor._copy_utils import astype, copy
 from dpctl.tensor._copy_utils import copy_from_numpy as from_numpy
+from dpctl.tensor._copy_utils import copy_to_numpy as asnumpy
 from dpctl.tensor._copy_utils import copy_to_numpy as to_numpy
 from dpctl.tensor._reshape import reshape
 from dpctl.tensor._usmarray import usm_ndarray
 
 __all__ = [
     "usm_ndarray",
     "astype",
+    "copy",
     "reshape",
     "from_numpy",
     "to_numpy",
+    "asnumpy",
 ]

dpctl/tensor/_copy_utils.py

@@ -253,6 +253,71 @@ def copy_from_usm_ndarray_to_usm_ndarray(dst, src):
     copy_same_shape(dst, src_same_shape)
 
 
+def copy(usm_ary, order="K"):
+    """
+    Creates a copy of given instance of `usm_ndarray`.
+
+    Memory layour of the copy is controlled by `order` keyword,
+    following NumPy's conventions. The `order` keywords can be
+    one of the following:
+
+       "C": C-contiguous memory layout
+       "F": Fotrant-contiguous memory layout
+       "A": Fotrant-contiguous if the input array is
+            F-contiguous, and C-contiguous otherwise
+       "K": match the layout of `usm_ary` as closely
+            as possible.
+
+    """
+    if not isinstance(usm_ary, dpt.usm_ndarray):
+        return TypeError(
+            "Expected object of type dpt.usm_ndarray, got {}".format(
+                type(usm_ary)
+            )
+        )
+    copy_order = "C"
+    if order == "C":
+        pass
+    elif order == "F":
+        copy_order = order
+    elif order == "A":
+        if usm_ary.flags & 2:
+            copy_order = "F"
+    elif order == "K":
+        if usm_ary.flags & 2:
+            copy_order = "F"
+    else:
+        raise ValueError(
+            "Unrecognized value of the order keyword. "
+            "Recognized values are 'A', 'C', 'F', or 'K'"
+        )
+    c_contig = usm_ary.flags & 1
+    f_contig = usm_ary.flags & 2
+    R = dpt.usm_ndarray(
+        usm_ary.shape,
+        dtype=usm_ary.dtype,
+        buffer=usm_ary.usm_type,
+        order=copy_order,
+        buffer_ctor_kwargs={"queue": usm_ary.sycl_queue},
+    )
+    if order == "K" and (not c_contig and not f_contig):
+        original_strides = usm_ary.strides
+        ind = sorted(
+            range(usm_ary.ndim),
+            key=lambda i: abs(original_strides[i]),
+            reverse=True,
+        )
+        new_strides = tuple(R.strides[ind[i]] for i in ind)
+        R = dpt.usm_ndarray(
+            usm_ary.shape,
+            dtype=usm_ary.dtype,
+            buffer=R.usm_data,
+            strides=new_strides,
+        )
+    copy_same_dtype(R, usm_ary)
+    return R
+
+
 def astype(usm_ary, newdtype, order="K", casting="unsafe", copy=True):
     """
     astype(usm_array, new_dtype, order="K", casting="unsafe", copy=True)
@@ -267,6 +332,11 @@ def astype(usm_ary, newdtype, order="K", casting="unsafe", copy=True):
                 type(usm_ary)
             )
         )
+    if not isinstance(order, str) or order not in ["A", "C", "F", "K"]:
+        raise ValueError(
+            "Unrecognized value of the order keyword. "
+            "Recognized values are 'A', 'C', 'F', or 'K'"
+        )
     ary_dtype = usm_ary.dtype
     target_dtype = np.dtype(newdtype)
     if not np.can_cast(ary_dtype, target_dtype, casting=casting):
@@ -294,6 +364,11 @@ def astype(usm_ary, newdtype, order="K", casting="unsafe", copy=True):
         elif order == "K":
             if usm_ary.flags & 2:
                 copy_order = "F"
+        else:
+            raise ValueError(
+                "Unrecognized value of the order keyword. "
+                "Recognized values are 'A', 'C', 'F', or 'K'"
+            )
         R = dpt.usm_ndarray(
             usm_ary.shape,
             dtype=target_dtype,

dpctl/tests/test_usm_ndarray_ctor.py

@@ -768,6 +768,34 @@ def test_astype():
     assert Y.usm_data is X.usm_data
 
 
+def test_astype_invalid_order():
+    X = dpt.usm_ndarray(5, "i4")
+    with pytest.raises(ValueError):
+        dpt.astype(X, "i4", order="WRONG")
+
+
+def test_copy():
+    X = dpt.usm_ndarray((5, 5), "i4")[2:4, 1:4]
+    X[:] = 42
+    Yc = dpt.copy(X, order="C")
+    Yf = dpt.copy(X, order="F")
+    Ya = dpt.copy(X, order="A")
+    Yk = dpt.copy(X, order="K")
+    assert Yc.usm_data is not X.usm_data
+    assert Yf.usm_data is not X.usm_data
+    assert Ya.usm_data is not X.usm_data
+    assert Yk.usm_data is not X.usm_data
+    assert Yc.strides == (3, 1)
+    assert Yf.strides == (1, 2)
+    assert Ya.strides == (3, 1)
+    assert Yk.strides == (3, 1)
+    ref = np.full(X.shape, 42, dtype=X.dtype)
+    assert np.array_equal(dpt.asnumpy(Yc), ref)
+    assert np.array_equal(dpt.asnumpy(Yf), ref)
+    assert np.array_equal(dpt.asnumpy(Ya), ref)
+    assert np.array_equal(dpt.asnumpy(Yk), ref)
+
+
 def test_ctor_invalid():
     m = dpm.MemoryUSMShared(12)
     with pytest.raises(ValueError):