def test_lt(self):
v = BlockVector(2)
a = np.ones(5)
b = np.zeros(9)
v.set_block(0, a)
v.set_block(1, b)
flags = v < 1
v.set_block(0, a - 1)
v.set_block(1, b + 1)
self.assertEqual(v.nblocks, flags.nblocks)
for bid, blk in enumerate(flags):
self.assertTrue(np.allclose(blk, v.get_block(bid)))
v.set_block(0, a + 1)
v.set_block(1, b - 1)
flags = v < np.ones(v.size)
v.set_block(0, a - 1)
v.set_block(1, b + 1)
self.assertEqual(v.nblocks, flags.nblocks)
for bid, blk in enumerate(flags):
self.assertTrue(np.allclose(blk, v.get_block(bid)))
v.set_block(0, a + 1)
v.set_block(1, b - 1)
vv = v.copy()
vv.fill(1.0)
flags = v < vv
v.set_block(0, a - 1)
v.set_block(1, b + 1)
self.assertEqual(v.nblocks, flags.nblocks)
for bid, blk in enumerate(flags):
self.assertTrue(np.allclose(blk, v.get_block(bid)))
def test_nonzero(self):
v = BlockVector(2)
a = np.ones(5)
b = np.zeros(9)
v.set_block(0, a)
v.set_block(1, b)
n = v.nonzero()
v2 = BlockVector(2)
v2.set_block(0, np.arange(5))
v2.set_block(1, np.zeros(0))
self.assertEqual(n[0].nblocks, v.nblocks)
for bid, blk in enumerate(n[0]):
self.assertTrue(np.allclose(blk, v2.get_block(bid)))
def calculate_full_space_lagrangian_hessians(self, lam, x):
y = self.evaluate_external_variables(x)
lam_g = self.calculate_external_multipliers(lam, x)
d2fdx0dx0 = 2.0
d2fdx1dx1 = 2.0
d2fdy0dy0 = 2.0
d2fdy1dy1 = 2.0
hfxx = np.array([[d2fdx0dx0, 0], [0, d2fdx1dx1]])
hfxy = np.array([[0, 0], [0, 0]])
hfyy = np.array([[d2fdy0dy0, 0], [0, d2fdy1dy1]])
dg0dx0dx0 = 2 * y[0] * x[1]**0.5 * y[1]
dg0dx0dx1 = x[0] * y[0] * y[1] / x[1]**0.5
dg0dx1dx1 = -1 / 4 * x[0]**2 * y[0] * y[1] / x[1]**(3 / 2)
dg0dx0dy0 = 2 * x[0] * x[1]**0.5 * y[1]
dg0dx0dy1 = 2 * x[0] * y[0] * x[1]**0.5
dg0dx1dy0 = 0.5 * x[0]**2 * y[1] / x[1]**0.5
dg0dx1dy1 = 0.5 * x[0]**2 * y[0] / x[1]**0.5
dg0dy0dy1 = x[0]**2 * x[1]**0.5
hg0xx = np.array([[dg0dx0dx0, dg0dx0dx1], [dg0dx0dx1, dg0dx1dx1]])
hg0xy = np.array([[dg0dx0dy0, dg0dx0dy1], [dg0dx1dy0, dg0dx1dy1]])
hg0yy = np.array([[0, dg0dy0dy1], [dg0dy0dy1, 0]])
dg1dx0dx1 = y[0]
dg1dx0dy0 = x[1]
dg1dx1dy0 = x[0]
hg1xx = np.array([[0, dg1dx0dx1], [dg1dx0dx1, 0]])
hg1xy = np.array([[dg1dx0dy0, 0], [dg1dx1dy0, 0]])
hg1yy = np.zeros((2, 2))
hlxx = lam[0] * hfxx + lam_g[0] * hg0xx + lam_g[1] * hg1xx
hlxy = lam[0] * hfxy + lam_g[0] * hg0xy + lam_g[1] * hg1xy
hlyy = lam[0] * hfyy + lam_g[0] * hg0yy + lam_g[1] * hg1yy
return hlxx, hlxy, hlyy
def test_y_init(self):
y_init = np.zeros(self.nlp3.ng)
self.assertTrue(np.allclose(self.nlp3.y_init(), y_init))
self.assertTrue(
np.allclose(self.nlp2.y_init(), self.pyomo_nlp2.y_init()))
self.assertTrue(
np.allclose(self.nlp3.y_init(), self.pyomo_nlp3.y_init()))
def test_copy(self):
v = BlockVector(2)
a = np.ones(5)
b = np.zeros(9)
v.set_block(0, a)
v.set_block(1, b)
v2 = v.copy()
self.assertTrue(np.allclose(v.flatten(), v2.flatten()))
def test_iadd(self):
v = self.ones
v += 3
self.assertListEqual(v.tolist(), [4] * v.size)
v.fill(1.0)
v += v
self.assertListEqual(v.tolist(), [2] * v.size)
v.fill(1.0)
v += np.ones(v.size) * 3
self.assertTrue(np.allclose(v.flatten(), np.ones(v.size) * 4))
v = BlockVector(2)
a = np.ones(5)
b = np.zeros(9)
a_copy = a.copy()
b_copy = b.copy()
v.set_block(0, a)
v.set_block(1, b)
v += 1.0
self.assertTrue(np.allclose(v.get_block(0), a_copy + 1))
self.assertTrue(np.allclose(v.get_block(1), b_copy + 1))
v = BlockVector(2)
a = np.ones(5)
b = np.zeros(9)
a_copy = a.copy()
b_copy = b.copy()
v.set_block(0, a)
v.set_block(1, b)
v2 = BlockVector(2)
v2.set_block(0, np.ones(5))
v2.set_block(1, np.ones(9))
v += v2
self.assertTrue(np.allclose(v.get_block(0), a_copy + 1))
self.assertTrue(np.allclose(v.get_block(1), b_copy + 1))
self.assertTrue(np.allclose(v2.get_block(0), np.ones(5)))
self.assertTrue(np.allclose(v2.get_block(1), np.ones(9)))
with self.assertRaises(Exception) as context:
v += 'hola'
def test_copyfrom(self):
v = self.ones
v1 = np.zeros(v.size)
v.copyfrom(v1)
self.assertListEqual(v.tolist(), v1.tolist())
v2 = BlockVector(len(self.list_sizes_ones))
for i, s in enumerate(self.list_sizes_ones):
v2.set_block(i, np.ones(s) * i)
v.copyfrom(v2)
for idx, blk in enumerate(v2):
self.assertListEqual(blk.tolist(), v2.get_block(idx).tolist())
v3 = BlockVector(2)
v4 = v.clone(2)
v3.set_block(0, v4)
v3.set_block(1, np.zeros(3))
self.assertListEqual(v3.tolist(), v4.tolist() + [0] * 3)
def test_copy_structure(self):
v = BlockVector(2)
a = np.ones(5)
b = np.zeros(9)
v.set_block(0, a)
v.set_block(1, b)
v2 = v.copy_structure()
self.assertEqual(v.get_block(0).size, v2.get_block(0).size)
self.assertEqual(v.get_block(1).size, v2.get_block(1).size)
def test_contains(self):
v = BlockVector(2)
a = np.ones(5)
b = np.zeros(9)
v.set_block(0, a)
v.set_block(1, b)
self.assertTrue(0 in v)
self.assertFalse(3 in v)
def test_copyto(self):
v = self.ones
v2 = BlockVector(len(self.list_sizes_ones))
v.copyto(v2)
self.assertListEqual(v.tolist(), v2.tolist())
v3 = np.zeros(v.size)
v.copyto(v3)
self.assertListEqual(v.tolist(), v3.tolist())
v *= 5
v.copyto(v2)
self.assertListEqual(v.tolist(), v2.tolist())
def __init__(self, A1, A2, c1, c2, N, dt):
self._A1 = A1
self._A2 = A2
self._c1 = c1
self._c2 = c2
self._N = N
self._dt = dt
self._input_names = ['F1_{}'.format(t) for t in range(1, N)]
self._input_names.extend(['F2_{}'.format(t) for t in range(1, N)])
self._input_names.extend(['h1_{}'.format(t) for t in range(0, N)])
self._input_names.extend(['h2_{}'.format(t) for t in range(0, N)])
self._output_names = ['F12_{}'.format(t) for t in range(0, N)]
self._output_names.extend(['Fo_{}'.format(t) for t in range(0, N)])
self._equality_constraint_names = [
'h1bal_{}'.format(t) for t in range(1, N)
]
self._equality_constraint_names.extend(
['h2bal_{}'.format(t) for t in range(1, N)])
# inputs
self._F1 = np.zeros(N) # we don't use the first one
self._F2 = np.zeros(N) # we don't use the first one
self._h1 = np.zeros(N)
self._h2 = np.zeros(N)
# outputs
self._F12 = np.zeros(N)
self._Fo = np.zeros(N)
# multipliers
self._eq_con_mult_values = np.ones(2 * (N - 1))
self._output_con_mult_values = np.ones(2 * N)
def test_matrix_multiply(self):
"""
Test
[A B C * [G J = [A*G + B*H + C*I A*J + B*K + C*L
D E F] H K D*G + E*H + F*I D*J + E*K + F*L]
I L]
"""
np.random.seed(0)
A = sp.csr_matrix(np.random.normal(0, 10, (2, 2)))
B = sp.csr_matrix(np.random.normal(0, 10, (2, 2)))
C = sp.csr_matrix(np.random.normal(0, 10, (2, 2)))
D = sp.csr_matrix(np.random.normal(0, 10, (2, 2)))
E = sp.csr_matrix(np.random.normal(0, 10, (2, 2)))
F = sp.csr_matrix(np.random.normal(0, 10, (2, 2)))
G = sp.csr_matrix(np.random.normal(0, 10, (2, 2)))
H = sp.csr_matrix(np.random.normal(0, 10, (2, 2)))
I = sp.csr_matrix(np.random.normal(0, 10, (2, 2)))
J = sp.csr_matrix(np.random.normal(0, 10, (2, 2)))
K = sp.csr_matrix(np.random.normal(0, 10, (2, 2)))
L = sp.csr_matrix(np.random.normal(0, 10, (2, 2)))
bm1 = BlockMatrix(2, 3)
bm2 = BlockMatrix(3, 2)
bm1.set_block(0, 0, A)
bm1.set_block(0, 1, B)
bm1.set_block(0, 2, C)
bm1.set_block(1, 0, D)
bm1.set_block(1, 1, E)
bm1.set_block(1, 2, F)
bm2.set_block(0, 0, G)
bm2.set_block(1, 0, H)
bm2.set_block(2, 0, I)
bm2.set_block(0, 1, J)
bm2.set_block(1, 1, K)
bm2.set_block(2, 1, L)
got = (bm1 * bm2).toarray()
exp00 = (A * G + B * H + C * I).toarray()
exp01 = (A * J + B * K + C * L).toarray()
exp10 = (D * G + E * H + F * I).toarray()
exp11 = (D * J + E * K + F * L).toarray()
exp = np.zeros((4, 4))
exp[0:2, 0:2] = exp00
exp[0:2, 2:4] = exp01
exp[2:4, 0:2] = exp10
exp[2:4, 2:4] = exp11
self.assertTrue(np.allclose(got, exp))
def test_rfloordiv(self):
v = self.ones
v.fill(2.0)
v1 = v.clone(5.0, copy=True)
result = v.__rfloordiv__(v1)
self.assertListEqual(result.tolist(), [5.0 // 2.0] * v.size)
result = v.flatten() // v1
self.assertTrue(
np.allclose(result.flatten(),
v.flatten() // v1.flatten()))
result = 2.0 // v1
self.assertTrue(np.allclose(result.flatten(), np.zeros(v1.size)))
result = v1 // 2.0
self.assertTrue(np.allclose(result.flatten(), np.ones(v1.size) * 2.0))
def evaluate_outputs(self):
N = self._N
h1 = self._h1
h2 = self._h2
resid = np.zeros(2 * N)
for t in range(N):
resid[t] = self._c1 * math.sqrt(h1[t])
for t in range(N):
resid[t + N] = self._c2 * math.sqrt(h2[t])
return resid
def test_gt(self):
v = BlockVector(2)
a = np.ones(5)
b = np.zeros(9)
v.set_block(0, a)
v.set_block(1, b)
flags = v > 0
self.assertEqual(v.nblocks, flags.nblocks)
for bid, blk in enumerate(flags):
self.assertTrue(np.allclose(blk, v.get_block(bid)))
flags = v > np.zeros(v.size)
self.assertEqual(v.nblocks, flags.nblocks)
for bid, blk in enumerate(flags):
self.assertTrue(np.allclose(blk, v.get_block(bid)))
vv = v.copy()
vv.fill(0.0)
flags = v > vv
self.assertEqual(v.nblocks, flags.nblocks)
for bid, blk in enumerate(flags):
self.assertTrue(np.allclose(blk, v.get_block(bid)))
def evaluate_hessian_outputs(self):
N = self._N
F1 = self._F1
F2 = self._F2
h1 = self._h1
h2 = self._h2
A1 = self._A1
A2 = self._A2
c1 = self._c1
c2 = self._c2
dt = self._dt
lam = self._output_con_mult_values
nnz = 2 * N
irow = np.zeros(nnz, dtype=np.int64)
jcol = np.zeros(nnz, dtype=np.int64)
data = np.zeros(nnz, dtype=np.float64)
idx = 0
# Hess F12_t
for i in range(N):
irow[idx] = 2 * (N - 1) + i
jcol[idx] = 2 * (N - 1) + i
data[idx] = lam[i] * c1 * (-1 / 4) * h1[i]**(-1.5)
idx += 1
# Hess Fo_t
for i in range(N):
irow[idx] = 2 * (N - 1) + N + i
jcol[idx] = 2 * (N - 1) + N + i
data[idx] = lam[N + i] * c2 * (-1 / 4) * h2[i]**(-1.5)
idx += 1
assert idx == nnz
hess = spa.coo_matrix((data, (irow, jcol)),
shape=(2 * (N - 1) + 2 * N, 2 * (N - 1) + 2 * N))
return hess
def evaluate_equality_constraints(self):
N = self._N
F1 = self._F1
F2 = self._F2
h1 = self._h1
h2 = self._h2
resid = np.zeros(2 * (N - 1))
for t in range(1, N):
resid[t-1] = (h1[t]-h1[t-1]) - \
self._dt/self._A1*(F1[t] - self._c1*math.sqrt(h1[t]))
for t in range(1, N):
resid[t-2+N] = (h2[t]-h2[t-1]) - \
self._dt/self._A2*(self._c1*math.sqrt(h1[t]) + F2[t] - self._c2*math.sqrt(h2[t]))
return resid
def test_util_maps(self):
anlp = AslNLP(self.filename)
full_to_compressed_mask = build_compression_mask_for_finite_values(anlp.primals_lb())
# test build_bounds_mask - should be the same as above
self.assertTrue(np.array_equal(full_to_compressed_mask, build_bounds_mask(anlp.primals_lb())))
expected_compressed_primals_lb = np.asarray([-1, 2, -3, -5, -7, -9], dtype=np.float64)
# test build_compression_matrix
C = build_compression_matrix(full_to_compressed_mask)
compressed_primals_lb = C*anlp.primals_lb()
self.assertTrue(np.array_equal(expected_compressed_primals_lb, compressed_primals_lb))
# test full_to_compressed
compressed_primals_lb = full_to_compressed(anlp.primals_lb(), full_to_compressed_mask)
self.assertTrue(np.array_equal(expected_compressed_primals_lb, compressed_primals_lb))
# test in place
compressed_primals_lb = np.zeros(len(expected_compressed_primals_lb))
ret = full_to_compressed(anlp.primals_lb(), full_to_compressed_mask, out=compressed_primals_lb)
self.assertTrue(ret is compressed_primals_lb)
self.assertTrue(np.array_equal(expected_compressed_primals_lb, compressed_primals_lb))
# test compressed_to_full
expected_full_primals_lb = np.asarray([-1, 2, -3, -np.inf, -5, -np.inf, -7, -np.inf, -9], dtype=np.float64)
full_primals_lb = compressed_to_full(compressed_primals_lb, full_to_compressed_mask, default=-np.inf)
self.assertTrue(np.array_equal(expected_full_primals_lb, full_primals_lb))
# test in place
full_primals_lb.fill(0.0)
ret = compressed_to_full(compressed_primals_lb, full_to_compressed_mask, out=full_primals_lb, default=-np.inf)
self.assertTrue(ret is full_primals_lb)
self.assertTrue(np.array_equal(expected_full_primals_lb, full_primals_lb))
# test no default
expected_full_primals_lb = np.asarray([-1, 2, -3, np.nan, -5, np.nan, -7, np.nan, -9], dtype=np.float64)
full_primals_lb = compressed_to_full(compressed_primals_lb, full_to_compressed_mask)
print(expected_full_primals_lb)
print(full_primals_lb)
np.testing.assert_array_equal(expected_full_primals_lb, full_primals_lb)
# test in place no default
expected_full_primals_lb = np.asarray([-1, 2, -3, 0.0, -5, 0.0, -7, 0.0, -9], dtype=np.float64)
full_primals_lb.fill(0.0)
ret = compressed_to_full(compressed_primals_lb, full_to_compressed_mask, out=full_primals_lb)
self.assertTrue(ret is full_primals_lb)
self.assertTrue(np.array_equal(expected_full_primals_lb, full_primals_lb))
def test_imul(self):
v = self.ones
v *= 3
self.assertListEqual(v.tolist(), [3] * v.size)
v.fill(1.0)
v *= v
self.assertListEqual(v.tolist(), [1] * v.size)
v.fill(1.0)
v *= np.ones(v.size) * 2
self.assertTrue(np.allclose(v.flatten(), np.ones(v.size) * 2))
v = BlockVector(2)
a = np.ones(5)
b = np.arange(9, dtype=np.float64)
a_copy = a.copy()
b_copy = b.copy()
v.set_block(0, a)
v.set_block(1, b)
v *= 2.0
self.assertTrue(np.allclose(v.get_block(0), a_copy * 2.0))
self.assertTrue(np.allclose(v.get_block(1), b_copy * 2.0))
v = BlockVector(2)
a = np.ones(5)
b = np.zeros(9)
a_copy = a.copy()
b_copy = b.copy()
v.set_block(0, a)
v.set_block(1, b)
v2 = BlockVector(2)
v2.set_block(0, np.ones(5) * 2)
v2.set_block(1, np.ones(9) * 2)
v *= v2
self.assertTrue(np.allclose(v.get_block(0), a_copy * 2))
self.assertTrue(np.allclose(v.get_block(1), b_copy * 2))
self.assertTrue(np.allclose(v2.get_block(0), np.ones(5) * 2))
self.assertTrue(np.allclose(v2.get_block(1), np.ones(9) * 2))
with self.assertRaises(Exception) as context:
v *= 'hola'
def test_itruediv(self):
v = self.ones
v /= 3
self.assertTrue(np.allclose(v.flatten(), np.ones(v.size) / 3))
v.fill(1.0)
v /= v
self.assertTrue(np.allclose(v.flatten(), np.ones(v.size)))
v.fill(1.0)
v /= np.ones(v.size) * 2
self.assertTrue(np.allclose(v.flatten(), np.ones(v.size) / 2))
v = BlockVector(2)
a = np.ones(5)
b = np.arange(9, dtype=np.float64)
a_copy = a.copy()
b_copy = b.copy()
v.set_block(0, a)
v.set_block(1, b)
v /= 2.0
self.assertTrue(np.allclose(v.get_block(0), a_copy / 2.0))
self.assertTrue(np.allclose(v.get_block(1), b_copy / 2.0))
v = BlockVector(2)
a = np.ones(5)
b = np.zeros(9)
a_copy = a.copy()
b_copy = b.copy()
v.set_block(0, a)
v.set_block(1, b)
v2 = BlockVector(2)
v2.set_block(0, np.ones(5) * 2)
v2.set_block(1, np.ones(9) * 2)
v /= v2
self.assertTrue(np.allclose(v.get_block(0), a_copy / 2))
self.assertTrue(np.allclose(v.get_block(1), b_copy / 2))
self.assertTrue(np.allclose(v2.get_block(0), np.ones(5) * 2))
self.assertTrue(np.allclose(v2.get_block(1), np.ones(9) * 2))
with self.assertRaises(Exception) as context:
v *= 'hola'
def test_clip(self):
v = BlockVector(3)
v2 = BlockVector(3)
a = np.zeros(5)
b = np.ones(3) * 5.0
c = np.ones(3) * 10.0
v.set_block(0, a)
v.set_block(1, b)
v.set_block(2, c)
v2.set_block(0, np.ones(5) * 4.0)
v2.set_block(1, np.ones(3) * 5.0)
v2.set_block(2, np.ones(3) * 9.0)
vv = v.clip(4.0, 9.0)
self.assertEqual(vv.nblocks, v.nblocks)
for bid, blk in enumerate(vv):
self.assertTrue(np.allclose(blk, v2.get_block(bid)))
def check_sparse_matrix_specific_order(tst,
m1,
m1rows,
m1cols,
m2,
m2rows,
m2cols,
m1_m2_rows_map=None,
m1_m2_cols_map=None):
tst.assertEqual(m1.shape[0], len(m1rows))
tst.assertEqual(m1.shape[1], len(m1cols))
tst.assertEqual(m2.shape[0], len(m2rows))
tst.assertEqual(m2.shape[1], len(m2cols))
tst.assertEqual(len(m1rows), len(m2rows))
tst.assertEqual(len(m1cols), len(m2cols))
m1c = m1
if scipy.sparse.issparse(m1c):
m1c = m1c.todense()
m2d = m2
if scipy.sparse.issparse(m2d):
m2d = m2d.todense()
m2c = np.zeros((len(m2rows), len(m2cols)))
if m1_m2_rows_map is None:
rowmap = [m2rows.index(x) for x in m1rows]
else:
rowmap = [m2rows.index(m1_m2_rows_map[x]) for x in m1rows]
if m1_m2_cols_map is None:
colmap = [m2cols.index(x) for x in m1cols]
else:
colmap = [m2cols.index(m1_m2_cols_map[x]) for x in m1cols]
for i in range(len(m1rows)):
for j in range(len(m1cols)):
m2c[i, j] = m2d[rowmap[i], colmap[j]]
for i in range(len(m1rows)):
for j in range(len(m1cols)):
tst.assertAlmostEqual(m1c[i, j], m2c[i, j], places=7)
def setUp(self):
row = np.array([0, 3, 1, 2, 3, 0])
col = np.array([0, 0, 1, 2, 3, 3])
data = np.array([2., 1, 3, 4, 5, 1])
m = coo_matrix((data, (row, col)), shape=(4, 4))
self.block_m = m
bm = BlockMatrix(2, 2)
bm.name = 'basic_matrix'
bm.set_block(0, 0, m.copy())
bm.set_block(1, 1, m.copy())
bm.set_block(0, 1, m.copy())
self.basic_m = bm
self.dense = np.zeros((8, 8))
self.dense[0:4, 0:4] = m.toarray()
self.dense[0:4, 4:8] = m.toarray()
self.dense[4:8, 4:8] = m.toarray()
self.composed_m = BlockMatrix(2, 2)
self.composed_m.set_block(0, 0, self.block_m.copy())
self.composed_m.set_block(1, 1, self.basic_m.copy())
def test_compare_evaluations(self):
A1 = 5
A2 = 10
c1 = 3
c2 = 4
N = 6
dt = 1
m = create_pyomo_model(A1, A2, c1, c2, N, dt)
solver = pyo.SolverFactory('ipopt')
solver.options['linear_solver'] = 'mumps'
status = solver.solve(m, tee=False)
m_nlp = PyomoNLP(m)
mex = create_pyomo_external_grey_box_model(A1, A2, c1, c2, N, dt)
# mex_nlp = PyomoGreyBoxNLP(mex)
mex_nlp = PyomoNLPWithGreyBoxBlocks(mex)
# get the variable and constraint order and create the maps
# reliable order independent comparisons
m_x_order = m_nlp.primals_names()
m_c_order = m_nlp.constraint_names()
mex_x_order = mex_nlp.primals_names()
mex_c_order = mex_nlp.constraint_names()
x1list = [
'h1[0]', 'h1[1]', 'h1[2]', 'h1[3]', 'h1[4]', 'h1[5]', 'h2[0]',
'h2[1]', 'h2[2]', 'h2[3]', 'h2[4]', 'h2[5]', 'F1[1]', 'F1[2]',
'F1[3]', 'F1[4]', 'F1[5]', 'F2[1]', 'F2[2]', 'F2[3]', 'F2[4]',
'F2[5]', 'F12[0]', 'F12[1]', 'F12[2]', 'F12[3]', 'F12[4]',
'F12[5]', 'Fo[0]', 'Fo[1]', 'Fo[2]', 'Fo[3]', 'Fo[4]', 'Fo[5]'
]
x2list = [
'egb.inputs[h1_0]', 'egb.inputs[h1_1]', 'egb.inputs[h1_2]',
'egb.inputs[h1_3]', 'egb.inputs[h1_4]', 'egb.inputs[h1_5]',
'egb.inputs[h2_0]', 'egb.inputs[h2_1]', 'egb.inputs[h2_2]',
'egb.inputs[h2_3]', 'egb.inputs[h2_4]', 'egb.inputs[h2_5]',
'egb.inputs[F1_1]', 'egb.inputs[F1_2]', 'egb.inputs[F1_3]',
'egb.inputs[F1_4]', 'egb.inputs[F1_5]', 'egb.inputs[F2_1]',
'egb.inputs[F2_2]', 'egb.inputs[F2_3]', 'egb.inputs[F2_4]',
'egb.inputs[F2_5]', 'egb.outputs[F12_0]', 'egb.outputs[F12_1]',
'egb.outputs[F12_2]', 'egb.outputs[F12_3]', 'egb.outputs[F12_4]',
'egb.outputs[F12_5]', 'egb.outputs[Fo_0]', 'egb.outputs[Fo_1]',
'egb.outputs[Fo_2]', 'egb.outputs[Fo_3]', 'egb.outputs[Fo_4]',
'egb.outputs[Fo_5]'
]
x1_x2_map = dict(zip(x1list, x2list))
x1idx_x2idx_map = {
i: mex_x_order.index(x1_x2_map[m_x_order[i]])
for i in range(len(m_x_order))
}
c1list = [
'h1bal[1]', 'h1bal[2]', 'h1bal[3]', 'h1bal[4]', 'h1bal[5]',
'h2bal[1]', 'h2bal[2]', 'h2bal[3]', 'h2bal[4]', 'h2bal[5]',
'F12con[0]', 'F12con[1]', 'F12con[2]', 'F12con[3]', 'F12con[4]',
'F12con[5]', 'Focon[0]', 'Focon[1]', 'Focon[2]', 'Focon[3]',
'Focon[4]', 'Focon[5]', 'min_inflow[1]', 'min_inflow[2]',
'min_inflow[3]', 'min_inflow[4]', 'min_inflow[5]',
'max_outflow[0]', 'max_outflow[1]', 'max_outflow[2]',
'max_outflow[3]', 'max_outflow[4]', 'max_outflow[5]', 'h10', 'h20'
]
c2list = [
'egb.h1bal_1', 'egb.h1bal_2', 'egb.h1bal_3', 'egb.h1bal_4',
'egb.h1bal_5', 'egb.h2bal_1', 'egb.h2bal_2', 'egb.h2bal_3',
'egb.h2bal_4', 'egb.h2bal_5', 'egb.output_constraints[F12_0]',
'egb.output_constraints[F12_1]', 'egb.output_constraints[F12_2]',
'egb.output_constraints[F12_3]', 'egb.output_constraints[F12_4]',
'egb.output_constraints[F12_5]', 'egb.output_constraints[Fo_0]',
'egb.output_constraints[Fo_1]', 'egb.output_constraints[Fo_2]',
'egb.output_constraints[Fo_3]', 'egb.output_constraints[Fo_4]',
'egb.output_constraints[Fo_5]', 'min_inflow[1]', 'min_inflow[2]',
'min_inflow[3]', 'min_inflow[4]', 'min_inflow[5]',
'max_outflow[0]', 'max_outflow[1]', 'max_outflow[2]',
'max_outflow[3]', 'max_outflow[4]', 'max_outflow[5]', 'h10', 'h20'
]
c1_c2_map = dict(zip(c1list, c2list))
c1idx_c2idx_map = {
i: mex_c_order.index(c1_c2_map[m_c_order[i]])
for i in range(len(m_c_order))
}
# get the primals from m and put them in the correct order for mex
m_x = m_nlp.get_primals()
mex_x = np.zeros(len(m_x))
for i in range(len(m_x)):
mex_x[x1idx_x2idx_map[i]] = m_x[i]
# get the duals from m and put them in the correct order for mex
m_lam = m_nlp.get_duals()
mex_lam = np.zeros(len(m_lam))
for i in range(len(m_x)):
mex_lam[c1idx_c2idx_map[i]] = m_lam[i]
mex_nlp.set_primals(mex_x)
mex_nlp.set_duals(mex_lam)
m_obj = m_nlp.evaluate_objective()
mex_obj = mex_nlp.evaluate_objective()
self.assertAlmostEqual(m_obj, mex_obj, places=4)
m_gobj = m_nlp.evaluate_grad_objective()
mex_gobj = mex_nlp.evaluate_grad_objective()
check_vectors_specific_order(self, m_gobj, m_x_order, mex_gobj,
mex_x_order, x1_x2_map)
m_c = m_nlp.evaluate_constraints()
mex_c = mex_nlp.evaluate_constraints()
check_vectors_specific_order(self, m_c, m_c_order, mex_c, mex_c_order,
c1_c2_map)
m_j = m_nlp.evaluate_jacobian()
mex_j = mex_nlp.evaluate_jacobian().todense()
check_sparse_matrix_specific_order(self, m_j, m_c_order, m_x_order,
mex_j, mex_c_order, mex_x_order,
c1_c2_map, x1_x2_map)
m_h = m_nlp.evaluate_hessian_lag()
mex_h = mex_nlp.evaluate_hessian_lag()
check_sparse_matrix_specific_order(self, m_h, m_x_order, m_x_order,
mex_h, mex_x_order, mex_x_order,
x1_x2_map, x1_x2_map)
mex_h = 0 * mex_h
mex_nlp.evaluate_hessian_lag(out=mex_h)
check_sparse_matrix_specific_order(self, m_h, m_x_order, m_x_order,
mex_h, mex_x_order, mex_x_order,
x1_x2_map, x1_x2_map)
def __init__(self):
self._input_names = ['Pin', 'c', 'F']
self._input_values = np.zeros(3, dtype=np.float64)
self._output_names = ['Pout']
def test_xl(self):
xl = np.array([-np.inf, 0, 0])
self.assertTrue(np.allclose(xl, self.nlp3.xl()))
xl = np.zeros(2)
self.assertTrue(np.allclose(xl, self.nlp3.xl(condensed=True)))
def _apply_to(self, model, **kwds):
complicating_vars = kwds.pop('complicating_vars', None)
z_estimates = kwds.pop('z_estimates', None)
w_estimates = kwds.pop('w_estimates', None)
rho = kwds.pop('rho', 1.0)
if complicating_vars is None:
raise RuntimeError('need to pass list of complicating variables')
assert isinstance(complicating_vars, list)
cloned_vars = []
original_vars = []
for v in complicating_vars:
vid = aml.ComponentUID(v)
vv = vid.find_component_on(model)
if v.is_indexed():
raise RuntimeError('Indexed variables not supported')
else:
cloned_vars.append(vv)
original_vars.append(v)
nz = len(cloned_vars)
z_vals = np.zeros(nz)
if z_estimates is not None:
assert len(z_estimates) == nz
z_vals = z_estimates
w_vals = np.zeros(nz)
if w_estimates is not None:
assert len(w_estimates) == nz
w_vals = w_estimates
model._z = aml.Param(range(nz), initialize=0.0, mutable=True)
model._w = aml.Param(range(nz), initialize=0.0, mutable=True)
for i in range(nz):
model._z[i].value = z_vals[i]
model._w[i].value = w_vals[i]
model._rho = aml.Param(initialize=rho, mutable=True)
# defines objective
objectives = model.component_map(aml.Objective, active=True)
if len(objectives) > 1:
raise RuntimeError('Multiple objectives not supported')
obj = list(objectives.values())[0]
def rule_linkin_exprs(m, i):
return cloned_vars[i] - m._z[i]
# store non-anticipativity expression
model._linking_residuals = aml.Expression(range(nz),
rule=rule_linkin_exprs)
dual_term = 0.0
penalty_term = 0.0
for zid in range(nz):
dual_term += (model._linking_residuals[zid]) * model._w[zid]
penalty_term += (model._linking_residuals[zid])**2
# multiplier terms in objective
model._dual_obj_term = aml.Expression(expr=dual_term)
# penalty term
model._penalty_obj_term = aml.Expression(expr=0.5 * model._rho *
penalty_term)
model._aug_obj = aml.Objective(expr=obj.expr + model._dual_obj_term +
model._penalty_obj_term)
obj.deactivate()
def execute_extended_nlp_interface(self, anlp):
self.assertEqual(anlp.n_primals(), 9)
self.assertEqual(anlp.n_constraints(), 9)
self.assertEqual(anlp.n_eq_constraints(), 2)
self.assertEqual(anlp.n_ineq_constraints(), 7)
self.assertEqual(anlp.nnz_jacobian(), 9 * 9)
self.assertEqual(anlp.nnz_jacobian_eq(), 2 * 9)
self.assertEqual(anlp.nnz_jacobian_ineq(), 7 * 9)
self.assertEqual(anlp.nnz_hessian_lag(), 9 * 9)
expected_primals_lb = np.asarray(
[-1, -np.inf, -3, -np.inf, -5, -np.inf, -7, -np.inf, -9],
dtype=np.float64)
expected_primals_ub = np.asarray(
[1, 2, np.inf, np.inf, 5, 6, np.inf, np.inf, 9], dtype=np.float64)
self.assertTrue(np.array_equal(expected_primals_lb, anlp.primals_lb()))
self.assertTrue(np.array_equal(expected_primals_ub, anlp.primals_ub()))
expected_constraints_lb = np.asarray(
[-1, 0, -3, -np.inf, -5, 0, -7, -np.inf, -9], dtype=np.float64)
expected_constraints_ub = np.asarray([1, 0, np.inf, 4, 5, 0, np.inf, 8, 9],
dtype=np.float64)
self.assertTrue(
np.array_equal(expected_constraints_lb, anlp.constraints_lb()))
self.assertTrue(
np.array_equal(expected_constraints_ub, anlp.constraints_ub()))
expected_ineq_lb = np.asarray([-1, -3, -np.inf, -5, -7, -np.inf, -9],
dtype=np.float64)
expected_ineq_ub = np.asarray([1, np.inf, 4, 5, np.inf, 8, 9],
dtype=np.float64)
self.assertTrue(np.array_equal(expected_ineq_lb, anlp.ineq_lb()))
self.assertTrue(np.array_equal(expected_ineq_ub, anlp.ineq_ub()))
expected_init_primals = np.ones(9)
self.assertTrue(np.array_equal(expected_init_primals, anlp.init_primals()))
expected_init_duals = np.asarray([1, 2, 3, 4, 5, 6, 7, 8, 9],
dtype=np.float64)
self.assertTrue(np.array_equal(expected_init_duals, anlp.init_duals()))
expected_init_duals_ineq = np.asarray([1, 3, 4, 5, 7, 8, 9],
dtype=np.float64)
self.assertTrue(
np.array_equal(expected_init_duals_ineq, anlp.init_duals_ineq()))
expected_init_duals_eq = np.asarray([2, 6], dtype=np.float64)
self.assertTrue(
np.array_equal(expected_init_duals_eq, anlp.init_duals_eq()))
t = anlp.create_new_vector('primals')
self.assertTrue(t.size == 9)
t = anlp.create_new_vector('constraints')
self.assertTrue(t.size == 9)
t = anlp.create_new_vector('eq_constraints')
self.assertTrue(t.size == 2)
t = anlp.create_new_vector('ineq_constraints')
self.assertTrue(t.size == 7)
t = anlp.create_new_vector('duals')
self.assertTrue(t.size == 9)
t = anlp.create_new_vector('duals_eq')
self.assertTrue(t.size == 2)
t = anlp.create_new_vector('duals_ineq')
self.assertTrue(t.size == 7)
expected_primals = [i + 1 for i in range(9)]
new_primals = np.asarray(expected_primals, dtype=np.float64)
expected_primals = np.asarray(expected_primals, dtype=np.float64)
anlp.set_primals(new_primals)
ret = anlp.get_primals()
self.assertTrue(np.array_equal(new_primals, ret))
self.assertTrue(np.array_equal(expected_primals, anlp._primals))
anlp.set_primals(np.ones(9))
expected_duals = [i + 1 for i in range(9)]
new_duals = np.asarray(expected_duals, dtype=np.float64)
expected_duals = np.asarray(expected_duals, dtype=np.float64)
anlp.set_duals(new_duals)
self.assertTrue(np.array_equal(expected_duals, anlp._duals_full))
ret = anlp.get_duals()
self.assertTrue(np.array_equal(new_duals, ret))
expected_duals_eq = np.asarray([2, 6], dtype=np.float64)
self.assertTrue(np.array_equal(expected_duals_eq, anlp._duals_eq))
expected_duals_ineq = np.asarray([1, 3, 4, 5, 7, 8, 9], dtype=np.float64)
self.assertTrue(np.array_equal(expected_duals_ineq, anlp._duals_ineq))
anlp.set_duals(np.ones(9))
expected_duals_eq = [i + 1 for i in range(2)]
new_duals_eq = np.asarray(expected_duals_eq, dtype=np.float64)
anlp.set_duals_eq(new_duals_eq)
ret = anlp.get_duals_eq()
self.assertTrue(np.array_equal(new_duals_eq, ret))
self.assertTrue(np.array_equal(expected_duals_eq, anlp._duals_eq))
expected_duals = np.asarray([1, 1, 1, 1, 1, 2, 1, 1, 1], dtype=np.float64)
self.assertTrue(np.array_equal(expected_duals, anlp._duals_full))
expected_duals_ineq = np.asarray([1, 1, 1, 1, 1, 1, 1], dtype=np.float64)
self.assertTrue(np.array_equal(expected_duals_ineq, anlp._duals_ineq))
anlp.set_duals_eq(np.ones(2))
expected_duals = np.asarray([1, 1, 1, 1, 1, 1, 1, 1, 1], dtype=np.float64)
self.assertTrue(np.array_equal(expected_duals, anlp._duals_full))
expected_duals_ineq = [i + 1 for i in range(7)]
new_duals_ineq = np.asarray(expected_duals_ineq, dtype=np.float64)
anlp.set_duals_ineq(new_duals_ineq)
ret = anlp.get_duals_ineq()
self.assertTrue(np.array_equal(new_duals_ineq, ret))
self.assertTrue(np.array_equal(expected_duals_ineq, anlp._duals_ineq))
expected_duals = np.asarray([1, 1, 2, 3, 4, 1, 5, 6, 7], dtype=np.float64)
self.assertTrue(np.array_equal(expected_duals, anlp._duals_full))
expected_duals_eq = np.asarray([1, 1], dtype=np.float64)
self.assertTrue(np.array_equal(expected_duals_eq, anlp._duals_eq))
anlp.set_duals_ineq(np.ones(7))
expected_duals = np.asarray([1, 1, 1, 1, 1, 1, 1, 1, 1], dtype=np.float64)
self.assertTrue(np.array_equal(expected_duals, anlp._duals_full))
# objective function
expected_objective = sum(
(i + 1) * (j + 1) for i in range(9) for j in range(9))
self.assertEqual(expected_objective, anlp.evaluate_objective())
# change the value of the primals
anlp.set_primals(2.0 * np.ones(9))
expected_objective = sum(2.0**2 * (i + 1) * (j + 1) for i in range(9)
for j in range(9))
self.assertEqual(expected_objective, anlp.evaluate_objective())
anlp.set_primals(np.ones(9))
# gradient of the objective
expected_gradient = np.asarray(
[2 * sum((i + 1) * (j + 1) for j in range(9)) for i in range(9)],
dtype=np.float64)
grad_obj = anlp.evaluate_grad_objective()
self.assertTrue(np.array_equal(expected_gradient, grad_obj))
# test inplace
grad_obj = np.ones(9)
ret = anlp.evaluate_grad_objective(out=grad_obj)
self.assertTrue(ret is grad_obj)
self.assertTrue(np.array_equal(expected_gradient, grad_obj))
# change the value of the primals
anlp.set_primals(2.0 * np.ones(9))
expected_gradient = np.asarray(
[2 * 2 * sum((i + 1) * (j + 1) for j in range(9)) for i in range(9)],
dtype=np.float64)
grad_obj = np.ones(9)
anlp.evaluate_grad_objective(out=grad_obj)
self.assertTrue(np.array_equal(expected_gradient, grad_obj))
anlp.set_primals(np.ones(9))
# full constraints
con = anlp.evaluate_constraints()
expected_con = np.asarray(
[45, 88, 3 * 45, 4 * 45, 5 * 45, 276, 7 * 45, 8 * 45, 9 * 45],
dtype=np.float64)
self.assertTrue(np.array_equal(expected_con, con))
# test inplace
con = np.zeros(9)
ret = anlp.evaluate_constraints(out=con)
self.assertTrue(ret is con)
self.assertTrue(np.array_equal(expected_con, con))
# change the value of the primals
anlp.set_primals(2.0 * np.ones(9))
con = np.zeros(9)
anlp.evaluate_constraints(out=con)
expected_con = np.asarray([
2 * 45, 2 * (88 + 2) - 2, 2 * 3 * 45, 2 * 4 * 45, 2 * 5 * 45, 2 *
(276 - 6) + 6, 2 * 7 * 45, 2 * 8 * 45, 2 * 9 * 45
],
dtype=np.float64)
self.assertTrue(np.array_equal(expected_con, con))
anlp.set_primals(np.ones(9))
# equality constraints
con_eq = anlp.evaluate_eq_constraints()
expected_con_eq = np.asarray([88, 276], dtype=np.float64)
self.assertTrue(np.array_equal(expected_con_eq, con_eq))
# test inplace
con_eq = np.zeros(2)
ret = anlp.evaluate_eq_constraints(out=con_eq)
self.assertTrue(ret is con_eq)
self.assertTrue(np.array_equal(expected_con_eq, con_eq))
# change the value of the primals
anlp.set_primals(2.0 * np.ones(9))
con_eq = np.zeros(2)
anlp.evaluate_eq_constraints(out=con_eq)
expected_con_eq = np.asarray([2 * (88 + 2) - 2, 2 * (276 - 6) + 6],
dtype=np.float64)
self.assertTrue(np.array_equal(expected_con_eq, con_eq))
anlp.set_primals(np.ones(9))
# inequality constraints
con_ineq = anlp.evaluate_ineq_constraints()
expected_con_ineq = np.asarray(
[45, 3 * 45, 4 * 45, 5 * 45, 7 * 45, 8 * 45, 9 * 45], dtype=np.float64)
self.assertTrue(np.array_equal(expected_con_ineq, con_ineq))
# test inplace
con_ineq = np.zeros(7)
ret = anlp.evaluate_ineq_constraints(out=con_ineq)
self.assertTrue(ret is con_ineq)
self.assertTrue(np.array_equal(expected_con_ineq, con_ineq))
# change the value of the primals
anlp.set_primals(2.0 * np.ones(9))
con_ineq = np.zeros(7)
anlp.evaluate_ineq_constraints(out=con_ineq)
expected_con_ineq = 2.0 * expected_con_ineq
self.assertTrue(np.array_equal(expected_con_ineq, con_ineq))
anlp.set_primals(np.ones(9))
# jacobian of all constraints
jac = anlp.evaluate_jacobian()
dense_jac = jac.todense()
expected_jac = [[(i) * (j) for j in range(1, 10)] for i in range(1, 10)]
expected_jac = np.asarray(expected_jac, dtype=np.float64)
self.assertTrue(np.array_equal(dense_jac, expected_jac))
# test inplace
jac.data = 0 * jac.data
ret = anlp.evaluate_jacobian(out=jac)
self.assertTrue(ret is jac)
dense_jac = jac.todense()
self.assertTrue(np.array_equal(dense_jac, expected_jac))
# change the value of the primals
# ToDo: not a great test since this problem is linear
anlp.set_primals(2.0 * np.ones(9))
anlp.evaluate_jacobian(out=jac)
dense_jac = jac.todense()
self.assertTrue(np.array_equal(dense_jac, expected_jac))
# jacobian of equality constraints
jac_eq = anlp.evaluate_jacobian_eq()
dense_jac_eq = jac_eq.todense()
expected_jac_eq = np.asarray([[2, 4, 6, 8, 10, 12, 14, 16, 18],
[6, 12, 18, 24, 30, 36, 42, 48, 54]],
dtype=np.float64)
self.assertTrue(np.array_equal(dense_jac_eq, expected_jac_eq))
# test inplace
jac_eq.data = 0 * jac_eq.data
ret = anlp.evaluate_jacobian_eq(out=jac_eq)
self.assertTrue(ret is jac_eq)
dense_jac_eq = jac_eq.todense()
self.assertTrue(np.array_equal(dense_jac_eq, expected_jac_eq))
# change the value of the primals
# ToDo: not a great test since this problem is linear
anlp.set_primals(2.0 * np.ones(9))
anlp.evaluate_jacobian_eq(out=jac_eq)
dense_jac_eq = jac_eq.todense()
self.assertTrue(np.array_equal(dense_jac_eq, expected_jac_eq))
# jacobian of inequality constraints
jac_ineq = anlp.evaluate_jacobian_ineq()
dense_jac_ineq = jac_ineq.todense()
expected_jac_ineq = [[(i) * (j) for j in range(1, 10)]
for i in [1, 3, 4, 5, 7, 8, 9]]
expected_jac_ineq = np.asarray(expected_jac_ineq, dtype=np.float64)
self.assertTrue(np.array_equal(dense_jac_ineq, expected_jac_ineq))
# test inplace
jac_ineq.data = 0 * jac_ineq.data
ret = anlp.evaluate_jacobian_ineq(out=jac_ineq)
self.assertTrue(ret is jac_ineq)
dense_jac_ineq = jac_ineq.todense()
self.assertTrue(np.array_equal(dense_jac_ineq, expected_jac_ineq))
# change the value of the primals
# ToDo: not a great test since this problem is linear
anlp.set_primals(2.0 * np.ones(9))
anlp.evaluate_jacobian_ineq(out=jac_ineq)
dense_jac_ineq = jac_ineq.todense()
self.assertTrue(np.array_equal(dense_jac_ineq, expected_jac_ineq))
# hessian
hess = anlp.evaluate_hessian_lag()
dense_hess = hess.todense()
expected_hess = [[2.0 * i * j for j in range(1, 10)] for i in range(1, 10)]
expected_hess = np.asarray(expected_hess, dtype=np.float64)
self.assertTrue(np.array_equal(dense_hess, expected_hess))
# test inplace
hess.data = np.zeros(len(hess.data))
ret = anlp.evaluate_hessian_lag(out=hess)
self.assertTrue(ret is hess)
dense_hess = hess.todense()
self.assertTrue(np.array_equal(dense_hess, expected_hess))
# change the value of the primals
anlp.set_primals(2.0 * np.ones(9))
anlp.evaluate_hessian_lag(out=hess)
dense_hess = hess.todense()
self.assertTrue(np.array_equal(dense_hess, expected_hess))
# change the value of the obj factor
anlp.set_obj_factor(2.0)
hess = anlp.evaluate_hessian_lag()
dense_hess = hess.todense()
expected_hess = [[4.0 * i * j for j in range(1, 10)] for i in range(1, 10)]
expected_hess = np.asarray(expected_hess, dtype=np.float64)
self.assertTrue(np.array_equal(dense_hess, expected_hess))
def test_max_with_empty_blocks(self):
b = BlockVector(3)
b.set_block(0, np.zeros(3))
b.set_block(1, np.zeros(0))
b.set_block(2, np.zeros(3))
self.assertEqual(b.max(), 0)
def __init__(self):
super(PressureDropTwoEqualitiesTwoOutputsWithHessian, self).__init__()
self._eq_con_mult_values = np.zeros(2, dtype=np.float64)
self._output_con_mult_values = np.zeros(2, dtype=np.float64)
