test: refactor and add test for get_overlapping_regions

Author: ycexiao

src/diffpy/morph/morphs/morphsqueeze.py

@@ -100,7 +100,7 @@ def _set_squeeze_info(self, x, x_sorted):
                     "and stretch parameter for a1."
                 )
             else:
-                overlapping_regions = self._get_overlapping_regions(x)
+                overlapping_regions = self.get_overlapping_regions(x)
                 self.squeeze_info["monotonic"] = False
                 self.squeeze_info["overlapping_regions"] = overlapping_regions
 
@@ -111,27 +111,29 @@ def _sort_squeeze(self, x, y):
         x_sorted, y_sorted = list(zip(*xy_sorted))
         return x_sorted, y_sorted
 
-    def _get_overlapping_regions(self, x):
+    def get_overlapping_regions(self, x):
         diffx = numpy.diff(x)
-        monotomic_regions = []
-        monotomic_signs = [numpy.sign(diffx[0])]
-        current_region = [x[0], x[1]]
-        for i in range(1, len(diffx)):
-            if numpy.sign(diffx[i]) == monotomic_signs[-1]:
-                current_region.append(x[i + 1])
-            else:
-                monotomic_regions.append(current_region)
-                monotomic_signs.append(numpy.sign(diffx[i]))
-                current_region = [x[i + 1]]
-        monotomic_regions.append(current_region)
+        diffx_sign = numpy.sign(diffx)
+        local_min_or_max_index = (
+            numpy.where(numpy.diff(diffx_sign) != 0)[0] + 1
+        )
+        monotonic_regions_x = numpy.concatenate(
+            (
+                [x[0]],
+                numpy.repeat(
+                    numpy.array(x)[local_min_or_max_index], 2
+                ).tolist()[:-1],
+            )
+        ).reshape(-1, 2)
+        monotinic_regions_sign = diffx_sign[local_min_or_max_index - 1]
+
         overlapping_regions_sign = -1 if x[0] < x[-1] else 1
-        overlapping_regions_x = [
-            monotomic_regions[i]
-            for i in range(len(monotomic_regions))
-            if monotomic_signs[i] == overlapping_regions_sign
-        ]
+        overlapping_regions_index = numpy.where(
+            monotinic_regions_sign == overlapping_regions_sign
+        )[0]
+        overlapping_regions = monotonic_regions_x[overlapping_regions_index]
         overlapping_regions = [
-            (min(region), max(region)) for region in overlapping_regions_x
+            sorted(region) for region in overlapping_regions
         ]
         return overlapping_regions
 

tests/test_morphsqueeze.py

@@ -261,6 +261,26 @@ def test_sort_squeeze_bad(user_filesystem, squeeze_coeffs, x_morph):
     assert expected_emsg in actual_emsg
 
 
+@pytest.mark.parametrize(
+    "turning_points, expected_overlapping_regions",
+    [
+        # x[-1] > x[0], monotonically decreasing regions are overlapping
+        ([0, 10, 7, 12], [[7, 10]]),
+        # x[-1] < x[0], monotonically increasing regions are overlapping
+        ([0, 5, 2, 4, -10], [[0, 5], [2, 4]])
+    ],
+)
+def test_get_overlapping_regions(turning_points, expected_overlapping_regions):
+    morph = MorphSqueeze()
+    regions = (
+        np.linspace(turning_points[i], turning_points[i + 1], 20)
+        for i in range(len(turning_points) - 1)
+    )
+    x_value = np.concatenate(list(regions))
+    actual_overlaping_regions = morph.get_overlapping_regions(x_value)
+    assert expected_overlapping_regions == actual_overlaping_regions
+
+
 def create_morph_data_file(
     data_dir_path, x_morph, y_morph, x_target, y_target
 ):