Allow 1-sided bounds, deterministic initialisation, keep any feasible x0, remove warnings in tests

Author: lindonroberts

pybobyqa/model.py

@@ -106,7 +106,7 @@ def fopt(self):
     def xpt(self, k, abs_coordinates=False):
         assert 0 <= k < self.npt(), "Invalid index %g" % k
         if not abs_coordinates:
-            return self.points[k, :].copy()
+            return np.minimum(np.maximum(self.sl, self.points[k, :].copy()), self.su)
         else:
             # Apply bounds and convert back to absolute coordinates
             return self.xbase + np.minimum(np.maximum(self.sl, self.points[k, :]), self.su)

pybobyqa/params.py

@@ -39,7 +39,7 @@ def __init__(self, n, npt, maxfun, objfun_has_noise=False, seek_global_minimum=F
         self.params["general.safety_step_thresh"] = 0.5  # safety step called if ||d|| <= thresh * rho
         self.params["general.check_objfun_for_overflow"] = True
         # Initialisation
-        self.params["init.random_initial_directions"] = True
+        self.params["init.random_initial_directions"] = False
         self.params["init.run_in_parallel"] = False  # only available for random directions at the moment
         self.params["init.random_directions_make_orthogonal"] = True  # although random > orthogonal, avoid for init
         # Interpolation

pybobyqa/solver.py

@@ -654,14 +654,18 @@ def solve(objfun, x0, args=(), bounds=None, npt=None, rhobeg=None, rhoend=1e-8,
         assert len(bounds) == 2, "bounds must be a 2-tuple of (lower, upper), where both are arrays of size(x0)"
         xl = bounds[0]
         if type(xl) == list:
-            xl = np.array(xl, dtype=np.float)
+            xl = np.array(xl, dtype=np.float) if xl is not None else None
         else:
-            xl = xl.astype(np.float)
+            xl = xl.astype(np.float) if xl is not None else None
         xu = bounds[1]
         if type(xu) == list:
-            xu = np.array(xu, dtype=np.float)
+            xu = np.array(xu, dtype=np.float) if xu is not None else None
         else:
-            xu = xu.astype(np.float)
+            xu = xu.astype(np.float) if xu is not None else None
+
+    if (xl is None or xu is None) and scaling_within_bounds:
+        scaling_within_bounds = False
+        warnings.warn("Ignoring scaling_within_bounds=True for unconstrained problem/1-sided bounds", RuntimeWarning)
 
     exit_info = None
     if seek_global_minimum and (xl is None or xu is None):
@@ -760,21 +764,11 @@ def solve(objfun, x0, args=(), bounds=None, npt=None, rhobeg=None, rhoend=1e-8,
         return results
 
     # Enforce lower & upper bounds on x0
-    idx = (xl < x0) & (x0 <= xl + rhobeg)
-    if np.any(idx):
-        warnings.warn("x0 too close to lower bound, adjusting", RuntimeWarning)
-    x0[idx] = xl[idx] + rhobeg
-
     idx = (x0 <= xl)
     if np.any(idx):
         warnings.warn("x0 below lower bound, adjusting", RuntimeWarning)
     x0[idx] = xl[idx]
 
-    idx = (xu - rhobeg <= x0) & (x0 < xu)
-    if np.any(idx):
-        warnings.warn("x0 too close to upper bound, adjusting", RuntimeWarning)
-    x0[idx] = xu[idx] - rhobeg
-
     idx = (x0 >= xu)
     if np.any(idx):
         warnings.warn("x0 above upper bound, adjusting", RuntimeWarning)

pybobyqa/tests/test_solver.py

@@ -114,7 +114,7 @@ def runTest(self):
         objfun = lambda x: sumsq(np.dot(A, x) - b)
         gradfun = lambda x: 2.0 * np.dot(A.T, np.dot(A,x)) - 2.0 * np.dot(A.T, b)
         hessfun = 2.0 * np.dot(A.T, A)  # constant Hessian
-        xmin = np.linalg.lstsq(A, b)[0]
+        xmin = np.linalg.lstsq(A, b, rcond=None)[0]
         fmin = objfun(xmin)
         x0 = np.zeros((n,))
         np.random.seed(0)
@@ -135,7 +135,7 @@ def runTest(self):
         objfun = lambda x: sumsq(np.dot(A, x) - b)
         gradfun = lambda x: 2.0 * np.dot(A.T, np.dot(A,x)) - 2.0 * np.dot(A.T, b)
         hessfun = 2.0 * np.dot(A.T, A)  # constant Hessian
-        xmin = np.linalg.lstsq(A, b)[0]
+        xmin = np.linalg.lstsq(A, b, rcond=None)[0]
         fmin = objfun(xmin)
         x0 = np.zeros((n,))
         np.random.seed(0)