def d_rule(disjunct, flag):
m = disjunct.model()
if flag:
disjunct.c1 = Constraint(expr=inequality(1, m.x, 2))
disjunct.c2 = Constraint(expr=inequality(3, m.y, 4))
else:
disjunct.c1 = Constraint(expr=inequality(3, m.x, 4))
disjunct.c2 = Constraint(expr=inequality(1, m.y, 2))
def grossmann_twoDisj():
m = grossmann_oneDisj()
m.disjunct3 = Disjunct()
m.disjunct3.constraintx = Constraint(expr=inequality(1, m.x, 2.5))
m.disjunct3.constrainty = Constraint(expr=inequality(6.5, m.y, 8))
m.disjunct4 = Disjunct()
m.disjunct4.constraintx = Constraint(expr=inequality(9, m.x, 11))
m.disjunct4.constrainty = Constraint(expr=inequality(2, m.y, 3.5))
m.disjunction2 = Disjunction(expr=[m.disjunct3, m.disjunct4])
return m
def twoSegments_SawayaGrossmann():
m = ConcreteModel()
m.x = Var(bounds=(0, 3))
m.disj1 = Disjunct()
m.disj1.c = Constraint(expr=inequality(0, m.x, 1))
m.disj2 = Disjunct()
m.disj2.c = Constraint(expr=inequality(2, m.x, 3))
m.disjunction = Disjunction(expr=[m.disj1, m.disj2])
# this is my objective because I want to make sure that when I am testing
# cutting planes, my first solution to rBigM is not on the convex hull.
m.obj = Objective(expr=m.x - m.disj2.indicator_var)
return m
def d_rule(disjunct, flag, s):
m = disjunct.model()
if flag == 0:
disjunct.c = Constraint(expr=m.a[s] == 0)
elif flag == 1:
disjunct.c = Constraint(expr=m.a[s] >= 5)
else:
disjunct.c = Constraint(expr=inequality(2, m.a[s], 4))
def to_break_constraint_tolerances():
m = ConcreteModel()
m.x = Var(bounds=(0, 130))
m.y = Var(bounds=(0, 130))
m.disjunct1 = Disjunct()
m.disjunct1.constraintx = Constraint(expr=inequality(0, m.x, 2))
m.disjunct1.constrainty = Constraint(expr=inequality(117, m.y, 127))
m.disjunct2 = Disjunct()
m.disjunct2.constraintx = Constraint(expr=inequality(118, m.x, 120))
m.disjunct2.constrainty = Constraint(expr=inequality(0, m.y, 3))
m.disjunction = Disjunction(expr=[m.disjunct1, m.disjunct2])
m.objective = Objective(expr=m.x + 2*m.y, sense=maximize)
return m
def grossmann_oneDisj():
m = ConcreteModel()
m.x = Var(bounds=(0,20))
m.y = Var(bounds=(0, 20))
m.disjunct1 = Disjunct()
m.disjunct1.constraintx = Constraint(expr=inequality(0, m.x, 2))
m.disjunct1.constrainty = Constraint(expr=inequality(7, m.y, 10))
m.disjunct2 = Disjunct()
m.disjunct2.constraintx = Constraint(expr=inequality(8, m.x, 10))
m.disjunct2.constrainty = Constraint(expr=inequality(0, m.y, 3))
m.disjunction = Disjunction(expr=[m.disjunct1, m.disjunct2])
m.objective = Objective(expr=m.x + 2*m.y, sense=maximize)
return m
def d_rule(disjunct, flag, s):
m = disjunct.model()
if flag == 0:
disjunct.c = Constraint(expr=m.a[s] == 0)
elif flag == 1:
disjunct.c = Constraint(expr=m.a[s] >= 5)
else:
disjunct.c = Constraint(expr=inequality(2, m.a[s], 4))
def test_cov11(self):
# Testing construction with a badly formed expression
M = self._setup()
M.cc = Complementarity(
expr=complements(inequality(1, M.x1, M.y), M.x2))
try:
M.cc.to_standard_form()
self.fail("Expected a RuntimeError")
except RuntimeError:
pass
def create_instance(scenario_name):
cnt = d[scenario_name]
model = ConcreteModel()
# first stage
model.x = Var(bounds=(0, 10))
# first stage derived
model.y = Expression(expr=model.x + 1)
model.fx = Var()
# second stage
model.z = Var(bounds=(-10, 10))
# second stage derived
model.q = Expression(expr=model.z**2)
model.fz = Var()
model.r = Var()
# stage costs
model.StageCost = Expression([1, 2])
model.StageCost.add(1, model.fx)
model.StageCost.add(2, -model.fz + model.r - cnt)
model.o = Objective(expr=sum_product(model.StageCost))
model.ZERO = Param(initialize=0, mutable=True)
if cnt == 0:
cnt = model.ZERO
model.c_first_stage = Constraint(expr=model.x >= 0)
# test our handling of intermediate variables that
# are created by Piecewise but can not necessarily
# be declared on the scenario tree
model.p_first_stage = Piecewise(model.fx,
model.x,
pw_pts=[0., 2., 5., 7., 10.],
pw_constr_type='EQ',
pw_repn='INC',
f_rule=[10., 10., 9., 10., 10.],
force_pw=True)
model.c_second_stage = Constraint(expr=model.x + model.r * cnt >= -100)
model.r_second_stage = Constraint(expr=inequality(-cnt, model.r, 0))
# exercise more of the code by making this an indexed
# block
model.p_second_stage = Piecewise([1],
model.fz,
model.z,
pw_pts=[-10, -5., 0., 5., 10.],
pw_constr_type='EQ',
pw_repn='INC',
f_rule=[0., 0., -1., 2. + cnt, 1.],
force_pw=True)
return model
def test_t12(self):
# x1 _|_ 2 <= y + x1 <= 3"""
M = self._setup()
M.cc = Complementarity(
expr=complements(M.x1, inequality(2, M.y + M.x1, 3)))
self._test("t12", M)
def test_t11(self):
# 2 <= y + x1 <= 3 _|_ x1
M = self._setup()
M.cc = Complementarity(expr=complements(inequality(2, M.y +
M.x1, 3), M.x1))
self._test("t11", M)
