bool dtype support, all and any functions (#77)

* bool dtype support
* all, any funcs

Author: Alexander-Makaryev

dpnp/backend.pxd

@@ -26,7 +26,7 @@
 # *****************************************************************************
 
 from libcpp.vector cimport vector
-from libcpp cimport bool
+from libcpp cimport bool as cpp_bool
 from dpnp.dparray cimport dparray, dparray_shape_type
 
 cdef extern from "backend/backend_iface_fptr.hpp" namespace "DPNPFuncName":  # need this namespace for Enum import
@@ -156,7 +156,7 @@ Logic functions
 cpdef dparray dpnp_equal(dparray array1, input2)
 cpdef dparray dpnp_greater(dparray input1, dparray input2)
 cpdef dparray dpnp_greater_equal(dparray input1, dparray input2)
-cpdef dparray dpnp_isclose(dparray input1, input2, double rtol=*, double atol=*, bool equal_nan=*)
+cpdef dparray dpnp_isclose(dparray input1, input2, double rtol=*, double atol=*, cpp_bool equal_nan=*)
 cpdef dparray dpnp_less(dparray input1, dparray input2)
 cpdef dparray dpnp_less_equal(dparray input1, dparray input2)
 cpdef dparray dpnp_logical_and(dparray input1, dparray input2)

dpnp/backend_logic.pyx

@@ -37,6 +37,8 @@ from dpnp.dpnp_utils cimport *
 
 
 __all__ += [
+    "dpnp_all",
+    "dpnp_any",
     "dpnp_equal",
     "dpnp_greater",
     "dpnp_greater_equal",
@@ -54,6 +56,34 @@ __all__ += [
 ]
 
 
+cpdef dparray dpnp_all(dparray array1):
+    cdef dparray result = dparray((1,), dtype=numpy.bool)
+
+    res = True
+    for i in range(array1.size):
+        if not numpy.bool(array1[i]):
+            res = False
+            break
+
+    result[0] = res
+
+    return result
+
+
+cpdef dparray dpnp_any(dparray array1):
+    cdef dparray result = dparray((1,), dtype=numpy.bool)
+
+    res = False
+    for i in range(array1.size):
+        if numpy.bool(array1[i]):
+            res = True
+            break
+
+    result[0] = res
+
+    return result
+
+
 cpdef dparray dpnp_equal(dparray array1, input2):
     cdef dparray result = dparray(array1.shape, dtype=numpy.bool)
 
@@ -85,7 +115,7 @@ cpdef dparray dpnp_greater_equal(dparray input1, dparray input2):
     return result
 
 
-cpdef dparray dpnp_isclose(dparray input1, input2, double rtol=1e-05, double atol=1e-08, bool equal_nan=False):
+cpdef dparray dpnp_isclose(dparray input1, input2, double rtol=1e-05, double atol=1e-08, cpp_bool equal_nan=False):
     cdef dparray result = dparray(input1.shape, dtype=numpy.bool)
 
     if isinstance(input2, int):

dpnp/dparray.pyx

@@ -34,12 +34,13 @@ using USB interface for an Intel GPU device.
 """
 
 
-from libcpp cimport bool
+from libcpp cimport bool as cpp_bool
 
 from dpnp.dpnp_iface_types import *
 from dpnp.dpnp_iface import *
 from dpnp.backend cimport *
 from dpnp.dpnp_iface_statistics import min, max
+from dpnp.dpnp_iface_logic import all, any
 import numpy
 cimport numpy
 
@@ -346,7 +347,7 @@ cdef class dparray:
         elif self.dtype == numpy.int32:
             return (< int * > self._dparray_data)[lin_idx]
         elif self.dtype == numpy.bool:
-            return (< bool * > self._dparray_data)[lin_idx]
+            return (< cpp_bool * > self._dparray_data)[lin_idx]
 
         utils.checker_throw_type_error("__getitem__", self.dtype)
 
@@ -371,7 +372,7 @@ cdef class dparray:
         elif self.dtype == numpy.int32:
             (< int * > self._dparray_data)[lin_idx] = <int > value
         elif self.dtype == numpy.bool:
-            (< bool * > self._dparray_data)[lin_idx] = <bool > value
+            (< cpp_bool * > self._dparray_data)[lin_idx] = < cpp_bool > value
         else:
             utils.checker_throw_type_error("__setitem__", self.dtype)
 
@@ -1029,6 +1030,40 @@ cdef class dparray:
 
         return argmin(self, axis, out)
 
+    """
+    -------------------------------------------------------------------------
+    Logic
+    -------------------------------------------------------------------------
+    """
+
+    def all(self, axis=None, out=None, keepdims=False):
+        """
+        Returns True if all elements evaluate to True.
+
+        Refer to `numpy.all` for full documentation.
+
+        See Also
+        --------
+        numpy.all : equivalent function
+
+        """
+
+        return all(self, axis, out, keepdims)
+
+    def any(self, axis=None, out=None, keepdims=False):
+        """
+        Returns True if any of the elements of `a` evaluate to True.
+
+        Refer to `numpy.any` for full documentation.
+
+        See Also
+        --------
+        numpy.any : equivalent function
+
+        """
+
+        return any(self, axis, out, keepdims)
+
     """
     -------------------------------------------------------------------------
     Other attributes

dpnp/dpnp_iface_logic.py

@@ -41,13 +41,16 @@
 
 
 import numpy
+import dpnp
 
 from dpnp.backend import *
 from dpnp.dparray import dparray
 from dpnp.dpnp_utils import *
 
 
 __all__ = [
+    "all",
+    "any",
     "equal",
     "greater",
     "greater_equal",
@@ -65,6 +68,160 @@
 ]
 
 
+def all(in_array1, axis=None, out=None, keepdims=False):
+    """
+    Test whether all array elements along a given axis evaluate to True.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array or object that can be converted to an array.
+    axis : None or int or tuple of ints, optional
+        Axis or axes along which a logical AND reduction is performed.
+        The default (``axis=None``) is to perform a logical AND over all
+        the dimensions of the input array. `axis` may be negative, in
+        which case it counts from the last to the first axis.
+
+        .. versionadded:: 1.7.0
+
+        If this is a tuple of ints, a reduction is performed on multiple
+        axes, instead of a single axis or all the axes as before.
+    out : ndarray, optional
+        Alternate output array in which to place the result.
+        It must have the same shape as the expected output and its
+        type is preserved (e.g., if ``dtype(out)`` is float, the result
+        will consist of 0.0's and 1.0's). See `ufuncs-output-type` for more
+        details.
+
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the input array.
+
+        If the default value is passed, then `keepdims` will not be
+        passed through to the `all` method of sub-classes of
+        `ndarray`, however any non-default value will be.  If the
+        sub-class' method does not implement `keepdims` any
+        exceptions will be raised.
+
+    Returns
+    -------
+    all : ndarray, bool
+        A new boolean or array is returned unless `out` is specified,
+        in which case a reference to `out` is returned.
+
+    See Also
+    --------
+    ndarray.all : equivalent method
+
+    any : Test whether any element along a given axis evaluates to True.
+
+    Notes
+    -----
+    Not a Number (NaN), positive infinity and negative infinity
+    evaluate to `True` because these are not equal to zero.
+
+    """
+
+    is_dparray1 = isinstance(in_array1, dparray)
+
+    if (not use_origin_backend(in_array1) and is_dparray1):
+        if axis is not None:
+            checker_throw_value_error("all", "axis", type(axis), None)
+        if out is not None:
+            checker_throw_value_error("all", "out", type(out), None)
+        if keepdims is not False:
+            checker_throw_value_error("all", "keepdims", keepdims, False)
+
+        result = dpnp_all(in_array1)
+
+        # scalar returned
+        if result.shape == (1,):
+            return result.dtype.type(result[0])
+
+        return result
+
+    return call_origin(numpy.all, axis, out, keepdims)
+
+
+def any(in_array1, axis=None, out=None, keepdims=False):
+    """
+    Test whether any array element along a given axis evaluates to True.
+
+    Returns single boolean unless `axis` is not ``None``
+
+    Parameters
+    ----------
+    a : array_like
+        Input array or object that can be converted to an array.
+    axis : None or int or tuple of ints, optional
+        Axis or axes along which a logical OR reduction is performed.
+        The default (``axis=None``) is to perform a logical OR over all
+        the dimensions of the input array. `axis` may be negative, in
+        which case it counts from the last to the first axis.
+
+        .. versionadded:: 1.7.0
+
+        If this is a tuple of ints, a reduction is performed on multiple
+        axes, instead of a single axis or all the axes as before.
+    out : ndarray, optional
+        Alternate output array in which to place the result.  It must have
+        the same shape as the expected output and its type is preserved
+        (e.g., if it is of type float, then it will remain so, returning
+        1.0 for True and 0.0 for False, regardless of the type of `a`).
+        See `ufuncs-output-type` for more details.
+
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the input array.
+
+        If the default value is passed, then `keepdims` will not be
+        passed through to the `any` method of sub-classes of
+        `ndarray`, however any non-default value will be.  If the
+        sub-class' method does not implement `keepdims` any
+        exceptions will be raised.
+
+    Returns
+    -------
+    any : bool or ndarray
+        A new boolean or `ndarray` is returned unless `out` is specified,
+        in which case a reference to `out` is returned.
+
+    See Also
+    --------
+    ndarray.any : equivalent method
+
+    all : Test whether all elements along a given axis evaluate to True.
+
+    Notes
+    -----
+    Not a Number (NaN), positive infinity and negative infinity evaluate
+    to `True` because these are not equal to zero.
+
+    """
+
+    is_dparray1 = isinstance(in_array1, dparray)
+
+    if (not use_origin_backend(in_array1) and is_dparray1):
+        if axis is not None:
+            checker_throw_value_error("any", "axis", type(axis), None)
+        if out is not None:
+            checker_throw_value_error("any", "out", type(out), None)
+        if keepdims is not False:
+            checker_throw_value_error("any", "keepdims", keepdims, False)
+
+        result = dpnp_any(in_array1)
+
+        # scalar returned
+        if result.shape == (1,):
+            return result.dtype.type(result[0])
+
+        return result
+
+    return call_origin(numpy.any, axis, out, keepdims)
+
+
 def equal(x1, x2):
     """
     Return (x1 == x2) element-wise.

dpnp/dpnp_iface_types.py

@@ -37,6 +37,8 @@
 import numpy
 
 __all__ = [
+    "bool",
+    "bool_",
     "dtype",
     "float",
     "float32",
@@ -48,6 +50,9 @@
     "newaxis"
 ]
 
+bool = numpy.bool
+bool_ = numpy.bool_
+
 dtype = numpy.dtype
 
 float = numpy.float

dpnp/dpnp_utils.pyx

@@ -31,6 +31,7 @@ This module contains differnt helpers and utilities
 
 """
 
+from libcpp cimport bool as cpp_bool
 import dpnp
 import dpnp.config as config
 import numpy
@@ -138,6 +139,8 @@ cdef long copy_values_to_dparray(dparray dst, input_obj, size_t dst_idx=0) excep
                 ( < long * > dst.get_data())[dst_idx] = elem_value
             elif elem_dtype == numpy.int32:
                 ( < int * > dst.get_data())[dst_idx] = elem_value
+            elif elem_dtype == numpy.bool_ or elem_dtype == numpy.bool:
+                (< cpp_bool * > dst.get_data())[dst_idx] = elem_value
             else:
                 checker_throw_type_error("copy_values_to_dparray", elem_dtype)