add gradient function (#503)

* add gradient function

Author: KsanaKozlova

dpnp/dpnp_algo/dpnp_algo_mathematical.pyx

@@ -57,6 +57,7 @@ __all__ += [
     "dpnp_floor",
     "dpnp_floor_divide",
     "dpnp_fmod",
+    "dpnp_gradient",
     'dpnp_hypot',
     "dpnp_maximum",
     "dpnp_minimum",
@@ -294,6 +295,27 @@ cpdef dparray dpnp_fmod(dparray x1, dparray x2):
     return call_fptr_2in_1out(DPNP_FN_FMOD, x1, x2, x1.shape)
 
 
+cpdef dparray dpnp_gradient(dparray y1, int dx=1):
+
+    size = y1.size
+
+    cdef dparray result = dparray(size, dtype=dpnp.float64)
+   
+    cur = (y1[1] - y1[0]) / dx
+
+    result._setitem_scalar(0, cur)
+
+    cur = (y1[-1] - y1[-2]) / dx
+
+    result._setitem_scalar(size - 1, cur)
+  
+    for i in range(1, size - 1):
+        cur = (y1[i + 1] - y1[i - 1]) / (2 * dx)
+        result._setitem_scalar(i, cur)
+
+    return result
+
+
 cpdef dparray dpnp_hypot(dparray x1, dparray x2):
     return call_fptr_2in_1out(DPNP_FN_HYPOT, x1, x2, x1.shape)
 

dpnp/dpnp_iface_mathematical.py

@@ -69,6 +69,7 @@
     "fmax",
     "fmin",
     "fmod",
+    "gradient",
     "maximum",
     "minimum",
     "mod",
@@ -795,6 +796,48 @@ def fmod(x1, x2, **kwargs):
     return call_origin(numpy.fmod, x1, x2, **kwargs)
 
 
+def gradient(y1, *varargs, **kwargs):
+    """
+    Return the gradient of an array.
+
+    For full documentation refer to :obj:`numpy.gradient`.
+
+    Limitations
+    -----------
+        Parameter ``y1`` is supported as :obj:`dpnp.ndarray`.
+        Argument ``varargs[0]`` is supported as `int`.
+        Keyword arguments ``kwargs`` are currently unsupported.
+        Otherwise the functions will be executed sequentially on CPU.
+        Input array data types are limited by supported DPNP :ref:`Data types`.
+   
+    Example
+    -------
+    >>> import dpnp as np
+    >>> y = np.array([1, 2, 4, 7, 11, 16], dtype=float)
+    >>> result = np.gradient(y)
+    >>> [x for x in result]
+    [1.0, 1.5, 2.5, 3.5, 4.5, 5.0]
+    >>> result = np.gradient(y, 2)
+    >>> [x for x in result]
+    [0.5, 0.75, 1.25, 1.75, 2.25, 2.5]
+
+    """
+    if not use_origin_backend(y1) and not kwargs:
+        if not isinstance(y1, dparray):
+            pass
+        elif len(varargs) > 1:
+            pass
+        elif len(varargs) == 1 and not isinstance(varargs[0], int):
+            pass
+        else:
+            if len(varargs) == 0:
+                return dpnp_gradient(y1)
+
+            return dpnp_gradient(y1, varargs[0])
+
+    return call_origin(numpy.gradient, y1, *varargs, **kwargs)
+
+
 def maximum(x1, x2, **kwargs):
     """
     Element-wise maximum of array elements.

tests/test_mathematical.py

@@ -215,3 +215,55 @@ def test_cross_3x3(self, x1, x2, axisa, axisb, axisc, axis):
         result = inp.cross(ix1_, ix2_, axisa, axisb, axisc, axis)
         expected = numpy.cross(x1_, x2_, axisa, axisb, axisc, axis)
         numpy.testing.assert_array_equal(expected, result)
+
+
+class TestGradient:
+
+    @pytest.mark.parametrize("array", [[2, 3, 6, 8, 4, 9],
+                                       [3., 4., 7.5, 9.],
+                                       [2, 6, 8, 10]])
+    def test_gradient_y1(self, array):
+        y1 = numpy.array(array)
+        iy1 = inp.array(y1)
+
+        result = inp.gradient(iy1)
+        expected = numpy.gradient(y1)
+        numpy.testing.assert_array_equal(expected, result)
+
+    @pytest.mark.parametrize("array", [[2, 3, 6, 8, 4, 9],
+                                       [3., 4., 7.5, 9.],
+                                       [2, 6, 8, 10]])
+    @pytest.mark.parametrize("dx", [2, 3.5])
+    def test_gradient_y1_dx(self, array, dx):
+        y1 = numpy.array(array)
+        iy1 = inp.array(y1)
+
+        result = inp.gradient(iy1, dx)
+        expected = numpy.gradient(y1, dx)
+        numpy.testing.assert_array_equal(expected, result)
+
+
+class TestGradient:
+
+    @pytest.mark.parametrize("array", [[2, 3, 6, 8, 4, 9],
+                                       [3., 4., 7.5, 9.],
+                                       [2, 6, 8, 10]])
+    def test_gradient_y1(self, array):
+        y1 = numpy.array(array)
+        iy1 = inp.array(y1)
+
+        result = inp.gradient(iy1)
+        expected = numpy.gradient(y1)
+        numpy.testing.assert_array_equal(expected, result)
+
+    @pytest.mark.parametrize("array", [[2, 3, 6, 8, 4, 9],
+                                       [3., 4., 7.5, 9.],
+                                       [2, 6, 8, 10]])
+    @pytest.mark.parametrize("dx", [2, 3.5])
+    def test_gradient_y1_dx(self, array, dx):
+        y1 = numpy.array(array)
+        iy1 = inp.array(y1)
+
+        result = inp.gradient(iy1, dx)
+        expected = numpy.gradient(y1, dx)
+        numpy.testing.assert_array_equal(expected, result)