def evaluate_hessian_equality_constraints(self): c = self._input_values[1] F = self._input_values[2] irow = np.asarray([2, 2], dtype=np.int64) jcol = np.asarray([1, 2], dtype=np.int64) nonzeros = self._eq_con_mult_values[0]*np.asarray([8*F, 8*c], dtype=np.float64) hess = spa.coo_matrix((nonzeros, (irow, jcol)), shape=(4,4)) return hess
def evaluate_jacobian_outputs(self): c = self._input_values[1] F = self._input_values[2] irow = np.asarray([0, 0, 0], dtype=np.int64) jcol = np.asarray([0, 1, 2], dtype=np.int64) nonzeros = np.asarray([1, -4 * F**2, -4 * c * 2 * F], dtype=np.float64) jac = spa.coo_matrix((nonzeros, (irow, jcol)), shape=(1, 3)) return jac
def evaluate_jacobian_equality_constraints(self): c = self._input_values[1] F = self._input_values[2] irow = np.asarray([0, 0, 0, 0, 1, 1, 1, 1], dtype=np.int64) jcol = np.asarray([0, 1, 2, 3, 1, 2, 3, 4], dtype=np.int64) nonzeros = np.asarray([-1, F**2, 2*c*F, 1, 2*F**2, 4*c*F, -1, 1], dtype=np.float64) jac = spa.coo_matrix((nonzeros, (irow, jcol)), shape=(2,5)) return jac
def evaluate_hessian_outputs(self): c = self._input_values[1] F = self._input_values[2] irow = np.asarray([2, 2], dtype=np.int64) jcol = np.asarray([1, 2], dtype=np.int64) data = self._output_con_mult_values[0]*np.asarray([-8*F, -8*c], dtype=np.float64) hess = spa.coo_matrix((data, (irow, jcol)), shape=(3,3)) return hess
def evaluate_hessian_outputs(self): c = self._input_values[1] F = self._input_values[2] y1 = self._output_con_mult_values[0] y2 = self._output_con_mult_values[1] irow = np.asarray([2, 2], dtype=np.int64) jcol = np.asarray([1, 2], dtype=np.int64) nonzeros = np.asarray([y1*(-2*F) + y2*(-8*F), y1*(-2*c)+y2*(-8*c)], dtype=np.float64) hess = spa.coo_matrix((nonzeros, (irow, jcol)), shape=(5,5)) return hess
def test_interface(self): # weird, this is really a test of the test class above # but we could add code later, so... iom = PressureDropModel() iom.set_inputs(np.ones(4)) o = iom.evaluate_outputs() expected_o = np.asarray([0.0, -1.0], dtype=np.float64) self.assertTrue(np.array_equal(o, expected_o)) jac = iom.evaluate_derivatives() expected_jac = np.asarray([[1, -1, 0, -2], [1, -1, -1, -4]], dtype=np.float64) self.assertTrue(np.array_equal(jac.todense(), expected_jac))
def evaluate_outputs(self): Pin = self._input_values[0] c = self._input_values[1] F = self._input_values[2] P1 = self._input_values[3] return np.asarray([P1 - c * F**2, Pin - 4 * c * F**2], dtype=np.float64)
def evaluate_outputs(self): Pin = self._input_values[0] c = self._input_values[1] F = self._input_values[2] P2 = Pin - 2 * c * F**2 Pout = Pin - 4 * c * F**2 return np.asarray([P2, Pout], dtype=np.float64)
def evaluate_equality_constraints(self): Pin = self._input_values[0] c = self._input_values[1] F = self._input_values[2] P1 = self._input_values[3] P3 = self._input_values[4] return np.asarray([P1 - (Pin - c*F**2), P3 - (P1 - 2*c*F**2)], dtype=np.float64)
def evaluate_equality_constraints(self): Pin = self._input_values[0] c = self._input_values[1] F = self._input_values[2] P2 = self._input_values[3] Pout = self._input_values[4] return np.asarray([P2 - (Pin - 2*c*F**2), Pout - (P2 - 2*c*F**2)], dtype=np.float64)
def evaluate_derivatives(self): jac = [[1, -self._F**2, 0, -2 * self._c1 * self._F], [ 1, -self._F**2, -self._F**2, -2 * self._F * (self._c1 + self._c2) ]] jac = np.asarray(jac, dtype=np.float64) return spa.coo_matrix(jac)
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_repeated_row_col(self): data = [1.0, 0.0, 2.0] row = [1, 2, 1] col = [2, 2, 2] A = scipy.sparse.coo_matrix((data, (row, col)), shape=(3, 3)) data = [3.0, 0.0] row = [1, 2] col = [2, 2] B = scipy.sparse.coo_matrix((data, (row, col)), shape=(3, 3)) # Our CondensedSparseSummation should not remove any # structural nonzeros sparse_sum = utils.CondensedSparseSummation([A, B]) C = sparse_sum.sum([A, B]) expected_data = np.asarray([6.0, 0.0], dtype=np.float64) expected_row = np.asarray([1, 2], dtype=np.int64) expected_col = np.asarray([2, 2], dtype=np.int64) self.assertTrue(np.array_equal(expected_data, C.data)) self.assertTrue(np.array_equal(expected_row, C.row)) self.assertTrue(np.array_equal(expected_col, C.col))
def test_nlp_interface(self): nlp = PyomoNLP(self.pm) execute_extended_nlp_interface(self, nlp) self.assertTrue(nlp.pyomo_model() is self.pm) self.assertEqual(float(nlp.get_obj_scaling()), 5.0) xs = nlp.get_primals_scaling() expected_xs = np.asarray([2.0, 4.0, 6.0, 8.0, 10.0, 12.0, 14.0, 16.0, 18.0]) self.assertTrue(np.array_equal(xs, expected_xs)) cs = nlp.get_constraints_scaling() expected_cs = np.asarray([ 3.0, 6.0, 9.0, 12.0, 15.0, 18.0, 21.0, 24.0, 27.0 ]) self.assertTrue(np.array_equal(cs, expected_cs)) eqcs = nlp.get_eq_constraints_scaling() expected_eqcs = np.asarray([ 6.0, 18.0 ]) self.assertTrue(np.array_equal(eqcs, expected_eqcs)) ineqcs = nlp.get_ineq_constraints_scaling() expected_ineqcs = np.asarray([ 3.0, 9.0, 12.0, 15.0, 21.0, 24.0, 27.0 ]) self.assertTrue(np.array_equal(ineqcs, expected_ineqcs))
def test_condensed_sparse_summation(self): data = [1.0, 0.0] row = [1, 2] col = [2, 2] A = scipy.sparse.coo_matrix((data, (row, col)), shape=(3, 3)) data = [3.0, 0.0] B = scipy.sparse.coo_matrix((data, (row, col)), shape=(3, 3)) # By default, scipy will remove structural nonzeros that # have zero values C = A + B self.assertEqual(C.nnz, 1) # Our CondensedSparseSummation should not remove any # structural nonzeros sparse_sum = utils.CondensedSparseSummation([A, B]) C = sparse_sum.sum([A, B]) expected_data = np.asarray([4.0, 0.0], dtype=np.float64) expected_row = np.asarray([1, 2], dtype=np.int64) expected_col = np.asarray([2, 2], dtype=np.int64) self.assertTrue(np.array_equal(expected_data, C.data)) self.assertTrue(np.array_equal(expected_row, C.row)) self.assertTrue(np.array_equal(expected_col, C.col)) B.data[1] = 5.0 C = sparse_sum.sum([A, B]) expected_data = np.asarray([4.0, 5.0], dtype=np.float64) self.assertTrue(np.array_equal(expected_data, C.data)) self.assertTrue(np.array_equal(expected_row, C.row)) self.assertTrue(np.array_equal(expected_col, C.col)) B.data[1] = 0.0 C = sparse_sum.sum([A, B]) expected_data = np.asarray([4.0, 0.0], dtype=np.float64) self.assertTrue(np.array_equal(expected_data, C.data)) self.assertTrue(np.array_equal(expected_row, C.row)) self.assertTrue(np.array_equal(expected_col, C.col))
def evaluate_equality_constraints(self): return np.asarray([self._u**2 - 1])
def test_indices_methods(self): nlp = PyomoNLP(self.pm) # get_pyomo_variables variables = nlp.get_pyomo_variables() expected_ids = [id(self.pm.x[i]) for i in range(1, 10)] ids = [id(variables[i]) for i in range(9)] self.assertTrue(expected_ids == ids) variable_names = nlp.variable_names() expected_names = [self.pm.x[i].getname() for i in range(1, 10)] self.assertTrue(variable_names == expected_names) # get_pyomo_constraints constraints = nlp.get_pyomo_constraints() expected_ids = [id(self.pm.c[i]) for i in range(1, 10)] ids = [id(constraints[i]) for i in range(9)] self.assertTrue(expected_ids == ids) constraint_names = nlp.constraint_names() expected_names = [c.getname() for c in nlp.get_pyomo_constraints()] self.assertTrue(constraint_names == expected_names) # get_primal_indices expected_primal_indices = [i for i in range(9)] self.assertTrue( expected_primal_indices == nlp.get_primal_indices([self.pm.x])) expected_primal_indices = [0, 3, 8, 4] variables = [self.pm.x[1], self.pm.x[4], self.pm.x[9], self.pm.x[5]] self.assertTrue( expected_primal_indices == nlp.get_primal_indices(variables)) # get_constraint_indices expected_constraint_indices = [i for i in range(9)] self.assertTrue(expected_constraint_indices == nlp.get_constraint_indices([self.pm.c])) expected_constraint_indices = [0, 3, 8, 4] constraints = [self.pm.c[1], self.pm.c[4], self.pm.c[9], self.pm.c[5]] self.assertTrue(expected_constraint_indices == nlp.get_constraint_indices(constraints)) # extract_subvector_grad_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 = nlp.extract_subvector_grad_objective([self.pm.x]) self.assertTrue(np.array_equal(expected_gradient, grad_obj)) expected_gradient = np.asarray([ 2 * sum((i + 1) * (j + 1) for j in range(9)) for i in [0, 3, 8, 4] ], dtype=np.float64) variables = [self.pm.x[1], self.pm.x[4], self.pm.x[9], self.pm.x[5]] grad_obj = nlp.extract_subvector_grad_objective(variables) self.assertTrue(np.array_equal(expected_gradient, grad_obj)) # extract_subvector_constraints expected_con = np.asarray( [45, 88, 3 * 45, 4 * 45, 5 * 45, 276, 7 * 45, 8 * 45, 9 * 45], dtype=np.float64) con = nlp.extract_subvector_constraints([self.pm.c]) self.assertTrue(np.array_equal(expected_con, con)) expected_con = np.asarray([45, 4 * 45, 9 * 45, 5 * 45], dtype=np.float64) constraints = [self.pm.c[1], self.pm.c[4], self.pm.c[9], self.pm.c[5]] con = nlp.extract_subvector_constraints(constraints) self.assertTrue(np.array_equal(expected_con, con)) # extract_submatrix_jacobian 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) jac = nlp.extract_submatrix_jacobian(pyomo_variables=[self.pm.x], pyomo_constraints=[self.pm.c]) dense_jac = jac.todense() self.assertTrue(np.array_equal(dense_jac, expected_jac)) expected_jac = [[(i) * (j) for j in [1, 4, 9, 5]] for i in [2, 6, 4]] expected_jac = np.asarray(expected_jac, dtype=np.float64) variables = [self.pm.x[1], self.pm.x[4], self.pm.x[9], self.pm.x[5]] constraints = [self.pm.c[2], self.pm.c[6], self.pm.c[4]] jac = nlp.extract_submatrix_jacobian(pyomo_variables=variables, pyomo_constraints=constraints) dense_jac = jac.todense() self.assertTrue(np.array_equal(dense_jac, expected_jac)) # extract_submatrix_hessian_lag 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) hess = nlp.extract_submatrix_hessian_lag( pyomo_variables_rows=[self.pm.x], pyomo_variables_cols=[self.pm.x]) dense_hess = hess.todense() self.assertTrue(np.array_equal(dense_hess, expected_hess)) expected_hess = [[2.0 * i * j for j in [1, 4, 9, 5]] for i in [1, 4, 9, 5]] expected_hess = np.asarray(expected_hess, dtype=np.float64) variables = [self.pm.x[1], self.pm.x[4], self.pm.x[9], self.pm.x[5]] hess = nlp.extract_submatrix_hessian_lag( pyomo_variables_rows=variables, pyomo_variables_cols=variables) dense_hess = hess.todense() self.assertTrue(np.array_equal(dense_hess, expected_hess))
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 evaluate_outputs(self): P1 = self._Pin - self._c1*self._F**2 P2 = P1 - self._c2*self._F**2 return np.asarray([P1, P2], dtype=np.float64)
def test_model1(self): model = create_model1() nlp = PyomoNLP(model) cynlp = CyIpoptNLP(nlp) # test x_init expected_xinit = np.asarray([4.0, 4.0, 4.0], dtype=np.float64) xinit = cynlp.x_init() self.assertTrue(np.array_equal(xinit, expected_xinit)) # test x_lb expected_xlb = list() for v in nlp.get_pyomo_variables(): if v.lb == None: expected_xlb.append(-np.inf) else: expected_xlb.append(v.lb) expected_xlb = np.asarray(expected_xlb) xlb = cynlp.x_lb() self.assertTrue(np.array_equal(xlb, expected_xlb)) # test x_ub expected_xub = list() for v in nlp.get_pyomo_variables(): if v.ub == None: expected_xub.append(np.inf) else: expected_xub.append(v.ub) expected_xub = np.asarray(expected_xub) xub = cynlp.x_ub() self.assertTrue(np.array_equal(xub, expected_xub)) # test g_lb expected_glb = np.asarray([-np.inf, 0.0], dtype=np.float64) glb = cynlp.g_lb() self.assertTrue(np.array_equal(glb, expected_glb)) # test g_ub expected_gub = np.asarray([18, 0.0], dtype=np.float64) gub = cynlp.g_ub() print(expected_gub) print(gub) self.assertTrue(np.array_equal(gub, expected_gub)) x = cynlp.x_init() # test objective self.assertEqual(cynlp.objective(x), -504) # test gradient expected = np.asarray([-576, 8, 64], dtype=np.float64) self.assertTrue(np.allclose(expected, cynlp.gradient(x))) # test constraints expected = np.asarray([20, -5], dtype=np.float64) constraints = cynlp.constraints(x) self.assertTrue(np.allclose(expected, constraints)) # test jacobian expected = np.asarray([[8.0, 0, 1.0],[0.0, 8.0, 1.0]]) spexpected = spa.coo_matrix(expected).todense() rows, cols = cynlp.jacobianstructure() values = cynlp.jacobian(x) jac = spa.coo_matrix((values, (rows,cols)), shape=(len(constraints), len(x))).todense() self.assertTrue(np.allclose(spexpected, jac)) # test hessian y = constraints.copy() y.fill(1.0) rows, cols = cynlp.hessianstructure() values = cynlp.hessian(x, y, obj_factor=1.0) hess_lower = spa.coo_matrix((values, (rows,cols)), shape=(len(x), len(x))).todense() expected_hess_lower = np.asarray([[-286.0, 0.0, 0.0], [0.0, 4.0, 0.0], [-144.0, 0.0, 192.0]], dtype=np.float64) self.assertTrue(np.allclose(expected_hess_lower, hess_lower))
def test_indices_methods(self): nlp = PyomoNLP(self.pm) # get_pyomo_variables variables = nlp.get_pyomo_variables() expected_ids = [id(self.pm.x[i]) for i in range(1, 10)] ids = [id(variables[i]) for i in range(9)] self.assertTrue(expected_ids == ids) variable_names = nlp.variable_names() expected_names = [self.pm.x[i].getname() for i in range(1, 10)] self.assertTrue(variable_names == expected_names) # get_pyomo_constraints constraints = nlp.get_pyomo_constraints() expected_ids = [id(self.pm.c[i]) for i in range(1, 10)] ids = [id(constraints[i]) for i in range(9)] self.assertTrue(expected_ids == ids) constraint_names = nlp.constraint_names() expected_names = [c.getname() for c in nlp.get_pyomo_constraints()] self.assertTrue(constraint_names == expected_names) # get_pyomo_equality_constraints eq_constraints = nlp.get_pyomo_equality_constraints() # 2 and 6 are the equality constraints eq_indices = [2, 6] # "indices" here is a bit overloaded expected_eq_ids = [id(self.pm.c[i]) for i in eq_indices] eq_ids = [id(con) for con in eq_constraints] self.assertEqual(eq_ids, expected_eq_ids) eq_constraint_names = nlp.equality_constraint_names() expected_eq_names = [ c.getname(fully_qualified=True) for c in nlp.get_pyomo_equality_constraints() ] self.assertEqual(eq_constraint_names, expected_eq_names) # get_pyomo_inequality_constraints ineq_constraints = nlp.get_pyomo_inequality_constraints() # 1, 3, 4, 5, 7, 8, and 9 are the inequality constraints ineq_indices = [1, 3, 4, 5, 7, 8, 9] expected_ineq_ids = [id(self.pm.c[i]) for i in ineq_indices] ineq_ids = [id(con) for con in ineq_constraints] self.assertEqual(eq_ids, expected_eq_ids) # get_primal_indices expected_primal_indices = [i for i in range(9)] self.assertTrue( expected_primal_indices == nlp.get_primal_indices([self.pm.x])) expected_primal_indices = [0, 3, 8, 4] variables = [self.pm.x[1], self.pm.x[4], self.pm.x[9], self.pm.x[5]] self.assertTrue( expected_primal_indices == nlp.get_primal_indices(variables)) # get_constraint_indices expected_constraint_indices = [i for i in range(9)] self.assertTrue(expected_constraint_indices == nlp.get_constraint_indices([self.pm.c])) expected_constraint_indices = [0, 3, 8, 4] constraints = [self.pm.c[1], self.pm.c[4], self.pm.c[9], self.pm.c[5]] self.assertTrue(expected_constraint_indices == nlp.get_constraint_indices(constraints)) # get_equality_constraint_indices pyomo_eq_indices = [2, 6] with self.assertRaises(KeyError): # At least one data object in container is not an equality nlp.get_equality_constraint_indices([self.pm.c]) eq_constraints = [self.pm.c[i] for i in pyomo_eq_indices] expected_eq_indices = [0, 1] # ^indices in the list of equality constraints eq_constraint_indices = nlp.get_equality_constraint_indices( eq_constraints) self.assertEqual(expected_eq_indices, eq_constraint_indices) # get_inequality_constraint_indices pyomo_ineq_indices = [1, 3, 4, 5, 7, 9] with self.assertRaises(KeyError): # At least one data object in container is not an equality nlp.get_inequality_constraint_indices([self.pm.c]) ineq_constraints = [self.pm.c[i] for i in pyomo_ineq_indices] expected_ineq_indices = [0, 1, 2, 3, 4, 6] # ^indices in the list of equality constraints; didn't include 8 ineq_constraint_indices = nlp.get_inequality_constraint_indices( ineq_constraints) self.assertEqual(expected_ineq_indices, ineq_constraint_indices) # extract_subvector_grad_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 = nlp.extract_subvector_grad_objective([self.pm.x]) self.assertTrue(np.array_equal(expected_gradient, grad_obj)) expected_gradient = np.asarray([ 2 * sum((i + 1) * (j + 1) for j in range(9)) for i in [0, 3, 8, 4] ], dtype=np.float64) variables = [self.pm.x[1], self.pm.x[4], self.pm.x[9], self.pm.x[5]] grad_obj = nlp.extract_subvector_grad_objective(variables) self.assertTrue(np.array_equal(expected_gradient, grad_obj)) # extract_subvector_constraints expected_con = np.asarray( [45, 88, 3 * 45, 4 * 45, 5 * 45, 276, 7 * 45, 8 * 45, 9 * 45], dtype=np.float64) con = nlp.extract_subvector_constraints([self.pm.c]) self.assertTrue(np.array_equal(expected_con, con)) expected_con = np.asarray([45, 4 * 45, 9 * 45, 5 * 45], dtype=np.float64) constraints = [self.pm.c[1], self.pm.c[4], self.pm.c[9], self.pm.c[5]] con = nlp.extract_subvector_constraints(constraints) self.assertTrue(np.array_equal(expected_con, con)) # extract_submatrix_jacobian 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) jac = nlp.extract_submatrix_jacobian(pyomo_variables=[self.pm.x], pyomo_constraints=[self.pm.c]) dense_jac = jac.todense() self.assertTrue(np.array_equal(dense_jac, expected_jac)) expected_jac = [[(i) * (j) for j in [1, 4, 9, 5]] for i in [2, 6, 4]] expected_jac = np.asarray(expected_jac, dtype=np.float64) variables = [self.pm.x[1], self.pm.x[4], self.pm.x[9], self.pm.x[5]] constraints = [self.pm.c[2], self.pm.c[6], self.pm.c[4]] jac = nlp.extract_submatrix_jacobian(pyomo_variables=variables, pyomo_constraints=constraints) dense_jac = jac.todense() self.assertTrue(np.array_equal(dense_jac, expected_jac)) # extract_submatrix_hessian_lag 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) hess = nlp.extract_submatrix_hessian_lag( pyomo_variables_rows=[self.pm.x], pyomo_variables_cols=[self.pm.x]) dense_hess = hess.todense() self.assertTrue(np.array_equal(dense_hess, expected_hess)) expected_hess = [[2.0 * i * j for j in [1, 4, 9, 5]] for i in [1, 4, 9, 5]] expected_hess = np.asarray(expected_hess, dtype=np.float64) variables = [self.pm.x[1], self.pm.x[4], self.pm.x[9], self.pm.x[5]] hess = nlp.extract_submatrix_hessian_lag( pyomo_variables_rows=variables, pyomo_variables_cols=variables) dense_hess = hess.todense() self.assertTrue(np.array_equal(dense_hess, expected_hess))
def test_pyomo_external_model_ndarray_scaling(self): m = pyo.ConcreteModel() m.Pin = pyo.Var(initialize=100, bounds=(0, None)) m.c1 = pyo.Var(initialize=1.0, bounds=(0, None)) m.c2 = pyo.Var(initialize=1.0, bounds=(0, None)) m.F = pyo.Var(initialize=10, bounds=(0, None)) m.P1 = pyo.Var() m.P2 = pyo.Var() m.F_con = pyo.Constraint(expr=m.F == 10) m.Pin_con = pyo.Constraint(expr=m.Pin == 100) # simple parameter estimation test m.obj = pyo.Objective(expr=(m.P1 - 90)**2 + (m.P2 - 40)**2) # set scaling parameters for the pyomo variables and constraints m.scaling_factor = pyo.Suffix(direction=pyo.Suffix.EXPORT) m.scaling_factor[m.obj] = 0.1 # scale the objective m.scaling_factor[m.Pin] = 2.0 # scale the variable m.scaling_factor[m.c1] = 3.0 # scale the variable m.scaling_factor[m.c2] = 4.0 # scale the variable m.scaling_factor[m.F] = 5.0 # scale the variable m.scaling_factor[m.P1] = 6.0 # scale the variable m.scaling_factor[m.P2] = 7.0 # scale the variable m.scaling_factor[m.F_con] = 8.0 # scale the pyomo constraint m.scaling_factor[m.Pin_con] = 9.0 # scale the pyomo constraint # test that this all works with ndarray input as well cyipopt_problem = \ PyomoExternalCyIpoptProblem(pyomo_model=m, ex_input_output_model=PressureDropModel(), inputs=[m.Pin, m.c1, m.c2, m.F], outputs=[m.P1, m.P2], outputs_eqn_scaling=np.asarray([10.0, 11.0], dtype=np.float64) ) # solve the problem options = { 'hessian_approximation': 'limited-memory', 'nlp_scaling_method': 'user-scaling', 'output_file': '_cyipopt-pyomo-ext-scaling-ndarray.log', 'file_print_level': 10, 'max_iter': 0 } solver = CyIpoptSolver(cyipopt_problem, options=options) x, info = solver.solve(tee=False) with open('_cyipopt-pyomo-ext-scaling-ndarray.log', 'r') as fd: solver_trace = fd.read() os.remove('_cyipopt-pyomo-ext-scaling-ndarray.log') self.assertIn('nlp_scaling_method = user-scaling', solver_trace) self.assertIn('output_file = _cyipopt-pyomo-ext-scaling-ndarray.log', solver_trace) self.assertIn('objective scaling factor = 0.1', solver_trace) self.assertIn('x scaling provided', solver_trace) self.assertIn('c scaling provided', solver_trace) self.assertIn('d scaling provided', solver_trace) self.assertIn('DenseVector "x scaling vector" with 7 elements:', solver_trace) self.assertIn('x scaling vector[ 1]= 6.0000000000000000e+00', solver_trace) self.assertIn('x scaling vector[ 2]= 7.0000000000000000e+00', solver_trace) self.assertIn('x scaling vector[ 3]= 2.0000000000000000e+00', solver_trace) self.assertIn('x scaling vector[ 4]= 3.0000000000000000e+00', solver_trace) self.assertIn('x scaling vector[ 5]= 4.0000000000000000e+00', solver_trace) self.assertIn('x scaling vector[ 6]= 5.0000000000000000e+00', solver_trace) self.assertIn('x scaling vector[ 7]= 1.0000000000000000e+00', solver_trace) self.assertIn('DenseVector "c scaling vector" with 5 elements:', solver_trace) self.assertIn('c scaling vector[ 1]= 8.0000000000000000e+00', solver_trace) self.assertIn('c scaling vector[ 2]= 9.0000000000000000e+00', solver_trace) self.assertIn('c scaling vector[ 3]= 1.0000000000000000e+00', solver_trace) self.assertIn('c scaling vector[ 4]= 1.0000000000000000e+01', solver_trace) self.assertIn('c scaling vector[ 5]= 1.1000000000000000e+01', solver_trace)
def test_projected(self): m = create_pyomo_model() nlp = PyomoNLP(m) projected_nlp = ProjectedNLP(nlp, ['x[0]', 'x[1]', 'x[2]']) expected_names = ['x[0]', 'x[1]', 'x[2]'] self.assertEqual(projected_nlp.primals_names(), expected_names) self.assertTrue( np.array_equal(projected_nlp.get_primals(), np.asarray([1.0, 2.0, 4.0]))) self.assertTrue( np.array_equal(projected_nlp.evaluate_grad_objective(), np.asarray([8.0, 1.0, 9.0]))) self.assertEqual(projected_nlp.nnz_jacobian(), 5) self.assertEqual(projected_nlp.nnz_hessian_lag(), 6) J = projected_nlp.evaluate_jacobian() self.assertEqual(len(J.data), 5) denseJ = J.todense() expected_jac = np.asarray([[6.0, 1.0, 1.0], [1.0, 0.0, 1.0]]) self.assertTrue(np.array_equal(denseJ, expected_jac)) # test the use of "out" J = 0.0 * J projected_nlp.evaluate_jacobian(out=J) denseJ = J.todense() self.assertTrue(np.array_equal(denseJ, expected_jac)) H = projected_nlp.evaluate_hessian_lag() self.assertEqual(len(H.data), 6) expectedH = np.asarray([[2.0, 1.0, 1.0], [1.0, 0.0, 0.0], [1.0, 0.0, 2.0]]) denseH = H.todense() self.assertTrue(np.array_equal(denseH, expectedH)) # test the use of "out" H = 0.0 * H projected_nlp.evaluate_hessian_lag(out=H) denseH = H.todense() self.assertTrue(np.array_equal(denseH, expectedH)) # now test a reordering projected_nlp = ProjectedNLP(nlp, ['x[0]', 'x[2]', 'x[1]']) expected_names = ['x[0]', 'x[2]', 'x[1]'] self.assertEqual(projected_nlp.primals_names(), expected_names) self.assertTrue( np.array_equal(projected_nlp.get_primals(), np.asarray([1.0, 4.0, 2.0]))) self.assertTrue( np.array_equal(projected_nlp.evaluate_grad_objective(), np.asarray([8.0, 9.0, 1.0]))) self.assertEqual(projected_nlp.nnz_jacobian(), 5) self.assertEqual(projected_nlp.nnz_hessian_lag(), 6) J = projected_nlp.evaluate_jacobian() self.assertEqual(len(J.data), 5) denseJ = J.todense() expected_jac = np.asarray([[6.0, 1.0, 1.0], [1.0, 1.0, 0.0]]) self.assertTrue(np.array_equal(denseJ, expected_jac)) # test the use of "out" J = 0.0 * J projected_nlp.evaluate_jacobian(out=J) denseJ = J.todense() self.assertTrue(np.array_equal(denseJ, expected_jac)) H = projected_nlp.evaluate_hessian_lag() self.assertEqual(len(H.data), 6) expectedH = np.asarray([[2.0, 1.0, 1.0], [1.0, 2.0, 0.0], [1.0, 0.0, 0.0]]) denseH = H.todense() self.assertTrue(np.array_equal(denseH, expectedH)) # test the use of "out" H = 0.0 * H projected_nlp.evaluate_hessian_lag(out=H) denseH = H.todense() self.assertTrue(np.array_equal(denseH, expectedH)) # now test an expansion projected_nlp = ProjectedNLP(nlp, ['x[0]', 'x[2]', 'y', 'x[1]']) expected_names = ['x[0]', 'x[2]', 'y', 'x[1]'] self.assertEqual(projected_nlp.primals_names(), expected_names) np.testing.assert_equal(projected_nlp.get_primals(), np.asarray([1.0, 4.0, np.nan, 2.0])) self.assertTrue( np.array_equal(projected_nlp.evaluate_grad_objective(), np.asarray([8.0, 9.0, 0.0, 1.0]))) self.assertEqual(projected_nlp.nnz_jacobian(), 5) self.assertEqual(projected_nlp.nnz_hessian_lag(), 6) J = projected_nlp.evaluate_jacobian() self.assertEqual(len(J.data), 5) denseJ = J.todense() expected_jac = np.asarray([[6.0, 1.0, 0.0, 1.0], [1.0, 1.0, 0.0, 0.0]]) self.assertTrue(np.array_equal(denseJ, expected_jac)) # test the use of "out" J = 0.0 * J projected_nlp.evaluate_jacobian(out=J) denseJ = J.todense() self.assertTrue(np.array_equal(denseJ, expected_jac)) H = projected_nlp.evaluate_hessian_lag() self.assertEqual(len(H.data), 6) expectedH = np.asarray([[2.0, 1.0, 0.0, 1.0], [1.0, 2.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [1.0, 0.0, 0.0, 0.0]]) denseH = H.todense() self.assertTrue(np.array_equal(denseH, expectedH)) # test the use of "out" H = 0.0 * H projected_nlp.evaluate_hessian_lag(out=H) denseH = H.todense() self.assertTrue(np.array_equal(denseH, expectedH)) # now test an expansion projected_nlp = ProjectedNLP(nlp, ['x[0]', 'x[2]']) expected_names = ['x[0]', 'x[2]'] self.assertEqual(projected_nlp.primals_names(), expected_names) np.testing.assert_equal(projected_nlp.get_primals(), np.asarray([1.0, 4.0])) self.assertTrue( np.array_equal(projected_nlp.evaluate_grad_objective(), np.asarray([8.0, 9.0]))) self.assertEqual(projected_nlp.nnz_jacobian(), 4) self.assertEqual(projected_nlp.nnz_hessian_lag(), 4) J = projected_nlp.evaluate_jacobian() self.assertEqual(len(J.data), 4) denseJ = J.todense() expected_jac = np.asarray([[6.0, 1.0], [1.0, 1.0]]) self.assertTrue(np.array_equal(denseJ, expected_jac)) # test the use of "out" J = 0.0 * J projected_nlp.evaluate_jacobian(out=J) denseJ = J.todense() self.assertTrue(np.array_equal(denseJ, expected_jac)) H = projected_nlp.evaluate_hessian_lag() self.assertEqual(len(H.data), 4) expectedH = np.asarray([[2.0, 1.0], [1.0, 2.0]]) denseH = H.todense() self.assertTrue(np.array_equal(denseH, expectedH)) # test the use of "out" H = 0.0 * H projected_nlp.evaluate_hessian_lag(out=H) denseH = H.todense() self.assertTrue(np.array_equal(denseH, expectedH))
def evaluate_hessian_equality_constraints(self): irow = np.asarray([0], dtype=np.int64) jcol = np.asarray([0], dtype=np.int64) data = np.asarray([self._equality_mult * 2.0], dtype=np.float64) hess = spa.coo_matrix((data, (irow, jcol)), shape=(1, 1)) return hess
def evaluate_hessian_outputs(self): irow = np.asarray([], dtype=np.int64) jcol = np.asarray([], dtype=np.int64) data = np.asarray([], dtype=np.float64) hess = spa.coo_matrix((data, (irow, jcol)), shape=(1, 1)) return hess
def evaluate_jacobian_outputs(self): irow = np.asarray([0], dtype=np.int64) jcol = np.asarray([0], dtype=np.int64) nonzeros = np.asarray([5.0], dtype=np.float64) jac = spa.coo_matrix((nonzeros, (irow, jcol)), shape=(1, 1)) return jac
def evaluate_jacobian_equality_constraints(self): irow = np.asarray([0], dtype=np.int64) jcol = np.asarray([0], dtype=np.int64) nonzeros = np.asarray([2 * self._u], dtype=np.float64) jac = spa.coo_matrix((nonzeros, (irow, jcol)), shape=(1, 1)) return jac
def evaluate_outputs(self): return np.asarray([5 * self._u])
def get_equality_constraint_scaling_factors(self): return np.asarray([3.1, 3.2], dtype=np.float64)
def get_output_constraint_scaling_factors(self): return np.asarray([4.1, 4.2])