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