Add modf implementation as an instance of DPNPUnaryTwoOutputsFunc class

Author: antonwolfy

dpnp/dpnp_iface_mathematical.py

@@ -61,7 +61,6 @@
 import dpnp
 import dpnp.backend.extensions.ufunc._ufunc_impl as ufi
 
-from .dpnp_algo import dpnp_modf
 from .dpnp_algo.dpnp_elementwise_common import (
     DPNPI0,
     DPNPAngle,
@@ -81,7 +80,7 @@
     resolve_weak_types_2nd_arg_int,
 )
 from .dpnp_array import dpnp_array
-from .dpnp_utils import call_origin, get_usm_allocations
+from .dpnp_utils import get_usm_allocations
 from .dpnp_utils.dpnp_utils_linearalgebra import dpnp_cross
 from .dpnp_utils.dpnp_utils_reduction import dpnp_wrap_reduction_call
 
@@ -2365,7 +2364,6 @@ def ediff1d(ary, to_end=None, to_begin=None):
     as `x` and the expected data type.
 
     Default: ``None``.
-
 out : tuple of None, dpnp.ndarray, or usm_ndarray, optional
     A location into which the result is stored. If provided, it must be a tuple
     and have length equal to the number of outputs. Each provided array must
@@ -3351,42 +3349,80 @@ def interp(x, xp, fp, left=None, right=None, period=None):
 )
 
 
-def modf(x1, **kwargs):
-    """
-    Return the fractional and integral parts of an array, element-wise.
+_MODF_DOCSTRING = """
+Decompose each element :math:`x_i` of the input array `x` into the fractional
+and the integral parts.
 
-    For full documentation refer to :obj:`numpy.modf`.
+The fractional and integral parts are negative if the given :math:`x_i` is
+negative.
 
-    Limitations
-    -----------
-    Parameter `x` is supported as :obj:`dpnp.ndarray`.
-    Keyword argument `kwargs` is currently unsupported.
-    Otherwise the function will be executed sequentially on CPU.
-    Input array data types are limited by supported DPNP :ref:`Data types`.
+Parameters
+----------
+x : {dpnp.ndarray, usm_ndarray}
+    Array of numbers to be decomposed, expected to have a real-valued
+    floating-point data type.
+out1 : {None, dpnp.ndarray, usm_ndarray}, optional
+    Output array for the fractional parts to populate. Array must have the same
+    shape as `x` and the expected data type.
 
-    Examples
-    --------
-    >>> import dpnp as np
-    >>> a = np.array([1, 2])
-    >>> result = np.modf(a)
-    >>> [[x for x in y] for y in result ]
-    [[1.0, 2.0], [0.0, 0.0]]
+    Default: ``None``.
+out2 : {None, dpnp.ndarray, usm_ndarray}, optional
+    Output array for the integral parts to populate. Array must have the same
+    shape as `x` and the expected data type.
 
-    """
+    Default: ``None``.
+out : tuple of None, dpnp.ndarray, or usm_ndarray, optional
+    A location into which the result is stored. If provided, it must be a tuple
+    and have length equal to the number of outputs. Each provided array must
+    have the same shape as `x` and the expected data type.
+    It is prohibited to pass output arrays through `out` keyword when either
+    `out1` or `out2` is passed.
 
-    x1_desc = dpnp.get_dpnp_descriptor(x1, copy_when_nondefault_queue=False)
-    if x1_desc:
-        if dpnp.is_cuda_backend(x1_desc.get_array()):  # pragma: no cover
-            raise NotImplementedError(
-                "Running on CUDA is currently not supported"
-            )
+    Default: ``(None, None)``.
+order : {None, "C", "F", "A", "K"}, optional
+    Memory layout of the newly output array, if parameter `out` is ``None``.
 
-        if kwargs:
-            pass
-        else:
-            return dpnp_modf(x1_desc)
+    Default: ``"K"``.
+
+Returns
+-------
+y1 : dpnp.ndarray
+    Fractional part of `x`.
+y2 : dpnp.ndarray
+    Integral part of `x`.
+
+Limitations
+-----------
+Parameters `where`, `dtype` and `subok` are supported with their default values.
+Keyword argument `kwargs` is currently unsupported.
+Otherwise ``NotImplementedError`` exception will be raised.
 
-    return call_origin(numpy.modf, x1, **kwargs)
+See Also
+--------
+:obj:`dpnp.divmod` : ``divmod(x, 1)`` is an equivalent to ``modf(x)`` with the
+    return values switched, except it always has a positive remainder.
+
+Notes
+-----
+For integer input the return values are floats.
+
+Examples
+--------
+>>> import dpnp as np
+>>> x = np.array([0, 3.5])
+>>> np.modf(x)
+(array([0. , 0.5]), array([0., 3.]))
+>>> np.modf(np.array(-0.5))
+(array(-0.5), array(-0.))
+
+"""
+
+modf = DPNPUnaryTwoOutputsFunc(
+    "_modf",
+    ufi._modf_result_type,
+    ufi._modf,
+    _MODF_DOCSTRING,
+)
 
 
 _MULTIPLY_DOCSTRING = """