def test_solve_LP_clp_cmd_duals_A_ineq(self): x = optmod.VariableScalar('x') c = 3 * x >= 4 # -3x <= -4 p = optmod.Problem(objective=minimize(5 * x), constraints=[c]) try: info = p.solve(solver=optalg.opt_solver.OptSolverClpCMD(), parameters={'quiet': True}) except ImportError: raise unittest.SkipTest('clp cmd not available') self.assertEqual(info['status'], 'solved') self.assertAlmostEqual(x.get_value(), 4. / 3., places=4) self.assertLess(np.abs(5. - 3 * c.get_dual()), 1e-7) c = 3 * x <= 4 p = optmod.Problem(objective=minimize(-5 * x), constraints=[c]) try: info = p.solve(solver=optalg.opt_solver.OptSolverClpCMD(), parameters={'quiet': True}) except ImportError: raise unittest.SkipTest('clp cmd not available') self.assertEqual(info['status'], 'solved') self.assertAlmostEqual(x.get_value(), 4. / 3., places=4) self.assertLess(np.abs(-5. + 3 * c.get_dual()), 1e-7)
def test_var_order_consistency(self): x1 = optmod.variable.VariableScalar('x1') x2 = optmod.variable.VariableScalar('x2') x3 = optmod.variable.VariableScalar('x3') x4 = optmod.variable.VariableScalar('x4') f = x1 + x2 constraints = [x1 >= x2, x2 + x3 <= -4, 4 * x4 >= x1] p = optmod.Problem(minimize(f), constraints) std_prob = p.__get_std_problem__() A0 = std_prob.A.copy() for i in range(1000): x1 = optmod.variable.VariableScalar('x1') x2 = optmod.variable.VariableScalar('x2') x3 = optmod.variable.VariableScalar('x3') x4 = optmod.variable.VariableScalar('x4') f = x1 + x2 constraints = [x1 >= x2, x2 + x3 <= -4, 4 * x4 >= x1] p = optmod.Problem(minimize(f), constraints) A1 = p.__get_std_problem__().A self.assertTrue(np.all(A0.row == A1.row)) self.assertTrue(np.all(A0.col == A1.col)) self.assertTrue(np.all(A0.data == A1.data))
def test_solve_QP(self): x = optmod.VariableScalar('x') y = optmod.VariableScalar('y') f = 3 * x * x + y * y + 2 * x * y + x + 6 * y + 2 # Problem p = optmod.Problem(objective=minimize(f)) # std prob std_prob = p.__get_std_problem__() self.assertListEqual(std_prob.properties, ['nonlinear', 'continuous', 'optimization']) info = p.solve(solver=optalg.opt_solver.OptSolverINLP(), parameters={'quiet': True}) self.assertEqual(info['status'], 'solved') self.assertAlmostEqual(x.get_value(), 1.25, places=4) self.assertAlmostEqual(y.get_value(), -4.25, places=4) info = p.solve(solver=optalg.opt_solver.OptSolverAugL(), parameters={'quiet': True}) self.assertEqual(info['status'], 'solved') self.assertAlmostEqual(x.get_value(), 1.25, places=4) self.assertAlmostEqual(y.get_value(), -4.25, places=4) # Problem p = optmod.Problem(objective=minimize(f), constraints=[2 * x + 3 * y >= 4, x >= 0, y >= 0]) info = p.solve(solver=optalg.opt_solver.OptSolverINLP(), parameters={'quiet': True}) self.assertEqual(info['status'], 'solved') self.assertAlmostEqual(x.get_value(), 0.5, places=4) self.assertAlmostEqual(y.get_value(), 1, places=4) self.assertAlmostEqual(f.get_value(), 11.25, places=4) info = p.solve(solver=optalg.opt_solver.OptSolverAugL(), parameters={'quiet': True}) self.assertEqual(info['status'], 'solved') self.assertAlmostEqual(x.get_value(), 0.5, places=4) self.assertAlmostEqual(y.get_value(), 1, places=4) self.assertAlmostEqual(f.get_value(), 11.25, places=4)
def test_solve_ipopt_duals_J(self): x = optmod.VariableScalar('x') c1 = optmod.cos(x) == 0.75 c2 = x >= -np.pi c3 = x <= np.pi p = optmod.Problem(objective=minimize(5 * x), constraints=[c1, c2, c3]) try: info = p.solve(solver=optalg.opt_solver.OptSolverIpopt(), parameters={'quiet': True}) except ImportError: raise unittest.SkipTest('ipopt not available') self.assertEqual(info['status'], 'solved') self.assertAlmostEqual(x.get_value(), -np.abs(np.arccos(0.75)), places=5) self.assertAlmostEqual(np.cos(x.get_value()), 0.75, places=5) self.assertGreater(x.get_value(), -np.pi) self.assertLess(x.get_value(), np.pi) self.assertEqual(c2.get_dual(), 0.) self.assertEqual(c3.get_dual(), 0.) self.assertLess(np.abs(5. - (-np.sin(x.get_value())) * c1.get_dual()), 1e-7)
def test_solve_LP_clp_cmd_duals_ub(self): x = optmod.VariableScalar('x') y = optmod.VariableScalar('y') c1 = 100 <= x c2 = x <= 200 c3 = 80 <= y c4 = y <= 170 c5 = y >= -x + 200 # Problem p = optmod.Problem(objective=minimize(2 * x - 5 * y), constraints=[c1, c2, c3, c4, c5]) try: info = p.solve(solver=optalg.opt_solver.OptSolverClpCMD(), parameters={'quiet': True}) except ImportError: raise unittest.SkipTest('clp cmd not available') self.assertEqual(info['status'], 'solved') self.assertAlmostEqual(x.get_value(), 100, places=4) self.assertAlmostEqual(y.get_value(), 170, places=4) self.assertEqual(c2.get_dual(), 0.) self.assertEqual(c3.get_dual(), 0.) self.assertEqual(c5.get_dual(), 0.) self.assertEqual(2. - c1.get_dual(), 0.) self.assertEqual(-5. + c4.get_dual(), 0.)
def test_solve_NLP_rosenbrock(self): N = 500 x = optmod.VariableMatrix(name='x', shape=(N, 1)) f = 0. for i in range(N - 1): f = f + 100 * (x[i + 1, 0] - x[i, 0] * x[i, 0]) * (x[ i + 1, 0] - x[i, 0] * x[i, 0]) + (1 - x[i, 0]) * (1 - x[i, 0]) p = optmod.Problem(minimize(f)) try: info = p.solve(solver=optalg.opt_solver.OptSolverIpopt(), parameters={ 'quiet': True, 'max_iter': 1500 }) except ImportError: raise unittest.SkipTest('ipopt not available') self.assertEqual(info['status'], 'solved') self.assertAlmostEqual(f.get_value(), 0.) self.assertTrue(np.all(np.abs(x.get_value() - 1.) < 1e-10))
def test_solve_LP(self): x = optmod.VariableScalar('x') y = optmod.VariableScalar('y') # Problem p = optmod.Problem( objective=maximize(-2 * x + 5 * y), constraints=[100 <= x, x <= 200, 80 <= y, y <= 170, y >= -x + 200]) # std prob std_prob = p.__get_std_problem__() self.assertListEqual(std_prob.properties, ['linear', 'continuous', 'optimization']) info = p.solve(parameters={'quiet': True}) self.assertTrue('iterations' in info) self.assertTrue('time_transformation' in info) self.assertTrue('time_solver' in info) self.assertEqual(info['status'], 'solved') self.assertAlmostEqual(x.get_value(), 100, places=4) self.assertAlmostEqual(y.get_value(), 170, places=4) info = p.solve(solver=optalg.opt_solver.OptSolverAugL(), parameters={'quiet': True}) self.assertEqual(info['status'], 'solved') self.assertAlmostEqual(x.get_value(), 100, places=4) self.assertAlmostEqual(y.get_value(), 170, places=4)
def test_solve_MILP_cbc(self): x1 = optmod.VariableScalar('x1', type='integer') x2 = optmod.VariableScalar('x2', type='integer') x3 = optmod.VariableScalar('x3') x4 = optmod.VariableScalar('x4') obj = -x1 - x2 constr = [ -2 * x1 + 2 * x2 + x3 == 1, -8 * x1 + 10 * x2 + x4 == 13, x4 >= 0, x3 <= 0 ] p = optmod.Problem(minimize(obj), constr) # std prob std_prob = p.__get_std_problem__() self.assertListEqual(std_prob.properties, ['linear', 'integer', 'optimization']) try: self.assertRaises(TypeError, p.solve, optalg.opt_solver.OptSolverIpopt(), {'quiet': True}) except ImportError: raise unittest.SkipTest('ipopt not available') self.assertRaises(TypeError, p.solve, optalg.opt_solver.OptSolverAugL(), {'quiet': True}) try: self.assertRaises(TypeError, p.solve, optalg.opt_solver.OptSolverClp(), {'quiet': True}) except ImportError: raise unittest.SkipTest('clp not available') self.assertRaises(TypeError, p.solve, optalg.opt_solver.OptSolverINLP(), {'quiet': True}) try: info = p.solve(optalg.opt_solver.OptSolverCbc(), parameters={'quiet': True}) except ImportError: raise unittest.SkipTest('cbc not available') self.assertEqual(info['status'], 'solved') self.assertEqual(x1.get_value(), 1.) self.assertEqual(x2.get_value(), 2.) x1.type = 'continuous' x2.type = 'continuous' try: info = p.solve(optalg.opt_solver.OptSolverCbc(), parameters={'quiet': True}) except ImportError: raise unittest.SkipTest('cbc not available') self.assertEqual(info['status'], 'solved') self.assertEqual(x1.get_value(), 4.) self.assertEqual(x2.get_value(), 4.5)
def test_solve_NLP_constrained(self): # Hock-Schittkowski # Problem 71 x1 = optmod.VariableScalar('x1', value=1) x2 = optmod.VariableScalar('x2', value=5) x3 = optmod.VariableScalar('x3', value=5) x4 = optmod.VariableScalar('x4', value=1) f = x1 * x4 * (x1 + x2 + x3) + x3 constraints = [ x1 * x2 * x3 * x4 >= 25, x1 * x1 + x2 * x2 + x3 * x3 + x4 * x4 == 40, 1 <= x1, x1 <= 5, 1 <= x2, x2 <= 5, 1 <= x3, x3 <= 5, 1 <= x4, x4 <= 5 ] p = optmod.Problem(minimize(f), constraints=constraints) # std prob std_prob = p.__get_std_problem__() self.assertListEqual(std_prob.properties, ['nonlinear', 'continuous', 'optimization']) try: info = p.solve(solver=optalg.opt_solver.OptSolverIpopt(), parameters={'quiet': True}, fast_evaluator=True) except ImportError: raise unittest.SkipTest('ipopt not available') self.assertEqual(info['status'], 'solved') self.assertAlmostEqual(f.get_value(), 17.0140173, places=3) self.assertAlmostEqual(x1.get_value(), 1., places=3) self.assertAlmostEqual(x2.get_value(), 4.7429994, places=3) self.assertAlmostEqual(x3.get_value(), 3.8211503, places=3) self.assertAlmostEqual(x4.get_value(), 1.3794082, places=3) x1.set_value(1.) x2.set_value(5.) x3.set_value(5.) x4.set_value(1.) info = p.solve(solver=optalg.opt_solver.OptSolverIpopt(), parameters={'quiet': True}, fast_evaluator=False) self.assertEqual(info['status'], 'solved') self.assertAlmostEqual(f.get_value(), 17.0140173, places=3) self.assertAlmostEqual(x1.get_value(), 1., places=3) self.assertAlmostEqual(x2.get_value(), 4.7429994, places=3) self.assertAlmostEqual(x3.get_value(), 3.8211503, places=3) self.assertAlmostEqual(x4.get_value(), 1.3794082, places=3)
def test_construction(self): x = optmod.variable.VariableScalar('x') f = x * x c1 = x >= 1 c2 = x <= 5 c = [c1, c2] p = optmod.Problem(minimize(f), c) self.assertTrue(isinstance(p.objective, minimize)) self.assertTrue(p.objective.get_function() is f) self.assertEqual(len(p.constraints), 2) self.assertTrue(p.constraints[0] is c1) self.assertTrue(p.constraints[1] is c2) p = optmod.Problem() self.assertTrue(p.objective.get_function().is_constant(0.)) self.assertEqual(len(p.constraints), 0) p = optmod.Problem(maximize(f)) self.assertTrue(isinstance(p.objective, maximize)) self.assertTrue(p.objective.get_function() is f) self.assertEqual(len(p.constraints), 0) p = optmod.Problem() self.assertEqual(len(p.constraints), 0) self.assertTrue(isinstance(p.objective, optmod.problem.EmptyObjective)) p = optmod.Problem(objective=None) self.assertEqual(len(p.constraints), 0) self.assertTrue(isinstance(p.objective, optmod.problem.EmptyObjective)) self.assertRaises(TypeError, optmod.Problem, objective=f) self.assertRaises(TypeError, optmod.Problem, None, ['foo'])
def test_construction_constr_not_flat(self): x = optmod.variable.VariableMatrix('x', value=np.random.randn(3, 2)) y = optmod.variable.VariableScalar('y') c0 = x == 0 self.assertTrue(isinstance(c0, optmod.constraint.ConstraintArray)) c1 = y == 2 p = optmod.Problem(EmptyObjective(), constraints=[c0, [[c1]]]) self.assertEqual(len(p.constraints), 7) for c in p.constraints: self.assertTrue(isinstance(c, optmod.constraint.Constraint))
def test_solve_feasibility(self): x = optmod.VariableScalar('x', value=1.) constr = [x * optmod.cos(x) - x * x == 0] p = optmod.Problem(EmptyObjective(), constr) # std prob std_prob = p.__get_std_problem__() self.assertListEqual(std_prob.properties, ['nonlinear', 'continuous', 'feasibility']) try: self.assertRaises(TypeError, p.solve, optalg.opt_solver.OptSolverClp(), {'quiet': True}) except ImportError: raise unittest.SkipTest('clp not available') try: self.assertRaises(TypeError, p.solve, optalg.opt_solver.OptSolverCbc(), {'quiet': True}) except ImportError: raise unittest.SkipTest('cbc not available') info = p.solve(optalg.opt_solver.OptSolverNR(), parameters={ 'quiet': True, 'feastol': 1e-10 }) self.assertEqual(info['status'], 'solved') self.assertAlmostEqual(x.get_value(), 0.739085133215161, places=7) x.value = 1. self.assertNotAlmostEqual(x.get_value(), 0.739085133215161, places=7) info = p.solve(optalg.opt_solver.OptSolverNR(), parameters={ 'quiet': True, 'feastol': 1e-10 }, fast_evaluator=False) self.assertEqual(info['status'], 'solved') self.assertAlmostEqual(x.get_value(), 0.739085133215161, places=7)
def test_solve_LP_clp_cmd(self): x = optmod.VariableScalar('x') y = optmod.VariableScalar('y') # Problem p = optmod.Problem( objective=maximize(-2 * x + 5 * y), constraints=[100 <= x, x <= 200, 80 <= y, y <= 170, y >= -x + 200]) try: info = p.solve(solver=optalg.opt_solver.OptSolverClpCMD(), parameters={'quiet': True}) except ImportError: raise unittest.SkipTest('clp cmd not available') self.assertEqual(info['status'], 'solved') self.assertAlmostEqual(x.get_value(), 100, places=4) self.assertAlmostEqual(y.get_value(), 170, places=4)
def test_solve_NLP_unconstrained(self): n = 5 x = optmod.VariableMatrix(name='x', value=[1.3, 0.7, 0.8, 1.9, 1.2], shape=(5, 1)) f = 0. for i in range(0, n - 1): f = f + 100 * (x[i + 1, 0] - x[i, 0] * x[i, 0]) * ( x[i + 1, 0] - x[i, 0] * x[i, 0]) + (1. - x[i, 0]) * (1. - x[i, 0]) # Problem p = optmod.Problem(minimize(f)) # std prob std_prob = p.__get_std_problem__() self.assertListEqual(std_prob.properties, ['nonlinear', 'continuous', 'optimization']) try: info = p.solve(solver=optalg.opt_solver.OptSolverIpopt(), parameters={'quiet': True}, fast_evaluator=True) except ImportError: raise unittest.SkipTest('ipopt not available') self.assertEqual(info['status'], 'solved') self.assertAlmostEqual(f.get_value(), 0, places=4) self.assertLess(norm(x.get_value() - np.ones((5, 1)), np.inf), 1e-2) x.set_value(np.matrix([1.3, 0.7, 0.8, 1.9, 1.2]).T) info = p.solve(solver=optalg.opt_solver.OptSolverIpopt(), parameters={'quiet': True}, fast_evaluator=False) self.assertEqual(info['status'], 'solved') self.assertAlmostEqual(f.get_value(), 0, places=4) self.assertLess(norm(x.get_value() - np.ones((5, 1)), np.inf), 1e-2)
def test_infeasible_MILP_cplex_cmd(self): x1 = optmod.VariableScalar('x1', type='integer') x2 = optmod.VariableScalar('x2', type='integer') x3 = optmod.VariableScalar('x3') x4 = optmod.VariableScalar('x4') obj = -x1 - x2 constr = [ -2 * x1 + 2 * x2 + x3 == 1, -8 * x1 + 10 * x2 + x4 == 13, x1 >= 2, x1 <= 1, x4 >= 0, x3 <= 0 ] p = optmod.Problem(minimize(obj), constr) try: info = p.solve(optalg.opt_solver.OptSolverCplexCMD(), parameters={'quiet': True}) except ImportError: raise unittest.SkipTest('cplex cmd not available') self.assertEqual(info['status'], 'error')
def test_solve_NLP_beam(self): N = 500 h = 1. / N alpha = 350. t = optmod.VariableMatrix('t', shape=(N + 1, 1)) x = optmod.VariableMatrix('x', shape=(N + 1, 1)) u = optmod.VariableMatrix('u', shape=(N + 1, 1)) f = sum([ 0.5 * h * (u[i, 0] * u[i, 0] + u[i + 1, 0] * u[i + 1, 0]) + 0.5 * alpha * h * (cos(t[i, 0]) + cos(t[i + 1, 0])) for i in range(N) ]) constraints = [] for i in range(N): constraints.append(x[i + 1, 0] - x[i, 0] - 0.5 * h * (sin(t[i + 1, 0]) + sin(t[i, 0])) == 0) constraints.append(t[i + 1, 0] - t[i, 0] - 0.5 * h * (u[i + 1, 0] - u[i, 0]) == 0) constraints.append(t <= 1) constraints.append(t >= -1) constraints.append(-0.05 <= x) constraints.append(x <= 0.05) p = optmod.Problem(minimize(f), constraints) try: info = p.solve(solver=optalg.opt_solver.OptSolverIpopt(), parameters={'quiet': True}) except ImportError: raise unittest.SkipTest('ipopt not available') self.assertEqual(info['status'], 'solved') self.assertAlmostEqual(f.get_value(), 350.)
def test_std_components(self): x = optmod.variable.VariableScalar('x') y = optmod.variable.VariableScalar('y') f = x * x + 2 * x * y + y * y c0 = x <= 10 c1 = x + y == 3 c2 = 3 * x <= 10 c3 = y >= 19. c4 = x * y == 20. c5 = optmod.sin(x) <= 3 c6 = optmod.cos(y) >= 4. p = optmod.Problem(minimize(f), [c0, c1, c2, c3, c4, c5, c6]) comp = p.__get_std_components__() self.assertEqual(len(comp), 14) phi = comp['phi'] gphi_list = comp['gphi_list'] Hphi_list = comp['Hphi_list'] phi_prop = comp['phi_prop'] cA_list = comp['cA_list'] cJ_list = comp['cJ_list'] A_list = comp['A_list'] b_list = comp['b_list'] f_list = comp['f_list'] J_list = comp['J_list'] H_list = comp['H_list'] u_list = comp['u_list'] l_list = comp['l_list'] prop_list = comp['prop_list'] self.assertEqual(len(cA_list), len(b_list)) self.assertEqual(len(cJ_list), len(f_list)) self.assertEqual(str(phi), 'x*x + x*2.00e+00*y + y*y') self.assertEqual(str(gphi_list), '[(x, x + x + y*2.00e+00), (y, x*2.00e+00 + y + y)]') self.assertEqual( str(Hphi_list), '[(x, x, 2.00e+00), (x, y, 2.00e+00), (y, y, 2.00e+00)]') self.assertEqual( str(A_list), '[(0, x, 1.0), (0, y, 1.0), (1, x, 3.0), (1, s, -1.0)]') self.assertEqual(str(b_list), '[3.0, 10.0]') self.assertEqual( str(f_list), '[x*y + -2.00e+01, sin(x) + -3.00e+00 + s*-1.00e+00, cos(y) + -4.00e+00 + s*-1.00e+00]' ) self.assertEqual( str(J_list), '[(0, x, y), (0, y, x), (1, x, cos(x)), (1, s, -1.00e+00), (2, y, sin(y)*-1.00e+00), (2, s, -1.00e+00)]' ) self.assertEqual( str(H_list), '[[(x, y, 1.00e+00)], [(x, x, sin(x)*-1.00e+00)], [(y, y, -1.00e+00*cos(y))]]' ) self.assertEqual(str([(x[0], x[1]) for x in u_list]), '[(x, 10.0), (s, 0), (s, 0)]') self.assertEqual(str([(x[0], x[1]) for x in l_list]), '[(y, 19.0), (s, 0)]')
from optmod import sum, cos, sin, minimize N = 1000 h = 1./N alpha = 350. t = optmod.VariableMatrix('t', shape=(N+1,1)) x = optmod.VariableMatrix('x', shape=(N+1,1)) u = optmod.VariableMatrix('u', shape=(N+1,1)) f = sum([0.5*h*(u[i,0]*u[i,0]+u[i+1,0]*u[i+1,0]) + 0.5*alpha*h*(cos(t[i,0]) + cos(t[i+1,0])) for i in range(N)]) constraints = [] for i in range(N): constraints.append(x[i+1,0] - x[i,0] - 0.5*h*(sin(t[i+1,0])+sin(t[i,0])) == 0) constraints.append(t[i+1,0] - t[i,0] - 0.5*h*(u[i+1,0] - u[i,0]) == 0) constraints.append(t <= 1) constraints.append(t >= -1) constraints.append(-0.05 <= x) constraints.append(x <= 0.05) p = optmod.Problem(minimize(f), constraints) info = p.solve(solver=optalg.opt_solver.OptSolverIpopt(), fast_evaluator=True) print(info) print(f.get_value())
def test_std_problem(self): np.random.seed(0) x = optmod.variable.VariableScalar('x', value=3.) y = optmod.variable.VariableScalar('y', value=4.) f = x * x + 2 * x * y + y * y c0 = x <= 10 c1 = x + y == 3 c2 = 3 * x <= 10 # slack s1 c3 = y >= 19. c4 = x * y == 20. c5 = optmod.sin(x) <= 3 # slack s2 c6 = optmod.cos(y) >= 4. # slack s3 p = optmod.Problem(minimize(f), [c0, c1, c2, c3, c4, c5, c6]) std_prob = p.__get_std_problem__() # vars self.assertEqual(len(std_prob.var2index), 5) self.assertEqual(len(std_prob.index2var), 5) index_x = std_prob.var2index[x] index_y = std_prob.var2index[y] index_s1 = std_prob.var2index[c2.slack] index_s2 = std_prob.var2index[c5.slack] index_s3 = std_prob.var2index[c6.slack] # x self.assertEqual(std_prob.x.size, 5) temp = np.zeros(5) temp[index_x] = 3. temp[index_y] = 4. self.assertTrue(np.all(std_prob.x == temp)) # A, b self.assertTupleEqual(std_prob.A.shape, (2, 5)) self.assertEqual(std_prob.A.nnz, 4) self.assertTrue(np.all(std_prob.A.row == np.array([0, 0, 1, 1]))) self.assertTrue( np.all(std_prob.A.col == np.array( [index_x, index_y, index_x, index_s1]))) self.assertTrue(np.all(std_prob.A.data == np.array([1, 1, 3, -1]))) self.assertTrue(np.all(std_prob.b == np.array([3., 10.]))) # u, l inf = 1e8 self.assertEqual(std_prob.u.size, 5) self.assertEqual(std_prob.l.size, 5) temp = np.zeros(5) temp[index_x] = 10. temp[index_y] = inf temp[index_s1] = 0 temp[index_s2] = 0 temp[index_s3] = inf self.assertTrue(np.all(std_prob.u == temp)) temp = np.zeros(5) temp[index_x] = -inf temp[index_y] = 19 temp[index_s1] = -inf temp[index_s2] = -inf temp[index_s3] = 0 self.assertTrue(np.all(std_prob.l == temp)) # integer flags self.assertTrue(isinstance(std_prob.P, np.ndarray)) self.assertEqual(std_prob.P.size, 5) self.assertNotEqual(std_prob.P.dtype, int) self.assertEqual(std_prob.P.dtype, bool) self.assertTrue(np.all(std_prob.P == False)) self.assertFalse(np.any(std_prob.P == True)) # phi, gphi, Hphi before eval self.assertEqual(std_prob.phi, 0.) self.assertTrue(np.all(std_prob.gphi == np.zeros(5))) self.assertTupleEqual(std_prob.Hphi.shape, (5, 5)) self.assertEqual(std_prob.Hphi.nnz, 3) if index_x <= index_y: self.assertTrue( np.all(std_prob.Hphi.row == np.array( [index_x, index_y, index_y]))) self.assertTrue( np.all(std_prob.Hphi.col == np.array( [index_x, index_x, index_y]))) else: self.assertTrue( np.all(std_prob.Hphi.row == np.array( [index_x, index_x, index_y]))) self.assertTrue( np.all(std_prob.Hphi.col == np.array( [index_x, index_y, index_y]))) self.assertTrue(np.all(std_prob.Hphi.data == np.zeros(3))) # f, J, H_combined before eval self.assertEqual(std_prob.f.size, 3) self.assertTrue(np.all(std_prob.f == np.zeros(3))) self.assertTupleEqual(std_prob.J.shape, (3, 5)) self.assertEqual(std_prob.J.nnz, 6) self.assertTrue(np.all(std_prob.J.row == np.array([0, 0, 1, 1, 2, 2]))) self.assertTrue( np.all(std_prob.J.col == np.array( [index_x, index_y, index_x, index_s2, index_y, index_s3]))) self.assertTrue(np.all(std_prob.J.data == np.zeros(6))) self.assertEqual(std_prob.H_combined.nnz, 3) if index_x <= index_y: self.assertTrue( np.all(std_prob.H_combined.row == np.array( [index_y, index_x, index_y]))) self.assertTrue( np.all(std_prob.H_combined.col == np.array( [index_x, index_x, index_y]))) else: self.assertTrue( np.all(std_prob.H_combined.row == np.array( [index_x, index_x, index_y]))) self.assertTrue( np.all(std_prob.H_combined.col == np.array( [index_y, index_x, index_y]))) self.assertTrue(np.all(std_prob.H_combined.data == np.zeros(3))) var = np.random.randn(5) # Eval std_prob.eval(var) # phi, gphi, Hphi after eval self.assertAlmostEqual( std_prob.phi, (var[index_x] * var[index_x] + 2. * var[index_x] * var[index_y] + var[index_y] * var[index_y])) temp = np.zeros(5) temp[index_x] = 2. * var[index_x] + 2. * var[index_y] temp[index_y] = 2. * var[index_x] + 2. * var[index_y] self.assertTrue(norm(std_prob.gphi - temp) < 1e-8) self.assertTrue(np.all(std_prob.Hphi.data == np.array([2., 2., 2.]))) # f, J after eval self.assertTrue( norm(std_prob.f - np.array([ var[index_x] * var[index_y] - 20., np.sin(var[index_x]) - var[index_s2] - 3., np.cos(var[index_y]) - var[index_s3] - 4. ])) < 1e-8) self.assertTrue( np.all(std_prob.J.data == np.array([ var[index_y], var[index_x], np.cos(var[index_x]), -1., -np.sin(var[index_y]), -1. ]))) # Combine H - ones std_prob.combine_H(np.ones(3)) self.assertTrue( np.all(std_prob.H_combined.data == np.array( [1., -np.sin(var[index_x]), -np.cos(var[index_y])]))) # Combine H - rand lam = np.random.randn(3) std_prob.combine_H(lam) self.assertTrue( np.all(std_prob.H_combined.data == np.array([ 1. * lam[0], -np.sin(var[index_x]) * lam[1], -np.cos(var[index_y]) * lam[2] ]))) # Properties self.assertTrue(len(std_prob.properties), 3) self.assertTrue('continuous' in std_prob.properties) self.assertTrue('optimization' in std_prob.properties) self.assertTrue('nonlinear' in std_prob.properties)