Add some algo module functions to descriptor (#843)

Author: shssf

dpnp/dpnp_algo/dpnp_algo_arraycreation.pyx

@@ -98,7 +98,7 @@ cpdef utils.dpnp_descriptor dpnp_diag(utils.dpnp_descriptor v, int k):
 
 
 cpdef utils.dpnp_descriptor dpnp_full(result_shape, value_in, result_dtype):
-    # Convert string type names (dparray.dtype) to C enum DPNPFuncType
+    # Convert string type names (array.dtype) to C enum DPNPFuncType
     cdef DPNPFuncType dtype_in = dpnp_dtype_to_DPNPFuncType(result_dtype)
 
     # get the FPTR data structure
@@ -121,7 +121,7 @@ cpdef utils.dpnp_descriptor dpnp_full(result_shape, value_in, result_dtype):
 
 
 cpdef utils.dpnp_descriptor dpnp_full_like(result_shape, value_in, result_dtype):
-    # Convert string type names (dparray.dtype) to C enum DPNPFuncType
+    # Convert string type names (array.dtype) to C enum DPNPFuncType
     cdef DPNPFuncType dtype_in = dpnp_dtype_to_DPNPFuncType(result_dtype)
 
     # get the FPTR data structure
@@ -143,8 +143,9 @@ cpdef utils.dpnp_descriptor dpnp_full_like(result_shape, value_in, result_dtype)
     return result
 
 
-cpdef dparray dpnp_geomspace(start, stop, num, endpoint, dtype, axis):
-    cdef dparray result = dparray(num, dtype=dtype)
+cpdef utils.dpnp_descriptor dpnp_geomspace(start, stop, num, endpoint, dtype, axis):
+    cdef shape_type_c obj_shape = utils._object_to_tuple(num)
+    cdef utils.dpnp_descriptor result = utils_py.create_output_descriptor_py(obj_shape, dtype, None)
 
     if endpoint:
         steps_count = num - 1
@@ -156,28 +157,27 @@ cpdef dparray dpnp_geomspace(start, stop, num, endpoint, dtype, axis):
         step = dpnp.power(dpnp.float64(stop) / start, 1.0 / steps_count)
         mult = step
         for i in range(1, result.size):
-            result[i] = start * mult
+            result.get_pyobj()[i] = start * mult
             mult = mult * step
     else:
         step = dpnp.nan
 
     # if result is not empty, then fiil first and last elements
     if num > 0:
-        result[0] = start
+        result.get_pyobj()[0] = start
         if endpoint and result.size > 1:
-            result[result.size - 1] = stop
+            result.get_pyobj()[result.size - 1] = stop
 
     return result
 
 
-cpdef dparray dpnp_identity(n, result_dtype):
+cpdef utils.dpnp_descriptor dpnp_identity(n, result_dtype):
     cdef DPNPFuncType dtype_in = dpnp_dtype_to_DPNPFuncType(result_dtype)
 
     cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_IDENTITY, dtype_in, DPNP_FT_NONE)
 
-    result_type = dpnp_DPNPFuncType_to_dtype(< size_t > kernel_data.return_type)
-
-    cdef dparray result = dparray((n, n), dtype=result_type)
+    cdef shape_type_c shape_in = (n, n)
+    cdef utils.dpnp_descriptor result = utils.create_output_descriptor(shape_in, kernel_data.return_type, None)
 
     cdef fptr_1out_t func = <fptr_1out_t > kernel_data.ptr
     func(result.get_data(), n)
@@ -187,7 +187,8 @@ cpdef dparray dpnp_identity(n, result_dtype):
 
 # TODO this function should work through dpnp_arange_c
 cpdef tuple dpnp_linspace(start, stop, num, endpoint, retstep, dtype, axis):
-    cdef dparray result = dparray(num, dtype=dtype)
+    cdef shape_type_c obj_shape = utils._object_to_tuple(num)
+    cdef utils.dpnp_descriptor result = utils_py.create_output_descriptor_py(obj_shape, dtype, None)
 
     if endpoint:
         steps_count = num - 1
@@ -198,20 +199,20 @@ cpdef tuple dpnp_linspace(start, stop, num, endpoint, retstep, dtype, axis):
     if steps_count > 0:
         step = (dpnp.float64(stop) - start) / steps_count
         for i in range(1, result.size):
-            result[i] = start + step * i
+            result.get_pyobj()[i] = start + step * i
     else:
         step = dpnp.nan
 
     # if result is not empty, then fiil first and last elements
     if num > 0:
-        result[0] = start
+        result.get_pyobj()[0] = start
         if endpoint and result.size > 1:
-            result[result.size - 1] = stop
+            result.get_pyobj()[result.size - 1] = stop
 
-    return (result, step)
+    return (result.get_pyobj(), step)
 
 
-cpdef dparray dpnp_logspace(start, stop, num, endpoint, base, dtype, axis):
+cpdef object dpnp_logspace(start, stop, num, endpoint, base, dtype, axis):
     temp = dpnp.linspace(start, stop, num=num, endpoint=endpoint)
     return dpnp.power(base, temp).astype(dtype)
 
@@ -278,7 +279,7 @@ cpdef utils.dpnp_descriptor dpnp_trace(utils.dpnp_descriptor arr, offset=0, axis
     else:
         dtype_ = dtype
 
-    cdef dparray diagonal_arr = dpnp.diagonal(arr, offset, axis1, axis2)
+    cdef utils.dpnp_descriptor diagonal_arr = dpnp_diagonal(arr, offset)
     cdef size_t diagonal_ndim = diagonal_arr.ndim
     cdef shape_type_c diagonal_shape = diagonal_arr.shape
 
@@ -298,22 +299,19 @@ cpdef utils.dpnp_descriptor dpnp_trace(utils.dpnp_descriptor arr, offset=0, axis
     return result
 
 
-cpdef dparray dpnp_tri(N, M=None, k=0, dtype=numpy.float):
+cpdef utils.dpnp_descriptor dpnp_tri(N, M=None, k=0, dtype=numpy.float):
     if M is None:
         M = N
 
     if dtype == numpy.float:
         dtype = numpy.float64
 
-    cdef dparray result
-
     cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(dtype)
 
     cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_TRI, param1_type, param1_type)
 
-    result_type = dpnp_DPNPFuncType_to_dtype(< size_t > kernel_data.return_type)
-
-    result = dparray(shape=(N, M), dtype=result_type)
+    cdef shape_type_c shape_in = (N, M)
+    cdef utils.dpnp_descriptor result = utils.create_output_descriptor(shape_in, kernel_data.return_type, None)
 
     cdef custom_indexing_1out_func_ptr_t func = <custom_indexing_1out_func_ptr_t > kernel_data.ptr
 

dpnp/dpnp_algo/dpnp_algo_indexing.pyx

@@ -83,7 +83,7 @@ cpdef tuple dpnp_diag_indices(n, ndim):
     return tuple(result)
 
 
-cpdef dparray dpnp_diagonal(dpnp_descriptor input, offset=0):
+cpdef utils.dpnp_descriptor dpnp_diagonal(dpnp_descriptor input, offset=0):
     cdef shape_type_c input_shape = input.shape
 
     n = min(input.shape[0], input.shape[1])
@@ -100,18 +100,23 @@ cpdef dparray dpnp_diagonal(dpnp_descriptor input, offset=0):
     else:
         res_shape[-1] = n + offset
 
+    cdef shape_type_c result_shape = res_shape
     res_ndim = len(res_shape)
 
     cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(input.dtype)
 
     cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_DIAGONAL, param1_type, param1_type)
 
-    result_type = dpnp_DPNPFuncType_to_dtype( < size_t > kernel_data.return_type)
-    cdef dparray result = dparray(res_shape, dtype=result_type)
+    cdef utils.dpnp_descriptor result = utils.create_output_descriptor(result_shape, kernel_data.return_type, None)
 
     cdef custom_indexing_2in_1out_func_ptr_t_ func = <custom_indexing_2in_1out_func_ptr_t_ > kernel_data.ptr
 
-    func(input.get_data(), result.get_data(), offset, < size_t * > input_shape.data(), < size_t * > result._dparray_shape.data(), res_ndim)
+    func(input.get_data(),
+         result.get_data(),
+         offset,
+         < size_t * > input_shape.data(),
+         < size_t * > result_shape.data(),
+         res_ndim)
 
     return result
 

dpnp/dpnp_iface_arraycreation.py

@@ -742,9 +742,9 @@ def geomspace(start, stop, num=50, endpoint=True, dtype=None, axis=0):
 
     if not use_origin_backend():
         if axis != 0:
-            checker_throw_value_error("linspace", "axis", axis, 0)
-
-        return dpnp_geomspace(start, stop, num, endpoint, dtype, axis)
+            pass
+        else:
+            return dpnp_geomspace(start, stop, num, endpoint, dtype, axis).get_pyobj()
 
     return call_origin(numpy.geomspace, start, stop, num, endpoint, dtype, axis)
 
@@ -778,7 +778,7 @@ def identity(n, dtype=None, *, like=None):
         else:
             if dtype is None:
                 dtype = dpnp.float64
-            return dpnp_identity(n, dtype)
+            return dpnp_identity(n, dtype).get_pyobj()
 
     return call_origin(numpy.identity, n, dtype=dtype, like=like)
 
@@ -1175,7 +1175,7 @@ def tri(N, M=None, k=0, dtype=numpy.float, **kwargs):
         elif not isinstance(k, int):
             pass
         else:
-            return dpnp_tri(N, M, k, dtype)
+            return dpnp_tri(N, M, k, dtype).get_pyobj()
 
     return call_origin(numpy.tri, N, M, k, dtype, **kwargs)
 

dpnp/dpnp_iface_indexing.py

@@ -241,7 +241,7 @@ def diagonal(x1, offset=0, axis1=0, axis2=1):
         elif axis2 != 1:
             pass
         else:
-            return dpnp_diagonal(x1_desc, offset)
+            return dpnp_diagonal(x1_desc, offset).get_pyobj()
 
     return call_origin(numpy.diagonal, x1, offset, axis1, axis2)
 

dpnp/dpnp_utils/dpnp_algo_utils.pyx

@@ -163,7 +163,9 @@ cpdef checker_throw_value_error(function_name, param_name, param, expected):
 
 
 cpdef dpnp_descriptor create_output_descriptor_py(shape_type_c output_shape, object d_type, object requested_out):
-    cdef DPNPFuncType c_type = dpnp_dtype_to_DPNPFuncType(d_type)
+    py_type = dpnp.default_float_type() if d_type is None else d_type
+    
+    cdef DPNPFuncType c_type = dpnp_dtype_to_DPNPFuncType(py_type)
 
     return create_output_descriptor(output_shape, c_type, requested_out)