add allclose function (#770)

* add allclose function

Author: KsanaKozlova

dpnp/backend/include/dpnp_iface.hpp

@@ -116,6 +116,20 @@ void dpnp_memory_memcpy_c(void* dst, const void* src, size_t size_in_bytes);
 template <typename _DataType, typename _ResultType>
 INP_DLLEXPORT void dpnp_all_c(const void* array, void* result, const size_t size);
 
+/**
+ * @ingroup BACKEND_API
+ * @brief Test whether all array elements along a given axis evaluate to True.
+ *
+ * @param [in]  array1_in      First input array.
+ * @param [in]  array2_in      Second input array.
+ * @param [out] result1        Output array.
+ * @param [in]  size           Number of input elements in `array`.
+ * @param [in]  rtol_val       The relative tolerance parameter.
+ * @param [in]  atol_val       The absolute tolerance parameter.
+ */
+template <typename _DataType1, typename _DataType2, typename _ResultType>
+INP_DLLEXPORT void dpnp_allclose_c(const void* array1_in, const void* array2_in, void* result1, const size_t size, double rtol, double atol);
+
 /**
  * @ingroup BACKEND_API
  * @brief Test whether any array element along a given axis evaluates to True.

dpnp/backend/include/dpnp_iface_fptr.hpp

@@ -61,6 +61,7 @@ enum class DPNPFuncName : size_t
     DPNP_FN_ABSOLUTE,                 /**< Used in numpy.absolute() implementation  */
     DPNP_FN_ADD,                      /**< Used in numpy.add() implementation  */
     DPNP_FN_ALL,                      /**< Used in numpy.all() implementation  */
+    DPNP_FN_ALLCLOSE,                 /**< Used in numpy.allclose() implementation  */
     DPNP_FN_ANY,                      /**< Used in numpy.any() implementation  */
     DPNP_FN_ARANGE,                   /**< Used in numpy.arange() implementation  */
     DPNP_FN_ARCCOS,                   /**< Used in numpy.arccos() implementation  */

dpnp/backend/kernels/dpnp_krnl_logic.cpp

@@ -71,6 +71,52 @@ void dpnp_all_c(const void* array1_in, void* result1, const size_t size)
     event.wait();
 }
 
+template <typename _DataType1, typename _DataType2, typename _ResultType>
+class dpnp_allclose_c_kernel;
+
+template <typename _DataType1, typename _DataType2, typename _ResultType>
+void dpnp_allclose_c(const void* array1_in, const void* array2_in, void* result1, const size_t size, double rtol_val, double atol_val)
+{
+    if (!array1_in || !result1)
+    {
+        return;
+    }
+
+    const _DataType1* array1 = reinterpret_cast<const _DataType1*>(array1_in);
+    const _DataType2* array2 = reinterpret_cast<const _DataType2*>(array2_in);
+    _ResultType* result = reinterpret_cast<_ResultType*>(result1);
+
+    result[0] = true;
+
+    if (!size)
+    {
+        return;
+    }
+
+    cl::sycl::event event;
+
+    cl::sycl::range<1> gws(size);
+    auto kernel_parallel_for_func = [=](cl::sycl::id<1> global_id) {
+        size_t i = global_id[0];
+
+        if (std::abs(array1[i] - array2[i]) > (atol_val + rtol_val * std::abs(array2[i]))){
+            
+            result[0]= false;
+
+        }
+
+    };
+
+    auto kernel_func = [&](cl::sycl::handler& cgh) {
+        cgh.parallel_for<class dpnp_allclose_c_kernel<_DataType1, _DataType2, _ResultType>>(gws, kernel_parallel_for_func);
+    };
+
+    event = DPNP_QUEUE.submit(kernel_func);
+
+    event.wait();
+
+}
+
 template <typename _DataType, typename _ResultType>
 class dpnp_any_c_kernel;
 
@@ -121,6 +167,23 @@ void func_map_init_logic(func_map_t& fmap)
     fmap[DPNPFuncName::DPNP_FN_ALL][eft_FLT][eft_FLT] = {eft_FLT, (void*)dpnp_all_c<float, bool>};
     fmap[DPNPFuncName::DPNP_FN_ALL][eft_DBL][eft_DBL] = {eft_DBL, (void*)dpnp_all_c<double, bool>};
 
+    fmap[DPNPFuncName::DPNP_FN_ALLCLOSE][eft_INT][eft_INT] = {eft_BLN, (void*)dpnp_allclose_c<int, int, bool>};
+    fmap[DPNPFuncName::DPNP_FN_ALLCLOSE][eft_LNG][eft_INT] = {eft_BLN, (void*)dpnp_allclose_c<long, int, bool>};
+    fmap[DPNPFuncName::DPNP_FN_ALLCLOSE][eft_FLT][eft_INT] = {eft_BLN, (void*)dpnp_allclose_c<float, int, bool>};
+    fmap[DPNPFuncName::DPNP_FN_ALLCLOSE][eft_DBL][eft_INT] = {eft_BLN, (void*)dpnp_allclose_c<double, int, bool>};
+    fmap[DPNPFuncName::DPNP_FN_ALLCLOSE][eft_INT][eft_LNG] = {eft_BLN, (void*)dpnp_allclose_c<int, long, bool>};
+    fmap[DPNPFuncName::DPNP_FN_ALLCLOSE][eft_LNG][eft_LNG] = {eft_BLN, (void*)dpnp_allclose_c<long, long, bool>};
+    fmap[DPNPFuncName::DPNP_FN_ALLCLOSE][eft_FLT][eft_LNG] = {eft_BLN, (void*)dpnp_allclose_c<float, long, bool>};
+    fmap[DPNPFuncName::DPNP_FN_ALLCLOSE][eft_DBL][eft_LNG] = {eft_BLN, (void*)dpnp_allclose_c<double, long, bool>};
+    fmap[DPNPFuncName::DPNP_FN_ALLCLOSE][eft_INT][eft_FLT] = {eft_BLN, (void*)dpnp_allclose_c<int, float, bool>};
+    fmap[DPNPFuncName::DPNP_FN_ALLCLOSE][eft_LNG][eft_FLT] = {eft_BLN, (void*)dpnp_allclose_c<long, float, bool>};
+    fmap[DPNPFuncName::DPNP_FN_ALLCLOSE][eft_FLT][eft_FLT] = {eft_BLN, (void*)dpnp_allclose_c<float, float, bool>};
+    fmap[DPNPFuncName::DPNP_FN_ALLCLOSE][eft_DBL][eft_FLT] = {eft_BLN, (void*)dpnp_allclose_c<double, float, bool>};
+    fmap[DPNPFuncName::DPNP_FN_ALLCLOSE][eft_INT][eft_DBL] = {eft_BLN, (void*)dpnp_allclose_c<int, double, bool>};
+    fmap[DPNPFuncName::DPNP_FN_ALLCLOSE][eft_LNG][eft_DBL] = {eft_BLN, (void*)dpnp_allclose_c<long, double, bool>};
+    fmap[DPNPFuncName::DPNP_FN_ALLCLOSE][eft_FLT][eft_DBL] = {eft_BLN, (void*)dpnp_allclose_c<float, double, bool>};
+    fmap[DPNPFuncName::DPNP_FN_ALLCLOSE][eft_DBL][eft_DBL] = {eft_BLN, (void*)dpnp_allclose_c<double, double, bool>};
+
     fmap[DPNPFuncName::DPNP_FN_ANY][eft_BLN][eft_BLN] = {eft_BLN, (void*)dpnp_any_c<bool, bool>};
     fmap[DPNPFuncName::DPNP_FN_ANY][eft_INT][eft_INT] = {eft_INT, (void*)dpnp_any_c<int, bool>};
     fmap[DPNPFuncName::DPNP_FN_ANY][eft_LNG][eft_LNG] = {eft_LNG, (void*)dpnp_any_c<long, bool>};

dpnp/dpnp_algo/dpnp_algo.pxd

@@ -36,6 +36,7 @@ cdef extern from "dpnp_iface_fptr.hpp" namespace "DPNPFuncName":  # need this na
         DPNP_FN_ABSOLUTE
         DPNP_FN_ADD
         DPNP_FN_ALL
+        DPNP_FN_ALLCLOSE
         DPNP_FN_ANY
         DPNP_FN_ARANGE
         DPNP_FN_ARCCOS

dpnp/dpnp_algo/dpnp_algo_logic.pyx

@@ -36,6 +36,7 @@ and the rest of the library
 
 __all__ += [
     "dpnp_all",
+    "dpnp_allclose",
     "dpnp_any",
     "dpnp_equal",
     "dpnp_greater",
@@ -55,6 +56,7 @@ __all__ += [
 
 
 ctypedef void(*custom_logic_1in_1out_func_ptr_t)(void * , void * , const size_t)
+ctypedef void(*custom_allclose_1in_1out_func_ptr_t)(void * , void * , void *, const size_t, double, double)
 
 
 cpdef dparray dpnp_all(dpnp_descriptor array1):
@@ -71,6 +73,21 @@ cpdef dparray dpnp_all(dpnp_descriptor array1):
     return result
 
 
+cpdef dparray dpnp_allclose(dpnp_descriptor array1, dpnp_descriptor array2, double rtol_val, double atol_val):
+    cdef dparray result = dparray((1,), dtype=numpy.bool)
+
+    cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(array1.dtype)
+    cdef DPNPFuncType param2_type = dpnp_dtype_to_DPNPFuncType(array2.dtype)
+
+    cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_ALLCLOSE, param1_type, param2_type)
+
+    cdef custom_allclose_1in_1out_func_ptr_t func = <custom_allclose_1in_1out_func_ptr_t > kernel_data.ptr
+
+    func(array1.get_data(), array2.get_data(), result.get_data(), array1.size, rtol_val, atol_val)
+
+    return result
+
+
 cpdef dparray dpnp_any(dpnp_descriptor array1):
     cdef dparray result = dparray((1,), dtype=numpy.bool)
 

dpnp/dpnp_iface_logic.py

@@ -50,6 +50,7 @@
 
 __all__ = [
     "all",
+    "allclose",
     "any",
     "equal",
     "greater",
@@ -122,6 +123,42 @@ def all(x1, axis=None, out=None, keepdims=False):
     return call_origin(numpy.all, x1, axis, out, keepdims)
 
 
+def allclose(x1, x2, rtol=1.e-5, atol=1.e-8, **kwargs):
+    """
+    Returns True if two arrays are element-wise equal within a tolerance.
+
+    For full documentation refer to :obj:`numpy.allclose`.
+
+    Limitations
+    -----------
+    Parameters ``x1`` and ``x2`` are supported as either :obj:`dpnp.ndarray` or scalar.
+    Keyword arguments ``kwargs`` are currently unsupported.
+    Otherwise the functions will be executed sequentially on CPU.
+    Input array data types are limited by supported DPNP :ref:`Data types`.
+
+    Examples
+    --------
+    >>> import dpnp as np
+    >>> np.allclose([1e10,1e-7], [1.00001e10,1e-8])
+    >>> False
+
+    """
+
+    rtol_is_scalar = dpnp.isscalar(rtol)
+    atol_is_scalar = dpnp.isscalar(atol)
+    x1_desc = dpnp.get_dpnp_descriptor(x1)
+    x2_desc = dpnp.get_dpnp_descriptor(x2)
+
+    if x1_desc and x2_desc and not kwargs:
+        if not rtol_is_scalar or not atol_is_scalar:
+            pass
+        else:
+            result = dpnp_allclose(x1_desc, x2_desc, rtol, atol)
+            return result[0]
+
+    return call_origin(numpy.allclose, x1, x2, rtol=rtol, atol=atol, **kwargs)
+
+
 def any(x1, axis=None, out=None, keepdims=False):
     """
     Test whether any array element along a given axis evaluates to True.

tests/test_logic.py

@@ -37,6 +37,28 @@ def test_all(type, shape):
         dpnp_res = ia.all()
         numpy.testing.assert_allclose(dpnp_res, np_res)
 
+@pytest.mark.parametrize("type",
+                         [numpy.float64, numpy.float32, numpy.int64, numpy.int32],
+                         ids=['float64', 'float32', 'int64', 'int32'])
+def test_allclose(type):
+
+    a = numpy.random.rand(10)
+    b = a + numpy.random.rand(10) * 1e-8
+
+    dpnp_a = dpnp.array(a, dtype=type)
+    dpnp_b = dpnp.array(b, dtype=type)
+
+    np_res = numpy.allclose(a, b)
+    dpnp_res = dpnp.allclose(dpnp_a, dpnp_b)
+    numpy.testing.assert_allclose(dpnp_res, np_res)
+
+    a[0] = numpy.inf
+
+    dpnp_a = dpnp.array(a)
+
+    np_res = numpy.allclose(a, b)
+    dpnp_res = dpnp.allclose(dpnp_a, dpnp_b)
+    numpy.testing.assert_allclose(dpnp_res, np_res)
 
 @pytest.mark.parametrize("type",
                          [numpy.float64, numpy.float32, numpy.int64, numpy.int32, numpy.bool, numpy.bool_],