Updated np.float to float throughout to remove deprecation warning

Author: lindonroberts

dfols/hessian.py

@@ -39,7 +39,7 @@ class Hessian(object):
     def __init__(self, n, vals=None):
         self.n = n
         if vals is None:
-            self.hq = np.zeros((n * (n + 1) // 2,), dtype=np.float)
+            self.hq = np.zeros((n * (n + 1) // 2,), dtype=float)
         else:
             assert isinstance(vals, np.ndarray), "Can only set Hessian from NumPy array"
             assert len(vals.shape) in [1, 2], "Can only set Hessian from vector or matrix"

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.float)
+    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.float) if bounds[0] is not None else None
-        xu = bounds[1].astype(np.float) 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_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')