def Portfolio():
m = pe.ConcreteModel()
m.cons = pe.ConstraintList()
N = 5
index = list(range(N))
mean = [0.1, 0.3, 0.5, 0.7, 0.4]
m.x = pe.Var(index, bounds=(0, 1))
m.z = pe.Var(within=pe.PositiveReals)
m.U = ro.UncSet()
m.r = ro.UncParam(index, uncset=m.U, nominal=mean)
r = m.r
expr = 0
for i in index:
expr += (m.r[i] - mean[i])**2
m.U.cons = pe.Constraint(expr=expr <= 0.0005)
m.Elib = ro.uncset.EllipsoidalSet(mean,
[[0.0005, 0, 0, 0, 0],
[0, 0.0005, 0, 0, 0],
[0, 0, 0.0005, 0, 0],
[0, 0, 0, 0.0005, 0],
[0, 0, 0, 0, 0.0005]])
P = [[1, 1, 0, 0, 0],
[-1, 1, 0, 0, 0],
[1, -1, 0, 0, 0],
[-1, -1, 0, 0, 0],
[0, 0, 1, 0, 0],
[0, 0, -1, 0, 0],
[0, 0, 0, 1, 0],
[0, 0, 0, -1, 0],
[0, 0, 0, 0, 1],
[0, 0, 0, 0, -1]]
rhs = [0.001 + mean[0] + mean[1],
0.001 - mean[0] + mean[1],
0.001 + mean[0] - mean[1],
0.001 - mean[0] - mean[1],
0.001 + mean[2],
0.001 - mean[2],
0.001 + mean[3],
0.001 - mean[3],
0.001 + mean[4],
0.001 - mean[4]]
m.Plib = ro.uncset.PolyhedralSet(P, rhs)
m.P = ro.UncSet()
m.P.cons = pe.ConstraintList()
for i, row in enumerate(P):
m.P.cons.add(expr=pe.quicksum(row[j]*m.r[j] for j in m.r) <= rhs[i])
m.Obj = pe.Objective(expr=m.z, sense=pe.maximize)
# x0 = m.x[0]
# expr = x0*3
expr = sum([m.x[i] for i in index]) == 1
m.cons.add(expr)
m.cons.add(sum([r[i]*m.x[i] for i in index]) >= m.z)
return m
def Pooling():
m = pe.ConcreteModel()
m.q = pe.Var(con_feed_pool, bounds=(0, 1))
m.y = pe.Var(con_pool_prod, within=pe.NonNegativeReals)
m.z = pe.Var(con_feed_prod, within=pe.NonNegativeReals)
m.U = ro.UncSet()
m.price_product = ro.UncParam(products, nominal=price_product, uncset=m.U)
expr = 0
for j in products:
expr += (m.price_product[j] - price_product[j])**2
m.U.c = pe.Constraint(expr=expr <= 0.1)
m.P = ro.UncSet()
m.P.cons = pe.ConstraintList()
for j in products:
m.P.cons.add(m.price_product[j] - price_product[j] <= 0.01)
m.P.cons.add(m.price_product[j] - price_product[j] >= -0.01)
m.P.cons.add((m.price_product[0] - price_product[0]) +
(m.price_product[1] - price_product[1]) <= 0.01)
m.C = ro.UncSet()
m.C.cons = pe.ConstraintList()
for j in products:
m.C.cons.add(m.price_product[j] - price_product[j] <= 0.01)
m.C.cons.add(m.price_product[j] - price_product[j] >= -0.01)
m.C.cons.add((m.price_product[0] - price_product[0]) +
(m.price_product[1] - price_product[1]) <= 0.01)
expr = 0
for j in products:
expr += (m.price_product[j] - price_product[j])**2
m.C.cons.add(expr <= 0.1)
pp = m.price_product
obj = 0
for i, l in con_feed_pool:
for j in [jj for ll, jj in con_pool_prod if ll == l]:
obj += price_feed[j] * m.y[(l, j)] * m.q[i, l]
for l, j in con_pool_prod:
obj -= pp[j] * m.y[(l, j)]
for i, j in con_feed_prod:
obj -= (pp[j] - price_feed[i]) * m.z[(i, j)]
m.obj = pe.Objective(expr=obj, sense=pe.minimize)
m.feed_availability = pe.Constraint(feeds, rule=feed_availability_rule)
m.pool_capacity = pe.Constraint(pools, rule=pool_capacity_rule)
m.product_demand = pe.Constraint(products, rule=prod_demand_rule)
m.simplex = pe.Constraint(pools, rule=simplex_rule)
m.prod_quality_upper = pe.Constraint(products,
qualities,
rule=prod_quality_rule_upper)
m.prod_quality_lower = pe.Constraint(products,
qualities,
rule=prod_quality_rule_lower)
return m
def Portfolio():
m = pe.ConcreteModel()
m.cons = pe.ConstraintList()
N = 5
index = list(range(N))
mean = [0.1, 0.3, 0.5, 0.7, 0.4]
m.x = pe.Var(index, bounds=(0, 1))
m.z = pe.Var(within=pe.PositiveReals)
m.U = ro.UncSet()
m.r = ro.UncParam(index, uncset=m.U, nominal=mean)
r = m.r
expr = 0
for i in index:
expr += (m.r[i] - mean[i])**2
m.U.cons = pe.Constraint(expr=expr <= 0.0005)
m.Obj = pe.Objective(expr=m.z, sense=pe.maximize)
# x0 = m.x[0]
# expr = x0*3
expr = sum([m.x[i] for i in index]) == 1
m.cons.add(expr)
m.cons.add(sum([r[i] * m.x[i] for i in index]) >= m.z)
return m
def Facility():
m = pe.ConcreteModel()
# Define variables
m.x = pe.Var(range(N), within=pe.Binary)
# Define uncertainty set
m.uncset = ro.UncSet()
m.uncset.cons = pe.ConstraintList()
# Define uncertain parameters
m.demand = ro.UncParam(range(M), nominal=demand, uncset=m.uncset)
m.y = ro.AdjustableVar(range(N), range(M), bounds=(0, None), uncparams=[m.demand])
for i in range(M):
m.uncset.cons.add(expr=pe.inequality(0.9*demand[i], m.demand[i], 1.1*demand[i]))
# Add objective
expr = 0
for i in range(N):
for j in range(M):
expr += cost_transport[i][j]*m.y[i, j]
expr += cost_facility[i]*m.x[i]
m.obj = pe.Objective(expr=expr, sense=pe.minimize)
# Add constraints
def sum_y_rule(m, j):
return sum(m.y[i, j] for i in range(N)) == m.demand[j]
m.sum_y = pe.Constraint(range(M), rule=sum_y_rule)
def max_demand_rule(m, i):
lhs = sum(m.y[i, j] for j in range(M))
return lhs <= max_dem[i]*m.x[i]
m.max_dem = pe.Constraint(range(N), rule=max_demand_rule)
# m.bound_x = pe.Constraint(expr=pe.quicksum(m.x[i] for i in m.x) >= 2)
return m
def test_cons_nonlinear_in_uncparam(self):
m = pe.ConcreteModel()
m.U = ro.UncSet()
m.w = ro.UncParam(range(3), nominal=(1, 2, 3), uncset=m.U)
m.x = pe.Var(range(3))
expr = pe.quicksum(m.w[i]**2 * m.x[i] for i in range(3))
m.cons = pe.Constraint(expr=expr <= 5)
m.obj = pe.Objective(expr=m.x[0], sense=pe.maximize)
solver = pe.SolverFactory('romodel.reformulation')
self.assertRaises(AssertionError, lambda: solver.solve(m))
def test_polyhedral_cons_ub(self):
m = pe.ConcreteModel()
m.x = pe.Var(range(2))
m.P = ro.UncSet()
m.w = ro.UncParam(range(2), nominal=(1, 2), uncset=m.P)
m.P.cons = pe.ConstraintList()
m.P.cons.add(pe.inequality(0.5, m.w[0], 1.5))
m.P.cons.add(pe.inequality(1.5, m.w[1], 2.5))
expr = pe.sum_product(m.w, m.x)
m.cons = pe.Constraint(expr=expr <= 2)
m.obj = pe.Objective(expr=m.x[0], sense=pe.maximize)
t = ro.PolyhedralTransformation()
t.apply_to(m)
self.assertFalse(m.cons.active)
self.assertTrue(hasattr(m, 'cons_counterpart_upper'))
def test_unknown_uncset(self):
m = pe.ConcreteModel()
m.x = pe.Var(range(2))
m.U = ro.UncSet()
m.w = ro.UncParam(range(2), nominal=(1, 2), uncset=m.U)
m.obj = pe.Objective(expr=pe.sum_product(m.w, m.x), sense=pe.maximize)
m.cons = pe.Objective(expr=pe.quicksum(m.x[i] for i in m.x) <= 4)
m.U.cons = pe.Constraint(expr=(m.w[0] - 1)**4 + pe.sin(m.w[1]) <= 1)
solver = pe.SolverFactory('romodel.reformulation')
msg = "Cannot reformulate UncSet with unknown geometry: U"
try:
solver.solve(m)
except RuntimeError as e:
self.assertEqual(str(e), msg)
else:
self.fail('"solver.solve was expected to throw RuntimeError')
def test_ellipsoidal_cons_lb_root(self):
m = pe.ConcreteModel()
m.x = pe.Var(range(2))
m.U = ro.UncSet()
m.w = ro.UncParam(range(2), nominal=(1, 2), uncset=m.U)
expr = ((m.w[0] - 1)**2 + 0.1 * (m.w[0] - 1) * (m.w[1] - 2) +
(m.w[1] - 2)**2 <= 0.1)
m.U.cons = pe.Constraint(expr=expr)
expr = pe.sum_product(m.w, m.x)
m.cons = pe.Constraint(expr=2 <= expr)
m.obj = pe.Objective(expr=m.x[0], sense=pe.minimize)
t = ro.EllipsoidalTransformation()
t.apply_to(m, root=True)
self.assertFalse(m.cons.active)
self.assertTrue(hasattr(m, 'cons_counterpart'))
self.assertTrue(hasattr(m.cons_counterpart, 'lower'))
self.assertTrue(hasattr(m.cons_counterpart.lower, 'rob'))
def test_polyhedral_obj_max(self):
m = pe.ConcreteModel()
m.x = pe.Var(range(2))
m.P = ro.UncSet()
m.w = ro.UncParam(range(2), nominal=(1, 2), uncset=m.P)
m.P.cons = pe.ConstraintList()
m.P.cons.add(pe.inequality(0.5, m.w[0], 1.5))
m.P.cons.add(pe.inequality(1.5, m.w[1], 2.5))
expr = pe.sum_product(m.w, m.x)
m.obj = pe.Objective(expr=expr, sense=pe.maximize)
m.cons = pe.Constraint(expr=pe.quicksum(m.x[i] for i in m.x) <= 4)
t = ro.PolyhedralTransformation()
t.apply_to(m)
self.assertFalse(m.obj.active)
self.assertTrue(hasattr(m, 'obj_counterpart'))
self.assertTrue(hasattr(m, 'obj_new'))
self.assertIs(m.obj_new.sense, pe.maximize)
def test_ellipsoidal_obj_max_root(self):
m = pe.ConcreteModel()
m.x = pe.Var(range(2))
m.U = ro.UncSet()
m.w = ro.UncParam(range(2), nominal=(1, 2), uncset=m.U)
expr = ((m.w[0] - 1)**2 + 0.1 * (m.w[0] - 1) * (m.w[1] - 2) +
(m.w[1] - 2)**2 <= 0.1)
m.U.cons = pe.Constraint(expr=expr)
expr = pe.sum_product(m.w, m.x)
m.obj = pe.Objective(expr=expr, sense=pe.maximize)
m.cons = pe.Constraint(expr=pe.quicksum(m.x[i] for i in m.x) <= 4)
t = ro.EllipsoidalTransformation()
t.apply_to(m, root=True)
self.assertFalse(m.obj.active)
self.assertTrue(hasattr(m, 'obj_counterpart'))
self.assertFalse(hasattr(m.obj_counterpart, 'det'))
self.assertTrue(hasattr(m.obj_counterpart, 'rob'))
self.assertIs(m.obj_counterpart.rob.sense, pe.maximize)
def test_construct_separation_problem(self):
m = pe.ConcreteModel()
m.x = pe.Var([0, 1])
m.U = ro.UncSet()
m.w = ro.UncParam([0, 1], nominal=(0.5, 0.5), uncset=m.U)
m.U.c0 = pe.Constraint(expr=m.w[0] <= 1)
m.U.c1 = pe.Constraint(expr=m.w[1] <= 1)
# for i in m.w:
# m.w[i].value = 0.5.lower, m.c.expr, m.c.upper
for i in m.x:
m.x[i].value = 0.8
m.c = pe.Constraint(expr=m.x[0] * m.w[0] + m.x[1] * m.w[1] <= 1)
m.rc = ro.RobustConstraint()
m.rc.build(m.c.lower, m.c.body, m.c.upper)
sep = m.rc.construct_separation_problem()
repn = generate_standard_repn(sep.obj)
self.assertEqual(repn.linear_coefs, (0.8, 0.8))
def test_empty_uncset(self):
m = romodel.examples.Knapsack()
m.Uempty = ro.UncSet()
m.w.uncset = m.Uempty
solver = pe.SolverFactory('romodel.reformulation')
self.assertRaises(AssertionError, lambda: solver.solve(m))
max_demand = [10, 25, 30, 10]
min_demand = [0, 0, 0, 0]
feed_cons = [[1.0, 6.0, 4.0, 0.5], [4.0, 1.0, 3.0, 2.0], [4.0, 5.5, 3.0, 0.9],
[3.0, 3.0, 3.0, 1.0], [1.0, 2.7, 4.0, 1.6]]
max_cons = [[3.00, 3.00, 3.25, 0.75], [4.00, 2.50, 3.50, 1.50],
[1.50, 5.50, 3.90, 0.80], [3.00, 4.00, 4.00, 1.80]]
min_cons = [[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0],
[0.0, 0.0, 0.0, 0.0]]
m = pe.ConcreteModel()
m.q = pe.Var(con_feed_pool, bounds=(0, 1))
m.y = pe.Var(con_pool_prod, within=pe.NonNegativeReals)
m.z = pe.Var(con_feed_prod, within=pe.NonNegativeReals)
m.U = ro.UncSet()
m.price_product = ro.UncParam(products, nominal=price_product, uncset=m.U)
expr = 0
for j in products:
expr += (m.price_product[j] - price_product[j])**2
m.U.c = pe.Constraint(expr=expr <= 0.1)
price_product = m.price_product
obj = 0
for i, l in con_feed_pool:
for j in [jj for ll, jj in con_pool_prod if ll == l]:
obj += price_feed[j] * m.y[(l, j)] * m.q[i, l]
for l, j in con_pool_prod:
obj -= price_product[j] * m.y[(l, j)]
