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

pandas/tests/test_common.py

@@ -800,7 +800,7 @@ def test_1d_bool(self):
 
         result = com.take_1d(arr, [0, 2, 2, 1])
         expected = arr.take([0, 2, 2, 1])
-        self.assert_(np.array_equal(result, expected))
+        self.assert_numpy_array_equal(result, expected)
 
         result = com.take_1d(arr, [0, 2, -1])
         self.assertEqual(result.dtype, np.object_)
@@ -812,11 +812,11 @@ def test_2d_bool(self):
 
         result = com.take_nd(arr, [0, 2, 2, 1])
         expected = arr.take([0, 2, 2, 1], axis=0)
-        self.assert_(np.array_equal(result, expected))
+        self.assert_numpy_array_equal(result, expected)
 
         result = com.take_nd(arr, [0, 2, 2, 1], axis=1)
         expected = arr.take([0, 2, 2, 1], axis=1)
-        self.assert_(np.array_equal(result, expected))
+        self.assert_numpy_array_equal(result, expected)
 
         result = com.take_nd(arr, [0, 2, -1])
         self.assertEqual(result.dtype, np.object_)

pandas/tests/test_generic.py

@@ -447,7 +447,7 @@ def test_interpolate(self):
         ts_copy[5:10] = np.NaN
 
         linear_interp = ts_copy.interpolate(method='linear')
-        self.assert_(np.array_equal(linear_interp, ts))
+        self.assert_numpy_array_equal(linear_interp, ts)
 
         ord_ts = Series([d.toordinal() for d in self.ts.index],
                         index=self.ts.index).astype(float)
@@ -456,7 +456,7 @@ def test_interpolate(self):
         ord_ts_copy[5:10] = np.NaN
 
         time_interp = ord_ts_copy.interpolate(method='time')
-        self.assert_(np.array_equal(time_interp, ord_ts))
+        self.assert_numpy_array_equal(time_interp, ord_ts)
 
         # try time interpolation on a non-TimeSeries
         self.assertRaises(ValueError, self.series.interpolate, method='time')

pandas/tests/test_groupby.py

@@ -1720,7 +1720,7 @@ def test_apply_frame_to_series(self):
         result = grouped.apply(len)
         expected = grouped.count()['C']
         self.assert_(result.index.equals(expected.index))
-        self.assert_(np.array_equal(result.values, expected.values))
+        self.assert_numpy_array_equal(result.values, expected.values)
 
     def test_apply_frame_concat_series(self):
         def trans(group):
@@ -2198,17 +2198,17 @@ def test_panel_groupby(self):
 
         tm.assert_panel_equal(agged, agged2)
 
-        self.assert_(np.array_equal(agged.items, [0, 1]))
+        self.assert_numpy_array_equal(agged.items, [0, 1])
 
         grouped = self.panel.groupby(lambda x: x.month, axis='major')
         agged = grouped.mean()
 
-        self.assert_(np.array_equal(agged.major_axis, [1, 2]))
+        self.assert_numpy_array_equal(agged.major_axis, [1, 2])
 
         grouped = self.panel.groupby({'A': 0, 'B': 0, 'C': 1, 'D': 1},
                                      axis='minor')
         agged = grouped.mean()
-        self.assert_(np.array_equal(agged.minor_axis, [0, 1]))
+        self.assert_numpy_array_equal(agged.minor_axis, [0, 1])
 
     def test_numpy_groupby(self):
         from pandas.core.groupby import numpy_groupby
@@ -2234,8 +2234,8 @@ def test_groupby_2d_malformed(self):
         d['label'] = ['l1', 'l2']
         tmp = d.groupby(['group']).mean()
         res_values = np.array([[0., 1.], [0., 1.]])
-        self.assert_(np.array_equal(tmp.columns, ['zeros', 'ones']))
-        self.assert_(np.array_equal(tmp.values, res_values))
+        self.assert_numpy_array_equal(tmp.columns, ['zeros', 'ones'])
+        self.assert_numpy_array_equal(tmp.values, res_values)
 
     def test_int32_overflow(self):
         B = np.concatenate((np.arange(10000), np.arange(10000),
@@ -2290,19 +2290,19 @@ def test_groupby_sort_multi(self):
         tups = lmap(tuple, df[['a', 'b', 'c']].values)
         tups = com._asarray_tuplesafe(tups)
         result = df.groupby(['a', 'b', 'c'], sort=True).sum()
-        self.assert_(np.array_equal(result.index.values,
-                                    tups[[1, 2, 0]]))
+        self.assert_numpy_array_equal(result.index.values,
+                                      tups[[1, 2, 0]])
 
         tups = lmap(tuple, df[['c', 'a', 'b']].values)
         tups = com._asarray_tuplesafe(tups)
         result = df.groupby(['c', 'a', 'b'], sort=True).sum()
-        self.assert_(np.array_equal(result.index.values, tups))
+        self.assert_numpy_array_equal(result.index.values, tups)
 
         tups = lmap(tuple, df[['b', 'c', 'a']].values)
         tups = com._asarray_tuplesafe(tups)
         result = df.groupby(['b', 'c', 'a'], sort=True).sum()
-        self.assert_(np.array_equal(result.index.values,
-                                    tups[[2, 1, 0]]))
+        self.assert_numpy_array_equal(result.index.values,
+                                      tups[[2, 1, 0]])
 
         df = DataFrame({'a': [0, 1, 2, 0, 1, 2],
                         'b': [0, 0, 0, 1, 1, 1],
@@ -2452,7 +2452,7 @@ def test_agg_multiple_functions_maintain_order(self):
         result = self.df.groupby('A')['C'].agg(funcs)
         exp_cols = ['mean', 'max', 'min']
 
-        self.assert_(np.array_equal(result.columns, exp_cols))
+        self.assert_numpy_array_equal(result.columns, exp_cols)
 
     def test_multiple_functions_tuples_and_non_tuples(self):
         # #1359
@@ -2651,10 +2651,10 @@ def test_multiindex_columns_empty_level(self):
         df = DataFrame([[long(1), 'A']], columns=midx)
 
         grouped = df.groupby('to filter').groups
-        self.assert_(np.array_equal(grouped['A'], [0]))
+        self.assert_numpy_array_equal(grouped['A'], [0])
 
         grouped = df.groupby([('to filter', '')]).groups
-        self.assert_(np.array_equal(grouped['A'], [0]))
+        self.assert_numpy_array_equal(grouped['A'], [0])
 
         df = DataFrame([[long(1), 'A'], [long(2), 'B']], columns=midx)
 

pandas/tests/test_multilevel.py

@@ -1509,7 +1509,7 @@ def test_int_series_slicing(self):
         exp = self.ymd['A'].copy()
         s[5:] = 0
         exp.values[5:] = 0
-        self.assert_(np.array_equal(s.values, exp.values))
+        self.assert_numpy_array_equal(s.values, exp.values)
 
         result = self.ymd[5:]
         expected = self.ymd.reindex(s.index[5:])

pandas/tests/test_panel.py

@@ -754,8 +754,8 @@ def test_comp(func):
 
             # versus same index
             result = func(p1, p2)
-            self.assert_(np.array_equal(result.values,
-                                        func(p1.values, p2.values)))
+            self.assert_numpy_array_equal(result.values,
+                                          func(p1.values, p2.values))
 
             # versus non-indexed same objs
             self.assertRaises(Exception, func, p1, tp)
@@ -765,8 +765,8 @@ def test_comp(func):
 
             # versus scalar
             result3 = func(self.panel, 0)
-            self.assert_(np.array_equal(result3.values,
-                                        func(self.panel.values, 0)))
+            self.assert_numpy_array_equal(result3.values,
+                                          func(self.panel.values, 0))
 
         test_comp(operator.eq)
         test_comp(operator.ne)
@@ -2155,7 +2155,7 @@ def test_axis_dummies(self):
         transformed = make_axis_dummies(self.panel, 'minor',
                                         transform=mapping.get)
         self.assertEqual(len(transformed.columns), 2)
-        self.assert_(np.array_equal(transformed.columns, ['one', 'two']))
+        self.assert_numpy_array_equal(transformed.columns, ['one', 'two'])
 
         # TODO: test correctness
 
@@ -2165,7 +2165,7 @@ def test_get_dummies(self):
         self.panel['Label'] = self.panel.index.labels[1]
         minor_dummies = make_axis_dummies(self.panel, 'minor')
         dummies = get_dummies(self.panel['Label'])
-        self.assert_(np.array_equal(dummies.values, minor_dummies.values))
+        self.assert_numpy_array_equal(dummies.values, minor_dummies.values)
 
     def test_mean(self):
         means = self.panel.mean(level='minor')

pandas/tests/test_strings.py

@@ -133,7 +133,7 @@ def test_cat(self):
         # Multiple arrays
         result = strings.str_cat(one, [two], na_rep='NA')
         exp = ['aa', 'aNA', 'bb', 'bd', 'cfoo', 'NANA']
-        self.assert_(np.array_equal(result, exp))
+        self.assert_numpy_array_equal(result, exp)
 
         result = strings.str_cat(one, two)
         exp = ['aa', NA, 'bb', 'bd', 'cfoo', NA]