def test_problem_HS51(self): def f(x): y = (x[0] - x[1])**2 + (x[0] + x[2] - 2.)**2 + \ (x[3] - 1.)**2 + (x[4] - 1.)**2 eval_success = True return y, eval_success A = np.array([[1., 3., 0., 0., 0.], [0., 0., 1., 1., -2.], [0., 1., 0., 0., -1.]]) l = np.array([4., 0., 0.]) u = np.array([4., 0., 0.]) bl = np.array([-np.inf, -np.inf, -np.inf, -np.inf, -np.inf]) bu = np.array([np.inf, np.inf, np.inf, np.inf, np.inf]) n = 5 x0 = np.array([2.5, 0.5, 2., -1., 0.5]) xc = np.array([1., 1., 1., 1., 1.]) yc = 0. x1, y1, iterations, alpha, evaluations, history, exit_cause = \ psifa(f, x0, A, l, u, n, bl, bu, max_evals=2000, prec1=1e-8) self.assertTrue( np.allclose(x1, xc) or np.isclose(y1, yc) or np.allclose(xc, x1) or np.isclose(yc, y1) or y1 < yc) self.assertTrue(iterations <= 71) self.assertTrue(evaluations <= 302) self.assertTrue('VF' in exit_cause)
def test_problem_HS45(self): def f(x): y = 2. - (1. / 120.) * x[0] * x[1] * x[2] * x[3] * x[4] eval_success = True return y, eval_success A = np.array([]) l = np.array([]) u = np.array([]) bl = np.array([0., 0., 0., 0., 0.]) bu = np.array([1., 2., 3., 4., 5.]) n = 5 x0 = np.array([0., 1., 2., 3., 4.]) xc = np.array([1., 2., 3., 4., 5.]) yc = 1. x1, y1, iterations, alpha, evaluations, history, exit_cause = \ psifa(f, x0, A, l, u, n, bl, bu, max_evals=2000, prec1=1e-8) self.assertTrue( np.allclose(x1, xc) or np.isclose(y1, yc) or np.allclose(xc, x1) or np.isclose(yc, y1) or y1 < yc) self.assertTrue(iterations <= 16) self.assertTrue(evaluations <= 259) self.assertTrue('TP' in exit_cause)
def test_problem_HS09(self): def f(x): y = np.sin(np.pi * x[0] / 12.) * np.cos(np.pi * x[1] / 16.) eval_success = True return y, eval_success A = np.array([[4., -3.]]) l = np.array([0.]) u = np.array([0.]) bl = np.array([-np.inf, -np.inf]) bu = np.array([np.inf, np.inf]) n = 2 x0 = np.array([0., 0.]) xc = np.array([-3., -4.]) yc = -0.5 x1, y1, iterations, alpha, evaluations, history, exit_cause = \ psifa(f, x0, A, l, u, n, bl, bu, max_evals=2000, prec1=1e-8) self.assertTrue( np.allclose(x1, xc) or np.isclose(y1, yc) or np.allclose(xc, x1) or np.isclose(yc, y1) or y1 < yc) self.assertTrue(iterations <= 14) self.assertTrue(evaluations <= 50) self.assertTrue('VF' in exit_cause)
def test_problem_HS76(self): def f(x): y = x[0]**2 + 0.5 * x[1]**2 + x[2]**2 + 0.5 * x[3]**2 - \ x[0] * x[2] - x[2] * x[3] - x[0] - 3. * x[1] + x[2] - x[3] eval_success = True return y, eval_success A = np.array([[-1., -2., -1., -1.], [-3., -1., -2., 1.], [0., 1., 4., 0.]]) l = np.array([-5., -4., 1.5]) u = np.array([np.inf, np.inf, np.inf]) bl = np.array([0., 0., 0., 0.]) bu = np.array([np.inf, np.inf, np.inf, np.inf]) n = 4 x0 = np.array([0.5, 0.5, 0.5, 0.5]) # xc = np.array([0.2727273, 2.090909, 0.26e-10, 0.5454545]) # yc = -4.681818090904359 xc = np.array([0.47114044, 2.08220996, 0., 0.36443964]) yc = -4.62602936 x1, y1, iterations, alpha, evaluations, history, exit_cause = \ psifa(f, x0, A, l, u, n, bl, bu, max_evals=2000, prec1=1e-8) self.assertTrue( np.allclose(x1, xc) or np.isclose(y1, yc) or np.allclose(xc, x1) or np.isclose(yc, y1) or y1 < yc) # fail # self.assertTrue(iterations <= 16) # fail # self.assertTrue(evaluations <= 165) # fail self.assertTrue('TP' in exit_cause)
def test_problem_HS44(self): def f(x): y = x[0] - x[1] - x[2] - x[0] * x[2] + \ x[0] * x[3] + x[1] * x[2] - x[1] * x[3] eval_success = True return y, eval_success A = np.array([[-1., -2., 0., 0.], [-4., -1., 0., 0.], [-3., -4., 0., 0.], [0., 0., -2., -1.], [0., 0., -1., -2.], [0., 0., -1., -1.]]) l = np.array([-8., -12., -12., -8., -8., -5.]) u = np.array([np.inf, np.inf, np.inf, np.inf, np.inf, np.inf]) bl = np.array([0., 0., 0., 0.]) bu = np.array([np.inf, np.inf, np.inf, np.inf]) n = 4 x0 = np.array([0., 0., 0., 0.]) xc = np.array([0., 3., 0., 4.]) yc = -15. x1, y1, iterations, alpha, evaluations, history, exit_cause = \ psifa(f, x0, A, l, u, n, bl, bu, max_evals=2000, prec1=1e-8) self.assertTrue( np.allclose(x1, xc) or np.isclose(y1, yc) or np.allclose(xc, x1) or np.isclose(yc, y1) or y1 < yc) self.assertTrue(iterations <= 12) # self.assertTrue(evaluations <= 154) # fail self.assertTrue('TP' in exit_cause)
def test_problem_HS04(self): def f(x): y = 1. / 3. * (x[0] + 1.)**3 + x[1] eval_success = True return y, eval_success A = np.array([]) l = np.array([]) u = np.array([]) bl = np.array([1., 0.]) bu = np.array([np.inf, np.inf]) n = 2 x0 = np.array([1.125, 0.125]) xc = np.array([1., 0.]) yc = 8. / 3. x1, y1, iterations, alpha, evaluations, history, exit_cause = \ psifa(f, x0, A, l, u, n, bl, bu, max_evals=2000, prec1=1e-8) self.assertTrue( np.allclose(x1, xc) or np.isclose(y1, yc) or np.allclose(xc, x1) or np.isclose(yc, y1) or y1 < yc) self.assertTrue(iterations <= 12) self.assertTrue(evaluations <= 105) self.assertTrue('TP' in exit_cause)
def test_problem_HS55(self): def f(x): y = x[0] + 2. * x[1] + 4. * x[4] + np.exp(x[0] * x[3]) eval_success = True return y, eval_success A = np.array([[1., 2., 0., 0., 5., 0.], [1., 1., 1., 0., 0., 0.], [0., 0., 0., 1., 1., 1.], [1., 0., 0., 1., 0., 0.], [0., 1., 0., 0., 1., 0.], [0., 0., 1., 0., 0., 1.]]) l = np.array([6., 3., 2., 1., 2., 2.]) u = np.array([6., 3., 2., 1., 2., 2.]) bl = np.array([0., 0., 0., 0., 0., 0.]) bu = np.array([1., np.inf, np.inf, 1., np.inf, np.inf]) n = 6 x0 = np.array([ 0.447794849394555, 1.482598283131551, 1.069606867473851, 0.552205150605459, 0.517401716868434, 0.930393132526135 ]) xc = np.array([0., 4. / 3., 5. / 3., 1., 2. / 3., 1. / 3.]) yc = 19. / 3. x1, y1, iterations, alpha, evaluations, history, exit_cause = \ psifa(f, x0, A, l, u, n, bl, bu, max_evals=2000, prec1=1e-8) self.assertTrue( np.allclose(x1, xc) or np.isclose(y1, yc) or np.allclose(xc, x1) or np.isclose(yc, y1) or y1 < yc) self.assertTrue(iterations <= 10) self.assertTrue(evaluations <= 41) self.assertTrue('TP' in exit_cause)
def test_problem_HS36(self): def f(x): y = -x[0] * x[1] * x[2] eval_success = True return y, eval_success A = np.array([[-1., -2., -2.]]) l = np.array([-72.]) u = np.array([np.inf]) bl = np.array([0., 0., 0.]) bu = np.array([20., 11., 42.]) n = 3 x0 = np.array([10., 10., 10.]) # xc = np.array([20., 11., 15.]) # yc = -3300. xc = np.array([17.28, 11., 16.36]) yc = -3109.71 x1, y1, iterations, alpha, evaluations, history, exit_cause = \ psifa(f, x0, A, l, u, n, bl, bu, max_evals=2000, prec1=1e-8) self.assertTrue( np.allclose(x1, xc) or np.isclose(y1, yc) or np.allclose(xc, x1) or np.isclose(yc, y1) or y1 < yc) self.assertTrue(iterations <= 21) # self.assertTrue(evaluations <= 201) # fail self.assertTrue('TP' in exit_cause)
def test_problem_HS37(self): def f(x): y = -x[0] * x[1] * x[2] eval_success = True return y, eval_success A = np.array([[-1., -2., -2.], [1., 2., 2.]]) l = np.array([-72., 0.]) u = np.array([np.inf, np.inf]) bl = np.array([0., 0., 0.]) bu = np.array([42., 42., 42.]) n = 3 x0 = np.array([10., 10., 10.]) xc = np.array( [24.000130885714569, 11.999993260028832, 11.999941297113882]) yc = -3456. x1, y1, iterations, alpha, evaluations, history, exit_cause = \ psifa(f, x0, A, l, u, n, bl, bu, max_evals=2000, prec1=1e-8) self.assertTrue( np.allclose(x1, xc) or np.isclose(y1, yc) or np.allclose(xc, x1) or np.isclose(yc, y1) or y1 < yc) self.assertTrue(iterations <= 47) self.assertTrue(evaluations <= 289) self.assertTrue('VF' in exit_cause)
def test_problem_HS28(self): def f(x): y = (x[0] + x[1])**2 + (x[1] + x[2])**2 eval_success = True return y, eval_success A = np.array([[1., 2., 3.]]) l = np.array([1.]) u = np.array([1.]) bl = np.array([-np.inf, -np.inf, -np.inf]) bu = np.array([np.inf, np.inf, np.inf]) n = 3 x0 = np.array([-4., 1., 1.]) xc = np.array([0.5, -0.5, 0.5]) yc = 0. x1, y1, iterations, alpha, evaluations, history, exit_cause = \ psifa(f, x0, A, l, u, n, bl, bu, max_evals=2000, prec1=1e-8) self.assertTrue( np.allclose(x1, xc) or np.isclose(y1, yc) or np.allclose(xc, x1) or np.isclose(yc, y1) or y1 < yc) # fail # self.assertTrue(iterations <= 94) # fail self.assertTrue(evaluations <= 672) self.assertTrue('VF' in exit_cause)
def test_problem_HS35(self): def f(x): y = 9. - 8. * x[0] - 6. * x[1] - 4. * x[2] + 2. * x[0]**2 + \ 2. * x[1]**2 + x[2]**2 + 2. * x[0] * x[1] + 2. * x[0] * x[2] eval_success = True return y, eval_success A = np.array([[-1., -1., -2.]]) l = np.array([-3.]) u = np.array([np.inf]) bl = np.array([0., 0., 0.]) bu = np.array([np.inf, np.inf, np.inf]) n = 3 x0 = np.array([0.5, 0.5, 0.5]) xc = np.array([4. / 3., 7. / 9., 4. / 9.]) yc = 1. / 9. x1, y1, iterations, alpha, evaluations, history, exit_cause = \ psifa(f, x0, A, l, u, n, bl, bu, max_evals=2000, prec1=1e-8) self.assertTrue( np.allclose(x1, xc) or np.isclose(y1, yc) or np.allclose(xc, x1) or np.isclose(yc, y1) or y1 < yc) self.assertTrue(iterations <= 67) self.assertTrue(evaluations <= 336) self.assertTrue('VF' in exit_cause)
def test_problem_HS25(self): def f(x): y = 0. for i in range(1, 100): a = 25. + (-50. * np.log(0.01 * i))**(2. / 3.) b = -0.01 * i + np.exp((-1. / x[0]) * (a - x[1])**x[2]) y += b**2 eval_success = True return y, eval_success A = np.array([]) l = np.array([]) u = np.array([]) bl = np.array([0.1, 0., 0.]) bu = np.array([100., 25.6, 5.]) n = 3 x0 = np.array([100., 12.5, 3.]) # xc = np.array([50., 25., 1.5]) # yc = 0. xc = np.array([92.7664, 23.9537, 1.6871]) yc = 0.0048065 x1, y1, iterations, alpha, evaluations, history, exit_cause = \ psifa(f, x0, A, l, u, n, bl, bu, max_evals=2000, prec1=1e-8) self.assertTrue( np.allclose(x1, xc) or np.isclose(y1, yc) or np.allclose(xc, x1) or np.isclose(yc, y1) or y1 < yc) # fail self.assertTrue(iterations <= 157) self.assertTrue(evaluations <= 2008) self.assertTrue('AF' in exit_cause)
def test_problem_HS24(self): def f(x): y = (1. / (27. * np.sqrt(3.))) * ((x[0] - 3.)**2 - 9.) * x[1]**3 eval_success = True return y, eval_success A = np.array([[1. / np.sqrt(3.), -1.], [1., np.sqrt(3.)], [-1., -np.sqrt(3.)]]) l = np.array([0., 0., -6.]) u = np.array([np.inf, np.inf, np.inf]) bl = np.array([0., 0.]) bu = np.array([np.inf, np.inf]) n = 2 x0 = np.array([1., 0.5]) xc = np.array([3., np.sqrt(3.)]) yc = -1. x1, y1, iterations, alpha, evaluations, history, exit_cause = \ psifa(f, x0, A, l, u, n, bl, bu, max_evals=2000, prec1=1e-8) self.assertTrue( np.allclose(x1, xc) or np.isclose(y1, yc) or np.allclose(xc, x1) or np.isclose(yc, y1) or y1 < yc) self.assertTrue(iterations <= 17) self.assertTrue(evaluations <= 112) self.assertTrue('TP' in exit_cause)
def test_problem_HS21(self): def f(x): y = 0.01 * x[0]**2 + x[1]**2 - 100. eval_success = True return y, eval_success A = np.array([[10., -1.]]) l = np.array([10.]) u = np.array([np.inf]) bl = np.array([2., -50.]) bu = np.array([50., 50.]) n = 2 x0 = np.array([2., 2.]) xc = np.array([2., 0.]) yc = -99.96 x1, y1, iterations, alpha, evaluations, history, exit_cause = \ psifa(f, x0, A, l, u, n, bl, bu, max_evals=2000, prec1=1e-8) self.assertTrue( np.allclose(x1, xc) or np.isclose(y1, yc) or np.allclose(xc, x1) or np.isclose(yc, y1) or y1 < yc) self.assertTrue(iterations <= 18) self.assertTrue(evaluations <= 179) self.assertTrue('VF' in exit_cause)
def test_problem_HS52(self): def f(x): y = (4. * x[0] - x[1])**2 + (x[1] + x[2] - 2.)**2 + \ (x[3] - 1.)**2 + (x[4] - 1.)**2 eval_success = True return y, eval_success A = np.array([[1., 3., 0., 0., 0.], [0., 0., 1., 1., -2.], [0., 1., 0., 0., -1.]]) l = np.array([0., 0., 0.]) u = np.array([0., 0., 0.]) bl = np.array([-np.inf, -np.inf, -np.inf, -np.inf, -np.inf]) bu = np.array([np.inf, np.inf, np.inf, np.inf, np.inf]) n = 5 x0 = np.array([0, 0, 0., 0., 0.]) # xc = np.array([-33., 11., 180., -158., 11.]) / 349. # yc = 1859. / 349. xc = np.array( [-0.09472656, 0.03157552, 0.51529948, -0.45214844, 0.03157552]) yc = 5.32664861 x1, y1, iterations, alpha, evaluations, history, exit_cause = \ psifa(f, x0, A, l, u, n, bl, bu, max_evals=2000, prec1=1e-8) self.assertTrue( np.allclose(x1, xc) or np.isclose(y1, yc) or np.allclose(xc, x1) or np.isclose(yc, y1) or y1 < yc) self.assertTrue(iterations <= 9) self.assertTrue(evaluations <= 91) self.assertTrue('VF' in exit_cause)
def test_problem_HS38(self): def f(x): y = 100 * (x[1] - x[0]**2)**2 + (1. - x[0])**2 + \ 90. * (x[3] - x[2]**2)**2 + (1. - x[2])**2 + \ 10.1 * ((x[1] - 1.)**2 + (x[3] - 1.)**2) + \ 19.8 * (x[1] - 1.) * (x[3] - 1.) eval_success = True return y, eval_success A = np.array([]) l = np.array([]) u = np.array([]) bl = np.array([-10., -10., -10., -10.]) bu = np.array([10., 10., 10., 10.]) n = 4 x0 = np.array([-3., -1., -3., -1.]) # xc = np.array([1., 1., 1., 1.]) # yc = 0. xc = np.array([1.28472396, 1.65645037, -0.49984457, 0.26141631]) yc = 2.60824579786 x1, y1, iterations, alpha, evaluations, history, exit_cause = \ psifa(f, x0, A, l, u, n, bl, bu, max_evals=2000, prec1=1e-8) self.assertTrue( np.allclose(x1, xc) or np.isclose(y1, yc) or np.allclose(xc, x1) or np.isclose(yc, y1) or y1 < yc) self.assertTrue(iterations <= 135) self.assertTrue(evaluations <= 2011) self.assertTrue('AF' in exit_cause)
def test_problem_HS53(self): def f(x): y = (x[0] - x[1])**2 + (x[1] + x[2] - 2.)**2 + \ (x[3] - 1.)**2 + (x[4] - 1.)**2 eval_success = True return y, eval_success A = np.array([[1., 3., 0., 0., 0.], [0., 0., 1., 1., -2.], [0., 1., 0., 0., -1.]]) l = np.array([0., 0., 0.]) u = np.array([0., 0., 0.]) bl = np.array([-10., -10., -10., -10., -10.]) bu = np.array([10., 10., 10., 10., 10.]) n = 5 x0 = np.array([0, 0, 0., 0., 0.]) # xc = np.array([-33., 11., 27., -5., 11.]) / 43. # yc = 176. / 43. xc = np.array( [-0.76757812, 0.25585938, 0.62695312, -0.11523438, 0.25585938]) yc = 4.09302521 x1, y1, iterations, alpha, evaluations, history, exit_cause = \ psifa(f, x0, A, l, u, n, bl, bu, max_evals=2000, prec1=1e-8) self.assertTrue( np.allclose(x1, xc) or np.isclose(y1, yc) or np.allclose(xc, x1) or np.isclose(yc, y1) or y1 < yc) self.assertTrue(iterations <= 8) self.assertTrue(evaluations <= 95) self.assertTrue('VF' in exit_cause)
def test_problem_HS03(self): def f(x): y = x[1] + 10.**(-5) * (x[1] - x[0])**2 eval_success = True return y, eval_success A = np.array([]) l = np.array([]) u = np.array([]) bl = np.array([-np.inf, 0.]) bu = np.array([np.inf, np.inf]) n = 2 x0 = np.array([10., 1.]) xc = np.array([0., 0.]) yc = 0. x1, y1, iterations, alpha, evaluations, history, exit_cause = \ psifa(f, x0, A, l, u, n, bl, bu, max_evals=2000, prec1=1e-8) self.assertTrue( np.allclose(x1, xc) or np.isclose(y1, yc) or np.allclose(xc, x1) or np.isclose(yc, y1) or y1 < yc) self.assertTrue(iterations <= 13) self.assertTrue(evaluations <= 102) self.assertTrue('VF' in exit_cause)
def test_problem_HS54(self): def f(x): h = (((x[0] - 1e6)**2) / 6.4e7 + (x[0] - 1e4) * (x[1] - 1.) / 2e4 + (x[1] - 1.)**2) * ((x[2] - 2e6)**2) / (0.96 * 4.9e13) + \ ((x[3] - 10.)**2) / 2.5e3 + (x[4] - 1e-3)**2 / 2.5e-3 + \ (x[5] - 1e8)**2 / 2.5e17 y = -np.exp(-h / 2.) eval_success = True return y, eval_success A = np.array([[1., 4e3, 0., 0., 0., 0.]]) l = np.array([1.76e4]) u = np.array([1.76e4]) bl = np.array([0., -10., 0., 0., -1., 0.]) bu = np.array([2e4, 10., 1e7, 20., 1., 2e8]) n = 6 x0 = np.array([1.76e4, 0, 0., 0., 0., 0.]) # xc = np.array([91600. / 7., 79. / 70., 2e6, 10., 1e-3, 1e8]) # yc = -np.exp(-27. / 280.) xc = np.array([1.7600e4, -1.9531e-5, 0., 3.38281250, 0., 0.]) yc = 0. x1, y1, iterations, alpha, evaluations, history, exit_cause = \ psifa(f, x0, A, l, u, n, bl, bu, max_evals=2000, prec1=1e-8) self.assertTrue( np.allclose(x1, xc) or np.isclose(y1, yc) or np.allclose(xc, x1) or np.isclose(yc, y1) or y1 < yc) self.assertTrue(iterations <= 10) self.assertTrue(evaluations <= 129) self.assertTrue('VF' in exit_cause)
def test_problem_HS41(self): def f(x): y = 2. - x[0] * x[1] * x[2] eval_success = True return y, eval_success A = np.array([[1., 2., 2., -1.]]) l = np.array([0.]) u = np.array([0.]) bl = np.array([0., 0., 0., 0.]) bu = np.array([1., 1., 1., 2.]) n = 4 x0 = np.array([0., 0.5, 0.5, 2.]) # xc = np.array([2. / 3., 1. / 3., 1. / 3., 2.]) # yc = 52. / 27. xc = np.array([0.67188, 0.33203, 0.33203, 2.]) yc = 1.9259 x1, y1, iterations, alpha, evaluations, history, exit_cause = \ psifa(f, x0, A, l, u, n, bl, bu, max_evals=2000, prec1=1e-8) self.assertTrue( np.allclose(x1, xc) or np.isclose(y1, yc) or np.allclose(xc, x1) or np.isclose(yc, y1) or y1 < yc) self.assertTrue(iterations <= 10) self.assertTrue(evaluations <= 75) self.assertTrue('VF' in exit_cause)
def test_problem_HS62(self): def f(x): y = -32.174 * \ (255. * np.log((x[0] + x[1] + x[2] + 0.03) / (0.09 * x[0] + x[1] + x[2] + 0.03)) + 280. * np.log((x[1] + x[2] + 0.03) / (0.07 * x[1] + x[2] + 0.03)) + 290. * np.log((x[2] + 0.03) / (0.13 * x[2] + 0.03))) eval_success = True return y, eval_success A = np.array([[1., 1., 1.]]) l = np.array([1.]) u = np.array([1.]) bl = np.array([0., 0., 0.]) bu = np.array([1., 1., 1.]) n = 3 x0 = np.array([0.7, 0.2, 0.1]) xc = np.array( [0.617812690138817, 0.328202229738235, 0.053985080122948]) yc = -2.627251448e4 x1, y1, iterations, alpha, evaluations, history, exit_cause = \ psifa(f, x0, A, l, u, n, bl, bu, max_evals=2000, prec1=1e-8) self.assertTrue( np.allclose(x1, xc) or np.isclose(y1, yc) or np.allclose(xc, x1) or np.isclose(yc, y1) or y1 < yc) # fail # self.assertTrue(iterations <= 67) # fail # self.assertTrue(evaluations <= 300) # fail # self.assertTrue('TP' in exit_cause) self.assertTrue('VF' in exit_cause)
def test_problem_HS49(self): def f(x): y = (x[0] - x[1])**2 + (x[2] - 1.)**2 + \ (x[3] - 1.)**4 + (x[4] - 1.)**6 eval_success = True return y, eval_success A = np.array([[1., 1., 1., 4., 0.], [0., 0., 1., 0., 5.]]) l = np.array([7., 6.]) u = np.array([7., 6.]) bl = np.array([-np.inf, -np.inf, -np.inf, -np.inf, -np.inf]) bu = np.array([np.inf, np.inf, np.inf, np.inf, np.inf]) n = 5 x0 = np.array([10., 7., 2., -3., 0.8]) # xc = np.array([1., 1., 1., 1., 1.]) # yc = 0. xc = np.array( [1.55468750, 1.55859375, 0.98828125, 0.72460938, 1.00234375]) yc = 0.00590429 x1, y1, iterations, alpha, evaluations, history, exit_cause = \ psifa(f, x0, A, l, u, n, bl, bu, max_evals=2000, prec1=1e-8) self.assertTrue( np.allclose(x1, xc) or np.isclose(y1, yc) or np.allclose(xc, x1) or np.isclose(yc, y1) or y1 < yc) self.assertTrue(iterations <= 187) self.assertTrue(evaluations <= 2003) self.assertTrue('AF' in exit_cause)
def test_problem_HS05(self): def f(x): y = np.sin(x[0] + x[1]) + (x[0] - x[1])**2 - 1.5 * x[0] + \ 2.5 * x[1] + 1. eval_success = True return y, eval_success A = np.array([]) l = np.array([]) u = np.array([]) bl = np.array([-1.5, -3.]) bu = np.array([4., 3.]) n = 2 x0 = np.array([0., 0.]) xc = np.array([-np.pi / 3. + 0.5, -np.pi / 3. - 0.5]) yc = -0.5 * np.sqrt(3.) - np.pi / 3. x1, y1, iterations, alpha, evaluations, history, exit_cause = \ psifa(f, x0, A, l, u, n, bl, bu, max_evals=2000, prec1=1e-8) self.assertTrue( np.allclose(x1, xc) or np.isclose(y1, yc) or np.allclose(xc, x1) or np.isclose(yc, y1) or y1 < yc) self.assertTrue(iterations <= 59) self.assertTrue(evaluations <= 247) self.assertTrue('VF' in exit_cause)
def test_problem_HS110(self): def f(x): s = 0. p = 1. for i in range(10): s += (np.log(x[i] - 2.))**2 + (np.log(10. - x[i]))**2 p *= x[i] y = s - p**0.2 eval_success = True return y, eval_success A = np.array([]) l = np.array([]) u = np.array([]) bl = np.array([2.001] * 10) bu = np.array([9.999] * 10) n = 10 x0 = np.array([9.] * 10) xc = np.array([9.35025655] * 10) yc = -45.77846971 x1, y1, iterations, alpha, evaluations, history, exit_cause = \ psifa(f, x0, A, l, u, n, bl, bu, max_evals=2000, prec1=1e-8) self.assertTrue( np.allclose(x1, xc) or np.isclose(y1, yc) or np.allclose(xc, x1) or np.isclose(yc, y1) or y1 < yc) self.assertTrue(iterations <= 51) # self.assertTrue(evaluations <= 1411) # fail # self.assertTrue('AF' in exit_cause) self.assertTrue('VF' in exit_cause)
def test_problem_HS86(self): def f(x): e = np.array([-15., -27., -36., -18., -12.]) c = np.array([[30., -20., -10., 32., -10.], [-20., 39., -6., -31., 32.], [-10., -6., 10., -6., -10.], [32., -31., -6., 39., -20.], [-10., 32., -10., -20., 30.]]) d = np.array([4., 8., 10., 6., 2.]) s1 = 0. s2 = 0. s3 = 0. for j in range(5): s1 += e[j] * x[j] for i in range(5): s2 += c[i, j] * x[i] * x[j] s3 += d[j] * x[j]**3 y = s1 + s2 + s3 eval_success = True return y, eval_success A = np.array([[-16., 2., 0., 1., 0.], [0., -2., 0., 4., 2.], [-3.5, 0., 2., 0., 0.], [0., -2., 0., -4., -1.], [0., -9., -2., 1., -2.8], [2., 0., -4., 0., 0.], [-1., -1., -1., -1., -1.], [-1., -2., -3., -2., -1.], [1., 2., 3., 4., 5.], [1., 1., 1., 1., 1.]]) l = np.array([-40., -2., -0.25, -4., -4., -1., -40., -60., 5., 1.]) u = np.array([np.inf] * 10) bl = np.array([0., 0., 0., 0., 0.]) bu = np.array([np.inf, np.inf, np.inf, np.inf, np.inf]) n = 5 x0 = np.array([0., 0., 0., 0., 1.]) xc = np.array([ 0.299999998116435, 0.333467595429803, 0.399999998635825, 0.428310114302271, 0.223964911296049 ]) yc = -32.34867897 x1, y1, iterations, alpha, evaluations, history, exit_cause = \ psifa(f, x0, A, l, u, n, bl, bu, max_evals=2000, prec1=1e-8) self.assertTrue( np.allclose(x1, xc) or np.isclose(y1, yc) or np.allclose(xc, x1) or np.isclose(yc, y1) or y1 < yc) # fail self.assertTrue(iterations <= 86) # fail # self.assertTrue(evaluations <= 920) # fail self.assertTrue('VF' in exit_cause)
def test_problem_HS112(self): def f(x): c = np.array([ -6.089, -17.164, -34.054, -5.914, -24.721, -14.986, -24.1, -10.708, -26.662, -22.179 ]) y = 0. for i in range(10): y += x[i] * (c[i] + np.log(x[0] / (x[1] + np.sum(x)))) eval_success = True return y, eval_success A = np.array([[1., 2., 2., 0., 0., 1., 0., 0., 0., 1.], [0., 0., 0., 1., 2., 1., 1., 0., 0., 0.], [0., 0., 1., 0., 0., 0., 1., 1., 2., 1.]]) l = np.array([2., 1., 1.]) u = np.array([2., 1., 1.]) bl = np.array([1e-6] * 10) bu = np.array([np.inf] * 10) n = 10 x0 = np.array( [0.8, 0.5, 0.01, 0.01, 0.1, 0.01, 0.78, 0.01, 0.015, 0.17]) xc = np.array([ 0.000001000013433, 0.999987491743295, 0.000004802332244, 0.999960037649762, 0.000014076754094, 0.000006088443443, 0.000005720398607, 0.999971681334066, 0.000004736271518, 0.000008323392047 ]) # yc = -79.3911 yc = -71.5236117652 x1, y1, iterations, alpha, evaluations, history, exit_cause = \ psifa(f, x0, A, l, u, n, bl, bu, max_evals=2000, prec1=1e-8) self.assertTrue( np.allclose(x1, xc) or np.isclose(y1, yc) or np.allclose(xc, x1) or np.isclose(yc, y1) or y1 < yc) self.assertTrue(iterations <= 20) # self.assertTrue(evaluations <= 299) # fail self.assertTrue('TP' in exit_cause)
[1. / np.sqrt(3.), -1.], [1., np.sqrt(3.)], [-1., -np.sqrt(3.)] ]) l = np.array([0., 0., -6.]) u = np.array([np.inf, np.inf, np.inf]) bl = np.array([0., 0.]) bu = np.array([np.inf, np.inf]) n = 2 # Initial guess for the solution. x0 = np.array([1., 0.5]) # Find a global optimum using PSIFA. x, y, iterations, alpha, evaluations, history, exit_cause = \ psifa(f, x0, A, l, u, n, bl, bu, max_evals=2000, prec1=1e-8) # Show the results. print('------------------------------------------------------------') print(' Results ') print('------------------------------------------------------------') print('Solution: x = {}'.format(x)) print('Function value: f(x) = {}'.format(y)) print('Step length: alpha = {}'.format(alpha)) print('Number of iterations: {}'.format(iterations)) print('Function evaluations: {}'.format(evaluations)) print('Exit cause: {}'.format(exit_cause)) print('History:') pp = pprint.PrettyPrinter(indent=2) pp.pprint(history)
def test_problem_HS118(self): def f(x): y = 0. for i in range(5): j = 3 * i y += 2.3 * x[j + 0] + 1e-4 * x[j + 0]**2 + \ 1.7 * x[j + 1] + 1e-4 * x[j + 1] + \ 2.2 * x[j + 2] + 1.5e-4 * x[j + 2]**2 eval_success = True return y, eval_success A = np.array([[-1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, -1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, -1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, -1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, -1, 0, 0, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, -1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, -1, 0, 0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, -1, 0, 0, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, -1, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 0, 0, 1], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 0, 0, 1, 0], [1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1], [0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0]]) \ .astype(float) l = np.array([ -7., -7., -7., -7., -7., -7., -7., -7., -7., -7., -7., -7., 60., 70., 100., 50., 85. ]) u = np.array([ 6., 6., 7., 6., 6., 7., 6., 6., 7., 6., 6., 7., np.inf, np.inf, np.inf, np.inf, np.inf ]) bl = np.array( [8., 43., 3., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]) bu = np.array([ 21., 57., 16., 90., 120., 60., 90., 120., 60., 90., 120., 60., 90., 120., 60. ]) n = 15 x0 = np.array([ 20., 55., 15., 20., 60., 20., 20., 60., 20., 20., 60., 20., 20., 60., 20. ]) # xc = np.array([8., 49., 3., 1., 56., 0., 1., 63., # 6., 3., 70., 12., 5., 77., 18]) # yc = 664.8204500 # xc = np.array([8.2923, 4.8709e1, 3.0093, 1.3630, # 5.0331e1, 3.7989e-4, 7.3630, 5.7277e1, # 5.3619, 1.3302e1, 6.3991e1, 7.7069, # 1.6259e1, 7.0872e1, 1.2869e1]) # yc = 667.65 xc = np.array([ 8.2923146073, 48.7085129072, 3.0093215000, 1.3629991880, 50.3307789916, 0.0003798947, 7.3629991880, 57.2765915265, 5.3619399377, 13.3020232957, 63.9910701197, 7.7069065846, 16.2591149366, 70.8721322093, 12.8687528540 ]) yc = 667.6476831493 x1, y1, iterations, alpha, evaluations, history, exit_cause = \ psifa(f, x0, A, l, u, n, bl, bu, max_evals=2000, prec1=1e-8) self.assertTrue( np.allclose(x1, xc) or np.isclose(y1, yc) or np.allclose(xc, x1) or np.isclose(yc, y1) or y1 < yc) # fail self.assertTrue(iterations <= 89) self.assertTrue(evaluations <= 2019) self.assertTrue('AF' in exit_cause)