Final testing suite

Author: Sparks29032

src/diffpy/morph/morphs/morphrgrid.py

@@ -51,8 +51,21 @@ class MorphRGrid(Morph):
     youtlabel = LABEL_GR
     parnames = ["rmin", "rmax", "rstep"]
 
+    # Define rmin rmax holders for adaptive x-grid refinement
+    # Without these, the program r-grid can only decrease in interval size
+    rmin_origin = None
+    rmax_origin = None
+    rstep_origin = None
+
     def morph(self, x_morph, y_morph, x_target, y_target):
         """Resample arrays onto specified grid."""
+        if self.rmin is not None:
+            self.rmin_origin = self.rmin
+        if self.rmax is not None:
+            self.rmax_origin = self.rmax
+        if self.rstep is not None:
+            self.rstep_origin = self.rstep
+
         Morph.morph(self, x_morph, y_morph, x_target, y_target)
         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)) / (
@@ -66,11 +79,11 @@ def morph(self, x_morph, y_morph, x_target, y_target):
             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:
+        if self.rmin_origin is None or self.rmin_origin < rmininc:
             self.rmin = rmininc
-        if self.rmax is None or self.rmax > rmaxinc:
+        if self.rmax_origin is None or self.rmax_origin > rmaxinc:
             self.rmax = rmaxinc
-        if self.rstep is None or self.rstep < rstepinc:
+        if self.rstep_origin is None or self.rstep_origin < rstepinc:
             self.rstep = rstepinc
         # roundoff tolerance for selecting bounds on arrays.
         epsilon = self.rstep / 2

src/diffpy/morph/refine.py

@@ -96,8 +96,11 @@ def _residual(self, pvals):
                 rvec.extend([0] * diff_length)
                 rvec = array(rvec)
             # Removal
+            # For removal, pass the average RMS
+            # This is fast and easy to compute
+            # For sufficiently functions, this approximation becomes exact
             elif len(rvec) > self.res_length:
-                avg_rms = sum(rvec**2) / self.res_length
+                avg_rms = sum(rvec**2) / len(rvec)
                 rvec = array([avg_rms for _ in range(self.res_length)])
 
         return rvec

tests/test_morphfuncx.py

@@ -1,71 +1,63 @@
 import numpy as np
 import pytest
 
-# from diffpy.morph.morphs.morphfuncx import MorphFuncx
-from diffpy.morph.morphs.morphfuncy import MorphFuncy
+from diffpy.morph.morphs.morphfuncx import MorphFuncx
 
 
-def sine_function(x, y, amplitude, frequency):
-    return amplitude * np.sin(frequency * x) * y
+def x_exponential_function(x, y, x_amplitude, x_rate):
+    return x_amplitude * np.exp(x_rate * x)
 
 
-def exponential_decay_function(x, y, amplitude, decay_rate):
-    return amplitude * np.exp(-decay_rate * x) * y
+def x_linear_function(x, y, x_slope, x_intercept):
+    return x_slope * x + x_intercept
 
 
-def gaussian_function(x, y, amplitude, mean, sigma):
-    return amplitude * np.exp(-((x - mean) ** 2) / (2 * sigma**2)) * y
+def x_cubic_function(x, y, x_amplitude, x_shift):
+    return x_amplitude * (x - x_shift) ** 3
 
 
-def polynomial_function(x, y, a, b, c):
-    return (a * x**2 + b * x + c) * y
+def x_arctan_function(x, y, x_amplitude, x_frequency):
+    return x_amplitude * np.arctan(x_frequency * x)
 
 
-def logarithmic_function(x, y, scale):
-    return scale * np.log(1 + x) * y
+funcx_test_suite = [
+    (
+        x_exponential_function,
+        {"x_amplitude": 2, "x_rate": 5},
+        lambda x, y: 2 * np.exp(5 * x),
+    ),
+    (
+        x_linear_function,
+        {"x_slope": 5, "x_intercept": 0.1},
+        lambda x, y: 5 * x + 0.1,
+    ),
+    (
+        x_cubic_function,
+        {"x_amplitude": 2, "x_shift": 5},
+        lambda x, y: 2 * (x - 5) ** 3,
+    ),
+    (
+        x_arctan_function,
+        {"x_amplitude": 4, "x_frequency": 2},
+        lambda x, y: 4 * np.arctan(2 * x),
+    ),
+]
 
 
-# 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,
-        ),
-    ],
+    funcx_test_suite,
 )
 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_expected = expected_function(x_morph, y_morph)
+    y_morph_expected = y_morph
+    morph = MorphFuncx()
+    morph.funcx_function = function
+    morph.funcx = parameters
     x_morph_actual, y_morph_actual, x_target_actual, y_target_actual = (
         morph.morph(x_morph, y_morph, x_target, y_target)
     )

tests/test_morphfuncxy.py

@@ -1,71 +1,66 @@
 import numpy as np
 import pytest
 
-# from diffpy.morph.morphs.morphfuncxy import MorphFuncxy
-from diffpy.morph.morphs.morphfuncy import MorphFuncy
+from diffpy.morph.morphs.morphfuncxy import MorphFuncxy
 
+from .test_morphfuncx import funcx_test_suite
+from .test_morphfuncy import funcy_test_suite
 
-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
+funcxy_test_suite = []
+for entry_y in funcy_test_suite:
+    for entry_x in funcx_test_suite:
+        funcxy_test_suite.append(
+            (
+                entry_x[0],
+                entry_y[0],
+                entry_x[1],
+                entry_y[1],
+                entry_x[2],
+                entry_y[2],
+            )
+        )
 
 
 # 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,
-        ),
-    ],
+    "funcx_func, funcy_func, funcx_params, funcy_params, "
+    "funcx_lambda, funcy_lambda",
+    funcxy_test_suite,
 )
-def test_funcy(function, parameters, expected_function):
+def test_funcy(
+    funcx_func,
+    funcy_func,
+    funcx_params,
+    funcy_params,
+    funcx_lambda,
+    funcy_lambda,
+):
     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_expected = funcx_lambda(x_morph, y_morph)
+    y_morph_expected = funcy_lambda(x_morph, y_morph)
+
+    funcxy_params = {}
+    funcxy_params.update(funcx_params)
+    funcxy_params.update(funcy_params)
+
+    def funcxy_func(x, y, **funcxy_params):
+        funcx_params = {}
+        funcy_params = {}
+        for param in funcxy_params.keys():
+            if param[:2] == "x_":
+                funcx_params.update({param: funcxy_params[param]})
+            elif param[:2] == "y_":
+                funcy_params.update({param: funcxy_params[param]})
+        return funcx_func(x, y, **funcx_params), funcy_func(
+            x, y, **funcy_params
+        )
+
+    morph = MorphFuncxy()
+    morph.funcxy_function = funcxy_func
+    morph.funcxy = funcxy_params
     x_morph_actual, y_morph_actual, x_target_actual, y_target_actual = (
         morph.morph(x_morph, y_morph, x_target, y_target)
     )

tests/test_morphfuncy.py

@@ -4,55 +4,58 @@
 from diffpy.morph.morphs.morphfuncy import MorphFuncy
 
 
-def sine_function(x, y, amplitude, frequency):
-    return amplitude * np.sin(frequency * x) * y
+def y_sine_function(x, y, y_amplitude, y_frequency):
+    return y_amplitude * np.sin(y_frequency * x) * y
 
 
-def exponential_decay_function(x, y, amplitude, decay_rate):
-    return amplitude * np.exp(-decay_rate * x) * y
+def y_exponential_decay_function(x, y, y_amplitude, y_decay_rate):
+    return y_amplitude * np.exp(-y_decay_rate * x) * y
 
 
-def gaussian_function(x, y, amplitude, mean, sigma):
-    return amplitude * np.exp(-((x - mean) ** 2) / (2 * sigma**2)) * y
+def y_gaussian_function(x, y, y_amplitude, y_mean, y_sigma):
+    return y_amplitude * np.exp(-((x - y_mean) ** 2) / (2 * y_sigma**2)) * y
 
 
-def polynomial_function(x, y, a, b, c):
-    return (a * x**2 + b * x + c) * y
+def y_polynomial_function(x, y, y_a, y_b, y_c):
+    return (y_a * x**2 + y_b * x + y_c) * y
 
 
-def logarithmic_function(x, y, scale):
-    return scale * np.log(1 + x) * y
+def y_logarithmic_function(x, y, y_scale):
+    return y_scale * np.log(1 + x) * y
+
+
+funcy_test_suite = [
+    (
+        y_sine_function,
+        {"y_amplitude": 2, "y_frequency": 5},
+        lambda x, y: 2 * np.sin(5 * x) * y,
+    ),
+    (
+        y_exponential_decay_function,
+        {"y_amplitude": 5, "y_decay_rate": 0.1},
+        lambda x, y: 5 * np.exp(-0.1 * x) * y,
+    ),
+    (
+        y_gaussian_function,
+        {"y_amplitude": 1, "y_mean": 5, "y_sigma": 1},
+        lambda x, y: np.exp(-((x - 5) ** 2) / (2 * 1**2)) * y,
+    ),
+    (
+        y_polynomial_function,
+        {"y_a": 1, "y_b": 2, "y_c": 0},
+        lambda x, y: (x**2 + 2 * x) * y,
+    ),
+    (
+        y_logarithmic_function,
+        {"y_scale": 0.5},
+        lambda x, y: 0.5 * np.log(1 + x) * y,
+    ),
+]
 
 
 @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,
-        ),
-    ],
+    funcy_test_suite,
 )
 def test_funcy(function, parameters, expected_function):
     x_morph = np.linspace(0, 10, 101)