def process_init(x, lb, ub):
if np.any((ub - lb) < 0):
raise ValueError(
'Lower bounds for variables/inequalities should not be larger than upper bounds.'
)
if np.any((ub - lb) == 0):
raise ValueError(
'Variables and inequalities should not have equal lower and upper bounds.'
)
lb_mask = build_bounds_mask(lb)
ub_mask = build_bounds_mask(ub)
lb_only = np.logical_and(lb_mask, np.logical_not(ub_mask))
ub_only = np.logical_and(ub_mask, np.logical_not(lb_mask))
lb_and_ub = np.logical_and(lb_mask, ub_mask)
out_of_bounds = ((x >= ub) + (x <= lb))
out_of_bounds_lb_only = np.logical_and(out_of_bounds, lb_only)
out_of_bounds_ub_only = np.logical_and(out_of_bounds, ub_only)
out_of_bounds_lb_and_ub = np.logical_and(out_of_bounds, lb_and_ub)
cm = build_compression_matrix(out_of_bounds_lb_only)
x[out_of_bounds_lb_only] = cm * (lb + 1)
cm = build_compression_matrix(out_of_bounds_ub_only)
x[out_of_bounds_ub_only] = cm * (ub - 1)
del cm
cm1 = build_compression_matrix(lb_and_ub)
cm2 = build_compression_matrix(out_of_bounds_lb_and_ub)
x[out_of_bounds_lb_and_ub] = cm2 * (0.5 * cm1.transpose() *
(cm1 * lb + cm1 * ub))
def process_init(x, lb, ub):
if np.any((ub - lb) < 0):
raise ValueError(
'Lower bounds for variables/inequalities should not be larger than upper bounds.')
if np.any((ub - lb) == 0):
raise ValueError(
'Variables and inequalities should not have equal lower and upper bounds.')
lb_mask = build_bounds_mask(lb)
ub_mask = build_bounds_mask(ub)
lb_only = np.logical_and(lb_mask, np.logical_not(ub_mask))
ub_only = np.logical_and(ub_mask, np.logical_not(lb_mask))
lb_and_ub = np.logical_and(lb_mask, ub_mask)
out_of_bounds = ((x >= ub) + (x <= lb))
out_of_bounds_lb_only = np.logical_and(out_of_bounds, lb_only).nonzero()[0]
out_of_bounds_ub_only = np.logical_and(out_of_bounds, ub_only).nonzero()[0]
out_of_bounds_lb_and_ub = np.logical_and(out_of_bounds, lb_and_ub).nonzero()[0]
np.put(x, out_of_bounds_lb_only, lb[out_of_bounds_lb_only] + 1)
np.put(x, out_of_bounds_ub_only, ub[out_of_bounds_ub_only] - 1)
cm = build_compression_matrix(lb_and_ub).tocsr()
np.put(x, out_of_bounds_lb_and_ub,
(0.5 * cm.transpose() * (cm * lb + cm * ub))[out_of_bounds_lb_and_ub])
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))
solver.solve(model, tee=True)
# build nlp initialized at the solution
nlp = PyomoNLP(model)
# get initial point
print(nlp.variable_names())
x0 = nlp.init_primals()
# vectors of lower and upper bounds
xl = nlp.primals_lb()
xu = nlp.primals_ub()
# demonstrate use of compression from full set of bounds
# to only finite bounds using masks
xlb_mask = build_bounds_mask(xl)
xub_mask = build_bounds_mask(xu)
# get the compressed vector
compressed_xl = full_to_compressed(xl, xlb_mask)
compressed_xu = full_to_compressed(xu, xub_mask)
# we can also build compression matrices
Cx_xl = build_compression_matrix(xlb_mask)
Cx_xu = build_compression_matrix(xub_mask)
# lower and upper bounds residual
res_xl = Cx_xl * x0 - compressed_xl
res_xu = compressed_xu - Cx_xu * x0
print("Residuals lower bounds x-xl:", res_xl)
print("Residuals upper bounds xu-x:", res_xu)
# set the value of the primals (we can skip the duals)
def main():
model = create_basic_model()
solver = pyo.SolverFactory('ipopt')
solver.solve(model, tee=True)
# build nlp initialized at the solution
nlp = PyomoNLP(model)
# get initial point
print(nlp.primals_names())
x0 = nlp.get_primals()
# vectors of lower and upper bounds
xl = nlp.primals_lb()
xu = nlp.primals_ub()
# demonstrate use of compression from full set of bounds
# to only finite bounds using masks
xlb_mask = build_bounds_mask(xl)
xub_mask = build_bounds_mask(xu)
# get the compressed vector
compressed_xl = full_to_compressed(xl, xlb_mask)
compressed_xu = full_to_compressed(xu, xub_mask)
# we can also build compression matrices
Cx_xl = build_compression_matrix(xlb_mask)
Cx_xu = build_compression_matrix(xub_mask)
# lower and upper bounds residual
res_xl = Cx_xl * x0 - compressed_xl
res_xu = compressed_xu - Cx_xu * x0
print("Residuals lower bounds x-xl:", res_xl)
print("Residuals upper bounds xu-x:", res_xu)
# set the value of the primals (we can skip the duals)
# here we set them to the initial values, but we could
# set them to anything
nlp.set_primals(x0)
# evaluate residual of equality constraints
print(nlp.constraint_names())
res_eq = nlp.evaluate_eq_constraints()
print("Residuals of equality constraints:", res_eq)
# evaluate residual of inequality constraints
res_ineq = nlp.evaluate_ineq_constraints()
# demonstrate the use of compression from full set of
# lower and upper bounds on the inequality constraints
# to only the finite values using masks
ineqlb_mask = build_bounds_mask(nlp.ineq_lb())
inequb_mask = build_bounds_mask(nlp.ineq_ub())
# get the compressed vector
compressed_ineq_lb = full_to_compressed(nlp.ineq_lb(), ineqlb_mask)
compressed_ineq_ub = full_to_compressed(nlp.ineq_ub(), inequb_mask)
# we can also build compression matrices
Cineq_ineqlb = build_compression_matrix(ineqlb_mask)
Cineq_inequb = build_compression_matrix(inequb_mask)
# lower and upper inequalities residual
res_ineq_lb = Cineq_ineqlb * res_ineq - compressed_ineq_lb
res_ineq_ub = compressed_ineq_ub - Cineq_inequb * res_ineq
print("Residuals of inequality constraints lower bounds:", res_ineq_lb)
print("Residuals of inequality constraints upper bounds:", res_ineq_ub)
feasible = False
if np.all(res_xl >= 0) and np.all(res_xu >= 0) \
and np.all(res_ineq_lb >= 0) and np.all(res_ineq_ub >= 0) and \
np.allclose(res_eq, np.zeros(nlp.n_eq_constraints()), atol=1e-5):
feasible = True
print("Is x0 feasible:", feasible)
return feasible
