algo module free of dparray (#871)

Author: shssf

dpnp/dpnp_algo/dpnp_algo.pyx

@@ -39,7 +39,6 @@ import dpnp.dpnp_utils as utils_py
 import numpy
 
 cimport cpython
-from dpnp.dparray cimport dparray
 cimport dpnp.dpnp_utils as utils
 cimport numpy
 

dpnp/dpnp_algo/dpnp_algo_mathematical.pyx

@@ -80,19 +80,18 @@ ctypedef void(*ftpr_custom_trapz_2in_1out_with_2size_t)(void *, void * , void *
 ctypedef void(*ftpr_custom_around_1in_1out_t)(const void * , void * , const size_t, const int)
 
 
-cpdef dparray dpnp_absolute(utils.dpnp_descriptor input):
+cpdef utils.dpnp_descriptor dpnp_absolute(utils.dpnp_descriptor input):
     cdef shape_type_c input_shape = input.shape
     cdef size_t input_shape_size = input.ndim
 
-    # convert string type names (dparray.dtype) to C enum DPNPFuncType
+    # convert string type names (array.dtype) to C enum DPNPFuncType
     cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(input.dtype)
 
     # get the FPTR data structure
     cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_ABSOLUTE, param1_type, param1_type)
 
-    result_type = dpnp_DPNPFuncType_to_dtype( < size_t > kernel_data.return_type)
     # ceate result array with type given by FPTR data
-    cdef dparray result = dparray(input_shape, dtype=result_type)
+    cdef utils.dpnp_descriptor result = utils.create_output_descriptor(input_shape, kernel_data.return_type, None)
 
     cdef fptr_custom_elemwise_absolute_1in_1out_t func = <fptr_custom_elemwise_absolute_1in_1out_t > kernel_data.ptr
     # call FPTR function
@@ -117,15 +116,15 @@ cpdef utils.dpnp_descriptor dpnp_arctan2(utils.dpnp_descriptor x1_obj,
     return call_fptr_2in_1out(DPNP_FN_ARCTAN2, x1_obj, x2_obj, dtype, out, where, func_name="arctan2")
 
 
-cpdef dpnp_around(utils.dpnp_descriptor x1, int decimals):
+cpdef utils.dpnp_descriptor dpnp_around(utils.dpnp_descriptor x1, int decimals):
 
     cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(x1.dtype)
 
     cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_AROUND, param1_type, param1_type)
 
-    result_type = dpnp_DPNPFuncType_to_dtype(< size_t > kernel_data.return_type)
-
-    cdef dparray result = dparray(x1.shape, dtype=result_type)
+    # ceate result array with type given by FPTR data
+    cdef shape_type_c result_shape = x1.shape
+    cdef utils.dpnp_descriptor result = utils.create_output_descriptor(result_shape, kernel_data.return_type, None)
 
     cdef ftpr_custom_around_1in_1out_t func = <ftpr_custom_around_1in_1out_t > kernel_data.ptr
 
@@ -182,11 +181,11 @@ cpdef utils.dpnp_descriptor dpnp_cumsum(utils.dpnp_descriptor x1):
     return call_fptr_1in_1out(DPNP_FN_CUMSUM, x1, (x1.size,))
 
 
-cpdef dparray dpnp_diff(object input, int n):
+cpdef object dpnp_diff(utils.dpnp_descriptor input, int n):
     if n == 0:
-        return input
+        return input.get_pyobj()
     if n < input.shape[-1]:
-        arr = input
+        arr = input.get_pyobj()
         for _ in range(n):
             list_shape_i = list(arr.shape)
             list_shape_i[-1] = list_shape_i[-1] - 1
@@ -249,23 +248,25 @@ cpdef utils.dpnp_descriptor dpnp_fmod(utils.dpnp_descriptor x1_obj,
     return call_fptr_2in_1out(DPNP_FN_FMOD, x1_obj, x2_obj, dtype, out, where)
 
 
-cpdef dparray dpnp_gradient(object y1, int dx=1):
+cpdef utils.dpnp_descriptor dpnp_gradient(utils.dpnp_descriptor y1, int dx=1):
 
-    size = y1.size
+    cdef size_t size = y1.size
 
-    cdef dparray result = dparray(size, dtype=dpnp.float64)
+    # ceate result array with type given by FPTR data
+    cdef shape_type_c result_shape = utils._object_to_tuple(size)
+    cdef utils.dpnp_descriptor result = utils_py.create_output_descriptor_py(result_shape, dpnp.float64, None)
 
-    cur = (y1[1] - y1[0]) / dx
+    cdef double cur = (y1.get_pyobj()[1] - y1.get_pyobj()[0]) / dx
 
-    result._setitem_scalar(0, cur)
+    result.get_pyobj().flat[0] = cur
 
-    cur = (y1[-1] - y1[-2]) / dx
+    cur = (y1.get_pyobj()[-1] - y1.get_pyobj()[-2]) / dx
 
-    result._setitem_scalar(size - 1, cur)
+    result.get_pyobj().flat[size - 1] = cur
 
     for i in range(1, size - 1):
-        cur = (y1[i + 1] - y1[i - 1]) / (2 * dx)
-        result._setitem_scalar(i, cur)
+        cur = (y1.get_pyobj()[i + 1] - y1.get_pyobj()[i - 1]) / (2 * dx)
+        result.get_pyobj().flat[i] = cur
 
     return result
 
@@ -295,22 +296,22 @@ cpdef utils.dpnp_descriptor dpnp_minimum(utils.dpnp_descriptor x1_obj,
 
 
 cpdef tuple dpnp_modf(utils.dpnp_descriptor x1):
-    """ Convert string type names (dparray.dtype) to C enum DPNPFuncType """
+    """ Convert string type names (array.dtype) to C enum DPNPFuncType """
     cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(x1.dtype)
 
     """ get the FPTR data structure """
     cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_MODF, param1_type, DPNP_FT_NONE)
 
-    result_type = dpnp_DPNPFuncType_to_dtype( < size_t > kernel_data.return_type)
-    """ Create result arrays with type given by FPTR data """
-    cdef dparray result1 = dparray(x1.shape, dtype=result_type)
-    cdef dparray result2 = dparray(x1.shape, dtype=result_type)
+    # ceate result array with type given by FPTR data
+    cdef shape_type_c result_shape = x1.shape
+    cdef utils.dpnp_descriptor result1 = utils.create_output_descriptor(result_shape, kernel_data.return_type, None)
+    cdef utils.dpnp_descriptor result2 = utils.create_output_descriptor(result_shape, kernel_data.return_type, None)
 
     cdef fptr_1in_2out_t func = <fptr_1in_2out_t > kernel_data.ptr
     """ Call FPTR function """
     func(x1.get_data(), result1.get_data(), result2.get_data(), x1.size)
 
-    return result1, result2
+    return (result1.get_pyobj(), result2.get_pyobj())
 
 
 cpdef utils.dpnp_descriptor dpnp_multiply(utils.dpnp_descriptor x1_obj,
@@ -343,38 +344,32 @@ cpdef utils.dpnp_descriptor dpnp_nancumsum(utils.dpnp_descriptor x1):
     return dpnp_cumsum(x1_desc)
 
 
-cpdef dpnp_nanprod(object x1):
-    cdef dparray result = dparray(x1.shape, dtype=x1.dtype)
+cpdef utils.dpnp_descriptor dpnp_nanprod(utils.dpnp_descriptor x1):
+    cdef utils.dpnp_descriptor result = utils_py.create_output_descriptor_py(x1.shape, x1.dtype, None)
 
     for i in range(result.size):
-        input_elem = x1.item(i)
+        input_elem = x1.get_pyobj().flat[i]
 
         if dpnp.isnan(input_elem):
-            result._setitem_scalar(i, 1)
+            result.get_pyobj().flat[i] = 1
         else:
-            result._setitem_scalar(i, input_elem)
+            result.get_pyobj().flat[i] = input_elem
 
-    result_desc = dpnp.get_dpnp_descriptor(result)  # TODO remove it later
-    return dpnp_prod(result_desc)
+    return dpnp_prod(result)
 
 
-cpdef dpnp_nansum(object x1):
-    cdef dparray result = dparray(x1.shape, dtype=x1.dtype)
+cpdef utils.dpnp_descriptor dpnp_nansum(utils.dpnp_descriptor x1):
+    cdef utils.dpnp_descriptor result = utils_py.create_output_descriptor_py(x1.shape, x1.dtype, None)
 
     for i in range(result.size):
-        input_elem = x1.item(i)
+        input_elem = x1.get_pyobj().flat[i]
 
         if dpnp.isnan(input_elem):
-            result._setitem_scalar(i, 0)
+            result.get_pyobj().flat[i] = 0
         else:
-            result._setitem_scalar(i, input_elem)
+            result.get_pyobj().flat[i] = input_elem
 
-    # due to bug in dpnp_sum need this workaround
-    # return dpnp_sum(result)
-
-    result_desc = dpnp.get_dpnp_descriptor(result)  # TODO remove it later
-    sum_result = dpnp_sum(result_desc).get_pyobj()
-    return x1.dtype.type(sum_result[0])
+    return dpnp_sum(result)
 
 
 cpdef utils.dpnp_descriptor dpnp_negative(dpnp_descriptor x1):
@@ -476,20 +471,20 @@ cpdef utils.dpnp_descriptor dpnp_sum(utils.dpnp_descriptor input,
     return result
 
 
-cpdef dpnp_trapz(utils.dpnp_descriptor y1, dparray x1, double dx):
+cpdef utils.dpnp_descriptor dpnp_trapz(utils.dpnp_descriptor y1, utils.dpnp_descriptor x1, double dx):
 
     cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(y1.dtype)
     cdef DPNPFuncType param2_type = dpnp_dtype_to_DPNPFuncType(x1.dtype)
     cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_TRAPZ, param1_type, param2_type)
 
-    result_type = dpnp_DPNPFuncType_to_dtype( < size_t > kernel_data.return_type)
-
-    cdef dparray result = dparray((1,), dtype=result_type)
+    # ceate result array with type given by FPTR data
+    cdef shape_type_c result_shape = (1,)
+    cdef utils.dpnp_descriptor result = utils.create_output_descriptor(result_shape, kernel_data.return_type, None)
 
     cdef ftpr_custom_trapz_2in_1out_with_2size_t func = <ftpr_custom_trapz_2in_1out_with_2size_t > kernel_data.ptr
     func(y1.get_data(), x1.get_data(), result.get_data(), dx, y1.size, x1.size)
 
-    return result[0]
+    return result
 
 
 cpdef utils.dpnp_descriptor dpnp_trunc(utils.dpnp_descriptor x1, utils.dpnp_descriptor out):

dpnp/dpnp_iface_mathematical.py

@@ -148,7 +148,7 @@ def absolute(x1, **kwargs):
         if not x1_desc.ndim:
             pass
         else:
-            result = dpnp_absolute(x1_desc)
+            result = dpnp_absolute(x1_desc).get_pyobj()
 
             return result
 
@@ -246,7 +246,7 @@ def around(x1, decimals=0, out=None):
         elif decimals != 0:
             pass
         else:
-            return dpnp_around(x1_desc, decimals)
+            return dpnp_around(x1_desc, decimals).get_pyobj()
 
     return call_origin(numpy.around, x1, decimals=decimals, out=out)
 
@@ -529,7 +529,7 @@ def diff(x1, n=1, axis=-1, prepend=None, append=None):
         elif append is not None:
             pass
         else:
-            return dpnp_diff(x1, n)
+            return dpnp_diff(x1_desc, n)
 
     return call_origin(numpy.diff, x1, n, axis, prepend, append)
 
@@ -903,9 +903,9 @@ def gradient(x1, *varargs, **kwargs):
             pass
         else:
             if len(varargs) == 0:
-                return dpnp_gradient(x1)
+                return dpnp_gradient(x1_desc).get_pyobj()
 
-            return dpnp_gradient(x1, varargs[0])
+            return dpnp_gradient(x1_desc, varargs[0]).get_pyobj()
 
     return call_origin(numpy.gradient, x1, *varargs, **kwargs)
 
@@ -1045,7 +1045,7 @@ def mod(*args, **kwargs):
     return dpnp.remainder(*args, **kwargs)
 
 
-def modf(x, **kwargs):
+def modf(x1, **kwargs):
     """
     Return the fractional and integral parts of an array, element-wise.
 
@@ -1069,11 +1069,11 @@ def modf(x, **kwargs):
 
     """
 
-    dpnp_desc = dpnp.get_dpnp_descriptor(x)
-    if dpnp_desc and not kwargs:
-        return dpnp_modf(dpnp_desc)
+    x1_desc = dpnp.get_dpnp_descriptor(x1)
+    if x1_desc and not kwargs:
+        return dpnp_modf(x1_desc)
 
-    return call_origin(numpy.modf, x, **kwargs)
+    return call_origin(numpy.modf, x1, **kwargs)
 
 
 def multiply(x1, x2, dtype=None, out=None, where=True, **kwargs):
@@ -1224,7 +1224,7 @@ def nanprod(x1, **kwargs):
 
     x1_desc = dpnp.get_dpnp_descriptor(x1)
     if x1_desc and not kwargs:
-        return dpnp_nanprod(x1)
+        return dpnp_nanprod(x1_desc).get_pyobj()
 
     return call_origin(numpy.nanprod, x1, **kwargs)
 
@@ -1254,7 +1254,9 @@ def nansum(x1, **kwargs):
 
     x1_desc = dpnp.get_dpnp_descriptor(x1)
     if x1_desc and not kwargs:
-        return dpnp_nansum(x1)
+        result_obj = dpnp_nansum(x1_desc).get_pyobj()
+        result = dpnp.convert_single_elem_array_to_scalar(result_obj)
+        return result
 
     return call_origin(numpy.nansum, x1, **kwargs)
 
@@ -1586,7 +1588,7 @@ def sum(x1, axis=None, dtype=None, out=None, keepdims=False, initial=None, where
     return call_origin(numpy.sum, x1, axis=axis, dtype=dtype, out=out, keepdims=keepdims, initial=initial, where=where)
 
 
-def trapz(y, x=None, dx=1.0, axis=-1):
+def trapz(y1, x1=None, dx=1.0, axis=-1):
     """
     Integrate along the given axis using the composite trapezoidal rule.
 
@@ -1613,23 +1615,23 @@ def trapz(y, x=None, dx=1.0, axis=-1):
 
     """
 
-    y_desc = dpnp.get_dpnp_descriptor(y)
+    y_desc = dpnp.get_dpnp_descriptor(y1)
     if y_desc:
-        if not isinstance(x, dparray) and x is not None:
-            pass
-        elif x is not None and y_desc.size != x.size:
-            pass
-        elif x is not None and y_desc.shape != x.shape:
-            pass
-        elif y_desc.ndim > 1:
+        if y_desc.ndim > 1:
             pass
         else:
-            if x is None:
-                x = dpnp.empty(0, dtype=y_desc.dtype)
-
-            return dpnp_trapz(y_desc, x, dx)
-
-    return call_origin(numpy.trapz, y, x, dx, axis)
+            x_obj = dpnp.empty(y_desc.shape, dtype=y_desc.dtype) if x1 is None else x1
+            x_desc = dpnp.get_dpnp_descriptor(x_obj)
+            if x_desc:
+                pass
+            elif y_desc.size != x_desc.size:
+                pass
+            elif y_desc.shape != x_desc.shape:
+                pass
+            else:
+                return dpnp_trapz(y_desc, x_desc, dx).get_pyobj()
+
+    return call_origin(numpy.trapz, y1, x1, dx, axis)
 
 
 def true_divide(*args, **kwargs):

tests/test_mathematical.py

@@ -331,17 +331,17 @@ def test_trapz_with_x_params(self, y_array, x_array, data_type_y, data_type_x):
         np_x = numpy.array(x_array, dtype=data_type_x)
         dpnp_x = dpnp.array(x_array, dtype=data_type_x)
 
-        result = dpnp.trapz(dpnp_y, x=dpnp_x)
-        expected = numpy.trapz(np_y, x=np_x)
+        result = dpnp.trapz(dpnp_y, dpnp_x)
+        expected = numpy.trapz(np_y, np_x)
         numpy.testing.assert_array_equal(expected, result)
 
     @pytest.mark.parametrize("array", [[1, 2, 3], [4, 5, 6]])
     def test_trapz_with_x_param_2ndim(self, array):
         np_a = numpy.array(array)
         dpnp_a = dpnp.array(array)
 
-        result = dpnp.trapz(dpnp_a, x=dpnp_a)
-        expected = numpy.trapz(np_a, x=np_a)
+        result = dpnp.trapz(dpnp_a, dpnp_a)
+        expected = numpy.trapz(np_a, np_a)
         numpy.testing.assert_array_equal(expected, result)
 
     @pytest.mark.parametrize("y_array", [[1, 2, 4, 5],