def runTest(self):
n = 2
npt = (n + 1) * (n + 2) // 2
x0 = np.array([1.0, 1.0])
xl = -1e2 * np.ones((n, ))
xu = 1e2 * np.ones((n, ))
model = Model(npt, x0, objfun(x0), xl, xu, 1)
x1 = x0 + np.array([1.0, 0.0])
model.change_point(1, x1 - model.xbase, objfun(x1))
x2 = x0 + np.array([0.1, 0.9])
model.change_point(2, x2 - model.xbase, objfun(x2))
x3 = x0 + np.array([-0.1, 0.0])
model.change_point(3, x3 - model.xbase, objfun(x3))
x4 = x0 + np.array([-0.1, 2.0])
model.change_point(4, x4 - model.xbase, objfun(x4))
x5 = x0 + np.array([-1.1, 1.0])
model.change_point(5, x5 - model.xbase, objfun(x5))
xopt = model.xopt()
for i in range(npt):
c, g, hess = model.lagrange_polynomial(i) # based at xopt
for j in range(npt):
dx = model.xpt(j) - xopt
lag_value = c + model_value(g, hess, dx)
expected_value = 1.0 if i == j else 0.0
self.assertAlmostEqual(
lag_value,
expected_value,
msg="Lagrange for x%g has bad value at x%g" % (i, j))
def runTest(self):
n, m = 2, 2
npt = n + 1
x0 = np.array([-1.2, 1.0])
xl = -1e2 * np.ones((n, ))
xu = 1e2 * np.ones((n, ))
model = Model(npt, x0, rosenbrock(x0), xl, xu, 1)
x1 = np.array([1.0, 0.9])
model.change_point(1, x1 - model.xbase, rosenbrock(x1))
x2 = np.array([2.0, 0.9])
model.change_point(2, x2 - model.xbase, rosenbrock(x2))
# Now add a new point
x3 = np.array([1.0, 1.0]) # good point
add_ok = model.add_new_point(x3 - model.xbase, rosenbrock(x3))
self.assertTrue(add_ok, "Adding x3 failed")
self.assertEqual(model.npt(), 4, "Wrong number of points after x3")
self.assertTrue(array_compare(model.xpt(3, abs_coordinates=True), x3),
"Wrong new point after x3")
self.assertTrue(array_compare(model.fval(3), rosenbrock(x3)),
"Wrong fval after x3")
self.assertEqual(model.kopt, 3, "Wrong kopt after x3")
self.assertEqual(len(model.nsamples), 4,
"Wrong nsamples length after x3")
self.assertEqual(model.nsamples[-1], 1, "Wrong nsample value after x3")
x4 = np.array([-1.8, 1.8]) # bad point
add_ok = model.add_new_point(x4 - model.xbase, rosenbrock(x4))
self.assertTrue(add_ok, "Adding x4 failed")
self.assertEqual(model.npt(), 5, "Wrong number of points after x4")
self.assertTrue(array_compare(model.xpt(4, abs_coordinates=True), x4),
"Wrong new point after x4")
self.assertTrue(array_compare(model.fval(4), rosenbrock(x4)),
"Wrong fval after x4")
self.assertEqual(model.kopt, 3, "Wrong kopt after x4")
x5 = np.array([-1.0, 1.0])
add_ok = model.add_new_point(x5 - model.xbase, rosenbrock(x5))
self.assertTrue(add_ok, "Adding x5 failed")
self.assertEqual(model.npt(), 6, "Wrong number of points after x5")
x6 = np.array([-1.5, 1.5])
add_ok = model.add_new_point(x6 - model.xbase, rosenbrock(x6))
self.assertFalse(add_ok, "Adding x6 should have failed")
self.assertEqual(model.npt(), 6, "Wrong number of points after x6")
self.assertTrue(array_compare(model.xpt(5, abs_coordinates=True), x5),
"Wrong new point after x6")
self.assertTrue(array_compare(model.fval(5), rosenbrock(x5)),
"Wrong fval after x6")
self.assertEqual(model.kopt, 3, "Wrong kopt after x6")
def runTest(self):
n, m = 2, 2
npt = n + 1
x0 = np.array([-1.2, 1.0])
xl = -1e20 * np.ones((n, ))
xu = 1e20 * np.ones((n, ))
model = Model(npt, x0, rosenbrock(x0), xl, xu, 1)
# Now add better point
x1 = np.array([1.0, 0.9])
f1 = rosenbrock(x1)
model.change_point(1, x1 - model.xbase, f1, allow_kopt_update=True)
# Now add worse point
x2 = np.array([2.0, 0.9])
f2 = rosenbrock(x2)
model.change_point(2, x2 - model.xbase, f2, allow_kopt_update=True)
model.swap_points(0, 2)
self.assertTrue(array_compare(model.xpt(0, abs_coordinates=True), x2),
'Wrong xpt(0) after swap 1')
self.assertTrue(array_compare(model.xpt(1, abs_coordinates=True), x1),
'Wrong xpt(1) after swap 1')
self.assertTrue(array_compare(model.xpt(2, abs_coordinates=True), x0),
'Wrong xpt(2) after swap 1')
self.assertTrue(array_compare(model.xopt(abs_coordinates=True), x1),
'Wrong xopt after swap 1')
model.swap_points(1, 2)
self.assertTrue(array_compare(model.xpt(0, abs_coordinates=True), x2),
'Wrong xpt(0) after swap 2')
self.assertTrue(array_compare(model.xpt(1, abs_coordinates=True), x0),
'Wrong xpt(1) after swap 2')
self.assertTrue(array_compare(model.xpt(2, abs_coordinates=True), x1),
'Wrong xpt(2) after swap 2')
self.assertTrue(array_compare(model.xopt(abs_coordinates=True), x1),
'Wrong xopt after swap 2')
def runTest(self):
n = 2
npt = n + 1
x0 = np.array([-1.2, 1.0])
xl = -1e2 * np.ones((n, ))
xu = 1e2 * np.ones((n, ))
model = Model(npt, x0, rosenbrock(x0), xl, xu, 1)
x1 = np.array([1.0, 0.9])
model.change_point(1, x1 - model.xbase, rosenbrock(x1))
x2 = np.array([2.0, 0.9])
model.change_point(2, x2 - model.xbase, rosenbrock(x2))
xopt = model.xopt()
for i in range(npt):
c, g, hess = model.lagrange_polynomial(i) # based at xopt
for j in range(npt):
dx = model.xpt(j) - xopt
lag_value = c + model_value(g, hess, dx)
expected_value = 1.0 if i == j else 0.0
self.assertAlmostEqual(
lag_value,
expected_value,
msg="Lagrange for x%g has bad value at x%g" % (i, j))
def runTest(self):
n, m = 2, 2
npt = n + 1
x0 = np.array([-1.2, 1.0])
xl = -1e20 * np.ones((n, ))
xu = 1e20 * np.ones((n, ))
model = Model(npt, x0, rosenbrock(x0), xl, xu, 1)
self.assertEqual(model.npt(), npt, 'Wrong npt after initialisation')
self.assertTrue(array_compare(model.xopt(abs_coordinates=True), x0),
'Wrong xopt after initialisation')
self.assertTrue(array_compare(model.fopt(), rosenbrock(x0)),
'Wrong fopt after initialisation')
# Now add better point
x1 = np.array([1.0, 0.9])
rvec = rosenbrock(x1)
model.change_point(1, x1 - model.xbase, rvec, allow_kopt_update=True)
self.assertEqual(model.npt(), npt, 'Wrong npt after x1')
self.assertTrue(array_compare(model.xopt(abs_coordinates=True), x1),
'Wrong xopt after x1')
self.assertTrue(array_compare(model.fopt(), rosenbrock(x1)),
'Wrong fopt after x1')
# Now add worse point
x2 = np.array([2.0, 0.9])
rvec = rosenbrock(x2)
model.change_point(2, x2 - model.xbase, rvec, allow_kopt_update=True)
self.assertEqual(model.npt(), npt, 'Wrong npt after x2')
self.assertTrue(array_compare(model.xpt(0, abs_coordinates=True), x0),
'Wrong xpt(0) after x2')
self.assertTrue(array_compare(model.xpt(1, abs_coordinates=True), x1),
'Wrong xpt(1) after x2')
self.assertTrue(array_compare(model.xpt(2, abs_coordinates=True), x2),
'Wrong xpt(2) after x2')
self.assertTrue(array_compare(model.xopt(abs_coordinates=True), x1),
'Wrong xopt after x2')
self.assertTrue(array_compare(model.fopt(), rosenbrock(x1)),
'Wrong fopt after x2')
# Now add best point (but don't update kopt)
x3 = np.array([1.0, 1.0])
rvec = rosenbrock(x3)
model.change_point(0, x3 - model.xbase, rvec,
allow_kopt_update=False) # full: overwrite x0
self.assertEqual(model.npt(), npt, 'Wrong npt after x3')
self.assertTrue(array_compare(model.xopt(abs_coordinates=True), x1),
'Wrong xopt after x3')
self.assertTrue(array_compare(model.fopt(), rosenbrock(x1)),
'Wrong fopt after x3')
self.assertAlmostEqual(model.fopt(),
rosenbrock(x1),
msg='Wrong fopt after x3')
self.assertTrue(
array_compare(model.xopt(abs_coordinates=True),
model.as_absolute_coordinates(model.xopt())),
'Comparison wrong after x3')
dirns = model.xpt_directions(include_kopt=True)
self.assertTrue(array_compare(x3 - x1, dirns[0, :]), 'Wrong dirn 0')
self.assertTrue(array_compare(x1 - x1, dirns[1, :]), 'Wrong dirn 1')
self.assertTrue(array_compare(x2 - x1, dirns[2, :]), 'Wrong dirn 2')
dirns = model.xpt_directions(include_kopt=False)
self.assertTrue(array_compare(x3 - x1, dirns[0, :]),
'Wrong dirn 0 (no kopt)')
# self.assertTrue(array_compare(x1 - x1, dirns[1, :]), 'Wrong dirn 1')
self.assertTrue(array_compare(x2 - x1, dirns[1, :]),
'Wrong dirn 1 (no kopt)')