Dpnp ptp (#715)

* add python version ptp

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

Author: 3 people

dpnp/backend/include/dpnp_iface.hpp

@@ -459,6 +459,37 @@ INP_DLLEXPORT void dpnp_prod_c(void* result_out,
                                const void* initial,
                                const long* where);
 
+/**
+ * @ingroup BACKEND_API
+ * @brief Range of values (maximum - minimum) along an axis.
+ *
+ * @param [out] result_out          Output array.
+ * @param [in]  result_size         Size of output array.
+ * @param [in]  result_ndim         Number of output array dimensions.
+ * @param [in]  result_shape        Shape of output array.
+ * @param [in]  result_strides      Strides of output array.
+ * @param [in]  input_in            First input array.
+ * @param [in]  input_size          Size of first input array.
+ * @param [in]  input_ndim          Number of first input array dimensions.
+ * @param [in]  input_shape         Shape of first input array.
+ * @param [in]  input_strides       Strides of first input array.
+ * @param [in]  axis                Axis.
+ * @param [in]  naxis               Number of elements in axis.
+ */ 
+template <typename _DataType>
+INP_DLLEXPORT void dpnp_ptp_c(void* result_out,
+                              const size_t result_size,
+                              const size_t result_ndim,
+                              const shape_elem_type* result_shape,
+                              const shape_elem_type* result_strides,
+                              const void* input_in,
+                              const size_t input_size,
+                              const size_t input_ndim,
+                              const shape_elem_type* input_shape,
+                              const shape_elem_type* input_strides,
+                              const shape_elem_type* axis,
+                              const size_t naxis);
+                              
 /**
  * @ingroup BACKEND_API
  * @brief Product of array elements

dpnp/backend/include/dpnp_iface_fptr.hpp

@@ -149,6 +149,7 @@ enum class DPNPFuncName : size_t
     DPNP_FN_PLACE,                    /**< Used in numpy.place() implementation  */
     DPNP_FN_POWER,                    /**< Used in numpy.power() implementation  */
     DPNP_FN_PROD,                     /**< Used in numpy.prod() implementation  */
+    DPNP_FN_PTP,                      /**< Used in numpy.ptp() implementation  */
     DPNP_FN_PUT,                      /**< Used in numpy.put() implementation  */
     DPNP_FN_PUT_ALONG_AXIS,           /**< Used in numpy.put_along_axis() implementation  */
     DPNP_FN_QR,                       /**< Used in numpy.linalg.qr() implementation  */

dpnp/backend/kernels/dpnp_krnl_arraycreation.cpp

@@ -26,6 +26,7 @@
 #include <iostream>
 
 #include "dpnp_fptr.hpp"
+#include "dpnp_utils.hpp"
 #include "dpnp_iface.hpp"
 #include "dpnpc_memory_adapter.hpp"
 #include "queue_sycl.hpp"
@@ -205,6 +206,57 @@ void dpnp_ones_like_c(void* result, size_t size)
     dpnp_ones_c<_DataType>(result, size);
 }
 
+template <typename _DataType>
+void dpnp_ptp_c(void* result1_out,
+                const size_t result_size,
+                const size_t result_ndim,
+                const shape_elem_type* result_shape,
+                const shape_elem_type* result_strides,
+                const void* input1_in,
+                const size_t input_size,
+                const size_t input_ndim,
+                const shape_elem_type* input_shape,
+                const shape_elem_type* input_strides,
+                const shape_elem_type* axis,
+                const size_t naxis)
+{
+    (void) result_strides;
+    (void) input_strides;
+
+    if ((input1_in == nullptr) || (result1_out == nullptr))
+    {
+        return;
+    }
+
+    if (input_ndim < 1)
+    {
+        return;
+    }
+
+    DPNPC_ptr_adapter<_DataType> input1_ptr(input1_in, input_size, true);
+    DPNPC_ptr_adapter<_DataType> result_ptr(result1_out, result_size, false, true);
+    _DataType* arr = input1_ptr.get_ptr();
+    _DataType* result = result_ptr.get_ptr();
+
+    _DataType* min_arr = reinterpret_cast<_DataType*>(dpnp_memory_alloc_c(result_size * sizeof(_DataType)));
+    _DataType* max_arr = reinterpret_cast<_DataType*>(dpnp_memory_alloc_c(result_size * sizeof(_DataType)));
+
+    dpnp_min_c<_DataType>(arr, min_arr, result_size, input_shape, input_ndim, axis, naxis);
+    dpnp_max_c<_DataType>(arr, max_arr, result_size, input_shape, input_ndim, axis, naxis);
+
+    shape_elem_type* _strides = reinterpret_cast<shape_elem_type*>(dpnp_memory_alloc_c(result_ndim * sizeof(shape_elem_type)));
+    get_shape_offsets_inkernel(result_shape, result_ndim, _strides);
+
+    dpnp_subtract_c<_DataType, _DataType, _DataType>(result, result_size, result_ndim, result_shape, result_strides,
+                                                     max_arr, result_size, result_ndim, result_shape, _strides,
+                                                     min_arr, result_size, result_ndim, result_shape, _strides,
+                                                     NULL);
+
+    dpnp_memory_free_c(min_arr);
+    dpnp_memory_free_c(max_arr);
+
+}
+
 template <typename _DataType_input, typename _DataType_output>
 void dpnp_vander_c(const void* array1_in, void* result1, const size_t size_in, const size_t N, const int increasing)
 {
@@ -635,6 +687,11 @@ void func_map_init_arraycreation(func_map_t& fmap)
     fmap[DPNPFuncName::DPNP_FN_ONES_LIKE][eft_C128][eft_C128] = {eft_C128,
                                                                  (void*)dpnp_ones_like_c<std::complex<double>>};
 
+    fmap[DPNPFuncName::DPNP_FN_PTP][eft_INT][eft_INT] = {eft_INT, (void*)dpnp_ptp_c<int32_t>};
+    fmap[DPNPFuncName::DPNP_FN_PTP][eft_LNG][eft_LNG] = {eft_LNG, (void*)dpnp_ptp_c<int64_t>};
+    fmap[DPNPFuncName::DPNP_FN_PTP][eft_FLT][eft_FLT] = {eft_FLT, (void*)dpnp_ptp_c<float>};
+    fmap[DPNPFuncName::DPNP_FN_PTP][eft_DBL][eft_DBL] = {eft_DBL, (void*)dpnp_ptp_c<double>};
+
     fmap[DPNPFuncName::DPNP_FN_VANDER][eft_INT][eft_INT] = {eft_LNG, (void*)dpnp_vander_c<int32_t, int64_t>};
     fmap[DPNPFuncName::DPNP_FN_VANDER][eft_LNG][eft_LNG] = {eft_LNG, (void*)dpnp_vander_c<int64_t, int64_t>};
     fmap[DPNPFuncName::DPNP_FN_VANDER][eft_FLT][eft_FLT] = {eft_DBL, (void*)dpnp_vander_c<float, double>};

dpnp/dparray.pyx

@@ -1189,6 +1189,9 @@ cdef class dparray:
         """Return a copy of the array."""
         return copy(self, order=order)
 
+    def ptp(self, axis=None, out=None, keepdims=numpy._NoValue):
+        return ptp(self, axis=axis, out=out, keepdims=keepdims)
+
     def tobytes(self, order='C'):
         """ Construct Python bytes containing the raw data bytes in the array.
 

dpnp/dpnp_algo/dpnp_algo.pxd

@@ -128,6 +128,7 @@ cdef extern from "dpnp_iface_fptr.hpp" namespace "DPNPFuncName":  # need this na
         DPNP_FN_PLACE
         DPNP_FN_POWER
         DPNP_FN_PROD
+        DPNP_FN_PTP
         DPNP_FN_PUT
         DPNP_FN_QR
         DPNP_FN_RADIANS

dpnp/dpnp_algo/dpnp_algo_arraycreation.pyx

@@ -47,6 +47,7 @@ __all__ += [
     "dpnp_meshgrid",
     "dpnp_ones",
     "dpnp_ones_like",
+    "dpnp_ptp",
     "dpnp_trace",
     "dpnp_tri",
     "dpnp_tril",
@@ -59,6 +60,9 @@ __all__ += [
 
 ctypedef void(*custom_1in_1out_func_ptr_t)(void * , void * , const int , shape_elem_type * , shape_elem_type * , const size_t, const size_t)
 ctypedef void(*ftpr_custom_vander_1in_1out_t)(void *, void * , size_t, size_t, int)
+ctypedef void(*custom_arraycreation_1in_1out_func_ptr_t)(void * , const size_t, const size_t, const shape_elem_type*, const shape_elem_type*,
+                                                         void * , const size_t, const size_t, const shape_elem_type*, const shape_elem_type*,
+                                                         const shape_elem_type*, const size_t)
 ctypedef void(*custom_indexing_1out_func_ptr_t)(void *, const size_t , const size_t , const int)
 ctypedef void(*fptr_dpnp_eye_t)(void * , int , const shape_elem_type * )
 ctypedef void(*fptr_dpnp_trace_t)(const void * , void * , const shape_elem_type * , const size_t)
@@ -297,6 +301,63 @@ cpdef utils.dpnp_descriptor dpnp_ones_like(result_shape, result_dtype):
     return call_fptr_1out(DPNP_FN_ONES_LIKE, utils._object_to_tuple(result_shape), result_dtype)
 
 
+cpdef dpnp_ptp(utils.dpnp_descriptor arr, axis=None):
+    cdef shape_type_c shape_arr = arr.shape
+    cdef shape_type_c output_shape
+    if axis is None:
+        axis_ = axis
+        output_shape = (1,)
+    else:
+        if isinstance(axis, int):
+            if axis < 0:
+                axis_ = tuple([arr.ndim - axis])
+            else:
+                axis_ = tuple([axis])
+        else:
+            _axis_ = []
+            for i in range(len(axis)):
+                if axis[i] < 0:
+                    _axis_.append(arr.ndim - axis[i])
+                else:
+                    _axis_.append(axis[i])
+            axis_ = tuple(_axis_)
+
+        out_shape = []
+        ind = 0
+        for id, shape_axis in enumerate(shape_arr):
+            if id not in axis_:
+                out_shape.append(shape_axis)
+        output_shape = tuple(out_shape)
+ 
+    cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(arr.dtype)
+
+    cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_PTP, param1_type, param1_type)
+
+    cdef utils.dpnp_descriptor result = utils.create_output_descriptor(output_shape, kernel_data.return_type, None)
+
+    cdef custom_arraycreation_1in_1out_func_ptr_t func = <custom_arraycreation_1in_1out_func_ptr_t > kernel_data.ptr
+    
+    cdef shape_type_c axis1
+    cdef Py_ssize_t axis_size = 0
+    cdef shape_type_c axis2 = axis1
+    if axis_ is not None:
+        axis1 = axis_
+        axis2.reserve(len(axis1))
+        for shape_it in axis1:
+            if shape_it < 0:
+                raise ValueError("DPNP dparray::__init__(): Negative values in 'shape' are not allowed")
+            axis2.push_back(shape_it)
+        axis_size = len(axis1)
+
+    cdef shape_type_c result_strides = utils.strides_to_vector(result.strides, result.shape)
+    cdef shape_type_c arr_strides = utils.strides_to_vector(arr.strides, arr.shape)
+
+    func(result.get_data(), result.size, result.ndim, output_shape.data(), result_strides.data(),
+         arr.get_data(), arr.size, arr.ndim, shape_arr.data(), arr_strides.data(), axis2.data(), axis_size)
+
+    return result
+
+
 cpdef utils.dpnp_descriptor dpnp_trace(utils.dpnp_descriptor arr, offset=0, axis1=0, axis2=1, dtype=None, out=None):
     if dtype is None:
         dtype_ = arr.dtype

dpnp/dpnp_iface_arraycreation.py

@@ -79,6 +79,7 @@
     "ogrid",
     "ones",
     "ones_like",
+    "ptp",
     "trace",
     "tri",
     "tril",
@@ -1153,6 +1154,35 @@ def ones_like(x1, dtype=None, order='C', subok=False, shape=None):
     return call_origin(numpy.ones_like, x1, dtype, order, subok, shape)
 
 
+def ptp(arr, axis=None, out=None, keepdims=numpy._NoValue):
+    """
+    Range of values (maximum - minimum) along an axis.
+
+    For full documentation refer to :obj:`numpy.ptp`.
+
+    Limitations
+    -----------
+    Input array is supported as :obj:`dpnp.ndarray`.
+    Parameters ``out`` and ``keepdims`` are supported only with default values.
+    """
+    arr_desc = dpnp.get_dpnp_descriptor(arr)
+    if not arr_desc:
+        pass
+    elif axis is not None and not isinstance(axis, int):
+        pass
+    elif out is not None:
+        pass
+    elif keepdims is not numpy._NoValue:
+        pass
+    else:
+        result_obj = dpnp_ptp(arr_desc, axis=axis).get_pyobj()
+        result = dpnp.convert_single_elem_array_to_scalar(result_obj)
+
+        return result
+
+    return call_origin(numpy.ptp, arr, axis, out, keepdims)
+
+
 def trace(x1, offset=0, axis1=0, axis2=1, dtype=None, out=None):
     """
        Return the sum along diagonals of the array.

tests/skipped_tests.tbl

@@ -1452,10 +1452,3 @@ tests/third_party/cupy/statistics_tests/test_order.py::TestOrder::test_percentil
 tests/third_party/cupy/statistics_tests/test_order.py::TestOrder::test_percentile_scalar_q
 tests/third_party/cupy/statistics_tests/test_order.py::TestOrder::test_percentile_tuple_axis
 tests/third_party/cupy/statistics_tests/test_order.py::TestOrder::test_percentile_uxpected_interpolation
-tests/third_party/cupy/statistics_tests/test_order.py::TestOrder::test_ptp_all
-tests/third_party/cupy/statistics_tests/test_order.py::TestOrder::test_ptp_all_nan
-tests/third_party/cupy/statistics_tests/test_order.py::TestOrder::test_ptp_axis0
-tests/third_party/cupy/statistics_tests/test_order.py::TestOrder::test_ptp_axis1
-tests/third_party/cupy/statistics_tests/test_order.py::TestOrder::test_ptp_axis2
-tests/third_party/cupy/statistics_tests/test_order.py::TestOrder::test_ptp_axis_large
-tests/third_party/cupy/statistics_tests/test_order.py::TestOrder::test_ptp_nan

tests/skipped_tests_gpu.tbl

@@ -1630,10 +1630,3 @@ tests/third_party/cupy/statistics_tests/test_order.py::TestOrder::test_percentil
 tests/third_party/cupy/statistics_tests/test_order.py::TestOrder::test_percentile_scalar_q
 tests/third_party/cupy/statistics_tests/test_order.py::TestOrder::test_percentile_tuple_axis
 tests/third_party/cupy/statistics_tests/test_order.py::TestOrder::test_percentile_uxpected_interpolation
-tests/third_party/cupy/statistics_tests/test_order.py::TestOrder::test_ptp_all
-tests/third_party/cupy/statistics_tests/test_order.py::TestOrder::test_ptp_all_nan
-tests/third_party/cupy/statistics_tests/test_order.py::TestOrder::test_ptp_axis0
-tests/third_party/cupy/statistics_tests/test_order.py::TestOrder::test_ptp_axis1
-tests/third_party/cupy/statistics_tests/test_order.py::TestOrder::test_ptp_axis2
-tests/third_party/cupy/statistics_tests/test_order.py::TestOrder::test_ptp_axis_large
-tests/third_party/cupy/statistics_tests/test_order.py::TestOrder::test_ptp_nan