add backend to count_nonzero func (#893)

* add backend for count_nonzero func

* using ptr adapter

Co-authored-by: Alexander-Makaryev <alexander.makaryev@gmail.com>

Author: KsanaKozlova

dpnp/backend/include/dpnp_iface.hpp

@@ -389,6 +389,18 @@ INP_DLLEXPORT void dpnp_sum_c(void* result_out,
                               const void* initial,
                               const long* where);
 
+/**
+ * @ingroup BACKEND_API
+ * @brief Custom implementation of count_nonzero function
+ *
+ * @param [in]  array1_in     Input array.
+ * @param [out] result1_out   Output array.
+ * @param [in]  size          Number of elements in input arrays.
+ *
+ */
+template <typename _DataType_input, typename _DataType_output>
+INP_DLLEXPORT void dpnp_count_nonzero_c(void* array1_in, void* result1_out, size_t size);
+
 /**
  * @ingroup BACKEND_API
  * @brief Place of array elements

dpnp/backend/include/dpnp_iface_fptr.hpp

@@ -90,6 +90,7 @@ enum class DPNPFuncName : size_t
     DPNP_FN_CORRELATE,                /**< Used in numpy.correlate() implementation  */
     DPNP_FN_COS,                      /**< Used in numpy.cos() implementation  */
     DPNP_FN_COSH,                     /**< Used in numpy.cosh() implementation  */
+    DPNP_FN_COUNT_NONZERO,            /**< Used in numpy.count_nonzero() implementation  */
     DPNP_FN_COV,                      /**< Used in numpy.cov() implementation  */
     DPNP_FN_CROSS,                    /**< Used in numpy.cross() implementation  */
     DPNP_FN_CUMPROD,                  /**< Used in numpy.cumprod() implementation  */

dpnp/backend/kernels/dpnp_krnl_statistics.cpp

@@ -150,6 +150,33 @@ void dpnp_cov_c(void* array1_in, void* result1, size_t nrows, size_t ncols)
     return;
 }
 
+template <typename _DataType_input, typename _DataType_output>
+void dpnp_count_nonzero_c(void* array1_in, void* result1_out, size_t size)
+{
+    if (array1_in == nullptr)
+    {
+        return;
+    }
+
+    DPNPC_ptr_adapter<_DataType_input> input1_ptr(array1_in, size, true);
+    DPNPC_ptr_adapter<_DataType_output> result_ptr(result1_out, 1, true, true);
+    _DataType_input* array1 = input1_ptr.get_ptr();
+    _DataType_output* result1 = result_ptr.get_ptr();
+
+
+    result1[0] = 0;
+
+    for (size_t i = 0; i < size; ++i)
+    {
+        if (array1[i] != 0)
+        {
+            result1[0] += 1;
+        }
+    }
+
+    return;
+}
+
 template <typename _DataType>
 class dpnp_max_c_kernel;
 
@@ -731,6 +758,11 @@ void func_map_init_statistics(func_map_t& fmap)
     fmap[DPNPFuncName::DPNP_FN_CORRELATE][eft_DBL][eft_DBL] = {eft_DBL,
                                                                (void*)dpnp_correlate_c<double, double, double>};
 
+    fmap[DPNPFuncName::DPNP_FN_COUNT_NONZERO][eft_INT][eft_INT] = {eft_LNG, (void*)dpnp_count_nonzero_c<int, long>};
+    fmap[DPNPFuncName::DPNP_FN_COUNT_NONZERO][eft_LNG][eft_LNG] = {eft_LNG, (void*)dpnp_count_nonzero_c<long, long>};
+    fmap[DPNPFuncName::DPNP_FN_COUNT_NONZERO][eft_FLT][eft_FLT] = {eft_LNG, (void*)dpnp_count_nonzero_c<float, long>};
+    fmap[DPNPFuncName::DPNP_FN_COUNT_NONZERO][eft_DBL][eft_DBL] = {eft_LNG, (void*)dpnp_count_nonzero_c<double, long>};
+
     fmap[DPNPFuncName::DPNP_FN_COV][eft_INT][eft_INT] = {eft_DBL, (void*)dpnp_cov_c<double>};
     fmap[DPNPFuncName::DPNP_FN_COV][eft_LNG][eft_LNG] = {eft_DBL, (void*)dpnp_cov_c<double>};
     fmap[DPNPFuncName::DPNP_FN_COV][eft_FLT][eft_FLT] = {eft_DBL, (void*)dpnp_cov_c<double>};

dpnp/dpnp_algo/dpnp_algo.pxd

@@ -69,6 +69,7 @@ cdef extern from "dpnp_iface_fptr.hpp" namespace "DPNPFuncName":  # need this na
         DPNP_FN_COS
         DPNP_FN_COSH
         DPNP_FN_COV
+        DPNP_FN_COUNT_NONZERO
         DPNP_FN_CROSS
         DPNP_FN_CUMPROD
         DPNP_FN_CUMSUM

dpnp/dpnp_algo/dpnp_algo_counting.pyx

@@ -39,14 +39,5 @@ __all__ += [
 ]
 
 
-cpdef utils.dpnp_descriptor dpnp_count_nonzero(utils.dpnp_descriptor in_array1):
-    cdef utils.dpnp_descriptor result = utils_py.create_output_descriptor_py((1,), dpnp.int64, None)
-
-    count = 0
-    for i in range(in_array1.size):
-        if in_array1.get_pyobj()[i] != 0:
-            count += 1
-
-    result.get_pyobj()[0] = count
-
-    return result
+cpdef utils.dpnp_descriptor dpnp_count_nonzero(utils.dpnp_descriptor x1):
+    return call_fptr_1in_1out(DPNP_FN_COUNT_NONZERO, x1, (1,))

dpnp/dpnp_iface_counting.py

@@ -58,7 +58,7 @@ def count_nonzero(x1, axis=None, *, keepdims=False):
 
     Limitations
     -----------
-        Parameter ``in_array1`` is supported as :obj:`dpnp.ndarray`.
+        Parameter ``x1`` is supported as :obj:`dpnp.ndarray`.
         Otherwise the function will be executed sequentially on CPU.
         Parameter ``axis`` is supported only with default value `None`.
         Parameter ``keepdims`` is supported only with default value `False`.