(Issue #291) Add 1D TRSP solver Python test.

This fixes the TRSP solver interface for the outputs.  Note that the MINQ
wrapper had to be updated to satisfy that interface.  As a result, POUNDERS no
longer needs to squeeze the solution vector.

Tests passing.

Author: jared321

pounders/py/create_trsp_solver.py

@@ -40,9 +40,9 @@ def create_trsp_solver(spsolver):
           of the objective function,
         * ``Low`` and ``Upp`` are :math:`\np` element Numpy arrays that specify
           the bound constraints,
-        * ``Xsp`` is the subproblem solution,
+        * ``Xsp`` is the subproblem solution as a 1D Numpy array,
         * ``mdec`` is the value of the subproblem objective function at
-          the solution, and
+          the solution as a real scalar, and
         * ``found_solution`` is True if a solution was found that should be
           acceptable for POUNDERS's purposes; False, otherwise.
     """
@@ -73,6 +73,9 @@ def __minq5_wrapper(H, G, Low, Upp):
             # Assume that solver error checks its arguments thoroughly.
             n = H.shape[0]
             Xsp, mdec, minq_err, _ = minqsw(0, G, H, Low.T, Upp.T, 0, np.zeros((n, 1)))
+            Xsp = np.atleast_1d(np.squeeze(Xsp))
+            mdec = float(np.squeeze(mdec))
+
             # Continuous function restricted to (compact) k-cell.
             assert minq_err != 1
             # TODO: Since we are solving a subproblem, there is likely no sense
@@ -81,7 +84,7 @@ def __minq5_wrapper(H, G, Low, Upp):
             # developers/power users to be able to identify when the budget
             # limit is reached.  Once we have improved logging, print debug
             # messages at high verbosity levels if minq_err == 99?  Since we are
-            # returing a boolean, all logging would have to be done by this
+            # returning a boolean, all logging would have to be done by this
             # wrapper layer.
             # assert minq_err != 99
             return Xsp, mdec, (minq_err >= 0)

pounders/py/pounders.py

@@ -260,11 +260,10 @@ def pounders(Ffun, X_0, n, nf_max, g_tol, delta_0, m, Low, Upp, Prior=None, Opti
         Lows = np.maximum(Low - X[xk_in], -delta * np.ones((np.shape(Low))))
         Upps = np.minimum(Upp - X[xk_in], delta * np.ones((np.shape(Upp))))
         [Xsp, mdec, trsp_flag] = solve_trsp(H, G, Lows, Upps)
-        if trsp_flag < 0:
+        if not trsp_flag:
             X, F, hF, flag = prepare_outputs_before_return(X, F, hF, nf, -4)
             return X, F, hF, flag, xk_in
 
-        Xsp = Xsp.squeeze()
         step_norm = np.linalg.norm(Xsp, np.inf) if n > 1 else np.abs(Xsp)
 
         # 4. Evaluate the function at the new point (provided the model is

pounders/py/tests/TestCreateTrspSolver.py

@@ -2,9 +2,12 @@
 Unit test of create_trsp_solver()
 """
 
+import numbers
 import warnings
 import unittest
 
+import numpy as np
+
 import ibcdfo
 
 
@@ -27,7 +30,28 @@ def testWarnings(self):
                 for each in words:
                     self.assertTrue(each in str(w[0].message))
 
-    def testSuccessful(self):
+    def test1D(self):
+        EPS = np.finfo(float).eps
+
+        # Specify problem
+        G = np.array([-1.1])
+        H = np.atleast_2d([2.2])
+        Low = np.array([-1.9])
+        Upp = np.array([0.9])
+        self.assertTrue(H[0] > 0.0)
+
+        # Known solutions
+        s_expected = 0.5
+        f_expected = -0.275
+
+        too_small = np.array([0.25])
+        s_small = too_small[0]
+        f_small = -0.20625
+
+        too_large = np.array([0.8])
+        s_large = too_large[0]
+        f_large = -0.176
+
         for idx in self.__solvers:
             # Expected emission of warnings tested in testWarnings.  Ignore only those.
             warnings.simplefilter("default")
@@ -38,3 +62,33 @@ def testSuccessful(self):
 
             solve_trsp = ibcdfo.pounders.create_trsp_solver(idx)
             self.assertTrue(callable(solve_trsp))
+
+            # Unconstrained solution in bounds
+            s_0, f_0, was_successful = solve_trsp(H, G, Low, Upp)
+            self.assertTrue(was_successful)
+            self.assertTrue(isinstance(s_0, np.ndarray))
+            self.assertEqual(s_0.ndim, 1)
+            self.assertEqual(len(s_0), 1)
+            self.assertTrue(isinstance(f_0, numbers.Real))
+            self.assertTrue(np.fabs(1.0 - s_0[0] / s_expected) <= 110.0 * EPS)
+            self.assertTrue(np.fabs(1.0 - f_0 / f_expected) <= 110.0 * EPS)
+
+            # Unconstrained solution outside bounds
+            s_0, f_0, was_successful = solve_trsp(H, G, Low, too_small)
+            self.assertTrue(was_successful)
+            self.assertTrue(isinstance(s_0, np.ndarray))
+            self.assertEqual(s_0.ndim, 1)
+            self.assertEqual(len(s_0), 1)
+            self.assertTrue(isinstance(f_0, numbers.Real))
+            self.assertTrue(np.fabs(1.0 - s_0[0] / s_small) <= 110.0 * EPS)
+            self.assertTrue(np.fabs(1.0 - f_0 / f_small) <= 110.0 * EPS)
+
+            if idx != ibcdfo.pounders.constants.TRSP_SOLVER_SIMPLE:
+                # The simple sampler requires that Low <= 0 <= Upp
+                s_0, f_0, was_successful = solve_trsp(H, G, too_large, Upp)
+                self.assertTrue(was_successful)
+                self.assertTrue(isinstance(s_0, np.ndarray))
+                self.assertEqual(s_0.ndim, 1)
+                self.assertTrue(isinstance(f_0, numbers.Real))
+                self.assertTrue(np.fabs(1.0 - s_0 / s_large) <= 110.0 * EPS)
+                self.assertTrue(np.fabs(1.0 - f_0 / f_large) <= 1500.0 * EPS)