add kernel dpnp.flatten (#645)

* add kernel dpnp.flatten

Author: Rubtsowa

dpnp/backend/include/dpnp_iface_fptr.hpp

@@ -107,6 +107,7 @@ enum class DPNPFuncName : size_t
     DPNP_FN_FABS,                     /**< Used in numpy.fabs() implementation  */
     DPNP_FN_FFT_FFT,                  /**< Used in numpy.fft.fft() implementation  */
     DPNP_FN_FILL_DIAGONAL,            /**< Used in numpy.fill_diagonal() implementation  */
+    DPNP_FN_FLATTEN,                  /**< Used in numpy.flatten() implementation  */
     DPNP_FN_FLOOR,                    /**< Used in numpy.floor() implementation  */
     DPNP_FN_FLOOR_DIVIDE,             /**< Used in numpy.floor_divide() implementation  */
     DPNP_FN_FMOD,                     /**< Used in numpy.fmod() implementation  */

dpnp/backend/kernels/dpnp_krnl_elemwise.cpp

@@ -309,6 +309,13 @@ static void func_map_init_elemwise_1arg_1type(func_map_t& fmap)
     fmap[DPNPFuncName::DPNP_FN_ERF][eft_FLT][eft_FLT] = {eft_FLT, (void*)dpnp_erf_c<float>};
     fmap[DPNPFuncName::DPNP_FN_ERF][eft_DBL][eft_DBL] = {eft_DBL, (void*)dpnp_erf_c<double>};
 
+    fmap[DPNPFuncName::DPNP_FN_FLATTEN][eft_BLN][eft_BLN] = {eft_BLN, (void*)dpnp_copy_c<bool>};
+    fmap[DPNPFuncName::DPNP_FN_FLATTEN][eft_INT][eft_INT] = {eft_INT, (void*)dpnp_copy_c<int>};
+    fmap[DPNPFuncName::DPNP_FN_FLATTEN][eft_LNG][eft_LNG] = {eft_LNG, (void*)dpnp_copy_c<long>};
+    fmap[DPNPFuncName::DPNP_FN_FLATTEN][eft_FLT][eft_FLT] = {eft_FLT, (void*)dpnp_copy_c<float>};
+    fmap[DPNPFuncName::DPNP_FN_FLATTEN][eft_DBL][eft_DBL] = {eft_DBL, (void*)dpnp_copy_c<double>};
+    fmap[DPNPFuncName::DPNP_FN_FLATTEN][eft_C128][eft_C128] = {eft_C128, (void*)dpnp_copy_c<std::complex<double>>};
+
     fmap[DPNPFuncName::DPNP_FN_RECIP][eft_INT][eft_INT] = {eft_INT, (void*)dpnp_recip_c<int>};
     fmap[DPNPFuncName::DPNP_FN_RECIP][eft_LNG][eft_LNG] = {eft_LNG, (void*)dpnp_recip_c<long>};
     fmap[DPNPFuncName::DPNP_FN_RECIP][eft_FLT][eft_FLT] = {eft_FLT, (void*)dpnp_recip_c<float>};

dpnp/dparray.pyx

@@ -512,11 +512,7 @@ cdef class dparray:
                 if order == 'F':
                     return self.transpose().reshape(self.size)
 
-                result = dparray(self.size, dtype=self.dtype)
-                for i in range(result.size):
-                    result[i] = self[i]
-
-                return result
+                return dpnp_flatten(self)
 
         result = utils.dp2nd_array(self).flatten(order=order)
 

dpnp/dpnp_algo/dpnp_algo.pxd

@@ -80,6 +80,7 @@ cdef extern from "dpnp_iface_fptr.hpp" namespace "DPNPFuncName":  # need this na
         DPNP_FN_FABS
         DPNP_FN_FFT_FFT
         DPNP_FN_FILL_DIAGONAL
+        DPNP_FN_FLATTEN
         DPNP_FN_FLOOR
         DPNP_FN_FLOOR_DIVIDE
         DPNP_FN_FMOD
@@ -229,6 +230,7 @@ cdef dparray call_fptr_2in_1out(DPNPFuncName fptr_name, object x1_obj, object x2
 
 
 cpdef dparray dpnp_astype(dparray array1, dtype_target)
+cpdef dparray dpnp_flatten(dparray array1)
 
 
 """

dpnp/dpnp_algo/dpnp_algo.pyx

@@ -45,6 +45,7 @@ __all__ = [
     "dpnp_arange",
     "dpnp_array",
     "dpnp_astype",
+    "dpnp_flatten",
     "dpnp_init_val",
     "dpnp_matmul",
     "dpnp_queue_initialize",
@@ -70,6 +71,7 @@ include "dpnp_algo_trigonometric.pyx"
 
 ctypedef void(*fptr_dpnp_arange_t)(size_t, size_t, void *, size_t)
 ctypedef void(*fptr_dpnp_astype_t)(const void *, void * , const size_t)
+ctypedef void(*fptr_dpnp_flatten_t)(const void *, void * , const size_t)
 ctypedef void(*fptr_dpnp_initval_t)(void *, void * , size_t)
 
 
@@ -140,6 +142,20 @@ cpdef dparray dpnp_astype(dparray array1, dtype_target):
     return result
 
 
+cpdef dparray dpnp_flatten(dparray array_):
+    cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(array_.dtype)
+
+    cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_FLATTEN, param1_type, param1_type)
+
+    result_type = dpnp_DPNPFuncType_to_dtype(< size_t > kernel_data.return_type)
+    cdef dparray result = dparray(array_.size, dtype=result_type)
+
+    cdef fptr_dpnp_flatten_t func = <fptr_dpnp_flatten_t > kernel_data.ptr
+    func(array_.get_data(), result.get_data(), array_.size)
+
+    return result
+
+
 cpdef dparray dpnp_init_val(shape, dtype, value):
     cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(dtype)
 

tests/test_dparray.py

@@ -18,3 +18,17 @@ def test_astype(arr, arr_dtype, res_dtype):
     expected = numpy_array.astype(res_dtype)
     result = dpnp_array.astype(res_dtype)
     numpy.testing.assert_array_equal(expected, result)
+
+
+@pytest.mark.parametrize("arr_dtype",
+                         [numpy.float64, numpy.float32, numpy.int64, numpy.int32, numpy.bool, numpy.bool_, numpy.complex],
+                         ids=['float64', 'float32', 'int64', 'int32', 'bool', 'bool_', 'complex'])
+@pytest.mark.parametrize("arr",
+                         [[-2, -1, 0, 1, 2], [[-2, -1], [1, 2]], []],
+                         ids=['[-2, -1, 0, 1, 2]', '[[-2, -1], [1, 2]]', '[]'])
+def test_flatten(arr, arr_dtype):
+    numpy_array = numpy.array(arr, dtype=arr_dtype)
+    dpnp_array = dpnp.array(arr, dtype=arr_dtype)
+    expected = numpy_array.flatten()
+    result = dpnp_array.flatten()
+    numpy.testing.assert_array_equal(expected, result)