add vander function (#646)

* add vander function

Author: KsanaKozlova

doc/reference/creation.rst

@@ -20,6 +20,7 @@ Basic creation routines
    dpnp.zeros_like
    dpnp.full
    dpnp.full_like
+   dpnp.vander
 
 
 Creation from other data

dpnp/backend/include/dpnp_iface.hpp

@@ -871,6 +871,20 @@ template <typename _DataType_input1, typename _DataType_input2, typename _DataTy
 INP_DLLEXPORT void dpnp_trapz_c(
     const void* array1_in, const void* array2_in, void* result1, double dx, size_t array1_size, size_t array2_size);
 
+/**
+ * @ingroup BACKEND_API
+ * @brief Implementation of vander function
+ *
+ * @param [in]  array_in    Input array.
+ * @param [out] result      Output array.
+ * @param [in]  size_in     Number of elements in the input array.
+ * @param [in]  N           Number of columns in the output.
+ * @param [in]  increasing  Order of the powers of the columns.
+ * 
+ */
+template <typename _DataType_input, typename _DataType_output>
+INP_DLLEXPORT void dpnp_vander_c(const void* array1_in, void* result1, const size_t size_in, const size_t N, const int increasing);
+
 /**
  * @ingroup BACKEND_API
  * @brief Implementation of zeros function

dpnp/backend/include/dpnp_iface_fptr.hpp

@@ -201,6 +201,7 @@ enum class DPNPFuncName : size_t
     DPNP_FN_TRIL,                     /**< Used in numpy.tril() implementation  */
     DPNP_FN_TRIU,                     /**< Used in numpy.triu() implementation  */
     DPNP_FN_TRUNC,                    /**< Used in numpy.trunc() implementation  */
+    DPNP_FN_VANDER,                   /**< Used in numpy.vander() implementation  */
     DPNP_FN_VAR,                      /**< Used in numpy.var() implementation  */
     DPNP_FN_ZEROS,                    /**< Used in numpy.zeros() implementation */
     DPNP_FN_ZEROS_LIKE,               /**< Used in numpy.zeros_like() implementation */

dpnp/backend/kernels/dpnp_krnl_arraycreation.cpp

@@ -127,6 +127,59 @@ void dpnp_ones_like_c(void* result, size_t size)
     dpnp_ones_c<_DataType>(result, size);
 }
 
+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)
+{
+    if ((array1_in == nullptr) || (result1 == nullptr))
+        return;
+
+    if (!size_in || !N)
+        return;
+
+    const _DataType_input* array_in = reinterpret_cast<const _DataType_input*>(array1_in);
+    _DataType_output* result = reinterpret_cast<_DataType_output*>(result1);
+
+    if (N == 1)
+    {
+        dpnp_ones_c<_DataType_output>(result, size_in);
+        return;
+    }
+
+    if (increasing)
+    {
+        for (size_t i = 0; i < size_in; ++i)
+        {
+            result[i * N] = 1;
+        }
+        for (size_t i = 1; i < N; ++i)
+        {
+            for (size_t j = 0; j < size_in; ++j)
+            {
+                result[j * N + i] = result[j * N + i - 1] * array_in[j];
+            }
+        }
+    }
+    else
+    {
+        for (size_t i = 0; i < size_in; ++i)
+        {
+            result[i * N + N - 1] = 1;
+        }
+        for (size_t i = N - 2; i > 0; --i)
+        {
+            for (size_t j = 0; j < size_in; ++j)
+            {
+                result[j * N + i] = result[j * N + i + 1] * array_in[j];
+            }
+        }
+
+        for (size_t i = 0; i < size_in; ++i)
+        {
+            result[i * N] = result[i * N + 1] * array_in[i];
+        }
+    }
+}
+
 template <typename _DataType>
 class dpnp_tri_c_kernel;
 
@@ -439,6 +492,13 @@ void func_map_init_arraycreation(func_map_t& fmap)
     fmap[DPNPFuncName::DPNP_FN_ONES_LIKE][eft_BLN][eft_BLN] = {eft_BLN, (void*)dpnp_ones_like_c<bool>};
     fmap[DPNPFuncName::DPNP_FN_ONES_LIKE][eft_C128][eft_C128] = {eft_C128,
                                                                  (void*)dpnp_ones_like_c<std::complex<double>>};
+    
+    fmap[DPNPFuncName::DPNP_FN_VANDER][eft_INT][eft_INT] = {eft_LNG, (void*)dpnp_vander_c<int, long>};
+    fmap[DPNPFuncName::DPNP_FN_VANDER][eft_LNG][eft_LNG] = {eft_LNG, (void*)dpnp_vander_c<long, long>};
+    fmap[DPNPFuncName::DPNP_FN_VANDER][eft_FLT][eft_FLT] = {eft_DBL, (void*)dpnp_vander_c<float, double>};
+    fmap[DPNPFuncName::DPNP_FN_VANDER][eft_DBL][eft_DBL] = {eft_DBL, (void*)dpnp_vander_c<double, double>};
+    fmap[DPNPFuncName::DPNP_FN_VANDER][eft_BLN][eft_BLN] = {eft_LNG, (void*)dpnp_vander_c<bool, long>};
+    fmap[DPNPFuncName::DPNP_FN_VANDER][eft_C128][eft_C128] = {eft_C128, (void*)dpnp_vander_c<std::complex<double>, std::complex<double>>};
 
     fmap[DPNPFuncName::DPNP_FN_TRI][eft_INT][eft_INT] = {eft_INT, (void*)dpnp_tri_c<int>};
     fmap[DPNPFuncName::DPNP_FN_TRI][eft_LNG][eft_LNG] = {eft_LNG, (void*)dpnp_tri_c<long>};
@@ -460,15 +520,15 @@ void func_map_init_arraycreation(func_map_t& fmap)
     fmap[DPNPFuncName::DPNP_FN_ZEROS][eft_FLT][eft_FLT] = {eft_FLT, (void*)dpnp_zeros_c<float>};
     fmap[DPNPFuncName::DPNP_FN_ZEROS][eft_DBL][eft_DBL] = {eft_DBL, (void*)dpnp_zeros_c<double>};
     fmap[DPNPFuncName::DPNP_FN_ZEROS][eft_BLN][eft_BLN] = {eft_BLN, (void*)dpnp_zeros_c<bool>};
-    fmap[DPNPFuncName::DPNP_FN_ZEROS][eft_C128][eft_C128] = {eft_C128, (void*)dpnp_ones_c<std::complex<double>>};
+    fmap[DPNPFuncName::DPNP_FN_ZEROS][eft_C128][eft_C128] = {eft_C128, (void*)dpnp_zeros_c<std::complex<double>>};
 
     fmap[DPNPFuncName::DPNP_FN_ZEROS_LIKE][eft_INT][eft_INT] = {eft_INT, (void*)dpnp_zeros_like_c<int>};
     fmap[DPNPFuncName::DPNP_FN_ZEROS_LIKE][eft_LNG][eft_LNG] = {eft_LNG, (void*)dpnp_zeros_like_c<long>};
     fmap[DPNPFuncName::DPNP_FN_ZEROS_LIKE][eft_FLT][eft_FLT] = {eft_FLT, (void*)dpnp_zeros_like_c<float>};
     fmap[DPNPFuncName::DPNP_FN_ZEROS_LIKE][eft_DBL][eft_DBL] = {eft_DBL, (void*)dpnp_zeros_like_c<double>};
     fmap[DPNPFuncName::DPNP_FN_ZEROS_LIKE][eft_BLN][eft_BLN] = {eft_BLN, (void*)dpnp_zeros_like_c<bool>};
     fmap[DPNPFuncName::DPNP_FN_ZEROS_LIKE][eft_C128][eft_C128] = {eft_C128,
-                                                                  (void*)dpnp_ones_like_c<std::complex<double>>};
+                                                                  (void*)dpnp_zeros_like_c<std::complex<double>>};
 
     return;
 }

dpnp/dpnp_algo/dpnp_algo.pxd

@@ -174,6 +174,7 @@ cdef extern from "dpnp_iface_fptr.hpp" namespace "DPNPFuncName":  # need this na
         DPNP_FN_TRIL
         DPNP_FN_TRIU
         DPNP_FN_TRUNC
+        DPNP_FN_VANDER
         DPNP_FN_VAR
         DPNP_FN_ZEROS
         DPNP_FN_ZEROS_LIKE

dpnp/dpnp_algo/dpnp_algo_arraycreation.pyx

@@ -54,12 +54,14 @@ __all__ += [
     "dpnp_tri",
     "dpnp_tril",
     "dpnp_triu",
+    "dpnp_vander",
     "dpnp_zeros",
     "dpnp_zeros_like"
 ]
 
 
-ctypedef void(*custom_1in_1out_func_ptr_t)(void * , void * , const int , size_t * , size_t * , const size_t, const size_t)
+ctypedef void(*custom_1in_1out_func_ptr_t)(void *, void * , const int , size_t * , size_t * , const size_t, const size_t)
+ctypedef void(*ftpr_custom_vander_1in_1out_t)(void *, void *, size_t, size_t, int)
 ctypedef void(*custom_indexing_1out_func_ptr_t)(void * , const size_t , const size_t , const int)
 
 
@@ -317,6 +319,20 @@ cpdef dparray dpnp_triu(dparray m, int k):
     return result
 
 
+cpdef dparray dpnp_vander(dparray x1, int N, int increasing):
+    cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(x1.dtype)
+
+    cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_VANDER, param1_type, DPNP_FT_NONE)
+
+    result_type = dpnp_DPNPFuncType_to_dtype(< size_t > kernel_data.return_type)
+    cdef dparray result = dparray((x1.size, N), dtype=result_type)
+
+    cdef ftpr_custom_vander_1in_1out_t func = <ftpr_custom_vander_1in_1out_t > kernel_data.ptr
+    func(x1.get_data(), result.get_data(), x1.size, N, increasing)
+
+    return result
+
+
 cpdef dparray dpnp_zeros(result_shape, result_dtype):
     return call_fptr_1out(DPNP_FN_ZEROS, result_shape, result_dtype)
 

dpnp/dpnp_iface_arraycreation.py

@@ -77,6 +77,7 @@
     "tri",
     "tril",
     "triu",
+    "vander",
     "zeros",
     "zeros_like"
 ]
@@ -1135,6 +1136,47 @@ def triu(m, k=0):
     return call_origin(numpy.triu, m, k)
 
 
+def vander(x1, N=None, increasing=False):
+    """
+    Generate a Vandermonde matrix.
+
+    For full documentation refer to :obj:`numpy.vander`.
+
+    Examples
+    --------
+    >>> import dpnp as np
+    >>> x = np.array([1, 2, 3, 5])
+    >>> N = 3
+    >>> np.vander(x, N)
+    array([[ 1,  1,  1],
+           [ 4,  2,  1],
+           [ 9,  3,  1],
+           [25,  5,  1]])
+    >>> x = np.array([1, 2, 3, 5])
+    >>> np.vander(x)
+    array([[  1,   1,   1,   1],
+           [  8,   4,   2,   1],
+           [ 27,   9,   3,   1],
+           [125,  25,   5,   1]])
+    >>> np.vander(x, increasing=True)
+    array([[  1,   1,   1,   1],
+           [  1,   2,   4,   8],
+           [  1,   3,   9,  27],
+           [  1,   5,  25, 125]])
+    """
+    if (not use_origin_backend(x1)):
+        if not isinstance(x1, dparray):
+            pass
+        elif x1.ndim != 1:
+            pass
+        else:
+            if N is None:
+                N = x1.size
+            return dpnp_vander(x1, N, increasing)
+
+    return call_origin(numpy.vander, x1, N=N, increasing=increasing)
+
+
 def zeros(shape, dtype=None, order='C'):
     """
     Return a new array of given shape and type, filled with zeros.

tests/test_arraycreation.py

@@ -217,3 +217,29 @@ def test_triu_size_null(k):
     expected = numpy.triu(a, k)
     result = dpnp.triu(ia, k)
     numpy.testing.assert_array_equal(expected, result)
+
+
+@pytest.mark.parametrize("array",
+                         [[1, 2, 3, 4],
+                          [],
+                          [0, 3, 5]],
+                         ids=['[1, 2, 3, 4]',
+                              '[]',
+                              '[0, 3, 5]'])
+@pytest.mark.parametrize("type",
+                         [numpy.float64, numpy.float32, numpy.int64,
+                          numpy.int32, numpy.bool, numpy.complex128],
+                         ids=['float64', 'float32', 'int64', 'int32', 'bool', 'complex128'])
+@pytest.mark.parametrize("n",
+                         [0, 1, 4, None],
+                         ids=['0', '1', '4', 'None'])
+@pytest.mark.parametrize("increase",
+                         [True, False],
+                         ids=['True', 'False'])
+def test_vander(array, type, n, increase):
+    a_np = numpy.array(array, dtype=type)
+    a_dpnp = dpnp.array(array, dtype=type)
+
+    expected = numpy.vander(a_np, N=n, increasing=increase)
+    result = dpnp.vander(a_dpnp, N=n, increasing=increase)
+    numpy.testing.assert_array_equal(expected, result)