Merge pull request #6368 from bwignall/assert_6175_arrayequal_1

CLN: Specialize assert_(np.array_equal(...))

Author: jreback

doc/source/release.rst

@@ -82,6 +82,7 @@ Improvements to existing features
 - improve performance of slice indexing on Series with string keys (:issue:`6341`)
 - implement joining a single-level indexed DataFrame on a matching column of a multi-indexed DataFrame (:issue:`3662`)
 - Performance improvement in indexing into a multi-indexed Series (:issue:`5567`)
+- Testing statements updated to use specialized asserts (:issue: `6175`)
 
 .. _release.bug_fixes-0.14.0:
 

pandas/tests/test_algos.py

@@ -17,7 +17,7 @@ def test_ints(self):
 
         result = algos.match(to_match, values)
         expected = np.array([0, 2, 1, 1, 0, 2, -1, 0])
-        self.assert_numpy_array_equals(result, expected)
+        self.assert_numpy_array_equal(result, expected)
 
         result = Series(algos.match(to_match, values, np.nan))
         expected = Series(np.array([0, 2, 1, 1, 0, 2, np.nan, 0]))
@@ -26,7 +26,7 @@ def test_ints(self):
         s = pd.Series(np.arange(5),dtype=np.float32)
         result = algos.match(s, [2,4])
         expected = np.array([-1, -1, 0, -1, 1])
-        self.assert_numpy_array_equals(result, expected)
+        self.assert_numpy_array_equal(result, expected)
 
         result = Series(algos.match(s, [2,4], np.nan))
         expected = Series(np.array([np.nan, np.nan, 0, np.nan, 1]))
@@ -38,7 +38,7 @@ def test_strings(self):
 
         result = algos.match(to_match, values)
         expected = np.array([1, 0, -1, 0, 1, 2, -1])
-        self.assert_numpy_array_equals(result, expected)
+        self.assert_numpy_array_equal(result, expected)
 
         result = Series(algos.match(to_match, values, np.nan))
         expected = Series(np.array([1, 0, np.nan, 0, 1, 2, np.nan]))
@@ -51,42 +51,42 @@ def test_basic(self):
 
         labels, uniques = algos.factorize(['a', 'b', 'b', 'a',
                                            'a', 'c', 'c', 'c'])
-        # self.assert_numpy_array_equals(labels, np.array([ 0, 1, 1, 0, 0, 2, 2, 2],dtype=np.int64))
-        self.assert_numpy_array_equals(uniques, np.array(['a','b','c'], dtype=object))
+        # self.assert_numpy_array_equal(labels, np.array([ 0, 1, 1, 0, 0, 2, 2, 2],dtype=np.int64))
+        self.assert_numpy_array_equal(uniques, np.array(['a','b','c'], dtype=object))
 
         labels, uniques = algos.factorize(['a', 'b', 'b', 'a',
                                            'a', 'c', 'c', 'c'], sort=True)
-        self.assert_numpy_array_equals(labels, np.array([ 0, 1, 1, 0, 0, 2, 2, 2],dtype=np.int64))
-        self.assert_numpy_array_equals(uniques, np.array(['a','b','c'], dtype=object))
+        self.assert_numpy_array_equal(labels, np.array([ 0, 1, 1, 0, 0, 2, 2, 2],dtype=np.int64))
+        self.assert_numpy_array_equal(uniques, np.array(['a','b','c'], dtype=object))
 
         labels, uniques = algos.factorize(list(reversed(range(5))))
-        self.assert_numpy_array_equals(labels, np.array([0, 1, 2, 3, 4], dtype=np.int64))
-        self.assert_numpy_array_equals(uniques, np.array([ 4, 3, 2, 1, 0],dtype=np.int64))
+        self.assert_numpy_array_equal(labels, np.array([0, 1, 2, 3, 4], dtype=np.int64))
+        self.assert_numpy_array_equal(uniques, np.array([ 4, 3, 2, 1, 0],dtype=np.int64))
 
         labels, uniques = algos.factorize(list(reversed(range(5))), sort=True)
-        self.assert_numpy_array_equals(labels, np.array([ 4, 3, 2, 1, 0],dtype=np.int64))
-        self.assert_numpy_array_equals(uniques, np.array([0, 1, 2, 3, 4], dtype=np.int64))
+        self.assert_numpy_array_equal(labels, np.array([ 4, 3, 2, 1, 0],dtype=np.int64))
+        self.assert_numpy_array_equal(uniques, np.array([0, 1, 2, 3, 4], dtype=np.int64))
 
         labels, uniques = algos.factorize(list(reversed(np.arange(5.))))
-        self.assert_numpy_array_equals(labels, np.array([0., 1., 2., 3., 4.], dtype=np.float64))
-        self.assert_numpy_array_equals(uniques, np.array([ 4, 3, 2, 1, 0],dtype=np.int64))
+        self.assert_numpy_array_equal(labels, np.array([0., 1., 2., 3., 4.], dtype=np.float64))
+        self.assert_numpy_array_equal(uniques, np.array([ 4, 3, 2, 1, 0],dtype=np.int64))
 
         labels, uniques = algos.factorize(list(reversed(np.arange(5.))), sort=True)
-        self.assert_numpy_array_equals(labels, np.array([ 4, 3, 2, 1, 0],dtype=np.int64))
-        self.assert_numpy_array_equals(uniques, np.array([0., 1., 2., 3., 4.], dtype=np.float64))
+        self.assert_numpy_array_equal(labels, np.array([ 4, 3, 2, 1, 0],dtype=np.int64))
+        self.assert_numpy_array_equal(uniques, np.array([0., 1., 2., 3., 4.], dtype=np.float64))
 
     def test_mixed(self):
 
         # doc example reshaping.rst
         x = Series(['A', 'A', np.nan, 'B', 3.14, np.inf])
         labels, uniques = algos.factorize(x)
 
-        self.assert_numpy_array_equals(labels, np.array([ 0,  0, -1,  1,  2,  3],dtype=np.int64))
-        self.assert_numpy_array_equals(uniques, np.array(['A', 'B', 3.14, np.inf], dtype=object))
+        self.assert_numpy_array_equal(labels, np.array([ 0,  0, -1,  1,  2,  3],dtype=np.int64))
+        self.assert_numpy_array_equal(uniques, np.array(['A', 'B', 3.14, np.inf], dtype=object))
 
         labels, uniques = algos.factorize(x, sort=True)
-        self.assert_numpy_array_equals(labels, np.array([ 2,  2, -1,  3,  0,  1],dtype=np.int64))
-        self.assert_numpy_array_equals(uniques, np.array([3.14, np.inf, 'A', 'B'], dtype=object))
+        self.assert_numpy_array_equal(labels, np.array([ 2,  2, -1,  3,  0,  1],dtype=np.int64))
+        self.assert_numpy_array_equal(uniques, np.array([3.14, np.inf, 'A', 'B'], dtype=object))
 
     def test_datelike(self):
 
@@ -95,12 +95,12 @@ def test_datelike(self):
         v2 = pd.Timestamp('20130101')
         x = Series([v1,v1,v1,v2,v2,v1])
         labels, uniques = algos.factorize(x)
-        self.assert_numpy_array_equals(labels, np.array([ 0,0,0,1,1,0],dtype=np.int64))
-        self.assert_numpy_array_equals(uniques, np.array([v1.value,v2.value],dtype='M8[ns]'))
+        self.assert_numpy_array_equal(labels, np.array([ 0,0,0,1,1,0],dtype=np.int64))
+        self.assert_numpy_array_equal(uniques, np.array([v1.value,v2.value],dtype='M8[ns]'))
 
         labels, uniques = algos.factorize(x, sort=True)
-        self.assert_numpy_array_equals(labels, np.array([ 1,1,1,0,0,1],dtype=np.int64))
-        self.assert_numpy_array_equals(uniques, np.array([v2.value,v1.value],dtype='M8[ns]'))
+        self.assert_numpy_array_equal(labels, np.array([ 1,1,1,0,0,1],dtype=np.int64))
+        self.assert_numpy_array_equal(uniques, np.array([v2.value,v1.value],dtype='M8[ns]'))
 
         # period
         v1 = pd.Period('201302',freq='M')
@@ -109,12 +109,12 @@ def test_datelike(self):
 
         # periods are not 'sorted' as they are converted back into an index
         labels, uniques = algos.factorize(x)
-        self.assert_numpy_array_equals(labels, np.array([ 0,0,0,1,1,0],dtype=np.int64))
-        self.assert_numpy_array_equals(uniques, np.array([v1, v2],dtype=object))
+        self.assert_numpy_array_equal(labels, np.array([ 0,0,0,1,1,0],dtype=np.int64))
+        self.assert_numpy_array_equal(uniques, np.array([v1, v2],dtype=object))
 
         labels, uniques = algos.factorize(x,sort=True)
-        self.assert_numpy_array_equals(labels, np.array([ 0,0,0,1,1,0],dtype=np.int64))
-        self.assert_numpy_array_equals(uniques, np.array([v1, v2],dtype=object))
+        self.assert_numpy_array_equal(labels, np.array([ 0,0,0,1,1,0],dtype=np.int64))
+        self.assert_numpy_array_equal(uniques, np.array([v1, v2],dtype=object))
 
 class TestUnique(tm.TestCase):
     _multiprocess_can_split_ = True

pandas/tests/test_base.py

@@ -102,7 +102,7 @@ def test_shallow_copying(self):
         assert_isinstance(self.container.view(), FrozenNDArray)
         self.assert_(not isinstance(self.container.view(np.ndarray), FrozenNDArray))
         self.assert_(self.container.view() is not self.container)
-        self.assert_(np.array_equal(self.container, original))
+        self.assert_numpy_array_equal(self.container, original)
         # shallow copy should be the same too
         assert_isinstance(self.container._shallow_copy(), FrozenNDArray)
         # setting should not be allowed
@@ -114,10 +114,10 @@ def test_values(self):
         original = self.container.view(np.ndarray).copy()
         n = original[0] + 15
         vals = self.container.values()
-        self.assert_(np.array_equal(original, vals))
+        self.assert_numpy_array_equal(original, vals)
         self.assert_(original is not vals)
         vals[0] = n
-        self.assert_(np.array_equal(self.container, original))
+        self.assert_numpy_array_equal(self.container, original)
         self.assertEqual(vals[0], n)
 
 

pandas/tests/test_categorical.py

@@ -82,11 +82,11 @@ def test_comparisons(self):
         other = self.factor[np.random.permutation(n)]
         result = self.factor == other
         expected = np.asarray(self.factor) == np.asarray(other)
-        self.assert_(np.array_equal(result, expected))
+        self.assert_numpy_array_equal(result, expected)
 
         result = self.factor == 'd'
         expected = np.repeat(False, len(self.factor))
-        self.assert_(np.array_equal(result, expected))
+        self.assert_numpy_array_equal(result, expected)
 
     def test_na_flags_int_levels(self):
         # #1457
@@ -98,7 +98,7 @@ def test_na_flags_int_levels(self):
         cat = Categorical(labels, levels)
         repr(cat)
 
-        self.assert_(np.array_equal(com.isnull(cat), labels == -1))
+        self.assert_numpy_array_equal(com.isnull(cat), labels == -1)
 
     def test_levels_none(self):
         factor = Categorical(['a', 'b', 'b', 'a',