implement dpnp.reciprocal and dpnp.angle

Author: vtavana

dpnp/backend/include/dpnp_iface_fptr.hpp

@@ -237,8 +237,6 @@ enum class DPNPFuncName : size_t
                                parameters */
     DPNP_FN_REMAINDER,      /**< Used in numpy.remainder() impl  */
     DPNP_FN_RECIP,          /**< Used in numpy.recip() impl  */
-    DPNP_FN_RECIP_EXT,      /**< Used in numpy.recip() impl, requires extra
-                               parameters */
     DPNP_FN_REPEAT,         /**< Used in numpy.repeat() impl  */
     DPNP_FN_RIGHT_SHIFT,    /**< Used in numpy.right_shift() impl  */
     DPNP_FN_RNG_BETA,       /**< Used in numpy.random.beta() impl  */

dpnp/backend/kernels/dpnp_krnl_elemwise.cpp

@@ -928,15 +928,6 @@ static void func_map_init_elemwise_1arg_1type(func_map_t &fmap)
     fmap[DPNPFuncName::DPNP_FN_RECIP][eft_DBL][eft_DBL] = {
         eft_DBL, (void *)dpnp_recip_c_default<double>};
 
-    fmap[DPNPFuncName::DPNP_FN_RECIP_EXT][eft_INT][eft_INT] = {
-        eft_INT, (void *)dpnp_recip_c_ext<int32_t>};
-    fmap[DPNPFuncName::DPNP_FN_RECIP_EXT][eft_LNG][eft_LNG] = {
-        eft_LNG, (void *)dpnp_recip_c_ext<int64_t>};
-    fmap[DPNPFuncName::DPNP_FN_RECIP_EXT][eft_FLT][eft_FLT] = {
-        eft_FLT, (void *)dpnp_recip_c_ext<float>};
-    fmap[DPNPFuncName::DPNP_FN_RECIP_EXT][eft_DBL][eft_DBL] = {
-        eft_DBL, (void *)dpnp_recip_c_ext<double>};
-
     fmap[DPNPFuncName::DPNP_FN_SIGN][eft_INT][eft_INT] = {
         eft_INT, (void *)dpnp_sign_c_default<int32_t>};
     fmap[DPNPFuncName::DPNP_FN_SIGN][eft_LNG][eft_LNG] = {

dpnp/dpnp_algo/dpnp_algo.pxd

@@ -110,8 +110,6 @@ cdef extern from "dpnp_iface_fptr.hpp" namespace "DPNPFuncName":  # need this na
         DPNP_FN_QR_EXT
         DPNP_FN_RADIANS
         DPNP_FN_RADIANS_EXT
-        DPNP_FN_RECIP
-        DPNP_FN_RECIP_EXT
         DPNP_FN_RNG_BETA
         DPNP_FN_RNG_BETA_EXT
         DPNP_FN_RNG_BINOMIAL
@@ -342,4 +340,3 @@ Trigonometric functions
 """
 cpdef dpnp_descriptor dpnp_degrees(dpnp_descriptor array1)
 cpdef dpnp_descriptor dpnp_radians(dpnp_descriptor array1)
-cpdef dpnp_descriptor dpnp_recip(dpnp_descriptor array1)

dpnp/dpnp_algo/dpnp_algo_trigonometric.pxi

@@ -38,7 +38,6 @@ and the rest of the library
 __all__ += [
     'dpnp_degrees',
     'dpnp_radians',
-    'dpnp_recip',
     'dpnp_unwrap'
 ]
 
@@ -47,10 +46,6 @@ cpdef utils.dpnp_descriptor dpnp_degrees(utils.dpnp_descriptor x1):
     return call_fptr_1in_1out_strides(DPNP_FN_DEGREES_EXT, x1)
 
 
-cpdef utils.dpnp_descriptor dpnp_recip(utils.dpnp_descriptor x1):
-    return call_fptr_1in_1out_strides(DPNP_FN_RECIP_EXT, x1)
-
-
 cpdef utils.dpnp_descriptor dpnp_radians(utils.dpnp_descriptor x1):
     return call_fptr_1in_1out_strides(DPNP_FN_RADIANS_EXT, x1)
 

dpnp/dpnp_algo/dpnp_elementwise_common.py

@@ -38,6 +38,7 @@
     "dpnp_acos",
     "dpnp_acosh",
     "dpnp_add",
+    "dpnp_angle",
     "dpnp_asin",
     "dpnp_asinh",
     "dpnp_atan",
@@ -88,6 +89,7 @@
     "dpnp_power",
     "dpnp_proj",
     "dpnp_real",
+    "dpnp_reciprocal",
     "dpnp_remainder",
     "dpnp_right_shift",
     "dpnp_round",
@@ -182,6 +184,7 @@ def _make_unary_func(
 ):
     impl_fn = dpt_unary_fn.get_implementation_function()
     type_resolver_fn = dpt_unary_fn.get_type_result_resolver_function()
+    acceptance_fn = dpt_unary_fn.get_type_promotion_path_acceptance_function()
 
     def _call_func(src, dst, sycl_queue, depends=None):
         """A callback to register in UnaryElementwiseFunc class of dpctl.tensor"""
@@ -195,7 +198,7 @@ def _call_func(src, dst, sycl_queue, depends=None):
         return impl_fn(src, dst, sycl_queue, depends)
 
     func = dpt_unary_fn.__class__(
-        name, type_resolver_fn, _call_func, fn_docstring
+        name, type_resolver_fn, _call_func, fn_docstring, acceptance_fn
     )
     return func
 
@@ -404,6 +407,45 @@ def dpnp_add(x1, x2, out=None, order="K"):
     return dpnp_array._create_from_usm_ndarray(res_usm)
 
 
+_angle_docstring = """
+angle(x, out=None, order="K")
+
+Computes the phase angle (also called the argument) of each element `x_i` for
+input array `x`.
+
+Args:
+    x (dpnp.ndarray):
+        Input array, expected to have a complex-valued floating-point data type.
+    out ({None, dpnp.ndarray}, optional):
+        Output array to populate.
+        Array must have the correct shape and the expected data type.
+    order ("C", "F", "A", "K", optional):
+        Memory layout of the newly output array, if parameter `out` is ``None``.
+        Default: "K".
+Returns:
+    dpnp.ndarray:
+        An array containing the element-wise phase angles.
+        The returned array has a floating-point data type determined
+        by the Type Promotion Rules.
+"""
+
+angle_func = _make_unary_func("angle", dpt.angle, _angle_docstring)
+
+
+def dpnp_angle(x, out=None, order="K"):
+    """Invokes angle() from dpctl.tensor implementation for angle() function."""
+
+    # dpctl.tensor only works with usm_ndarray
+    x1_usm = dpnp.get_usm_ndarray(x)
+    out_usm = None if out is None else dpnp.get_usm_ndarray(out)
+
+    res_usm = angle_func(x1_usm, out=out_usm, order=order)
+    if out is None:
+        return dpnp_array._create_from_usm_ndarray(res_usm)
+    else:
+        return out
+
+
 _asin_docstring = """
 asin(x, out=None, order='K')
 
@@ -2452,6 +2494,46 @@ def dpnp_real(x, out=None, order="K"):
     return dpnp_array._create_from_usm_ndarray(res_usm)
 
 
+_reciprocal_docstring = """
+reciprocal(x, out=None, order="K")
+
+Computes the reciprocal of each element `x_i` for input array `x`.
+
+Args:
+    x (dpnp.ndarray):
+        Input array, expected to have a real-valued floating-point data type.
+    out ({None, dpnp.ndarray}, optional):
+        Output array to populate.
+        Array must have the correct shape and the expected data type.
+    order ("C", "F", "A", "K", optional):
+        Memory layout of the newly output array, if parameter `out` is ``None``.
+        Default: "K".
+Returns:
+    dpnp.ndarray:
+        An array containing the element-wise reciprocals.
+        The returned array has a floating-point data type determined
+        by the Type Promotion Rules.
+"""
+
+reciprocal_func = _make_unary_func(
+    "reciprocal", dpt.reciprocal, _reciprocal_docstring
+)
+
+
+def dpnp_reciprocal(x, out=None, order="K"):
+    """Invokes reciprocal() from dpctl.tensor implementation for reciprocal() function."""
+
+    # dpctl.tensor only works with usm_ndarray
+    x1_usm = dpnp.get_usm_ndarray(x)
+    out_usm = None if out is None else dpnp.get_usm_ndarray(out)
+
+    res_usm = reciprocal_func(x1_usm, out=out_usm, order=order)
+    if out is None:
+        return dpnp_array._create_from_usm_ndarray(res_usm)
+    else:
+        return out
+
+
 _remainder_docstring = """
 remainder(x1, x2, out=None, order='K')
 

dpnp/dpnp_iface_bitwise.py

@@ -1,5 +1,3 @@
-# cython: language_level=3
-# distutils: language = c++
 # -*- coding: utf-8 -*-
 # *****************************************************************************
 # Copyright (c) 2016-2023, Intel Corporation

dpnp/dpnp_iface_manipulation.py

@@ -1174,7 +1174,7 @@ def ravel(a, order="C"):
 
     Parameters
     ----------
-    x : {dpnp_array, usm_ndarray}
+    x : {dpnp.array, usm_ndarray}
         Input array. The elements in `a` are read in the order specified by order,
         and packed as a 1-D array.
     order : {'C', 'F'}, optional
@@ -1187,7 +1187,7 @@ def ravel(a, order="C"):
 
     Returns
     -------
-    out : dpnp_array
+    out : dpnp.array
         A contiguous 1-D array of the same subtype as `a`, with shape (a.size,).
 
     See Also
@@ -1220,7 +1220,7 @@ def repeat(a, repeats, axis=None):
 
     Parameters
     ----------
-    x : {dpnp_array, usm_ndarray}
+    x : {dpnp.array, usm_ndarray}
         Input array.
     repeat : int or array of int
         The number of repetitions for each element. `repeats` is broadcasted to fit
@@ -1231,7 +1231,7 @@ def repeat(a, repeats, axis=None):
 
     Returns
     -------
-    out : dpnp_array
+    out : dpnp.array
         Output array which has the same shape as `a`, except along the given axis.
 
     See Also

dpnp/dpnp_iface_mathematical.py

@@ -54,6 +54,7 @@
     check_nd_call_func,
     dpnp_abs,
     dpnp_add,
+    dpnp_angle,
     dpnp_ceil,
     dpnp_conj,
     dpnp_copysign,
@@ -82,6 +83,7 @@
     "abs",
     "absolute",
     "add",
+    "angle",
     "around",
     "ceil",
     "clip",
@@ -291,6 +293,62 @@ def add(
     )
 
 
+def angle(z, deg=False):
+    """
+    Return the angle of the complex argument.
+
+    For full documentation refer to :obj:`numpy.angle`.
+
+    Parameters
+    ----------
+    x : {dpnp.array, usm_ndarray}
+        Input array, expected to have a complex-valued floating-point data type.
+    deg : bool, optional
+        Return angle in degrees if True, radians if False (default).
+
+    Returns
+    -------
+    out : dpnp.ndarray
+        The counterclockwise angle from the positive real axis on
+        the complex plane in the range `(-pi, pi]`.
+        The returned array has a floating-point data type determined
+        by the Type Promotion Rules.
+
+    Notes
+    -----
+    Although the angle of the complex number 0 is undefined, `dpnp.angle(0)` returns the value 0.
+
+    See Also
+    --------
+    :obj:`dpnp.arctan2` : Element-wise arc tangent of `x1/x2` choosing the quadrant correctly.
+    :obj:`dpnp.absolute` : Calculate the absolute value element-wise.
+
+    Examples
+    --------
+    >>> import dpnp as np
+    >>> a = np.array([1.0, 1.0j, 1+1j])
+    >>> np.angle(a) # in radians
+    array([0.        , 1.57079633, 0.78539816]) # may vary
+
+    >>> np.angle(a, deg=True) # in degrees
+    array([ 0., 90., 45.])
+
+    """
+
+    if not dpnp.isscalar(z):
+        dpnp.check_supported_arrays_type(z)
+        res = dpnp_angle(z)
+        if deg is True:
+            res = res * (180 / dpnp.pi)
+        return res
+    else:
+        return call_origin(
+            numpy.angle,
+            z,
+            deg=deg,
+        )
+
+
 def around(x, /, decimals=0, out=None):
     """
     Round an array to the given number of decimals.
@@ -390,12 +448,12 @@ def clip(a, a_min, a_max, *, out=None, order="K", **kwargs):
 
     Parameters
     ----------
-    a : {dpnp_array, usm_ndarray}
+    a : {dpnp.array, usm_ndarray}
         Array containing elements to clip.
-    a_min, a_max : {dpnp_array, usm_ndarray, None}
+    a_min, a_max : {dpnp.array, usm_ndarray, None}
         Minimum and maximum value. If ``None``, clipping is not performed on the corresponding edge.
         Only one of `a_min` and `a_max` may be ``None``. Both are broadcast against `a`.
-    out : {dpnp_array, usm_ndarray}, optional
+    out : {dpnp.array, usm_ndarray}, optional
         The results will be placed in this array. It may be the input array for in-place clipping.
         `out` must be of the right shape to hold the output. Its type is preserved.
     order : {"C", "F", "A", "K", None}, optional
@@ -404,7 +462,7 @@ def clip(a, a_min, a_max, *, out=None, order="K", **kwargs):
 
     Returns
     -------
-    out : dpnp_array
+    out : dpnp.array
         An array with the elements of `a`, but where values < `a_min` are replaced with `a_min`,
         and those > `a_max` with `a_max`.