def test_abs_expr_to_grb_expr(self): """ min |x + 1| s.t. x <= -4 """ aff = AffExpr(np.ones((1,1)), np.ones((1,1))) abs_expr = AbsExpr(aff) 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() abs_grb_expr, abs_grb_cnt = prob._abs_expr_to_grb_expr(abs_expr, var) model.update() model.setObjective(abs_grb_expr[0,0]) bexpr = BoundExpr(comp, var) prob.add_cnt_expr(bexpr) model.optimize() var.update() self.assertTrue(np.allclose(var.get_value(), np.array([[-4]]))) # makes assumption about the construction of the Gurobi variable, needs # to be changed TODO pos = abs_grb_expr[0,0].getVar(0).X neg = abs_grb_expr[0,0].getVar(1).X self.assertTrue(np.allclose(pos, 0.0)) self.assertTrue(np.allclose(neg, 3.0))
def test_hinge_expr_to_grb_expr2(self): """ min max(0, x+1) st. x == 1 """ aff = AffExpr(np.ones((1,1)), np.ones((1,1))) hinge = HingeExpr(aff) 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() hinge_grb_expr, hinge_grb_cnt = prob._hinge_expr_to_grb_expr(hinge, var) model.update() obj = hinge_grb_expr[0,0] model.setObjective(obj) aff = AffExpr(np.ones((1,1)), np.zeros((1,1))) comp = EqExpr(aff, np.array([[1.0]])) bound_expr = BoundExpr(comp, var) prob.add_cnt_expr(bound_expr) model.optimize() var.update() self.assertTrue(np.allclose(var.get_value(), np.array([[1.0]]))) self.assertTrue(np.allclose(obj.X, 2.0))
def test_find_closest_feasible_point_leq_cnts(self): cnt_vals = [np.ones((2,1)), np.array([[-1.0],[1.0]]), \ np.array([[-1.0],[-1.0]])] true_var_vals = [np.zeros((2,1)), np.array([[-1.0],[0.0]]), \ -1*np.ones((2,1))] for true_var_val, cnt_val in zip(true_var_vals, cnt_vals): 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, np.zeros((2, 1))) model.update() aff_expr = AffExpr(np.eye(2), np.zeros((2, 1))) leq_expr = LEqExpr(aff_expr, cnt_val) bexpr = BoundExpr(leq_expr, var) prob.add_cnt_expr(bexpr) prob.find_closest_feasible_point() self.assertTrue(np.allclose(var.get_value(), true_var_val))
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_hinge_expr_to_grb_expr2(self): """ min max(0, x+1) st. x == 1 """ aff = AffExpr(np.ones((1, 1)), np.ones((1, 1))) hinge = HingeExpr(aff) 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() hinge_grb_expr, hinge_grb_cnt = prob._hinge_expr_to_grb_expr( hinge, var) model.update() obj = hinge_grb_expr[0, 0] model.setObjective(obj) aff = AffExpr(np.ones((1, 1)), np.zeros((1, 1))) comp = EqExpr(aff, np.array([[1.0]])) bound_expr = BoundExpr(comp, var) prob.add_cnt_expr(bound_expr) model.optimize() var.update() self.assertTrue(np.allclose(var.get_value(), np.array([[1.0]]))) self.assertTrue(np.allclose(obj.X, 2.0))
def test_abs_expr_to_grb_expr(self): """ min |x + 1| s.t. x <= -4 """ aff = AffExpr(np.ones((1, 1)), np.ones((1, 1))) abs_expr = AbsExpr(aff) 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() abs_grb_expr, abs_grb_cnt = prob._abs_expr_to_grb_expr(abs_expr, var) model.update() model.setObjective(abs_grb_expr[0, 0]) bexpr = BoundExpr(comp, var) prob.add_cnt_expr(bexpr) model.optimize() var.update() self.assertTrue(np.allclose(var.get_value(), np.array([[-4]]))) # makes assumption about the construction of the Gurobi variable, needs # to be changed TODO pos = abs_grb_expr[0, 0].getVar(0).X neg = abs_grb_expr[0, 0].getVar(1).X self.assertTrue(np.allclose(pos, 0.0)) self.assertTrue(np.allclose(neg, 3.0))
def test_get_max_cnt_violation_leq_cnts(self): model = grb.Model() prob = Prob(model) dummy_var = Variable(np.zeros((1, 1)), np.zeros((1, 1))) f = lambda x: np.array([[1, 3]]) f_expr = Expr(f) leq_expr = LEqExpr(f_expr, np.array([[1, 1]])) bexpr = BoundExpr(leq_expr, dummy_var) prob.add_cnt_expr(bexpr) self.assertTrue(np.allclose(prob.get_max_cnt_violation(), 2.0)) f_expr = Expr(f) f_expr.f = lambda x: np.array([[2, 1]]) leq_expr.expr = f_expr leq_expr.val = np.array([[1, 1]]) self.assertTrue(np.allclose(prob.get_max_cnt_violation(), 1.0)) f_expr = Expr(f) f_expr.f = lambda x: np.array([[2, -2]]) leq_expr.expr = f_expr leq_expr.val = np.array([[1, 1]]) self.assertTrue(np.allclose(prob.get_max_cnt_violation(), 1.0)) f_expr = Expr(f) f_expr.f = lambda x: np.array([[2, -2]]) leq_expr.expr = f_expr leq_expr.val = np.array([[2, -2]]) self.assertTrue(np.allclose(prob.get_max_cnt_violation(), 0.0)) f_expr = Expr(f) f_expr.f = lambda x: np.array([[2, 0]]) leq_expr.expr = f_expr leq_expr.val = np.array([[2, -2]]) self.assertTrue(np.allclose(prob.get_max_cnt_violation(), 2.0))
def test_get_max_cnt_violation_leq_cnts(self): model = grb.Model() prob = Prob(model) dummy_var = Variable(np.zeros((1,1)), np.zeros((1,1))) f = lambda x: np.array([[1,3]]) f_expr = Expr(f) leq_expr = LEqExpr(f_expr, np.array([[1,1]])) bexpr = BoundExpr(leq_expr, dummy_var) prob.add_cnt_expr(bexpr) self.assertTrue(np.allclose(prob.get_max_cnt_violation(), 2.0)) f_expr = Expr(f) f_expr.f = lambda x: np.array([[2,1]]) leq_expr.expr = f_expr leq_expr.val = np.array([[1,1]]) self.assertTrue(np.allclose(prob.get_max_cnt_violation(), 1.0)) f_expr = Expr(f) f_expr.f = lambda x: np.array([[2,-2]]) leq_expr.expr = f_expr leq_expr.val = np.array([[1,1]]) self.assertTrue(np.allclose(prob.get_max_cnt_violation(), 1.0)) f_expr = Expr(f) f_expr.f = lambda x: np.array([[2,-2]]) leq_expr.expr = f_expr leq_expr.val = np.array([[2, -2]]) self.assertTrue(np.allclose(prob.get_max_cnt_violation(), 0.0)) f_expr = Expr(f) f_expr.f = lambda x: np.array([[2, 0]]) leq_expr.expr = f_expr leq_expr.val = np.array([[2, -2]]) self.assertTrue(np.allclose(prob.get_max_cnt_violation(), 2.0))
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_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_cnt_expr_eq_aff(self): aff = AffExpr(np.ones((1, 1)), np.zeros((1, 1))) comp = EqExpr(aff, np.array([[2]])) 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 = BoundExpr(comp, var) prob.add_cnt_expr(bexpr) prob.optimize() self.assertTrue(np.allclose(var.get_value(), np.array([[2]])))
def test_add_cnt_expr_eq_aff(self): aff = AffExpr(np.ones((1,1)), np.zeros((1,1))) comp = EqExpr(aff, np.array([[2]])) 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 = BoundExpr(comp, var) prob.add_cnt_expr(bexpr) prob.optimize() self.assertTrue(np.allclose(var.get_value(), np.array([[2]])))
def test_find_closest_feasible_point_eq_cnts(self): 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, np.zeros((2,1))) model.update() val = np.array([[5.0],[-10.0]]) aff_expr = AffExpr(np.eye(2), np.zeros((2,1))) eq_expr = EqExpr(aff_expr, val) bexpr = BoundExpr(eq_expr, var) prob.add_cnt_expr(bexpr) prob.find_closest_feasible_point() self.assertTrue(np.allclose(var.get_value(), val))
def test_get_max_cnt_violation_mult_cnts(self): model = grb.Model() prob = Prob(model) dummy_var = Variable(np.zeros((1,1)), np.zeros((1,1))) f1 = lambda x: np.array([[1,3]]) f2 = lambda x: np.array([[0,0]]) f1_expr = Expr(f1) leq_expr = LEqExpr(f1_expr, np.array([[1,1]])) bexpr = BoundExpr(leq_expr, dummy_var) prob.add_cnt_expr(bexpr) f2_expr = Expr(f2) eq_expr = EqExpr(f2_expr, np.array([[1,1]])) bexpr = BoundExpr(eq_expr, dummy_var) prob.add_cnt_expr(bexpr) self.assertTrue(np.allclose(prob.get_max_cnt_violation(), 2.0))
def test_get_max_cnt_violation_mult_cnts(self): model = grb.Model() prob = Prob(model) dummy_var = Variable(np.zeros((1, 1)), np.zeros((1, 1))) f1 = lambda x: np.array([[1, 3]]) f2 = lambda x: np.array([[0, 0]]) f1_expr = Expr(f1) leq_expr = LEqExpr(f1_expr, np.array([[1, 1]])) bexpr = BoundExpr(leq_expr, dummy_var) prob.add_cnt_expr(bexpr) f2_expr = Expr(f2) eq_expr = EqExpr(f2_expr, np.array([[1, 1]])) bexpr = BoundExpr(eq_expr, dummy_var) prob.add_cnt_expr(bexpr) self.assertTrue(np.allclose(prob.get_max_cnt_violation(), 2.0))
def test_convexify_leq(self): 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() grb_cnt = model.addConstr(grb_var, GRB.EQUAL, 0) model.optimize() var.update() e = Expr(f) eq = LEqExpr(e, np.array([[4]])) bexpr = BoundExpr(eq, var) prob.add_cnt_expr(bexpr) prob.convexify() self.assertTrue(len(prob._penalty_exprs) == 1) self.assertTrue(isinstance(prob._penalty_exprs[0].expr, HingeExpr))
def test_convexify_leq(self): 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() grb_cnt = model.addConstr(grb_var, GRB.EQUAL, 0) model.optimize() var.update() e = Expr(f) eq = LEqExpr(e, np.array([[4]])) bexpr = BoundExpr(eq, var) prob.add_cnt_expr(bexpr) prob.convexify() self.assertTrue(len(prob._penalty_exprs) == 1) self.assertTrue(isinstance(prob._penalty_exprs[0].expr, HingeExpr))
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_find_closest_feasible_point_eq_cnts(self): 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, np.zeros((2, 1))) model.update() val = np.array([[5.0], [-10.0]]) aff_expr = AffExpr(np.eye(2), np.zeros((2, 1))) eq_expr = EqExpr(aff_expr, val) bexpr = BoundExpr(eq_expr, var) prob.add_cnt_expr(bexpr) prob.find_closest_feasible_point() self.assertTrue(np.allclose(var.get_value(), val))
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_find_closest_feasible_point_leq_cnts(self): cnt_vals = [np.ones((2,1)), np.array([[-1.0],[1.0]]), \ np.array([[-1.0],[-1.0]])] true_var_vals = [np.zeros((2,1)), np.array([[-1.0],[0.0]]), \ -1*np.ones((2,1))] for true_var_val, cnt_val in zip(true_var_vals, cnt_vals): 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, np.zeros((2,1))) model.update() aff_expr = AffExpr(np.eye(2), np.zeros((2,1))) leq_expr = LEqExpr(aff_expr, cnt_val) bexpr = BoundExpr(leq_expr, var) prob.add_cnt_expr(bexpr) prob.find_closest_feasible_point() self.assertTrue(np.allclose(var.get_value(), true_var_val))