add parameter out to four mathematical functions (#785)

* add parameter out to exp, log and cos funcs

Author: KsanaKozlova

dpnp/dpnp_algo/dpnp_algo.pxd

@@ -294,7 +294,7 @@ cpdef dparray dpnp_maximum(object x1_obj, object x2_obj, object dtype=*, dparray
 cpdef dparray dpnp_minimum(object x1_obj, object x2_obj, object dtype=*, dparray out=*, object where=*)
 cpdef dparray dpnp_multiply(object x1_obj, object x2_obj, object dtype=*, dparray out=*, object where=*)
 cpdef dparray dpnp_negative(dpnp_descriptor array1)
-cpdef dparray dpnp_power(object x1_obj, object x2_obj, object dtype=*, dparray out=*, object where=*)
+cpdef dparray dpnp_power(dpnp_descriptor x1_obj, dpnp_descriptor x2_obj, object dtype=*, dparray out=*, object where=*)
 cpdef dparray dpnp_remainder(object x1_obj, object x2_obj, object dtype=*, dparray out=*, object where=*)
 cpdef dparray dpnp_subtract(object x1_obj, object x2_obj, object dtype=*, dparray out=*, object where=*)
 

dpnp/dpnp_algo/dpnp_algo.pyx

@@ -277,26 +277,38 @@ cdef dparray call_fptr_1in_1out(DPNPFuncName fptr_name, utils.dpnp_descriptor x1
         result = out
 
     cdef fptr_1in_1out_t func = <fptr_1in_1out_t > kernel_data.ptr
-    """ Call FPTR function """
+
     func(x1.get_data(), result.get_data(), x1.size)
 
     return result
 
 
 cdef dparray call_fptr_2in_1out(DPNPFuncName fptr_name, utils.dpnp_descriptor x1_obj, utils.dpnp_descriptor x2_obj,
-                                object dtype=None, dparray out=None, object where=True):
+                                object dtype=None, dparray out=None, object where=True, func_name=None):
     # Convert string type names (dparray.dtype) to C enum DPNPFuncType
     cdef DPNPFuncType x1_c_type = dpnp_dtype_to_DPNPFuncType(x1_obj.dtype)
     cdef DPNPFuncType x2_c_type = dpnp_dtype_to_DPNPFuncType(x2_obj.dtype)
 
     # get the FPTR data structure
     cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(fptr_name, x1_c_type, x2_c_type)
 
+    result_type = dpnp_DPNPFuncType_to_dtype(< size_t > kernel_data.return_type)
+
     # Create result array
     cdef dparray_shape_type x1_shape = x1_obj.shape
     cdef dparray_shape_type x2_shape = x2_obj.shape
     cdef dparray_shape_type result_shape = utils.get_common_shape(x1_shape, x2_shape)
-    cdef dparray result = utils.create_output_array(result_shape, kernel_data.return_type, out)
+    cdef dparray result
+
+    if out is None:
+        """ Create result array with type given by FPTR data """
+        result = utils.create_output_array(result_shape, kernel_data.return_type, None)
+    else:
+        if out.dtype != result_type:
+            utils.checker_throw_value_error(func_name, 'out.dtype', out.dtype, result_type)
+        if out.shape != result_shape:
+            utils.checker_throw_value_error(func_name, 'out.shape', out.shape, result_shape)
+        result = out
 
     """ Call FPTR function """
     cdef fptr_2in_1out_t func = <fptr_2in_1out_t > kernel_data.ptr

dpnp/dpnp_algo/dpnp_algo_mathematical.pyx

@@ -126,8 +126,8 @@ cpdef dpnp_around(utils.dpnp_descriptor x1, int decimals):
     return result
 
 
-cpdef dparray dpnp_ceil(utils.dpnp_descriptor x1):
-    return call_fptr_1in_1out(DPNP_FN_CEIL, x1, x1.shape)
+cpdef dparray dpnp_ceil(utils.dpnp_descriptor x1, dparray out):
+    return call_fptr_1in_1out(DPNP_FN_CEIL, x1, x1.shape, out=out, func_name='ceil')
 
 
 cpdef dparray dpnp_conjugate(utils.dpnp_descriptor x1):
@@ -209,8 +209,8 @@ cpdef dparray dpnp_fabs(utils.dpnp_descriptor x1):
     return call_fptr_1in_1out(DPNP_FN_FABS, x1, x1.shape)
 
 
-cpdef dparray dpnp_floor(utils.dpnp_descriptor x1):
-    return call_fptr_1in_1out(DPNP_FN_FLOOR, x1, x1.shape)
+cpdef dparray dpnp_floor(utils.dpnp_descriptor x1, dparray out):
+    return call_fptr_1in_1out(DPNP_FN_FLOOR, x1, x1.shape, out=out, func_name='floor')
 
 
 cpdef dparray dpnp_floor_divide(object x1_obj, object x2_obj, object dtype=None, dparray out=None, object where=True):
@@ -339,8 +339,8 @@ cpdef dparray dpnp_negative(dpnp_descriptor x1):
     return call_fptr_1in_1out(DPNP_FN_NEGATIVE, x1, x1.shape)
 
 
-cpdef dparray dpnp_power(object x1_obj, object x2_obj, object dtype=None, dparray out=None, object where=True):
-    return call_fptr_2in_1out(DPNP_FN_POWER, x1_obj, x2_obj, dtype=dtype, out=out, where=where)
+cpdef dparray dpnp_power(utils.dpnp_descriptor x1_obj, utils.dpnp_descriptor x2_obj, object dtype=None, dparray out=None, object where=True):
+    return call_fptr_2in_1out(DPNP_FN_POWER, x1_obj, x2_obj, dtype=dtype, out=out, where=where, func_name="power")
 
 
 cpdef dparray dpnp_prod(utils.dpnp_descriptor input, object axis=None, object dtype=None, dparray out=None, cpp_bool keepdims=False, object initial=None, object where=True):
@@ -426,5 +426,5 @@ cpdef dpnp_trapz(utils.dpnp_descriptor y1, dparray x1, double dx):
     return result[0]
 
 
-cpdef dparray dpnp_trunc(utils.dpnp_descriptor x1):
-    return call_fptr_1in_1out(DPNP_FN_TRUNC, x1, x1.shape)
+cpdef dparray dpnp_trunc(utils.dpnp_descriptor x1, dparray out):
+    return call_fptr_1in_1out(DPNP_FN_TRUNC, x1, x1.shape, out=out, func_name='trunc')

dpnp/dpnp_iface_mathematical.py

@@ -250,7 +250,7 @@ def around(x1, decimals=0, out=None):
     return call_origin(numpy.around, x1, decimals=decimals, out=out)
 
 
-def ceil(x1, **kwargs):
+def ceil(x1, out=None, **kwargs):
     """
     Compute  the ceiling of the input, element-wise.
 
@@ -280,9 +280,9 @@ def ceil(x1, **kwargs):
 
     x1_desc = dpnp.get_dpnp_descriptor(x1)
     if x1_desc and not kwargs:
-        return dpnp_ceil(x1_desc)
+        return dpnp_ceil(x1_desc, out)
 
-    return call_origin(numpy.ceil, x1, **kwargs)
+    return call_origin(numpy.ceil, x1, out=out, **kwargs)
 
 
 def conjugate(x1, **kwargs):
@@ -638,7 +638,7 @@ def fabs(x1, **kwargs):
     return call_origin(numpy.fabs, x1, **kwargs)
 
 
-def floor(x1, **kwargs):
+def floor(x1, out=None, **kwargs):
     """
     Round a number to the nearest integer toward minus infinity.
 
@@ -673,9 +673,9 @@ def floor(x1, **kwargs):
 
     x1_desc = dpnp.get_dpnp_descriptor(x1)
     if x1_desc and not kwargs:
-        return dpnp_floor(x1_desc)
+        return dpnp_floor(x1_desc, out)
 
-    return call_origin(numpy.floor, x1, **kwargs)
+    return call_origin(numpy.floor, x1, out=out, **kwargs)
 
 
 def floor_divide(x1, x2, dtype=None, out=None, where=True, **kwargs):
@@ -1322,8 +1322,6 @@ def power(x1, x2, dtype=None, out=None, where=True, **kwargs):
             pass
         elif dtype is not None:
             pass
-        elif out is not None:
-            pass
         elif not where:
             pass
         else:
@@ -1614,7 +1612,7 @@ def true_divide(*args, **kwargs):
     return dpnp.divide(*args, **kwargs)
 
 
-def trunc(x1, **kwargs):
+def trunc(x1, out=None, **kwargs):
     """
     Compute the truncated value of the input, element-wise.
 
@@ -1644,6 +1642,6 @@ def trunc(x1, **kwargs):
 
     x1_desc = dpnp.get_dpnp_descriptor(x1)
     if x1_desc and not kwargs:
-        return dpnp_trunc(x1_desc)
+        return dpnp_trunc(x1_desc, out)
 
-    return call_origin(numpy.trunc, x1, **kwargs)
+    return call_origin(numpy.trunc, x1, out=out, **kwargs)

tests/test_mathematical.py

@@ -409,3 +409,168 @@ def test_gradient_y1_dx(self, array, dx):
         result = inp.gradient(iy1, dx)
         expected = numpy.gradient(y1, dx)
         numpy.testing.assert_array_equal(expected, result)
+
+
+class TestCeil:
+
+    def test_ceil(self):
+        array_data = numpy.arange(10)
+        out = numpy.empty(10, dtype=numpy.float64)
+
+        # DPNP
+        dp_array = inp.array(array_data, dtype=inp.float64)
+        dp_out = inp.array(out, dtype=inp.float64)
+        result = inp.ceil(dp_array, out=dp_out)
+
+        # original
+        np_array = numpy.array(array_data, dtype=numpy.float64)
+        expected = numpy.ceil(np_array, out=out)
+
+        numpy.testing.assert_array_equal(expected, result)
+
+    @pytest.mark.parametrize("dtype",
+                             [numpy.float32, numpy.int64, numpy.int32],
+                             ids=['numpy.float32', 'numpy.int64', 'numpy.int32'])
+    def test_invalid_dtype(self, dtype):
+
+        dp_array = inp.arange(10, dtype=inp.float64)
+        dp_out = inp.empty(10, dtype=dtype)
+
+        with pytest.raises(ValueError):
+            inp.ceil(dp_array, out=dp_out)
+
+    @pytest.mark.parametrize("shape",
+                             [(0,), (15, ), (2, 2)],
+                             ids=['(0,)', '(15, )', '(2,2)'])
+    def test_invalid_shape(self, shape):
+
+        dp_array = inp.arange(10, dtype=inp.float64)
+        dp_out = inp.empty(shape, dtype=inp.float64)
+
+        with pytest.raises(ValueError):
+            inp.ceil(dp_array, out=dp_out)
+
+
+class TestFloor:
+
+    def test_floor(self):
+        array_data = numpy.arange(10)
+        out = numpy.empty(10, dtype=numpy.float64)
+
+        # DPNP
+        dp_array = inp.array(array_data, dtype=inp.float64)
+        dp_out = inp.array(out, dtype=inp.float64)
+        result = inp.floor(dp_array, out=dp_out)
+
+        # original
+        np_array = numpy.array(array_data, dtype=numpy.float64)
+        expected = numpy.floor(np_array, out=out)
+
+        numpy.testing.assert_array_equal(expected, result)
+
+    @pytest.mark.parametrize("dtype",
+                             [numpy.float32, numpy.int64, numpy.int32],
+                             ids=['numpy.float32', 'numpy.int64', 'numpy.int32'])
+    def test_invalid_dtype(self, dtype):
+
+        dp_array = inp.arange(10, dtype=inp.float64)
+        dp_out = inp.empty(10, dtype=dtype)
+
+        with pytest.raises(ValueError):
+            inp.floor(dp_array, out=dp_out)
+
+    @pytest.mark.parametrize("shape",
+                             [(0,), (15, ), (2, 2)],
+                             ids=['(0,)', '(15, )', '(2,2)'])
+    def test_invalid_shape(self, shape):
+
+        dp_array = inp.arange(10, dtype=inp.float64)
+        dp_out = inp.empty(shape, dtype=inp.float64)
+
+        with pytest.raises(ValueError):
+            inp.floor(dp_array, out=dp_out)
+
+
+class TestTrunc:
+
+    def test_trunc(self):
+        array_data = numpy.arange(10)
+        out = numpy.empty(10, dtype=numpy.float64)
+
+        # DPNP
+        dp_array = inp.array(array_data, dtype=inp.float64)
+        dp_out = inp.array(out, dtype=inp.float64)
+        result = inp.trunc(dp_array, out=dp_out)
+
+        # original
+        np_array = numpy.array(array_data, dtype=numpy.float64)
+        expected = numpy.trunc(np_array, out=out)
+
+        numpy.testing.assert_array_equal(expected, result)
+
+    @pytest.mark.parametrize("dtype",
+                             [numpy.float32, numpy.int64, numpy.int32],
+                             ids=['numpy.float32', 'numpy.int64', 'numpy.int32'])
+    def test_invalid_dtype(self, dtype):
+
+        dp_array = inp.arange(10, dtype=inp.float64)
+        dp_out = inp.empty(10, dtype=dtype)
+
+        with pytest.raises(ValueError):
+            inp.trunc(dp_array, out=dp_out)
+
+    @pytest.mark.parametrize("shape",
+                             [(0,), (15, ), (2, 2)],
+                             ids=['(0,)', '(15, )', '(2,2)'])
+    def test_invalid_shape(self, shape):
+
+        dp_array = inp.arange(10, dtype=inp.float64)
+        dp_out = inp.empty(shape, dtype=inp.float64)
+
+        with pytest.raises(ValueError):
+            inp.trunc(dp_array, out=dp_out)
+
+
+class TestPower:
+
+    def test_power(self):
+        array1_data = numpy.arange(10)
+        array2_data = numpy.arange(5, 15)
+        out = numpy.empty(10, dtype=numpy.float64)
+
+        # DPNP
+        dp_array1 = inp.array(array1_data, dtype=inp.float64)
+        dp_array2 = inp.array(array2_data, dtype=inp.float64)
+        dp_out = inp.array(out, dtype=inp.float64)
+        result = inp.power(dp_array1, dp_array2, out=dp_out)
+
+        # original
+        np_array1 = numpy.array(array1_data, dtype=numpy.float64)
+        np_array2 = numpy.array(array2_data, dtype=numpy.float64)
+        expected = numpy.power(np_array1, np_array2, out=out)
+
+        numpy.testing.assert_array_equal(expected, result)
+
+    @pytest.mark.parametrize("dtype",
+                             [numpy.float32, numpy.int64, numpy.int32],
+                             ids=['numpy.float32', 'numpy.int64', 'numpy.int32'])
+    def test_invalid_dtype(self, dtype):
+
+        dp_array1 = inp.arange(10, dtype=inp.float64)
+        dp_array2 = inp.arange(5, 15, dtype=inp.float64)
+        dp_out = inp.empty(10, dtype=dtype)
+
+        with pytest.raises(ValueError):
+            inp.power(dp_array1, dp_array2, out=dp_out)
+
+    @pytest.mark.parametrize("shape",
+                             [(0,), (15, ), (2, 2)],
+                             ids=['(0,)', '(15, )', '(2,2)'])
+    def test_invalid_shape(self, shape):
+
+        dp_array1 = inp.arange(10, dtype=inp.float64)
+        dp_array2 = inp.arange(5, 15, dtype=inp.float64)
+        dp_out = inp.empty(shape, dtype=inp.float64)
+
+        with pytest.raises(ValueError):
+            inp.power(dp_array1, dp_array2, out=dp_out)