add parameter out to exp, log and cos funcs (#775)

* add parameter out to exp, log and cos funcs

* change call_fptr_1in_1out function

* fix typo

* remove keyword parameters

* Update dpnp_algo.pyx

Co-authored-by: Sergey Shalnov <shssf@users.noreply.github.com>

Author: KsanaKozlova

dpnp/dpnp_algo/dpnp_algo.pxd

@@ -336,19 +336,19 @@ cpdef dparray dpnp_arcsinh(dpnp_descriptor array1)
 cpdef dparray dpnp_arctan(dpnp_descriptor array1)
 cpdef dparray dpnp_arctanh(dpnp_descriptor array1)
 cpdef dparray dpnp_cbrt(dpnp_descriptor array1)
-cpdef dparray dpnp_cos(dpnp_descriptor array1)
+cpdef dparray dpnp_cos(dpnp_descriptor array1, dparray out)
 cpdef dparray dpnp_cosh(dpnp_descriptor array1)
 cpdef dparray dpnp_degrees(dpnp_descriptor array1)
-cpdef dparray dpnp_exp(dpnp_descriptor array1)
+cpdef dparray dpnp_exp(dpnp_descriptor array1, dparray out)
 cpdef dparray dpnp_exp2(dpnp_descriptor array1)
 cpdef dparray dpnp_expm1(dpnp_descriptor array1)
-cpdef dparray dpnp_log(dpnp_descriptor array1)
+cpdef dparray dpnp_log(dpnp_descriptor array1, dparray out)
 cpdef dparray dpnp_log10(dpnp_descriptor array1)
 cpdef dparray dpnp_log1p(dpnp_descriptor array1)
 cpdef dparray dpnp_log2(dpnp_descriptor array1)
 cpdef dparray dpnp_radians(dpnp_descriptor array1)
 cpdef dparray dpnp_recip(dpnp_descriptor array1)
-cpdef dparray dpnp_sin(dpnp_descriptor array1, dparray out=*)
+cpdef dparray dpnp_sin(dpnp_descriptor array1, dparray out)
 cpdef dparray dpnp_sinh(dpnp_descriptor array1)
 cpdef dparray dpnp_sqrt(dpnp_descriptor array1)
 cpdef dparray dpnp_square(dpnp_descriptor array1)

dpnp/dpnp_algo/dpnp_algo.pyx

@@ -254,16 +254,27 @@ cdef dparray call_fptr_1out(DPNPFuncName fptr_name, dparray_shape_type result_sh
     return result
 
 
-cdef dparray call_fptr_1in_1out(DPNPFuncName fptr_name, utils.dpnp_descriptor x1, dparray_shape_type result_shape):
+cdef dparray call_fptr_1in_1out(DPNPFuncName fptr_name, utils.dpnp_descriptor x1, dparray_shape_type result_shape, dparray out=None, func_name=None):
 
     """ Convert string type names (dparray.dtype) to C enum DPNPFuncType """
     cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(x1.dtype)
 
     """ get the FPTR data structure """
     cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(fptr_name, param1_type, param1_type)
+    
+    result_type = dpnp_DPNPFuncType_to_dtype(< size_t > kernel_data.return_type)
 
-    """ Create result array with type given by FPTR data """
-    cdef dparray result = utils.create_output_array(result_shape, kernel_data.return_type, None)
+    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
 
     cdef fptr_1in_1out_t func = <fptr_1in_1out_t > kernel_data.ptr
     """ Call FPTR function """

dpnp/dpnp_algo/dpnp_algo_trigonometric.pyx

@@ -92,8 +92,8 @@ cpdef dparray dpnp_cbrt(utils.dpnp_descriptor x1):
     return call_fptr_1in_1out(DPNP_FN_CBRT, x1, x1.shape)
 
 
-cpdef dparray dpnp_cos(utils.dpnp_descriptor x1):
-    return call_fptr_1in_1out(DPNP_FN_COS, x1, x1.shape)
+cpdef dparray dpnp_cos(utils.dpnp_descriptor x1, dparray out):
+    return call_fptr_1in_1out(DPNP_FN_COS, x1, x1.shape, out=out, func_name='cos')
 
 
 cpdef dparray dpnp_cosh(utils.dpnp_descriptor x1):
@@ -104,8 +104,8 @@ cpdef dparray dpnp_degrees(utils.dpnp_descriptor x1):
     return call_fptr_1in_1out(DPNP_FN_DEGREES, x1, x1.shape)
 
 
-cpdef dparray dpnp_exp(utils.dpnp_descriptor x1):
-    return call_fptr_1in_1out(DPNP_FN_EXP, x1, x1.shape)
+cpdef dparray dpnp_exp(utils.dpnp_descriptor x1, dparray out):
+    return call_fptr_1in_1out(DPNP_FN_EXP, x1, x1.shape, out=out, func_name='exp')
 
 
 cpdef dparray dpnp_exp2(utils.dpnp_descriptor x1):
@@ -116,8 +116,8 @@ cpdef dparray dpnp_expm1(utils.dpnp_descriptor x1):
     return call_fptr_1in_1out(DPNP_FN_EXPM1, x1, x1.shape)
 
 
-cpdef dparray dpnp_log(utils.dpnp_descriptor x1):
-    return call_fptr_1in_1out(DPNP_FN_LOG, x1, x1.shape)
+cpdef dparray dpnp_log(utils.dpnp_descriptor x1, dparray out):
+    return call_fptr_1in_1out(DPNP_FN_LOG, x1, x1.shape, out=out, func_name='log')
 
 
 cpdef dparray dpnp_log10(utils.dpnp_descriptor x1):
@@ -140,32 +140,8 @@ cpdef dparray dpnp_radians(utils.dpnp_descriptor x1):
     return call_fptr_1in_1out(DPNP_FN_RADIANS, x1, x1.shape)
 
 
-cpdef dparray dpnp_sin(utils.dpnp_descriptor x1, dparray out=None):
-
-    cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(x1.dtype)
-
-    cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_SIN, param1_type, param1_type)
-
-    result_type = dpnp_DPNPFuncType_to_dtype(< size_t > kernel_data.return_type)
-
-    shape_result = x1.shape
-
-    cdef dparray result
-
-    if out is not None:
-        if out.dtype != result_type:
-            utils.checker_throw_value_error('sin', 'out.dtype', out.dtype, result_type)
-        if out.shape != shape_result:
-            utils.checker_throw_value_error('sin', 'out.shape', out.shape, shape_result)
-        result = out
-    else:
-        result = dparray(shape_result, dtype=result_type)
-
-    cdef fptr_1in_1out_t func = <fptr_1in_1out_t > kernel_data.ptr
-
-    func(x1.get_data(), result.get_data(), x1.size)
-
-    return result
+cpdef dparray dpnp_sin(utils.dpnp_descriptor x1, dparray out):
+    return call_fptr_1in_1out(DPNP_FN_SIN, x1, x1.shape, out=out, func_name='sin')
 
 
 cpdef dparray dpnp_sinh(utils.dpnp_descriptor x1):

dpnp/dpnp_iface_trigonometric.py

@@ -371,7 +371,7 @@ def arctan2(x1, x2, dtype=None, out=None, where=True, **kwargs):
     return call_origin(numpy.arctan2, x1, x2, dtype=dtype, out=out, where=where, **kwargs)
 
 
-def cos(x1):
+def cos(x1, out=None, **kwargs):
     """
     Trigonometric cosine, element-wise.
 
@@ -395,9 +395,9 @@ def cos(x1):
 
     x1_desc = dpnp.get_dpnp_descriptor(x1)
     if x1_desc:
-        return dpnp_cos(x1_desc)
+        return dpnp_cos(x1_desc, out)
 
-    return call_origin(numpy.cos, x1, **kwargs)
+    return call_origin(numpy.cos, x1, out=out, **kwargs)
 
 
 def cosh(x1):
@@ -479,7 +479,7 @@ def degrees(x1):
     return call_origin(numpy.degrees, x1, **kwargs)
 
 
-def exp(x1):
+def exp(x1, out=None, **kwargs):
     """
     Trigonometric exponent, element-wise.
 
@@ -507,9 +507,9 @@ def exp(x1):
 
     x1_desc = dpnp.get_dpnp_descriptor(x1)
     if x1_desc:
-        return dpnp_exp(x1_desc)
+        return dpnp_exp(x1_desc, out)
 
-    return call_origin(numpy.exp, x1)
+    return call_origin(numpy.exp, x1, out=out, **kwargs)
 
 
 def exp2(x1):
@@ -630,7 +630,7 @@ def hypot(x1, x2, dtype=None, out=None, where=True, **kwargs):
     return call_origin(numpy.hypot, x1, x2, dtype=dtype, out=out, where=where, **kwargs)
 
 
-def log(x1):
+def log(x1, out=None, **kwargs):
     """
     Trigonometric logarithm, element-wise.
 
@@ -662,9 +662,9 @@ def log(x1):
 
     x1_desc = dpnp.get_dpnp_descriptor(x1)
     if x1_desc:
-        return dpnp_log(x1_desc)
+        return dpnp_log(x1_desc, out)
 
-    return call_origin(numpy.log, x1)
+    return call_origin(numpy.log, x1, out=out, **kwargs)
 
 
 def log10(x1):
@@ -876,7 +876,7 @@ def sin(x1, out=None, **kwargs):
 
     x1_desc = dpnp.get_dpnp_descriptor(x1)
     if x1_desc:
-        return dpnp_sin(x1_desc, out=out)
+        return dpnp_sin(x1_desc, out)
 
     return call_origin(numpy.sin, x1, out=out, **kwargs)
 

tests/test_umath.py

@@ -73,17 +73,160 @@ def test_umaths(test_cases):
     numpy.testing.assert_allclose(result, expected, rtol=1e-6)
 
 
-def test_sin():
-    array_data = numpy.arange(10)
-    out = numpy.empty(10, dtype=numpy.float64)
+class TestSin:
 
-    # DPNP
-    dp_array = dpnp.array(array_data, dtype=dpnp.float64)
-    dp_out = dpnp.array(out, dtype=dpnp.float64)
-    result = dpnp.sin(dp_array, out=dp_out)
+    def test_sin_ordinary(self):
+        array_data = numpy.arange(10)
+        out = numpy.empty(10, dtype=numpy.float64)
 
-    # original
-    np_array = numpy.array(array_data, dtype=numpy.float64)
-    expected = numpy.sin(np_array, out=out)
+        # DPNP
+        dp_array = dpnp.array(array_data, dtype=dpnp.float64)
+        dp_out = dpnp.array(out, dtype=dpnp.float64)
+        result = dpnp.sin(dp_array, out=dp_out)
+
+        # original
+        np_array = numpy.array(array_data, dtype=numpy.float64)
+        expected = numpy.sin(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 = dpnp.arange(10, dtype=dpnp.float64)
+        dp_out = dpnp.empty(10, dtype=dtype)
+
+        with pytest.raises(ValueError):
+            dpnp.sin(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 = dpnp.arange(10, dtype=dpnp.float64)
+        dp_out = dpnp.empty(shape, dtype=dpnp.float64)
+
+        with pytest.raises(ValueError):
+            dpnp.sin(dp_array, out=dp_out)
+
+class TestCos:
+
+    def test_cos(self):
+        array_data = numpy.arange(10)
+        out = numpy.empty(10, dtype=numpy.float64)
+
+        # DPNP
+        dp_array = dpnp.array(array_data, dtype=dpnp.float64)
+        dp_out = dpnp.array(out, dtype=dpnp.float64)
+        result = dpnp.cos(dp_array, out=dp_out)
+
+        # original
+        np_array = numpy.array(array_data, dtype=numpy.float64)
+        expected = numpy.cos(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 = dpnp.arange(10, dtype=dpnp.float64)
+        dp_out = dpnp.empty(10, dtype=dtype)
+
+        with pytest.raises(ValueError):
+            dpnp.cos(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 = dpnp.arange(10, dtype=dpnp.float64)
+        dp_out = dpnp.empty(shape, dtype=dpnp.float64)
+
+        with pytest.raises(ValueError):
+            dpnp.cos(dp_array, out=dp_out)
+
+
+class TestsLog:
+
+    def test_log(self):
+        array_data = numpy.arange(10)
+        out = numpy.empty(10, dtype=numpy.float64)
+
+        # DPNP
+        dp_array = dpnp.array(array_data, dtype=dpnp.float64)
+        dp_out = dpnp.array(out, dtype=dpnp.float64)
+        result = dpnp.log(dp_array, out=dp_out)
+
+        # original
+        np_array = numpy.array(array_data, dtype=numpy.float64)
+        expected = numpy.log(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 = dpnp.arange(10, dtype=dpnp.float64)
+        dp_out = dpnp.empty(10, dtype=dtype)
+
+        with pytest.raises(ValueError):
+            dpnp.log(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 = dpnp.arange(10, dtype=dpnp.float64)
+        dp_out = dpnp.empty(shape, dtype=dpnp.float64)
+
+        with pytest.raises(ValueError):
+            dpnp.log(dp_array, out=dp_out)
+
+
+class TestExp:
+
+    def test_exp(self):
+        array_data = numpy.arange(10)
+        out = numpy.empty(10, dtype=numpy.float64)
+
+        # DPNP
+        dp_array = dpnp.array(array_data, dtype=dpnp.float64)
+        dp_out = dpnp.array(out, dtype=dpnp.float64)
+        result = dpnp.exp(dp_array, out=dp_out)
+
+        # original
+        np_array = numpy.array(array_data, dtype=numpy.float64)
+        expected = numpy.exp(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 = dpnp.arange(10, dtype=dpnp.float64)
+        dp_out = dpnp.empty(10, dtype=dtype)
+
+        with pytest.raises(ValueError):
+            dpnp.exp(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 = dpnp.arange(10, dtype=dpnp.float64)
+        dp_out = dpnp.empty(shape, dtype=dpnp.float64)
 
-    numpy.testing.assert_array_equal(expected, result)
+        with pytest.raises(ValueError):
+            dpnp.exp(dp_array, out=dp_out)