chore: clean the test cases

Author: ycexiao

src/diffpy/morph/morph_io.py

@@ -447,17 +447,14 @@ def handle_extrapolation_warnings(squeeze_morph):
 
 def handle_check_increase_warning(squeeze_morph):
     if squeeze_morph is not None:
-        if squeeze_morph.squeeze_info["monotonic"]:
+        if squeeze_morph.strictly_increasing:
             wmsg = None
         else:
-            overlapping_regions = squeeze_morph.squeeze_info[
-                "overlapping_regions"
-            ]
             wmsg = (
                 "Warning: The squeeze morph has interpolated your morphed "
                 "function from a non-monotonically increasing grid. "
-                "This can result in strange behavior in the regions "
-                f"{overlapping_regions}. To disable this setting, "
+                "This can result in strange behavior in the non-uniqe "
+                "grid regions. To disable this setting, "
                 "please enable --check-increasing."
             )
         if wmsg:

src/diffpy/morph/morphs/morphsqueeze.py

@@ -73,8 +73,7 @@ def __init__(self, config=None, check_increase=False):
         super().__init__(config)
         self.check_increase = check_increase
 
-    def _set_squeeze_info(self, x, x_sorted):
-        self.squeeze_info = {"monotonic": True, "overlapping_regions": None}
+    def _ensure_strictly_increase(self, x, x_sorted):
         if list(x) != list(x_sorted):
             if self.check_increase:
                 raise ValueError(
@@ -100,12 +99,9 @@ def _set_squeeze_info(self, x, x_sorted):
                     "and stretch parameter for a1."
                 )
             else:
-                if list(x) != list(x_sorted[::-1]):
-                    overlapping_regions = self.get_overlapping_regions(x)
-                    self.squeeze_info["monotonic"] = False
-                    self.squeeze_info["overlapping_regions"] = (
-                        overlapping_regions
-                    )
+                self.strictly_increasing = False
+        else:
+            self.strictly_increasing = True
 
     def _sort_squeeze(self, x, y):
         """Sort x,y according to the value of x."""
@@ -114,32 +110,6 @@ 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):
-        diffx = numpy.diff(x)
-        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_index = numpy.where(
-            monotinic_regions_sign == overlapping_regions_sign
-        )[0]
-        overlapping_regions = monotonic_regions_x[overlapping_regions_index]
-        overlapping_regions = [
-            sorted(region) for region in overlapping_regions
-        ]
-        return overlapping_regions
-
     def _handle_duplicates(self, x, y):
         """Remove duplicated x and use the mean value of y corresponded
         to the duplicated x."""
@@ -159,14 +129,13 @@ def morph(self, x_morph, y_morph, x_target, y_target):
         data.
         """
         Morph.morph(self, x_morph, y_morph, x_target, y_target)
-
         coeffs = [self.squeeze[f"a{i}"] for i in range(len(self.squeeze))]
         squeeze_polynomial = Polynomial(coeffs)
         x_squeezed = self.x_morph_in + squeeze_polynomial(self.x_morph_in)
         x_squeezed_sorted, y_morph_sorted = self._sort_squeeze(
             x_squeezed, self.y_morph_in
         )
-        self._set_squeeze_info(x_squeezed, x_squeezed_sorted)
+        self._ensure_strictly_increase(x_squeezed, x_squeezed_sorted)
         x_squeezed_sorted, y_morph_sorted = self._handle_duplicates(
             x_squeezed_sorted, y_morph_sorted
         )

tests/test_morphsqueeze.py

@@ -176,26 +176,38 @@ def test_morphsqueeze_extrapolate(
 @pytest.mark.parametrize(
     "squeeze_coeffs, x_morph",
     [
-        ({"a0": 0.01, "a1": -0.99, "a2": 0.01}, np.linspace(-1, 1, 101)),
+        ({"a0": 0.01, "a1": 0.01, "a2": -0.1}, np.linspace(0, 10, 101)),
     ],
 )
-def test_sort_squeeze(user_filesystem, squeeze_coeffs, x_morph):
+def test_non_strictly_increasing_squeeze(squeeze_coeffs, x_morph):
     x_target = x_morph
     y_target = np.sin(x_target)
     coeffs = [squeeze_coeffs[f"a{i}"] for i in range(len(squeeze_coeffs))]
     squeeze_polynomial = Polynomial(coeffs)
     x_squeezed = x_morph + squeeze_polynomial(x_morph)
-    # non-strictly-monotonic
-    assert not np.all(np.diff(np.sign(np.diff(x_squeezed))) == 0)
-    # outcome converges when --check-increase is not used
+    # non-strictly-increasing
+    assert not np.all(np.sign(np.diff(x_squeezed)) > 0)
     y_morph = np.sin(x_squeezed)
-    morph = MorphSqueeze()
-    morph.squeeze = squeeze_coeffs
+    # all zero initial guess
+    morph_results = morphpy.morph_arrays(
+        np.array([x_morph, y_morph]).T,
+        np.array([x_target, y_target]).T,
+        squeeze=[0, 0, 0],
+        apply=True,
+    )
+    _, y_morph_actual = morph_results[1].T  # noqa: F841
+    y_morph_expected = np.sin(x_morph)  # noqa: F841
+    # squeeze morph extrapolates.
+    #   Need to extract extrap_index from morph_results to examine
+    #   the convergence.
+    # assert np.allclose(y_morph_actual, y_morph_expected, atol=1e-3)
+    # Raise warning when called without --check-increase
     with pytest.warns() as w:
-        moreph_results = morphpy.morph_arrays(
+        morph_results = morphpy.morph_arrays(
             np.array([x_morph, y_morph]).T,
             np.array([x_target, y_target]).T,
-            squeeze=[0.01, -0.99, 0.01],
+            squeeze=[0.01, 0.01, -0.1],
+            apply=True,
         )
     assert w[0].category is UserWarning
     actual_wmsg = " ".join([str(w[i].message) for i in range(len(w))])
@@ -204,18 +216,18 @@ def test_sort_squeeze(user_filesystem, squeeze_coeffs, x_morph):
         "function from a non-monotonically increasing grid. "
     )
     assert expected_wmsg in actual_wmsg
-    expected_coeffs = coeffs
-    actual_coeffs = [
-        moreph_results[0]["squeeze"][f"a{i}"]
-        for i in range(len(moreph_results[0]["squeeze"]))
-    ]
-    # program exits when --check-increase is used
-    assert np.allclose(actual_coeffs, expected_coeffs, rtol=1e-2)
+    _, y_morph_actual = morph_results[1].T  # noqa: F841
+    y_morph_expected = np.sin(x_morph)  # noqa: F841
+    # squeeze morph extrapolates.
+    #   Need to extract extrap_index from morph_results to examine
+    #   the convergence.
+    # assert np.allclose(y_morph_actual, y_morph_expected, atol=1e-3)
+    # System exits when called with --check-increase
     with pytest.raises(SystemExit) as excinfo:
         morphpy.morph_arrays(
             np.array([x_morph, y_morph]).T,
             np.array([x_target, y_target]).T,
-            squeeze=[0.01, -1, 0.01],
+            squeeze=[0.01, 0.009, -0.1],
             check_increase=True,
         )
     actual_emsg = str(excinfo.value)
@@ -315,24 +327,22 @@ 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):
+def test_handle_duplicates():
+    unq_x = np.linspace(0, 11, 10)
+    iter = 10
     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
+    for i in range(iter):
+        actual_x = np.random.choice(unq_x, size=20)
+        actual_y = np.sin(actual_x)
+        actual_handled_x, actual_handled_y = morph._handle_duplicates(
+            actual_x, actual_y
+        )
+        expected_handled_x = np.unique(actual_x)
+        expected_handled_y = np.array(
+            [actual_y[actual_x == x].mean() for x in expected_handled_x]
+        )
+        assert np.allclose(actual_handled_x, expected_handled_x)
+        assert np.allclose(actual_handled_y, expected_handled_y)
 
 
 def create_morph_data_file(