Merge branch 'master' into master

Author: lindonroberts

.travis.yml

@@ -5,12 +5,14 @@ python:
   - "3.6"
   - "3.7"
   - "3.8"
+  - "3.9"
 
 install:
   - sudo apt-get install gfortran
   - pip install -r requirements.txt
+  - pip install --upgrade numpy  # some SciPy and pandas versions require newer NumPy
   - python setup.py build
 
 script:
   - pip install nose
-  - python setup.py test
+  - nosetests -v

dfols/solver.py

@@ -852,7 +852,7 @@ def solve_main(objfun, x0, args, xl, xu, npt, rhobeg, rhoend, maxfun, nruns_so_f
 
 def solve(objfun, x0, args=(), bounds=None, npt=None, rhobeg=None, rhoend=1e-8, maxfun=None, nsamples=None, user_params=None,
           objfun_has_noise=False, scaling_within_bounds=False, do_logging=True, print_progress=False):
-    x0 = x0.astype(np.float64)
+    x0 = x0.astype(float)
     n = len(x0)
 
     # Set missing inputs (if not specified) to some sensible defaults
@@ -861,8 +861,8 @@ def solve(objfun, x0, args=(), bounds=None, npt=None, rhobeg=None, rhoend=1e-8,
         xu = None
     else:
         assert len(bounds) == 2, "bounds must be a 2-tuple of (lower, upper), where both are arrays of size(x0)"
-        xl = bounds[0].astype(np.float64) if bounds[0] is not None else None
-        xu = bounds[1].astype(np.float64) if bounds[1] is not None else None
+        xl = bounds[0].astype(float) if bounds[0] is not None else None
+        xu = bounds[1].astype(float) if bounds[1] is not None else None
 
     if (xl is None or xu is None) and scaling_within_bounds:
         scaling_within_bounds = False

dfols/tests/test_hessian.py

@@ -48,7 +48,7 @@ class TestInitFromVector(unittest.TestCase):
     def runTest(self):
         n = 5
         nvals = n*(n+1)//2
-        x = np.arange(nvals, dtype=np.float)
+        x = np.arange(nvals, dtype=float)
         hess = Hessian(n, vals=x)
         self.assertEqual(hess.shape(), (nvals,), 'Wrong shape for initialisation')
         self.assertEqual(hess.dim(), n, 'Wrong dimension')
@@ -60,7 +60,7 @@ class TestInitFromMatrix(unittest.TestCase):
     def runTest(self):
         n = 3
         nvals = n*(n+1)//2
-        A = np.arange(n**2, dtype=np.float).reshape((n,n))
+        A = np.arange(n**2, dtype=float).reshape((n,n))
         hess = Hessian(n, vals=A+A.T)  # force symmetric
         self.assertEqual(hess.shape(), (nvals,), 'Wrong shape for initialisation')
         self.assertEqual(hess.dim(), n, 'Wrong dimension')
@@ -72,7 +72,7 @@ def runTest(self):
 class TestToFull(unittest.TestCase):
     def runTest(self):
         n = 7
-        A = np.arange(n ** 2, dtype=np.float).reshape((n, n))
+        A = np.arange(n ** 2, dtype=float).reshape((n, n))
         H = A + A.T  # force symmetric
         hess = Hessian(n, vals=H)
         self.assertTrue(np.all(hess.as_full() == H), 'Wrong values')
@@ -81,7 +81,7 @@ def runTest(self):
 class TestGetElementGood(unittest.TestCase):
     def runTest(self):
         n = 3
-        A = np.arange(n ** 2, dtype=np.float).reshape((n, n))
+        A = np.arange(n ** 2, dtype=float).reshape((n, n))
         H = A + A.T  # force symmetric
         hess = Hessian(n, vals=H)
         for i in range(n):
@@ -93,7 +93,7 @@ def runTest(self):
 class TestGetElementBad(unittest.TestCase):
     def runTest(self):
         n = 4
-        A = np.arange(n ** 2, dtype=np.float).reshape((n, n))
+        A = np.arange(n ** 2, dtype=float).reshape((n, n))
         H = A + A.T  # force symmetric
         hess = Hessian(n, vals=H)
         # When testing for assertion errors, need lambda to stop assertion from actually happening
@@ -114,7 +114,7 @@ def runTest(self):
 class TestSetElementGood(unittest.TestCase):
     def runTest(self):
         n = 3
-        A = np.arange(n ** 2, dtype=np.float).reshape((n, n))
+        A = np.arange(n ** 2, dtype=float).reshape((n, n))
         H = A + A.T  # force symmetric
         hess = Hessian(n, vals=H)
         H2 = np.sin(H)
@@ -130,7 +130,7 @@ def runTest(self):
 class TestSetElementBad(unittest.TestCase):
     def runTest(self):
         n = 5
-        A = np.arange(n ** 2, dtype=np.float).reshape((n, n))
+        A = np.arange(n ** 2, dtype=float).reshape((n, n))
         H = A + A.T  # force symmetric
         hess = Hessian(n, vals=H)
         # When testing for assertion errors, need lambda to stop assertion from actually happening
@@ -151,23 +151,23 @@ def runTest(self):
 class TestMultGood(unittest.TestCase):
     def runTest(self):
         n = 5
-        A = np.arange(n ** 2, dtype=np.float).reshape((n, n))
+        A = np.arange(n ** 2, dtype=float).reshape((n, n))
         H = np.sin(A + A.T)  # force symmetric
         hess = Hessian(n, vals=H)
-        vec = np.exp(np.arange(n, dtype=np.float))
+        vec = np.exp(np.arange(n, dtype=float))
         hs = np.dot(H, vec)
         self.assertTrue(array_compare(hess*vec, hs, thresh=1e-12), 'Wrong values')
 
 
 class TestMultBad(unittest.TestCase):
     def runTest(self):
         n = 5
-        A = np.arange(n ** 2, dtype=np.float).reshape((n, n))
+        A = np.arange(n ** 2, dtype=float).reshape((n, n))
         H = A + A.T  # force symmetric
         hess = Hessian(n, vals=H)
         # When testing for assertion errors, need lambda to stop assertion from actually happening
         self.assertRaises(AssertionError, lambda: hess * 1.0)
         self.assertRaises(AssertionError, lambda: hess * None)
         self.assertRaises(AssertionError, lambda: hess * [float(i) for i in range(n)])
-        self.assertRaises(AssertionError, lambda: hess * np.arange(n-1, dtype=np.float))
-        self.assertRaises(AssertionError, lambda: hess * np.arange(n+1, dtype=np.float))
+        self.assertRaises(AssertionError, lambda: hess * np.arange(n-1, dtype=float))
+        self.assertRaises(AssertionError, lambda: hess * np.arange(n+1, dtype=float))

dfols/tests/test_solver.py

@@ -168,6 +168,6 @@ def runTest(self):
         self.assertTrue(array_compare(soln.resid, objfun(soln.x), thresh=1e-10), "Wrong resid")
         print(soln.jacobian)
         print(jac(soln.x))
-        self.assertTrue(array_compare(soln.jacobian, jac(soln.x), thresh=1e-2), "Wrong Jacobian")
+        self.assertTrue(array_compare(soln.jacobian, jac(soln.x), thresh=1e-1), "Wrong Jacobian")
         self.assertTrue(abs(soln.f) < 1e-10, "Wrong fmin")
 

dfols/tests/test_trust_region.py

@@ -89,7 +89,7 @@ def runTest(self):
         # self.assertAlmostEqual(est_min, true_min, 'Wrong min value')
         s_cauchy, red_cauchy, crvmin_cauchy = cauchy_pt(g, H, Delta)
         self.assertTrue(est_min <= red_cauchy, 'Cauchy reduction not achieved')
-        self.assertTrue(np.all(gnew == g + H.dot(d)), 'Wrong gnew')
+        self.assertTrue(np.allclose(gnew, g + H.dot(d)), 'Wrong gnew')
         print(crvmin)
         self.assertAlmostEqual(crvmin, 1.2, 'Wrong crvmin')
 
@@ -112,7 +112,7 @@ def runTest(self):
         # self.assertAlmostEqual(est_min, true_min, 'Wrong min value')
         s_cauchy, red_cauchy, crvmin_cauchy = cauchy_pt(g, H, Delta)
         self.assertTrue(est_min <= red_cauchy, 'Cauchy reduction not achieved')
-        self.assertTrue(np.all(gnew == g + H.dot(d)), 'Wrong gnew')
+        self.assertTrue(np.allclose(gnew, g + H.dot(d)), 'Wrong gnew')
         self.assertAlmostEqual(crvmin, 0.0, 'Wrong crvmin')
 
 
@@ -134,7 +134,7 @@ def runTest(self):
         # self.assertAlmostEqual(est_min, true_min, 'Wrong min value')
         s_cauchy, red_cauchy, crvmin_cauchy = cauchy_pt(g, H, Delta)
         self.assertTrue(est_min <= red_cauchy, 'Cauchy reduction not achieved')
-        self.assertTrue(np.all(gnew == g + H.dot(d)), 'Wrong gnew')
+        self.assertTrue(np.allclose(gnew, g + H.dot(d)), 'Wrong gnew')
         self.assertAlmostEqual(crvmin, 0.0, 'Wrong crvmin')
 
 
@@ -156,7 +156,7 @@ def runTest(self):
         # self.assertAlmostEqual(est_min, true_min, 'Wrong min value')
         s_cauchy, red_cauchy, crvmin_cauchy = cauchy_pt(g, H, Delta)
         self.assertTrue(est_min <= red_cauchy, 'Cauchy reduction not achieved')
-        self.assertTrue(np.all(gnew == g + H.dot(d)), 'Wrong gnew')
+        self.assertTrue(np.allclose(gnew, g + H.dot(d)), 'Wrong gnew')
         self.assertAlmostEqual(crvmin, 0.0, 'Wrong crvmin')
         # self.assertAlmostEqual(crvmin, crvmin_cauchy, 'Wrong crvmin')
 
@@ -179,7 +179,7 @@ def runTest(self):
         # self.assertAlmostEqual(est_min, true_min, 'Wrong min value')
         s_cauchy, red_cauchy, crvmin_cauchy = cauchy_pt(g, H, Delta)
         self.assertTrue(est_min <= red_cauchy, 'Cauchy reduction not achieved')
-        self.assertTrue(np.all(gnew == g + H.dot(d)), 'Wrong gnew')
+        self.assertTrue(np.allclose(gnew, g + H.dot(d)), 'Wrong gnew')
         self.assertAlmostEqual(crvmin, 0.0, 'Wrong crvmin')
 
 
@@ -203,7 +203,7 @@ def runTest(self):
         # print(s_cauchy)
         # print(d)
         self.assertTrue(est_min <= red_cauchy, 'Cauchy reduction not achieved')
-        self.assertTrue(np.all(gnew == g + H.dot(d)), 'Wrong gnew')
+        self.assertTrue(np.allclose(gnew, g + H.dot(d)), 'Wrong gnew')
         print(crvmin)
         self.assertAlmostEqual(crvmin, -1.0, 'Wrong crvmin')
 

dfols/tests/test_util.py

@@ -53,10 +53,10 @@ def runTest(self):
 class TestModelValue(unittest.TestCase):
     def runTest(self):
         n = 5
-        A = np.arange(n ** 2, dtype=np.float).reshape((n, n))
+        A = np.arange(n ** 2, dtype=float).reshape((n, n))
         H = np.sin(A + A.T)  # force symmetric
-        vec = np.exp(np.arange(n, dtype=np.float))
-        g = np.cos(3*np.arange(n, dtype=np.float) - 2.0)
+        vec = np.exp(np.arange(n, dtype=float))
+        g = np.cos(3*np.arange(n, dtype=float) - 2.0)
         mval = np.dot(g, vec) + 0.5 * np.dot(vec, np.dot(H, vec))
         self.assertAlmostEqual(mval, model_value(g, H, vec), msg='Wrong value')
 

docs/advanced.rst

@@ -107,5 +107,5 @@ References
 ----------
 
 .. [CFMR2018]   
-   C. Cartis, J. Fiala, B. Marteau and L. Roberts, `Improving the Flexibility and Robustness of Model-Based Derivative-Free Optimization Solvers <https://arxiv.org/abs/1804.00154>`_, technical report, University of Oxford, (2018).
+   Coralia Cartis, Jan Fiala, Benjamin Marteau and Lindon Roberts, `Improving the Flexibility and Robustness of Model-Based Derivative-Free Optimization Solvers <https://doi.org/10.1145/3338517>`_, *ACM Transactions on Mathematical Software*, 45:3 (2019), pp. 32:1-32:41 [`preprint <https://arxiv.org/abs/1804.00154>`_]