Implement dpnp.isreal, dpnp.isrealobj, dpnp.iscomplex, dpnp.iscomplexobj. (#1916)

* Implement dpnp.isreal, dpnp.iscomplex

* Applied review comments

* Applied review comments

* Simplified isreal and iscomplex tests

---------

Co-authored-by: Anton <[email protected]>

Author: npolina4

dpnp/dpnp_iface.py

@@ -76,7 +76,7 @@
     "synchronize_array_data",
 ]
 
-from dpnp import float64, isscalar
+from dpnp import float64
 from dpnp.dpnp_iface_arraycreation import *
 from dpnp.dpnp_iface_arraycreation import __all__ as __all__arraycreation
 from dpnp.dpnp_iface_bitwise import *
@@ -533,7 +533,7 @@ def get_dpnp_descriptor(
 
     # If input object is a scalar, it means it was allocated on host memory.
     # We need to copy it to USM memory according to compute follows data.
-    if isscalar(ext_obj):
+    if dpnp.isscalar(ext_obj):
         ext_obj = array(
             ext_obj,
             dtype=alloc_dtype,
@@ -743,7 +743,7 @@ def get_usm_ndarray_or_scalar(a):
 
     """
 
-    return a if isscalar(a) else get_usm_ndarray(a)
+    return a if dpnp.isscalar(a) else get_usm_ndarray(a)
 
 
 def is_supported_array_or_scalar(a):
@@ -765,7 +765,7 @@ def is_supported_array_or_scalar(a):
 
     """
 
-    return isscalar(a) or is_supported_array_type(a)
+    return dpnp.isscalar(a) or is_supported_array_type(a)
 
 
 def is_supported_array_type(a):

dpnp/dpnp_iface_logic.py

@@ -63,11 +63,16 @@
     "greater",
     "greater_equal",
     "isclose",
+    "iscomplex",
+    "iscomplexobj",
     "isfinite",
     "isinf",
     "isnan",
     "isneginf",
     "isposinf",
+    "isreal",
+    "isrealobj",
+    "isscalar",
     "less",
     "less_equal",
     "logical_and",
@@ -233,7 +238,7 @@ def allclose(a, b, rtol=1.0e-5, atol=1.0e-8, **kwargs):
 
     """
 
-    if dpnp.isscalar(a) and dpnp.isscalar(b):
+    if isscalar(a) and isscalar(b):
         # at least one of inputs has to be an array
         pass
     elif not (
@@ -244,18 +249,18 @@ def allclose(a, b, rtol=1.0e-5, atol=1.0e-8, **kwargs):
     elif kwargs:
         pass
     else:
-        if not dpnp.isscalar(rtol):
+        if not isscalar(rtol):
             raise TypeError(
                 f"An argument `rtol` must be a scalar, but got {rtol}"
             )
-        if not dpnp.isscalar(atol):
+        if not isscalar(atol):
             raise TypeError(
                 f"An argument `atol` must be a scalar, but got {atol}"
             )
 
-        if dpnp.isscalar(a):
+        if isscalar(a):
             a = dpnp.full_like(b, fill_value=a)
-        elif dpnp.isscalar(b):
+        elif isscalar(b):
             b = dpnp.full_like(a, fill_value=b)
         elif a.shape != b.shape:
             a, b = dpt.broadcast_arrays(a.get_array(), b.get_array())
@@ -610,6 +615,90 @@ def isclose(x1, x2, rtol=1e-05, atol=1e-08, equal_nan=False):
     )
 
 
+def iscomplex(x):
+    """
+    Returns a bool array, where ``True`` if input element is complex.
+
+    What is tested is whether the input has a non-zero imaginary part, not if
+    the input type is complex.
+
+    For full documentation refer to :obj:`numpy.iscomplex`.
+
+    Parameters
+    ----------
+    x : {dpnp.ndarray, usm_ndarray}
+        Input array.
+
+    Returns
+    -------
+    out : dpnp.ndarray
+        Output array.
+
+    See Also
+    --------
+    :obj:`dpnp.isreal` : Returns a bool array, where ``True`` if input element
+                         is real.
+    :obj:`dpnp.iscomplexobj` : Return ``True`` if `x` is a complex type or an
+                               array of complex numbers.
+
+    Examples
+    --------
+    >>> import dpnp as np
+    >>> a = np.array([1+1j, 1+0j, 4.5, 3, 2, 2j])
+    >>> np.iscomplex(a)
+    array([ True, False, False, False, False,  True])
+
+    """
+    dpnp.check_supported_arrays_type(x)
+    if dpnp.issubdtype(x.dtype, dpnp.complexfloating):
+        return x.imag != 0
+    return dpnp.zeros_like(x, dtype=dpnp.bool)
+
+
+def iscomplexobj(x):
+    """
+    Check for a complex type or an array of complex numbers.
+
+    The type of the input is checked, not the value. Even if the input has an
+    imaginary part equal to zero, :obj:`dpnp.iscomplexobj` evaluates to
+    ``True``.
+
+    For full documentation refer to :obj:`numpy.iscomplexobj`.
+
+    Parameters
+    ----------
+    x : array_like
+        Input data, in any form that can be converted to an array. This
+        includes scalars, lists, lists of tuples, tuples, tuples of tuples,
+        tuples of lists, and ndarrays.
+
+    Returns
+    -------
+    out : bool
+        The return value, ``True`` if `x` is of a complex type or has at least
+        one complex element.
+
+    See Also
+    --------
+    :obj:`dpnp.isrealobj` : Return ``True`` if `x` is a not complex type or an
+                            array of complex numbers.
+    :obj:`dpnp.iscomplex` : Returns a bool array, where ``True`` if input
+                            element is complex.
+
+    Examples
+    --------
+    >>> import dpnp as np
+    >>> np.iscomplexobj(1)
+    False
+    >>> np.iscomplexobj(1+0j)
+    True
+    >>> np.iscomplexobj([3, 1+0j, True])
+    True
+
+    """
+    return numpy.iscomplexobj(x)
+
+
 _ISFINITE_DOCSTRING = """
 Test if each element of input array is a finite number.
 
@@ -923,6 +1012,123 @@ def isposinf(x, out=None):
     return dpnp.logical_and(is_inf, signbit, out=out)
 
 
+def isreal(x):
+    """
+    Returns a bool array, where ``True`` if input element is real.
+
+    If element has complex type with zero imaginary part, the return value
+    for that element is ``True``.
+
+    For full documentation refer to :obj:`numpy.isreal`.
+
+    Parameters
+    ----------
+    x : {dpnp.ndarray, usm_ndarray}
+        Input array.
+
+    Returns
+    -------
+    out : : dpnp.ndarray
+        Boolean array of same shape as `x`.
+
+    See Also
+    --------
+    :obj:`dpnp.iscomplex` : Returns a bool array, where ``True`` if input
+                            element is complex.
+    :obj:`dpnp.isrealobj` : Return ``True`` if `x` is not a complex type.
+
+    Examples
+    --------
+    >>> import dpnp as np
+    >>> a = np.array([1+1j, 1+0j, 4.5, 3, 2, 2j])
+    >>> np.isreal(a)
+    array([False,  True,  True,  True,  True, False])
+
+    """
+    dpnp.check_supported_arrays_type(x)
+    if dpnp.issubdtype(x.dtype, dpnp.complexfloating):
+        return x.imag == 0
+    return dpnp.ones_like(x, dtype=dpnp.bool)
+
+
+def isrealobj(x):
+    """
+    Return ``True`` if `x` is a not complex type or an array of complex numbers.
+
+    The type of the input is checked, not the value. So even if the input has
+    an imaginary part equal to zero, :obj:`dpnp.isrealobj` evaluates to
+    ``False`` if the data type is complex.
+
+    For full documentation refer to :obj:`numpy.isrealobj`.
+
+    Parameters
+    ----------
+    x : array_like
+        Input data, in any form that can be converted to an array. This
+        includes scalars, lists, lists of tuples, tuples, tuples of tuples,
+        tuples of lists, and ndarrays.
+
+    Returns
+    -------
+    out : bool
+        The return value, ``False`` if `x` is of a complex type.
+
+    See Also
+    --------
+    :obj:`dpnp.iscomplexobj` : Check for a complex type or an array of complex
+                               numbers.
+    :obj:`dpnp.isreal` : Returns a bool array, where ``True`` if input element
+                         is real.
+
+    Examples
+    --------
+    >>> import dpnp as np
+    >>> np.isrealobj(False)
+    True
+    >>> np.isrealobj(1)
+    True
+    >>> np.isrealobj(1+0j)
+    False
+    >>> np.isrealobj([3, 1+0j, True])
+    False
+
+    """
+    return not iscomplexobj(x)
+
+
+def isscalar(element):
+    """
+    Returns ``True`` if the type of `element` is a scalar type.
+
+    For full documentation refer to :obj:`numpy.isscalar`.
+
+    Parameters
+    ----------
+    element : any
+        Input argument, can be of any type and shape.
+
+    Returns
+    -------
+    out : bool
+        ``True`` if `element` is a scalar type, ``False`` if it is not.
+
+    Examples
+    --------
+    >>> import dpnp as np
+    >>> np.isscalar(3.1)
+    True
+    >>> np.isscalar(np.array(3.1))
+    False
+    >>> np.isscalar([3.1])
+    False
+    >>> np.isscalar(False)
+    True
+    >>> np.isscalar("dpnp")
+    True
+    """
+    return numpy.isscalar(element)
+
+
 _LESS_DOCSTRING = """
 Computes the less-than test results for each element `x1_i` of
 the input array `x1` with the respective element `x2_i` of the input array `x2`.

dpnp/dpnp_iface_types.py

@@ -71,7 +71,6 @@
     "integer",
     "intc",
     "intp",
-    "isscalar",
     "issubdtype",
     "issubsctype",
     "is_type_supported",
@@ -229,16 +228,6 @@ def iinfo(dtype):
     return dpt.iinfo(dtype)
 
 
-def isscalar(obj):
-    """
-    Returns ``True`` if the type of `obj` is a scalar type.
-
-    For full documentation refer to :obj:`numpy.isscalar`.
-
-    """
-    return numpy.isscalar(obj)
-
-
 def issubdtype(arg1, arg2):
     """
     Returns ``True`` if the first argument is a type code lower/equal

tests/test_sycl_queue.py

@@ -427,6 +427,8 @@ def test_meshgrid(device):
         pytest.param(
             "imag", [complex(1.0, 2.0), complex(3.0, 4.0), complex(5.0, 6.0)]
         ),
+        pytest.param("iscomplex", [1 + 1j, 1 + 0j, 4.5, 3, 2, 2j]),
+        pytest.param("isreal", [1 + 1j, 1 + 0j, 4.5, 3, 2, 2j]),
         pytest.param("log", [1.0, 2.0, 4.0, 7.0]),
         pytest.param("log10", [1.0, 2.0, 4.0, 7.0]),
         pytest.param("log1p", [1.0e-10, 1.0, 2.0, 4.0, 7.0]),

tests/test_usm_type.py

@@ -559,6 +559,8 @@ def test_norm(usm_type, ord, axis):
         pytest.param(
             "imag", [complex(1.0, 2.0), complex(3.0, 4.0), complex(5.0, 6.0)]
         ),
+        pytest.param("iscomplex", [1 + 1j, 1 + 0j, 4.5, 3, 2, 2j]),
+        pytest.param("isreal", [1 + 1j, 1 + 0j, 4.5, 3, 2, 2j]),
         pytest.param("log", [1.0, 2.0, 4.0, 7.0]),
         pytest.param("log10", [1.0, 2.0, 4.0, 7.0]),
         pytest.param("log1p", [1.0e-10, 1.0, 2.0, 4.0, 7.0]),