def test_get_value_and_get_approx_value_nonlin_constr(self):
"""
min x^2 -2x + 1 st. x^2 == 4
when convexified at x = 1,
min x^2 -2x + 1 + penalty_coeff*|2x-5|
when penalty_coeff == 0.5, solution is x = 1.5 and the value is 1.25
(according to Wolfram Alpha)
approx value should be 1.25
value should be 1.125
"""
quad = QuadExpr(2 * np.eye(1), -2 * np.ones((1, 1)), np.ones((1, 1)))
quad_cnt = QuadExpr(2 * np.eye(1), np.zeros((1, 1)), np.zeros((1, 1)))
eq = EqExpr(quad_cnt, np.array([[4]]))
model = grb.Model()
prob = Prob(model)
grb_var = model.addVar(lb=-1 * GRB.INFINITY, ub=GRB.INFINITY, name='x')
grb_vars = np.array([[grb_var]])
var = Variable(grb_vars, np.array([[1.0]]))
model.update()
obj = BoundExpr(quad, var)
prob.add_obj_expr(obj)
bexpr = BoundExpr(eq, var)
prob.add_cnt_expr(bexpr)
prob.convexify()
prob.update_obj(penalty_coeff=0.5)
prob.optimize()
self.assertTrue(np.allclose(var.get_value(), np.array([[1.5]])))
self.assertTrue(
np.allclose(prob.get_approx_value(0.5), np.array([[1.25]])))
self.assertTrue(np.allclose(prob.get_value(0.5), np.array([[1.125]])))
def test_get_value_and_get_approx_value_nonlin_constr(self):
"""
min x^2 -2x + 1 st. x^2 == 4
when convexified at x = 1,
min x^2 -2x + 1 + penalty_coeff*|2x-5|
when penalty_coeff == 0.5, solution is x = 1.5 and the value is 1.25
(according to Wolfram Alpha)
approx value should be 1.25
value should be 1.125
"""
quad = QuadExpr(2*np.eye(1), -2*np.ones((1,1)), np.ones((1,1)))
quad_cnt = QuadExpr(2*np.eye(1), np.zeros((1,1)), np.zeros((1,1)))
eq = EqExpr(quad_cnt, np.array([[4]]))
model = grb.Model()
prob = Prob(model)
grb_var = model.addVar(lb=-1 * GRB.INFINITY, ub=GRB.INFINITY, name='x')
grb_vars = np.array([[grb_var]])
var = Variable(grb_vars, np.array([[1.0]]))
model.update()
obj = BoundExpr(quad, var)
prob.add_obj_expr(obj)
bexpr = BoundExpr(eq, var)
prob.add_cnt_expr(bexpr)
prob.convexify()
prob.update_obj(penalty_coeff=0.5)
prob.optimize()
self.assertTrue(np.allclose(var.get_value(), np.array([[1.5]])))
self.assertTrue(np.allclose(prob.get_approx_value(0.5), np.array([[1.25]])))
self.assertTrue(np.allclose(prob.get_value(0.5), np.array([[1.125]])))
def test_optimize_multidim_quad_obj(self):
Q = np.array([[2, 0], [0, 0]])
A = np.array([[-4, 0]])
quad = QuadExpr(Q, A, np.zeros((1, 1)))
model = grb.Model()
prob = Prob(model)
grb_var1 = model.addVar(lb=-1 * GRB.INFINITY,
ub=GRB.INFINITY,
name='x1')
grb_var2 = model.addVar(lb=-1 * GRB.INFINITY,
ub=GRB.INFINITY,
name='x2')
grb_vars = np.array([[grb_var1], [grb_var2]])
var = Variable(grb_vars)
bexpr_quad = BoundExpr(quad, var)
prob.add_obj_expr(bexpr_quad)
self.assertTrue(bexpr_quad in prob._quad_obj_exprs)
self.assertTrue(var in prob._vars)
prob.update_obj(penalty_coeff=0)
prob.optimize()
var_value = var.get_value()
value = np.zeros((2, 1))
value[0, 0] = 2
self.assertTrue(np.allclose(var_value, value))
def test_add_obj_expr_nonquad(self):
expr = Expr(f)
model = grb.Model()
prob = Prob(model)
grb_var = model.addVar(lb=-1 * GRB.INFINITY, ub=GRB.INFINITY, name='x')
grb_vars = np.array([[grb_var]])
var = Variable(grb_vars)
bexpr = BoundExpr(expr, var)
prob.add_obj_expr(bexpr)
self.assertTrue(bexpr not in prob._quad_obj_exprs)
self.assertTrue(bexpr in prob._nonquad_obj_exprs)
self.assertTrue(var in prob._vars)
def test_add_obj_expr_nonquad(self):
expr = Expr(f)
model = grb.Model()
prob = Prob(model)
grb_var = model.addVar(lb=-1 * GRB.INFINITY, ub=GRB.INFINITY, name='x')
grb_vars = np.array([[grb_var]])
var = Variable(grb_vars)
bexpr = BoundExpr(expr, var)
prob.add_obj_expr(bexpr)
self.assertTrue(bexpr not in prob._quad_obj_exprs)
self.assertTrue(bexpr in prob._nonquad_obj_exprs)
self.assertTrue(var in prob._vars)
def test_prob(ut,
x0,
x_true,
f=zerofunc,
g=neginffunc,
h=zerofunc,
Q=np.zeros((N, N)),
q=np.zeros((1, N)),
A_ineq=np.zeros((1, N)),
b_ineq=np.zeros((1, 1)),
A_eq=np.zeros((1, 1)),
b_eq=np.zeros((1, 1))):
if not np.allclose(A_eq, np.zeros((1,1)))\
or not np.allclose(b_eq, np.zeros((1,1))):
raise NotImplementedError
model = grb.Model()
prob = Prob(model)
grb_var1 = model.addVar(lb=-1 * GRB.INFINITY, ub=GRB.INFINITY, name='x1')
grb_var2 = model.addVar(lb=-1 * GRB.INFINITY, ub=GRB.INFINITY, name='x2')
grb_vars = np.array([[grb_var1], [grb_var2]])
var = Variable(grb_vars, value=x0)
model.update()
quad_obj = BoundExpr(QuadExpr(Q, q, np.zeros((1, 1))), var)
prob.add_obj_expr(quad_obj)
nonquad_obj = BoundExpr(Expr(f), var)
prob.add_obj_expr(nonquad_obj)
cnts = []
lin_ineq = LEqExpr(AffExpr(A_ineq, -b_ineq), np.zeros(b_ineq.shape))
lin_ineq = BoundExpr(lin_ineq, var)
cnts.append(lin_ineq)
nonlin_ineq = LEqExpr(Expr(g), np.zeros(g(np.zeros((2, 1))).shape))
nonlin_ineq = BoundExpr(nonlin_ineq, var)
cnts.append(nonlin_ineq)
nonlin_eq = EqExpr(Expr(h), np.zeros(g(np.zeros((2, 1))).shape))
nonlin_eq = BoundExpr(nonlin_eq, var)
cnts.append(nonlin_eq)
for cnt in cnts:
prob.add_cnt_expr(cnt)
solv.solve(prob, method='penalty_sqp')
x_sol = var.get_value()
ut.assertTrue(np.allclose(x_sol, x_true, atol=1e-4))
def test_add_obj_expr_quad(self):
quad = QuadExpr(2 * np.eye(1), -2 * np.ones((1, 1)), np.zeros((1, 1)))
aff = AffExpr(-2 * np.ones((1, 1)), np.zeros((1, 1)))
model = grb.Model()
prob = Prob(model)
grb_var = model.addVar(lb=-1 * GRB.INFINITY, ub=GRB.INFINITY, name='x')
grb_vars = np.array([[grb_var]])
var = Variable(grb_vars)
bexpr_quad = BoundExpr(quad, var)
bexpr_aff = BoundExpr(aff, var)
prob.add_obj_expr(bexpr_quad)
prob.add_obj_expr(bexpr_aff)
self.assertTrue(bexpr_aff in prob._quad_obj_exprs)
self.assertTrue(bexpr_quad in prob._quad_obj_exprs)
self.assertTrue(var in prob._vars)
def test_add_obj_expr_quad(self):
quad = QuadExpr(2*np.eye(1), -2*np.ones((1,1)), np.zeros((1,1)))
aff = AffExpr(-2*np.ones((1,1)), np.zeros((1,1)))
model = grb.Model()
prob = Prob(model)
grb_var = model.addVar(lb=-1 * GRB.INFINITY, ub=GRB.INFINITY, name='x')
grb_vars = np.array([[grb_var]])
var = Variable(grb_vars)
bexpr_quad = BoundExpr(quad, var)
bexpr_aff = BoundExpr(aff, var)
prob.add_obj_expr(bexpr_quad)
prob.add_obj_expr(bexpr_aff)
self.assertTrue(bexpr_aff in prob._quad_obj_exprs)
self.assertTrue(bexpr_quad in prob._quad_obj_exprs)
self.assertTrue(var in prob._vars)
def test_add_cnt_leq_aff(self):
quad = QuadExpr(2 * np.eye(1), -2 * np.ones((1, 1)), np.zeros((1, 1)))
aff = AffExpr(np.ones((1, 1)), np.zeros((1, 1)))
comp = LEqExpr(aff, np.array([[-4]]))
model = grb.Model()
prob = Prob(model)
grb_var = model.addVar(lb=-1 * GRB.INFINITY, ub=GRB.INFINITY, name='x')
grb_vars = np.array([[grb_var]])
var = Variable(grb_vars)
model.update()
bexpr_quad = BoundExpr(quad, var)
prob.add_obj_expr(bexpr_quad)
bexpr = BoundExpr(comp, var)
prob.add_cnt_expr(bexpr)
prob.optimize()
self.assertTrue(np.allclose(var.get_value(), np.array([[-4]])))
def test_add_cnt_leq_aff(self):
quad = QuadExpr(2*np.eye(1), -2*np.ones((1,1)), np.zeros((1,1)))
aff = AffExpr(np.ones((1,1)), np.zeros((1,1)))
comp = LEqExpr(aff, np.array([[-4]]))
model = grb.Model()
prob = Prob(model)
grb_var = model.addVar(lb=-1 * GRB.INFINITY, ub=GRB.INFINITY, name='x')
grb_vars = np.array([[grb_var]])
var = Variable(grb_vars)
model.update()
bexpr_quad = BoundExpr(quad, var)
prob.add_obj_expr(bexpr_quad)
bexpr = BoundExpr(comp, var)
prob.add_cnt_expr(bexpr)
prob.optimize()
self.assertTrue(np.allclose(var.get_value(), np.array([[-4]])))
def test_get_approx_value_lin_constr(self):
"""
min x^2 st. x == 4
when convexified,
min x^2 + penalty_coeff*|x-4|
when penalty_coeff == 1, solution is x = 0.5 and the value is 3.75
(according to Wolfram Alpha)
when penalty_coeff == 2, solution is x = 1.0 and the value is 7.0
(according to Wolfram Alpha)
"""
quad = QuadExpr(2 * np.eye(1), np.zeros((1, 1)), np.zeros((1, 1)))
e = Expr(f)
eq = EqExpr(e, np.array([[4]]))
model = grb.Model()
prob = Prob(model)
grb_var = model.addVar(lb=-1 * GRB.INFINITY, ub=GRB.INFINITY, name='x')
grb_vars = np.array([[grb_var]])
var = Variable(grb_vars)
model.update()
obj = BoundExpr(quad, var)
prob.add_obj_expr(obj)
bexpr = BoundExpr(eq, var)
prob.add_cnt_expr(bexpr)
prob.optimize() # needed to set an initial value
prob.convexify()
prob.update_obj(penalty_coeff=1.0)
prob.optimize()
self.assertTrue(np.allclose(var.get_value(), np.array([[0.5]])))
self.assertTrue(
np.allclose(prob.get_approx_value(1.0), np.array([[3.75]])))
prob.update_obj(penalty_coeff=2.0)
prob.optimize()
self.assertTrue(np.allclose(var.get_value(), np.array([[1.0]])))
self.assertTrue(
np.allclose(prob.get_approx_value(2.0), np.array([[7]])))
def test_optimize_just_quad_obj(self):
quad = QuadExpr(2 * np.eye(1), -2 * np.ones((1, 1)), np.zeros((1, 1)))
aff = AffExpr(-2 * np.ones((1, 1)), np.zeros((1, 1)))
model = grb.Model()
prob = Prob(model)
grb_var = model.addVar(lb=-1 * GRB.INFINITY, ub=GRB.INFINITY, name='x')
grb_vars = np.array([[grb_var]])
var = Variable(grb_vars)
bexpr_quad = BoundExpr(quad, var)
bexpr_aff = BoundExpr(aff, var)
prob.add_obj_expr(bexpr_quad)
prob.add_obj_expr(bexpr_aff)
self.assertTrue(bexpr_aff in prob._quad_obj_exprs)
self.assertTrue(bexpr_quad in prob._quad_obj_exprs)
self.assertTrue(var in prob._vars)
prob.update_obj(penalty_coeff=0)
prob.optimize()
self.assertTrue(np.allclose(var.get_value(), np.array([[2.0]])))
def test_optimize_just_quad_obj(self):
quad = QuadExpr(2*np.eye(1), -2*np.ones((1,1)), np.zeros((1,1)))
aff = AffExpr(-2*np.ones((1,1)), np.zeros((1,1)))
model = grb.Model()
prob = Prob(model)
grb_var = model.addVar(lb=-1 * GRB.INFINITY, ub=GRB.INFINITY, name='x')
grb_vars = np.array([[grb_var]])
var = Variable(grb_vars)
bexpr_quad = BoundExpr(quad, var)
bexpr_aff = BoundExpr(aff, var)
prob.add_obj_expr(bexpr_quad)
prob.add_obj_expr(bexpr_aff)
self.assertTrue(bexpr_aff in prob._quad_obj_exprs)
self.assertTrue(bexpr_quad in prob._quad_obj_exprs)
self.assertTrue(var in prob._vars)
prob.update_obj(penalty_coeff=0)
prob.optimize()
self.assertTrue(np.allclose(var.get_value(), np.array([[2.0]])))
def test_prob(ut, x0, x_true, f=zerofunc, g=neginffunc, h=zerofunc,
Q=np.zeros((N,N)), q=np.zeros((1,N)), A_ineq=np.zeros((1,N)),
b_ineq=np.zeros((1,1)), A_eq=np.zeros((1,1)), b_eq=np.zeros((1,1))):
if not np.allclose(A_eq, np.zeros((1,1)))\
or not np.allclose(b_eq, np.zeros((1,1))):
raise NotImplementedError
model = grb.Model()
prob = Prob(model)
grb_var1 = model.addVar(lb=-1 * GRB.INFINITY, ub=GRB.INFINITY, name='x1')
grb_var2 = model.addVar(lb=-1 * GRB.INFINITY, ub=GRB.INFINITY, name='x2')
grb_vars = np.array([[grb_var1], [grb_var2]])
var = Variable(grb_vars, value=x0)
model.update()
quad_obj = BoundExpr(QuadExpr(Q, q, np.zeros((1,1))), var)
prob.add_obj_expr(quad_obj)
nonquad_obj = BoundExpr(Expr(f), var)
prob.add_obj_expr(nonquad_obj)
cnts = []
lin_ineq = LEqExpr(AffExpr(A_ineq, -b_ineq), np.zeros(b_ineq.shape))
lin_ineq = BoundExpr(lin_ineq, var)
cnts.append(lin_ineq)
nonlin_ineq = LEqExpr(Expr(g), np.zeros(g(np.zeros((2,1))).shape))
nonlin_ineq = BoundExpr(nonlin_ineq, var)
cnts.append(nonlin_ineq)
nonlin_eq = EqExpr(Expr(h), np.zeros(g(np.zeros((2,1))).shape))
nonlin_eq = BoundExpr(nonlin_eq, var)
cnts.append(nonlin_eq)
for cnt in cnts:
prob.add_cnt_expr(cnt)
solv.solve(prob, method='penalty_sqp')
x_sol = var.get_value()
ut.assertTrue(np.allclose(x_sol, x_true, atol=1e-4))
def test_get_approx_value_lin_constr(self):
"""
min x^2 st. x == 4
when convexified,
min x^2 + penalty_coeff*|x-4|
when penalty_coeff == 1, solution is x = 0.5 and the value is 3.75
(according to Wolfram Alpha)
when penalty_coeff == 2, solution is x = 1.0 and the value is 7.0
(according to Wolfram Alpha)
"""
quad = QuadExpr(2*np.eye(1), np.zeros((1,1)), np.zeros((1,1)))
e = Expr(f)
eq = EqExpr(e, np.array([[4]]))
model = grb.Model()
prob = Prob(model)
grb_var = model.addVar(lb=-1 * GRB.INFINITY, ub=GRB.INFINITY, name='x')
grb_vars = np.array([[grb_var]])
var = Variable(grb_vars)
model.update()
obj = BoundExpr(quad, var)
prob.add_obj_expr(obj)
bexpr = BoundExpr(eq, var)
prob.add_cnt_expr(bexpr)
prob.optimize() # needed to set an initial value
prob.convexify()
prob.update_obj(penalty_coeff=1.0)
prob.optimize()
self.assertTrue(np.allclose(var.get_value(), np.array([[0.5]])))
self.assertTrue(np.allclose(prob.get_approx_value(1.0), np.array([[3.75]])))
prob.update_obj(penalty_coeff=2.0)
prob.optimize()
self.assertTrue(np.allclose(var.get_value(), np.array([[1.0]])))
self.assertTrue(np.allclose(prob.get_approx_value(2.0), np.array([[7]])))
def test_optimize_multidim_quad_obj(self):
Q = np.array([[2,0], [0,0]])
A = np.array([[-4, 0]])
quad = QuadExpr(Q, A, np.zeros((1,1)))
model = grb.Model()
prob = Prob(model)
grb_var1 = model.addVar(lb=-1 * GRB.INFINITY, ub=GRB.INFINITY, name='x1')
grb_var2 = model.addVar(lb=-1 * GRB.INFINITY, ub=GRB.INFINITY, name='x2')
grb_vars = np.array([[grb_var1], [grb_var2]])
var = Variable(grb_vars)
bexpr_quad = BoundExpr(quad, var)
prob.add_obj_expr(bexpr_quad)
self.assertTrue(bexpr_quad in prob._quad_obj_exprs)
self.assertTrue(var in prob._vars)
prob.update_obj(penalty_coeff=0)
prob.optimize()
var_value = var.get_value()
value = np.zeros((2,1))
value[0,0] = 2
self.assertTrue(np.allclose(var_value, value))
