Merge

Author: Sparks29032

src/diffpy/morph/morphs/morphrgrid.py

@@ -54,17 +54,17 @@ class MorphRGrid(Morph):
     def morph(self, x_morph, y_morph, x_target, y_target):
         """Resample arrays onto specified grid."""
         Morph.morph(self, x_morph, y_morph, x_target, y_target)
-        rmininc = max(self.x_target_in[0], self.x_morph_in[0])
-        r_step_target = (self.x_target_in[-1] - self.x_target_in[0]) / (
+        rmininc = max(min(self.x_target_in), min(self.x_morph_in))
+        r_step_target = (max(self.x_target_in) - min(self.x_target_in)) / (
             len(self.x_target_in) - 1
         )
-        r_step_morph = (self.x_morph_in[-1] - self.x_morph_in[0]) / (
+        r_step_morph = (max(self.x_morph_in) - min(self.x_morph_in)) / (
             len(self.x_morph_in) - 1
         )
         rstepinc = max(r_step_target, r_step_morph)
         rmaxinc = min(
-            self.x_target_in[-1] + r_step_target,
-            self.x_morph_in[-1] + r_step_morph,
+            max(self.x_target_in) + r_step_target,
+            max(self.x_morph_in) + r_step_morph,
         )
         if self.rmin is None or self.rmin < rmininc:
             self.rmin = rmininc

tests/test_morphfuncx.py

@@ -0,0 +1,76 @@
+import numpy as np
+import pytest
+
+# from diffpy.morph.morphs.morphfuncx import MorphFuncx
+from diffpy.morph.morphs.morphfuncy import MorphFuncy
+
+
+def sine_function(x, y, amplitude, frequency):
+    return amplitude * np.sin(frequency * x) * y
+
+
+def exponential_decay_function(x, y, amplitude, decay_rate):
+    return amplitude * np.exp(-decay_rate * x) * y
+
+
+def gaussian_function(x, y, amplitude, mean, sigma):
+    return amplitude * np.exp(-((x - mean) ** 2) / (2 * sigma**2)) * y
+
+
+def polynomial_function(x, y, a, b, c):
+    return (a * x**2 + b * x + c) * y
+
+
+def logarithmic_function(x, y, scale):
+    return scale * np.log(1 + x) * y
+
+
+# FIXME:
+@pytest.mark.parametrize(
+    "function, parameters, expected_function",
+    [
+        (
+            sine_function,
+            {"amplitude": 2, "frequency": 5},
+            lambda x, y: 2 * np.sin(5 * x) * y,
+        ),
+        (
+            exponential_decay_function,
+            {"amplitude": 5, "decay_rate": 0.1},
+            lambda x, y: 5 * np.exp(-0.1 * x) * y,
+        ),
+        (
+            gaussian_function,
+            {"amplitude": 1, "mean": 5, "sigma": 1},
+            lambda x, y: np.exp(-((x - 5) ** 2) / (2 * 1**2)) * y,
+        ),
+        (
+            polynomial_function,
+            {"a": 1, "b": 2, "c": 0},
+            lambda x, y: (x**2 + 2 * x) * y,
+        ),
+        (
+            logarithmic_function,
+            {"scale": 0.5},
+            lambda x, y: 0.5 * np.log(1 + x) * y,
+        ),
+    ],
+)
+def test_funcy(function, parameters, expected_function):
+    x_morph = np.linspace(0, 10, 101)
+    y_morph = np.sin(x_morph)
+    x_target = x_morph.copy()
+    y_target = y_morph.copy()
+    x_morph_expected = x_morph
+    y_morph_expected = expected_function(x_morph, y_morph)
+    morph = MorphFuncy()
+    morph.funcy_function = function
+    morph.funcy = parameters
+    x_morph_actual, y_morph_actual, x_target_actual, y_target_actual = (
+        morph.morph(x_morph, y_morph, x_target, y_target)
+    )
+
+    assert np.allclose(y_morph_actual, y_morph_expected)
+    assert np.allclose(x_morph_actual, x_morph_expected)
+    assert np.allclose(x_target_actual, x_target)
+    assert np.allclose(y_target_actual, y_target)

tests/test_morphfuncxy.py

@@ -0,0 +1,76 @@
+import numpy as np
+import pytest
+
+# from diffpy.morph.morphs.morphfuncxy import MorphFuncxy
+from diffpy.morph.morphs.morphfuncy import MorphFuncy
+
+
+def sine_function(x, y, amplitude, frequency):
+    return amplitude * np.sin(frequency * x) * y
+
+
+def exponential_decay_function(x, y, amplitude, decay_rate):
+    return amplitude * np.exp(-decay_rate * x) * y
+
+
+def gaussian_function(x, y, amplitude, mean, sigma):
+    return amplitude * np.exp(-((x - mean) ** 2) / (2 * sigma**2)) * y
+
+
+def polynomial_function(x, y, a, b, c):
+    return (a * x**2 + b * x + c) * y
+
+
+def logarithmic_function(x, y, scale):
+    return scale * np.log(1 + x) * y
+
+
+# FIXME:
+@pytest.mark.parametrize(
+    "function, parameters, expected_function",
+    [
+        (
+            sine_function,
+            {"amplitude": 2, "frequency": 5},
+            lambda x, y: 2 * np.sin(5 * x) * y,
+        ),
+        (
+            exponential_decay_function,
+            {"amplitude": 5, "decay_rate": 0.1},
+            lambda x, y: 5 * np.exp(-0.1 * x) * y,
+        ),
+        (
+            gaussian_function,
+            {"amplitude": 1, "mean": 5, "sigma": 1},
+            lambda x, y: np.exp(-((x - 5) ** 2) / (2 * 1**2)) * y,
+        ),
+        (
+            polynomial_function,
+            {"a": 1, "b": 2, "c": 0},
+            lambda x, y: (x**2 + 2 * x) * y,
+        ),
+        (
+            logarithmic_function,
+            {"scale": 0.5},
+            lambda x, y: 0.5 * np.log(1 + x) * y,
+        ),
+    ],
+)
+def test_funcy(function, parameters, expected_function):
+    x_morph = np.linspace(0, 10, 101)
+    y_morph = np.sin(x_morph)
+    x_target = x_morph.copy()
+    y_target = y_morph.copy()
+    x_morph_expected = x_morph
+    y_morph_expected = expected_function(x_morph, y_morph)
+    morph = MorphFuncy()
+    morph.funcy_function = function
+    morph.funcy = parameters
+    x_morph_actual, y_morph_actual, x_target_actual, y_target_actual = (
+        morph.morph(x_morph, y_morph, x_target, y_target)
+    )
+
+    assert np.allclose(y_morph_actual, y_morph_expected)
+    assert np.allclose(x_morph_actual, x_morph_expected)
+    assert np.allclose(x_target_actual, x_target)
+    assert np.allclose(y_target_actual, y_target)

tests/test_morphpy.py

@@ -249,6 +249,68 @@ def gaussian_like_function(x, y, mu):
         assert pytest.approx(abs(morph_info["smear"])) == 4.0
         assert pytest.approx(morph_info["funcy"]["mu"]) == 50.0
 
+    # FIXME:
+    def test_morphfuncx(self, setup_morph):
+        def gaussian(x, mu, sigma):
+            return np.exp(-((x - mu) ** 2) / (2 * sigma**2)) / (
+                sigma * np.sqrt(2 * np.pi)
+            )
+
+        def gaussian_like_function(x, y, mu):
+            return gaussian((x + y) / 2, mu, 3)
+
+        morph_r = np.linspace(0, 100, 1001)
+        morph_gr = np.linspace(0, 100, 1001)
+
+        target_r = np.linspace(0, 100, 1001)
+        target_gr = 0.5 * gaussian(target_r, 50, 5) + 0.05
+
+        morph_info, _ = morph_arrays(
+            np.array([morph_r, morph_gr]).T,
+            np.array([target_r, target_gr]).T,
+            scale=1,
+            smear=3.75,
+            vshift=0.01,
+            funcy=(gaussian_like_function, {"mu": 47.5}),
+            tolerance=1e-12,
+        )
+
+        assert pytest.approx(morph_info["scale"]) == 0.5
+        assert pytest.approx(morph_info["vshift"]) == 0.05
+        assert pytest.approx(abs(morph_info["smear"])) == 4.0
+        assert pytest.approx(morph_info["funcy"]["mu"]) == 50.0
+
+    # FIXME:
+    def test_morphfuncxy(self, setup_morph):
+        def gaussian(x, mu, sigma):
+            return np.exp(-((x - mu) ** 2) / (2 * sigma**2)) / (
+                sigma * np.sqrt(2 * np.pi)
+            )
+
+        def gaussian_like_function(x, y, mu):
+            return gaussian((x + y) / 2, mu, 3)
+
+        morph_r = np.linspace(0, 100, 1001)
+        morph_gr = np.linspace(0, 100, 1001)
+
+        target_r = np.linspace(0, 100, 1001)
+        target_gr = 0.5 * gaussian(target_r, 50, 5) + 0.05
+
+        morph_info, _ = morph_arrays(
+            np.array([morph_r, morph_gr]).T,
+            np.array([target_r, target_gr]).T,
+            scale=1,
+            smear=3.75,
+            vshift=0.01,
+            funcy=(gaussian_like_function, {"mu": 47.5}),
+            tolerance=1e-12,
+        )
+
+        assert pytest.approx(morph_info["scale"]) == 0.5
+        assert pytest.approx(morph_info["vshift"]) == 0.05
+        assert pytest.approx(abs(morph_info["smear"])) == 4.0
+        assert pytest.approx(morph_info["funcy"]["mu"]) == 50.0
+
     def test_morphpy_outputs(self, tmp_path):
         r = np.linspace(0, 1, 11)
         gr = np.linspace(0, 1, 11)