Fix compatibility with NumPy 1.13

- Stop using assertFloatEqual for non-float fields

tests/test_astropyTableViews.py

@@ -127,9 +127,9 @@ def testFlagColumn(self):
         """Test that Flag columns can be viewed if copy=True or unviewable="copy".
         """
         v1 = self.catalog.asAstropy(unviewable="copy")
-        self.assertFloatsAlmostEqual(v1["a4"], self.catalog["a4"])
+        np.testing.assert_array_equal(v1["a4"], self.catalog["a4"])
         v2 = self.catalog.asAstropy(copy=True)
-        self.assertFloatsAlmostEqual(v2["a4"], self.catalog["a4"])
+        np.testing.assert_array_equal(v2["a4"], self.catalog["a4"])
 
     def testCoordColumn(self):
         """Test that Coord columns appears as a pair of columns with correct angle units.

tests/test_pupilFactory.py

@@ -51,40 +51,40 @@ def testBasePupilFactoryMethods(self):
         pupilFactory = afwCameraGeom.PupilFactory(
             self.visitInfo, self.size, self.npix)
         pupil = pupilFactory._fullPupil()
-        self.assertFloatsEqual(pupil.illuminated, True)
+        self.assertTrue(np.all(pupil.illuminated))
         nFull = np.sum(pupil.illuminated)
 
         # Cut out a primary aperture
         pupilFactory._cutCircleExterior(pupil, (0.0, 0.0), 8.4/2)
         nCircle = np.sum(pupil.illuminated)
         self.assertFloatsAlmostEqual(
             nCircle/nFull, np.pi*(8.4/2)**2 / 16.8**2, rtol=3e-4)
-        self.assertFloatsEqual(pupil.illuminated, pupil.illuminated.T)
+        np.testing.assert_array_equal(pupil.illuminated, pupil.illuminated.T)
 
         # Cut out a central obstruction making an annulus
         pupilFactory._cutCircleInterior(pupil, (0.0, 0.0), 8.4/2 * 0.6)
         nAnnulus = np.sum(pupil.illuminated)
         self.assertFloatsAlmostEqual(
             nAnnulus/nFull, nCircle/nFull * (1-0.6**2), rtol=3e-4)
-        self.assertFloatsEqual(pupil.illuminated, pupil.illuminated.T)
+        np.testing.assert_array_equal(pupil.illuminated, pupil.illuminated.T)
 
         # Cut a horizontal ray, which preserves vertical reflection symmetry
         # but removes horizontal reflection symmetry, and transpositional
         # symmetry.
         pupilFactory._cutRay(pupil, (0.0, 0.0), 0*degrees, 0.1)
-        self.assertFloatsEqual(pupil.illuminated, pupil.illuminated[::-1, :])
-        self.assertFloatsNotEqual(
-            pupil.illuminated, pupil.illuminated[:, ::-1])
-        self.assertFloatsNotEqual(pupil.illuminated, pupil.illuminated.T)
+        np.testing.assert_array_equal(pupil.illuminated, pupil.illuminated[::-1, :])
+        self.assertTrue(np.any(pupil.illuminated !=
+                        pupil.illuminated[:, ::-1]))
+        self.assertTrue(np.any(pupil.illuminated != pupil.illuminated.T))
 
         # Cut a vertical ray, which then gives transpositional symmetry but
         # removes vertical and horizontal reflection symmetry
         pupilFactory._cutRay(pupil, (0.0, 0.0), 90*degrees, 0.1)
-        self.assertFloatsNotEqual(
-            pupil.illuminated, pupil.illuminated[::-1, :])
-        self.assertFloatsNotEqual(
-            pupil.illuminated, pupil.illuminated[:, ::-1])
-        self.assertFloatsEqual(pupil.illuminated, pupil.illuminated.T)
+        self.assertTrue(np.any(pupil.illuminated !=
+                        pupil.illuminated[::-1, :]))
+        self.assertTrue(np.any(pupil.illuminated !=
+                        pupil.illuminated[:, ::-1]))
+        self.assertTrue(np.any(pupil.illuminated == pupil.illuminated.T))
 
 
 def setup_module(module):

tests/test_simpleTable.py

@@ -356,12 +356,18 @@ def testExtract(self):
             ({"where": sliceIdx, "copy": True}, sliceIdx),
         ]:
             d = catalog.extract("*", **kwds)
-            self.assertFloatsEqual(d["a_b_c1"], catalog.get("a_b_c1")[idx])
-            self.assertFloatsEqual(d["a_b_c2"], catalog.get("a_b_c2")[idx])
-            self.assertFloatsEqual(d["a_d1"], catalog.get("a_d1")[idx])
-            self.assertFloatsEqual(d["a_d2"], catalog.get("a_d2")[idx])
-            self.assertFloatsEqual(d["q_e1_x"], catalog.get("q_e1_x")[idx])
-            self.assertFloatsEqual(d["q_e1_y"], catalog.get("q_e1_y")[idx])
+            np.testing.assert_array_equal(
+                d["a_b_c1"], catalog.get("a_b_c1")[idx])
+            np.testing.assert_array_equal(
+                d["a_b_c2"], catalog.get("a_b_c2")[idx])
+            np.testing.assert_array_equal(
+                d["a_d1"], catalog.get("a_d1")[idx])
+            np.testing.assert_array_equal(
+                d["a_d2"], catalog.get("a_d2")[idx])
+            np.testing.assert_array_equal(
+                d["q_e1_x"], catalog.get("q_e1_x")[idx])
+            np.testing.assert_array_equal(
+                d["q_e1_y"], catalog.get("q_e1_y")[idx])
             if "copy" in kwds or idx is boolIdx:
                 for col in d.values():
                     self.assertTrue(col.flags.c_contiguous)

tests/test_sourceTable.py

@@ -278,23 +278,24 @@ def testForwarding(self):
             self.catalog.foo()
 
     def testBitsColumn(self):
+
         allBits = self.catalog.getBits()
         someBits = self.catalog.getBits(["a_flag", "c_flag"])
         self.assertEqual(allBits.getMask("a_flag"), 0x1)
         self.assertEqual(allBits.getMask("b_flag"), 0x2)
         self.assertEqual(allBits.getMask("c_flag"), 0x4)
         self.assertEqual(someBits.getMask(self.fluxFlagKey), 0x1)
         self.assertEqual(someBits.getMask(self.shapeFlagKey), 0x2)
-        self.assertFloatsEqual((allBits.array & 0x1 != 0),
-                               self.catalog.columns["a_flag"])
-        self.assertFloatsEqual((allBits.array & 0x2 != 0),
-                               self.catalog.columns["b_flag"])
-        self.assertFloatsEqual((allBits.array & 0x4 != 0),
-                               self.catalog.columns["c_flag"])
-        self.assertFloatsEqual((someBits.array & 0x1 != 0),
-                               self.catalog.columns["a_flag"])
-        self.assertFloatsEqual((someBits.array & 0x2 != 0),
-                               self.catalog.columns["c_flag"])
+        np.testing.assert_array_equal(
+            (allBits.array & 0x1 != 0), self.catalog.columns["a_flag"])
+        np.testing.assert_array_equal(
+            (allBits.array & 0x2 != 0), self.catalog.columns["b_flag"])
+        np.testing.assert_array_equal(
+            (allBits.array & 0x4 != 0), self.catalog.columns["c_flag"])
+        np.testing.assert_array_equal(
+            (someBits.array & 0x1 != 0), self.catalog.columns["a_flag"])
+        np.testing.assert_array_equal(
+            (someBits.array & 0x2 != 0), self.catalog.columns["c_flag"])
 
     def testCast(self):
         baseCat = self.catalog.cast(lsst.afw.table.BaseCatalog)
@@ -328,7 +329,8 @@ def testFootprints(self):
 
         for i, src in enumerate(self.catalog):
             if src != src2:
-                spanSet = lsst.afw.geom.SpanSet.fromShape(1+i*2).shiftedBy(50, 50)
+                spanSet = lsst.afw.geom.SpanSet.fromShape(
+                    1+i*2).shiftedBy(50, 50)
                 src.setFootprint(lsst.afw.detection.Footprint(spanSet))
 
         # insert this HeavyFootprint into an otherwise blank image (for comparing the results)