Merge pull request numpy#5590 from chebee7i/allclose_isclose

Make allclose use isclose.

Author: charris

doc/release/1.10.0-notes.rst

@@ -144,6 +144,18 @@ returned values, especially for corner cases.
 The strings produced by ``float.hex`` look like ``0x1.921fb54442d18p+1``,
 so this is not the hex used to represent unsigned integer types.
 
+*np.isclose* properly handles minimal values of integer dtypes
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+In order to properly handle minimal values of integer types, *np.isclose* will
+now cast to the float dtype during comparisons. This aligns its behavior with
+what was provided by *np.allclose*.
+
+*np.allclose* uses *np.isclose* internally.
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+*np.allcose* now uses *np.isclose* internally and inherits the ability to
+compare NaNs as equal by setting ``equal_nan=True``. Subclasses, such as
+*np.ma.MaskedArray*, are also preserved now.
+
 
 Changes
 =======

numpy/core/numeric.py

@@ -1024,9 +1024,8 @@ def outer(a, b, out=None):
         Second input vector.  Input is flattened if
         not already 1-dimensional.
     out : (M, N) ndarray, optional
-          A location where the result is stored
-
         .. versionadded:: 1.9.0
+        A location where the result is stored
 
     Returns
     -------
@@ -2206,42 +2205,7 @@ def identity(n, dtype=None):
     from numpy import eye
     return eye(n, dtype=dtype)
 
-def _allclose_points(a, b, rtol=1.e-5, atol=1.e-8):
-    """
-    This is the point-wise inner calculation of 'allclose', which is subtly
-    different from 'isclose'.  Provided as a comparison routine for use in
-    testing.assert_allclose.
-    See those routines for further details.
-
-    """
-    x = array(a, copy=False, ndmin=1)
-    y = array(b, copy=False, ndmin=1)
-
-    # make sure y is an inexact type to avoid abs(MIN_INT); will cause
-    # casting of x later.
-    dtype = multiarray.result_type(y, 1.)
-    y = array(y, dtype=dtype, copy=False)
-
-    xinf = isinf(x)
-    yinf = isinf(y)
-    if any(xinf) or any(yinf):
-        # Check that x and y have inf's only in the same positions
-        if not all(xinf == yinf):
-            return False
-        # Check that sign of inf's in x and y is the same
-        if not all(x[xinf] == y[xinf]):
-            return False
-
-        x = x[~xinf]
-        y = y[~xinf]
-
-    # ignore invalid fpe's
-    with errstate(invalid='ignore'):
-        r = less_equal(abs(x - y), atol + rtol * abs(y))
-
-    return r
-
-def allclose(a, b, rtol=1.e-5, atol=1.e-8):
+def allclose(a, b, rtol=1.e-5, atol=1.e-8, equal_nan=False):
     """
     Returns True if two arrays are element-wise equal within a tolerance.
 
@@ -2262,6 +2226,10 @@ def allclose(a, b, rtol=1.e-5, atol=1.e-8):
         The relative tolerance parameter (see Notes).
     atol : float
         The absolute tolerance parameter (see Notes).
+    equal_nan : bool
+        .. versionadded:: 1.10.0
+        Whether to compare NaN's as equal.  If True, NaN's in `a` will be
+        considered equal to NaN's in `b` in the output array.
 
     Returns
     -------
@@ -2294,9 +2262,11 @@ def allclose(a, b, rtol=1.e-5, atol=1.e-8):
     False
     >>> np.allclose([1.0, np.nan], [1.0, np.nan])
     False
+    >>> np.allclose([1.0, np.nan], [1.0, np.nan], equal_nan=True)
+    True
 
     """
-    return all(_allclose_points(a, b, rtol=rtol, atol=atol))
+    return all(isclose(a, b, rtol=rtol, atol=atol, equal_nan=equal_nan))
 
 def isclose(a, b, rtol=1.e-5, atol=1.e-8, equal_nan=False):
     """
@@ -2366,6 +2336,13 @@ def within_tol(x, y, atol, rtol):
 
     x = array(a, copy=False, subok=True, ndmin=1)
     y = array(b, copy=False, subok=True, ndmin=1)
+
+    # Make sure y is an inexact type to avoid bad behavior on abs(MIN_INT).
+    # This will cause casting of x later. Also, make sure to allow subclasses
+    # (e.g., for numpy.ma).
+    dt = multiarray.result_type(y, 1.)
+    y = array(y, dtype=dt, copy=False, subok=True)
+
     xfin = isfinite(x)
     yfin = isfinite(y)
     if all(xfin) and all(yfin):

numpy/core/tests/test_numeric.py

@@ -1574,6 +1574,11 @@ def test_min_int(self):
         assert_(allclose(a, a))
 
 
+    def test_equalnan(self):
+        x = np.array([1.0, np.nan])
+        assert_(allclose(x, x, equal_nan=True))
+
+
 class TestIsclose(object):
     rtol = 1e-5
     atol = 1e-8
@@ -1664,17 +1669,25 @@ def test_equal_nan(self):
         assert_array_equal(isclose(arr, arr, equal_nan=True), [True, True])
 
     def test_masked_arrays(self):
+        # Make sure to test the output type when arguments are interchanged.
+
         x = np.ma.masked_where([True, True, False], np.arange(3))
         assert_(type(x) is type(isclose(2, x)))
+        assert_(type(x) is type(isclose(x, 2)))
 
         x = np.ma.masked_where([True, True, False], [nan, inf, nan])
         assert_(type(x) is type(isclose(inf, x)))
+        assert_(type(x) is type(isclose(x, inf)))
 
         x = np.ma.masked_where([True, True, False], [nan, nan, nan])
         y = isclose(nan, x, equal_nan=True)
         assert_(type(x) is type(y))
         # Ensure that the mask isn't modified...
         assert_array_equal([True, True, False], y.mask)
+        y = isclose(x, nan, equal_nan=True)
+        assert_(type(x) is type(y))
+        # Ensure that the mask isn't modified...
+        assert_array_equal([True, True, False], y.mask)
 
         x = np.ma.masked_where([True, True, False], [nan, nan, nan])
         y = isclose(x, x, equal_nan=True)

numpy/testing/utils.py

@@ -1244,7 +1244,7 @@ def _assert_valid_refcount(op):
 
     assert_(sys.getrefcount(i) >= rc)
 
-def assert_allclose(actual, desired, rtol=1e-7, atol=0,
+def assert_allclose(actual, desired, rtol=1e-7, atol=0, equal_nan=False,
                     err_msg='', verbose=True):
     """
     Raises an AssertionError if two objects are not equal up to desired
@@ -1266,6 +1266,8 @@ def assert_allclose(actual, desired, rtol=1e-7, atol=0,
         Relative tolerance.
     atol : float, optional
         Absolute tolerance.
+    equal_nan : bool, optional.
+        If True, NaNs will compare equal.
     err_msg : str, optional
         The error message to be printed in case of failure.
     verbose : bool, optional
@@ -1289,7 +1291,8 @@ def assert_allclose(actual, desired, rtol=1e-7, atol=0,
     """
     import numpy as np
     def compare(x, y):
-        return np.core.numeric._allclose_points(x, y, rtol=rtol, atol=atol)
+        return np.core.numeric.isclose(x, y, rtol=rtol, atol=atol,
+                                       equal_nan=equal_nan)
 
     actual, desired = np.asanyarray(actual), np.asanyarray(desired)
     header = 'Not equal to tolerance rtol=%g, atol=%g' % (rtol, atol)