Update: further test functions

Author: heptaflar

test/retrieve/oe/test_oe_jax.py

@@ -2,46 +2,132 @@
 #  License: MIT
 
 import unittest
+from typing import Literal
 
 import numpy as np
 
-from uncertaintyx.f.jax import ToF
+from uncertaintyx.f.jax import Cigar
+from uncertaintyx.f.jax import DifferentPowers
+from uncertaintyx.f.jax import Ellipsoid
+from uncertaintyx.f.jax import Rosenbrock
+from uncertaintyx.f.jax import Sphere
+from uncertaintyx.f.jax import Tablet
 from uncertaintyx.retrieve.oe.jax import OE
 
 
-class Parabola(ToF):
-    """The parabolic test function."""
+class OptimalEstimationTest(unittest.TestCase):
+    """
+    Tests optimal estimation.
+    """
 
-    def __init__(self):
-        def f(x):
-            """The test function."""
-            return x * x
+    def setUp(self):
+        self.rng = np.random.default_rng(5489)
+        self.M = 50
+        self.m = 10
 
-        super().__init__(f)
+    def test_sphere(self):
+        """The sphere function has a unique minimum at zero."""
+        f = Sphere()
 
+        x = np.square(self.fuzzy(1.0, "x"))
+        y = np.square(self.fuzzy(0.0, "y"))
+        result = OE().retrieve(f, x, y)
 
-class OptimalEstimationTest(unittest.TestCase):
-    """
-    Tests EIV regression.
-    """
+        self.assertTrue(np.all(result.info == 0))
+        self.assertTrue(np.allclose(f.eval(result.xopt), y))
+        self.assertTrue(np.all(np.isfinite(result.xcov)))
+        self.assertTrue(np.all(np.isfinite(result.xunc)))
+        self.assertTrue(np.allclose(result.zvar, 0.0))
+        self.assertTrue(np.allclose(result.cost, 0.0))
+
+    def test_ellipsoid(self):
+        """The ellipsoid function has a unique minimum at zero."""
+        f = Ellipsoid()
 
-    def test_parabola(self):
+        x = self.fuzzy(1.0, "x")
+        y = self.sharp(0.0, "y")
+        result = OE().retrieve(f, x, y)
+
+        self.assertTrue(np.all(result.info == 0))
+        self.assertTrue(np.allclose(result.xopt, 0.0))
+        self.assertTrue(np.all(np.isfinite(result.xcov)))
+        self.assertTrue(np.all(np.isfinite(result.xunc)))
+        self.assertTrue(np.allclose(result.zvar, 0.0))
+        self.assertTrue(np.allclose(result.cost, 0.0))
+
+    def test_cigar(self):
+        """The cigar function has a unique minimum at zero."""
+        f = Cigar()
+
+        x = self.fuzzy(1.0, "x")
+        y = self.sharp(0.0, "y")
+        result = OE().retrieve(f, x, y)
+
+        self.assertTrue(np.all(result.info == 0))
+        self.assertTrue(np.allclose(result.xopt, 0.0))
+        self.assertTrue(np.all(np.isfinite(result.xcov)))
+        self.assertTrue(np.all(np.isfinite(result.xunc)))
+        self.assertTrue(np.allclose(result.zvar, 0.0))
+        self.assertTrue(np.allclose(result.cost, 0.0))
+
+    def test_tablet(self):
+        """The tablet function has a unique minimum at zero."""
+        f = Tablet()
+
+        x = self.fuzzy(1.0, "x")
+        y = self.sharp(0.0, "y")
+        result = OE().retrieve(f, x, y)
+
+        self.assertTrue(np.all(result.info == 0))
+        self.assertTrue(np.allclose(result.xopt, 0.0))
+        self.assertTrue(np.all(np.isfinite(result.xcov)))
+        self.assertTrue(np.all(np.isfinite(result.xunc)))
+        self.assertTrue(np.allclose(result.zvar, 0.0))
+        self.assertTrue(np.allclose(result.cost, 0.0))
+
+    def test_rosenbrock(self):
         """
-        Tests the EIV retrieval with a simple parabolic test function.
+        The Rosenbrock function has a global and a local minimum. The
+        minimization uses initial values biased toward the global minimum
+        to establish an unambiguous test condition.
         """
-        n = 100
+        f = Rosenbrock()
 
-        x = np.ones((n, 1))
-        y = np.zeros((n, 1))
-        result = OE().retrieve(Parabola(), x, y)
+        x = self.fuzzy(3.0, "x")
+        y = self.sharp(0.0, "y")
+        result = OE().retrieve(f, x, y)
 
         self.assertTrue(np.all(result.info == 0))
-        self.assertTrue(np.allclose(result.xopt, 0.0))
-        self.assertTrue(np.allclose(result.xcov, 0.0))
-        self.assertTrue(np.allclose(result.xunc, 0.0))
+        self.assertTrue(np.allclose(result.xopt, 1.0))
+        self.assertTrue(np.all(np.isfinite(result.xcov)))
+        self.assertTrue(np.all(np.isfinite(result.xunc)))
         self.assertTrue(np.allclose(result.zvar, 0.0))
         self.assertTrue(np.allclose(result.cost, 0.0))
 
+    def test_different_powers(self):
+        """
+        The different power function has a unique minimum at zero.
+        Only the value of the cost function is tested, since the
+        problem is badly scaled.
+        """
+        f = DifferentPowers()
+
+        x = self.fuzzy(1.0, "x")
+        y = self.sharp(0.0, "y")
+        result = OE().retrieve(f, x, y)
+
+        self.assertTrue(np.allclose(result.cost, 0.0))
+
+    def fuzzy(self, val, role: Literal["x", "y"]) -> np.ndarray:
+        """Returns an array filled with fuzzy values."""
+        return self.rng.normal(
+            val, 1.0, (self.M, self.m) if role == "x" else (self.M,)
+        )
+
+    def sharp(self, val, role: Literal["x", "y"]) -> np.ndarray:
+        """Returns an array filled with sharp values."""
+        return np.full((self.M, self.m) if role == "x" else (self.M,), val)
+
 
 if __name__ == "__main__":
     unittest.main()

uncertaintyx/f/jax.py

@@ -168,3 +168,109 @@ def lpu(
     @property
     def f(self) -> Callable[[Array], Array]:
         return self._f
+
+
+class Sphere(ToF):
+    """
+    A test function.
+
+    The test function has a global minimum at zero.
+    """
+
+    def __init__(self):
+        def f(x):
+            """The test function."""
+            return jnp.sum(jnp.square(x))
+
+        super().__init__(f)
+
+
+class Ellipsoid(ToF):
+    """
+    A test function.
+
+    The test function has a global minimum at zero.
+    All axes are scaled differently.
+    """
+
+    def __init__(self):
+        def f(x):
+            """The test function."""
+            m = x.size
+            p = jnp.pow(1.0e06, jnp.arange(0, m) / (m - 1))
+            return jnp.sum(p * jnp.square(x))
+
+        super().__init__(f)
+
+
+class Cigar(ToF):
+    """
+    A test function.
+
+    The test function has a global minimum at zero.
+    All but one axes are scaled extremely.
+    """
+
+    def __init__(self):
+        def f(x):
+            """The test function."""
+            a = jnp.sum(jnp.square(x[:1]))
+            b = jnp.sum(jnp.square(x[1:]))
+            return a + 1.0e06 * b
+
+        super().__init__(f)
+
+
+class Tablet(ToF):
+    """
+    A test function.
+
+    The test function has a global minimum at zero.
+    One axis is scaled extremely.
+    """
+
+    def __init__(self):
+        def f(x):
+            """The test function."""
+            a = jnp.sum(jnp.square(x[:1]))
+            b = jnp.sum(jnp.square(x[1:]))
+            return 1.0e06 * a + b
+
+        super().__init__(f)
+
+
+class Rosenbrock(ToF):
+    """
+    The Rosenbrock test function.
+
+    The Rosenbrock function has a global and a local minimum.
+    """
+
+    def __init__(self):
+        def f(x):
+            """The Rosenbrock test function."""
+            a = jnp.square(x[1:] - jnp.square(x[:-1]))
+            b = jnp.square(1.0 - x[:-1])
+            return jnp.sum(100.0 * a + b)
+
+        super().__init__(f)
+
+
+class DifferentPowers(ToF):
+    """
+    A test function.
+
+    The test function has a global minimum at zero.
+    Axes are badly scaled.
+    """
+
+    def __init__(self):
+        def f(x):
+            """The test function."""
+            m = x.size
+            p = jnp.pow(
+                jnp.square(x), 1.0 + (5.0 * jnp.arange(0, m)) / (m - 1)
+            )
+            return jnp.sum(p)
+
+        super().__init__(f)