Implement dpnp.astype (#961)

* Implement dpnp.astype

Co-authored-by: Alexander-Makaryev <[email protected]>

Author: densmirn

dpnp/dpnp_algo/dpnp_algo_arraycreation.pyx

@@ -212,9 +212,9 @@ cpdef tuple dpnp_linspace(start, stop, num, endpoint, retstep, dtype, axis):
     return (result.get_pyobj(), step)
 
 
-cpdef object dpnp_logspace(start, stop, num, endpoint, base, dtype, axis):
+cpdef utils.dpnp_descriptor dpnp_logspace(start, stop, num, endpoint, base, dtype, axis):
     temp = dpnp.linspace(start, stop, num=num, endpoint=endpoint)
-    return dpnp_astype(dpnp.get_dpnp_descriptor(dpnp.power(base, temp)), dtype)
+    return dpnp.get_dpnp_descriptor(dpnp.astype(dpnp.power(base, temp), dtype))
 
 
 cpdef list dpnp_meshgrid(xi, copy, sparse, indexing):

dpnp/dpnp_iface.py

@@ -55,6 +55,7 @@
 __all__ = [
     "array_equal",
     "asnumpy",
+    "astype",
     "convert_single_elem_array_to_scalar",
     "dpnp_queue_initialize",
     "dpnp_queue_is_cpu",
@@ -139,6 +140,34 @@ def asnumpy(input, order='C'):
     return numpy.asarray(input, order=order)
 
 
+def astype(x1, dtype, order='K', casting='unsafe', subok=True, copy=True):
+    """Copy the array with data type casting."""
+    if config.__DPNP_OUTPUT_DPCTL__ and hasattr(x1, "__sycl_usm_array_interface__"):
+        import dpctl.tensor as dpt
+        # TODO: remove check dpctl.tensor has attribute "astype"
+        if hasattr(dpt, "astype"):
+            return dpt.astype(x1, dtype, order=order, casting=casting, copy=copy)
+
+    x1_desc = get_dpnp_descriptor(x1)
+    if not x1_desc:
+        pass
+    elif order != 'K':
+        pass
+    elif casting != 'unsafe':
+        pass
+    elif not subok:
+        pass
+    elif not copy:
+        pass
+    elif x1_desc.dtype == numpy.complex128 or dtype == numpy.complex128:
+        pass
+    elif x1_desc.dtype == numpy.complex64 or dtype == numpy.complex64:
+        pass
+    else:
+        return dpnp_astype(x1_desc, dtype).get_pyobj()
+
+    return call_origin(numpy.ndarray.astype, x1, dtype, order=order, casting=casting, subok=subok, copy=copy)
+
 def convert_single_elem_array_to_scalar(obj, keepdims=False):
     """
     Convert array with single element to scalar

dpnp/dpnp_iface_statistics.py

@@ -292,7 +292,7 @@ def cov(x1, y=None, rowvar=True, bias=False, ddof=None, fweights=None, aweights=
             pass
         else:
             if x1_desc.dtype != dpnp.float64:
-                x1_desc = dpnp_astype(x1_desc, dpnp.float64)
+                x1_desc = dpnp.get_dpnp_descriptor(dpnp.astype(x1, dpnp.float64))
 
             return dpnp_cov(x1_desc).get_pyobj()
 

dpnp/linalg/dpnp_iface_linalg.py

@@ -94,7 +94,8 @@ def cholesky(input):
             pass
         else:
             if input.dtype == dpnp.int32 or input.dtype == dpnp.int64:
-                input_ = dpnp_astype(x1_desc, dpnp.float64)
+                # TODO memory copy. needs to move into DPNPC
+                input_ = dpnp.get_dpnp_descriptor(dpnp.astype(input, dpnp.float64))
             else:
                 input_ = x1_desc
             return dpnp_cholesky(input_).get_pyobj()

tests/test_random.py

@@ -946,7 +946,7 @@ def test_shuffle(self, dtype):
         input_x = dpnp.asarray([1, 2, 3, 4, 5, 6, 7, 8, 9, 0], dtype=dtype)
         dpnp.random.seed(seed)
         dpnp.random.shuffle(input_x_int64) # inplace
-        desired_x = input_x_int64.astype(dtype)
+        desired_x = dpnp.astype(input_x_int64, dtype)
         dpnp.random.seed(seed)
         dpnp.random.shuffle(input_x) # inplace
         actual_x = input_x
@@ -965,21 +965,21 @@ def test_no_miss_numbers(self, dtype):
         assert_array_equal(actual_x, desired_x)
 
     @pytest.mark.parametrize("conv", [lambda x: dpnp.array([]),
-                                      lambda x: dpnp.asarray(x).astype(dpnp.int8),
-                                      lambda x: dpnp.asarray(x).astype(dpnp.float32),
+                                      lambda x: dpnp.astype(asarray(x), dpnp.int8),
+                                      lambda x: dpnp.astype(asarray(x), dpnp.float32),
                                       # lambda x: dpnp.asarray(x).astype(dpnp.complex64),
-                                      lambda x: dpnp.asarray(x).astype(object),
+                                      lambda x: dpnp.astype(asarray(x), object),
                                       lambda x: dpnp.asarray([[i, i] for i in x]),
                                       lambda x: dpnp.vstack([x, x]).T,
                                       lambda x: (dpnp.asarray([(i, i) for i in x], [
                                                               ("a", int), ("b", int)]).view(dpnp.recarray)),
                                       lambda x: dpnp.asarray([(i, i) for i in x],
                                                              [("a", object), ("b", dpnp.int32)])],
                              ids=['lambda x: dpnp.array([])',
-                                  'lambda x: dpnp.asarray(x).astype(dpnp.int8)',
-                                  'lambda x: dpnp.asarray(x).astype(dpnp.float32)',
+                                  'lambda x: dpnp.astype(asarray(x), dpnp.int8)',
+                                  'lambda x: dpnp.astype(asarray(x), dpnp.float32)',
                                   # 'lambda x: dpnp.asarray(x).astype(dpnp.complex64)',
-                                  'lambda x: dpnp.asarray(x).astype(object)',
+                                  'lambda x: dpnp.astype(asarray(x), object)',
                                   'lambda x: dpnp.asarray([[i, i] for i in x])',
                                   'lambda x: dpnp.vstack([x, x]).T',
                                   'lambda x: (dpnp.asarray([(i, i) for i in x], ['\