Extend unit tests for bin1d_vec and .get_index_of

* in `test_calc.TestBin1d`:
    * add `test_bin1d_single_bin2`, which inputs a single bin _and_ a single point;
    * split off a new `test_scalar_inside` from `test_scalar_outside`, which checks:
        * _all_ corner cases (*.*5)
        * _all_ center bins (*.*0)
        * _all_ end of bins (*.*99999999)
        * one large value (10)
* add separate class `TestBin2d` in `test_region`, which makes more realistic unit tests by extending the self-check mentioned in #255 and performing it...
    * for three regions: Italy, California, NZ (New-Zealand);
    * for all origins, mid-points, and end-corners (in the bin, at the opposite side of origin);
    * for double precision (_float64_ / _f8_) and single precision (_float32_ / _f4_) of the points (not bin edges);
    * as loop (over each point individually) and single vector (all points at once).
    * ==> 36 unit test combinations
    * (albeit targeting `bin1d_vec`, it also unit-tests region's`CartesianGrid2D.get_index_of` and by extension `GriddedForecast.get_index_of`)

Author: mherrmann3

tests/test_calc.py

@@ -106,6 +106,13 @@ def test_bin1d_single_bin1(self):
         expected = [-1, -1, 0, 0, 0, 0, 0, -1]
         self.assertListEqual(test.tolist(), expected)
 
+    def test_bin1d_single_bin2(self):
+        data = [4.0]
+        bin_edges = [3.0]
+        test = bin1d_vec(data, bin_edges)
+        expected = [0]
+        self.assertListEqual(test.tolist(), expected)
+
     def test_upper_limit_right_continuous(self):
         data = [40, 40, 40]
         bin_edges = [0, 10, 20, 30]
@@ -134,18 +141,27 @@ def test_less_and_greater_than(self):
         expected = [-1, 3, -1]
         self.assertListEqual(test.tolist(), expected)
 
-    def test_scalar_outside(self):
-        from csep.utils.calc import bin1d_vec
-        mbins = numpy.arange(5.95, 9, 0.1)  # This gives bins from 5.95 to 8.95
-        idx = bin1d_vec(5.95, mbins, right_continuous=True)
-        self.assertEqual(idx, 0)
+    def test_scalar_inside(self):
+        mbins = numpy.arange(5.95, 9, 0.1)  # (magnitude) bins from 5.95 to 8.95
+
+        for i, m in enumerate(mbins):
+            idx = bin1d_vec(m, mbins, right_continuous=True)  # corner cases
+            self.assertEqual(idx, i)
 
-        idx = bin1d_vec(6, mbins, right_continuous=True)  # This would give 0: Which is fine.
-        self.assertEqual(idx, 0)
+            idx = bin1d_vec(m + 0.05, mbins, right_continuous=True)  # center bins
+            self.assertEqual(idx, i)
+
+            idx = bin1d_vec(m + 0.099999999, mbins, right_continuous=True)  # end of bins
+            self.assertEqual(idx, i)
+
+        idx = bin1d_vec(10, mbins, right_continuous=True)  # larger than last bin edge
+        self.assertEqual(idx, mbins.size - 1)
+
+    def test_scalar_outside(self):
+        mbins = numpy.arange(5.95, 9, 0.1)  # (magnitude) bins from 5.95 to 8.95
 
         idx = bin1d_vec(5, mbins, right_continuous=True)
         self.assertEqual(idx, -1)
 
         idx = bin1d_vec(4, mbins, right_continuous=True)
         self.assertEqual(idx, -1)
-

tests/test_regions.py

@@ -86,3 +86,72 @@ def test_origins(self):
         r = nz_csep_region()
         # they dont have to be in the same order, but they need
         numpy.testing.assert_array_equal(r.midpoints().sort(), self.from_dat.sort())
+
+class TestBin2d(unittest.TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        super(TestBin2d, cls).setUpClass()
+
+        # (loading those is the bottleneck of this test case)
+        cls.regions = [
+            italy_csep_region(),
+            california_relm_region(),
+            nz_csep_region()
+        ]
+
+    def test_bin2d_regions_origins(self):
+        """every origin must be inside its own bin
+        """
+
+        for region in self.regions:
+            origins = region.origins()
+            self._test_bin2d_region_loop(region, origins)
+            self._test_bin2d_region_vect(region, origins)
+            self._test_bin2d_region_vect(region, origins.astype(numpy.float32))
+
+    def test_bin2d_regions_midpoints(self):
+        """every midpoint must be inside its own bin
+        """
+
+        for region in self.regions:
+            midpoints = region.midpoints()
+            self._test_bin2d_region_loop(region, midpoints)
+            self._test_bin2d_region_vect(region, midpoints)
+            self._test_bin2d_region_vect(region, midpoints.astype(numpy.float32))
+
+    def test_bin2d_regions_endcorner(self):
+        """every corner point (~opposite end of the origin) must be inside its own bin
+        """
+
+        for region in self.regions:
+            frac = 0.9999999999
+            endcorners = region.origins() + frac*region.dh
+            self._test_bin2d_region_loop(region, endcorners)
+            self._test_bin2d_region_vect(region, endcorners)
+            frac = 0.999  # decrease frac for float32 due to its lower resolution
+            endcorners = region.origins() + frac*region.dh
+            self._test_bin2d_region_vect(region, endcorners.astype(numpy.float32))
+
+    def _test_bin2d_region_loop(self, region, coords):
+        """(slow) loop over origins; each time, calls bin1d_vec for lat & lon scalars
+        """
+
+        for i, origin in enumerate(coords):
+            idx = region.get_index_of(
+                origin[0],
+                origin[1],
+            )
+            self.assertEqual(i, idx)
+
+    def _test_bin2d_region_vect(self, region, coords):
+        """call bin1d_vec once for all lat origins & all lon origins
+
+        Besides, also tests if vectors with ndim=2 are consumed properly
+        (returns 2nd-order/nested list ([[...]]).
+        """
+
+        lons, lats = numpy.split(coords.T, 2)  # both have ndim=2!
+        test = region.get_index_of(lons, lats).tolist()  # nested list ([[...]])
+        expected = [numpy.arange(len(region.origins())).tolist()]  # embed in another list
+        self.assertListEqual(test, expected)