def test_indexed_two_uncparams(self):
m = pe.ConcreteModel()
m.w = ro.UncParam([0, 1, 2])
m.u = ro.UncParam()
m.y = ro.AdjustableVar([0, 1, 2], uncparams=[m.w])
m.z = ro.AdjustableVar([0, 1], uncparams=[m.w, m.u])
m.cons = pe.Constraint(expr=m.u + sum(m.z[i] for i in m.z) <= 1)
m.o = pe.Objective(expr=m.y[1] + m.u, sense=pe.maximize)
t = LDRAdjustableTransformation()
t.apply_to(m)
self.assertTrue(hasattr(m, 'cons_ldr'))
repn = generate_standard_repn(m.cons_ldr.body)
self.assertEqual(len(repn.linear_vars), 1)
self.assertEqual(len(repn.quadratic_vars), 8)
baseline = set(
(id(m.w[i]), id(m.z_w_coef[j, i])) for i in m.w for j in m.z)
baseline = baseline.union(
(id(m.u[None]), id(m.z_u_coef[j, None])) for j in m.z)
for x in repn.quadratic_vars:
self.assertIn((id(x[0]), id(x[1])), baseline)
self.assertTrue(hasattr(m, 'o_ldr'))
repn = generate_standard_repn(m.o_ldr.expr)
self.assertEqual(len(repn.linear_vars), 1)
self.assertEqual(id(repn.linear_vars[0]), id(m.u))
self.assertEqual(len(repn.quadratic_vars), 3)
baseline = set((id(m.w[i]), id(m.y_w_coef[1, i])) for i in m.w)
for x in repn.quadratic_vars:
self.assertIn((id(x[0]), id(x[1])), baseline)
def test_collect_uncparam(self):
m = pe.ConcreteModel()
m.w = ro.UncParam()
m.u = ro.UncParam(range(2))
m.x = pe.Var()
m.c = pe.Constraint(expr=3 * m.x + 4 * m.w <= 1)
m.o = pe.Objective(expr=m.x**2 + pe.sin(m.u[0]))
self.assertIs(collect_uncparam(m.c), m.w)
self.assertIs(collect_uncparam(m.o), m.u)
def test_simple_uncparam(self):
m = pe.ConcreteModel()
m.p = ro.UncParam()
m.pnom = ro.UncParam(nominal=3)
self.assertEqual(m.pnom.nominal, 3)
self.assertEqual(m.p.nominal, None)
self.assertFalse(m.p.is_constant())
self.assertTrue(m.p.is_potentially_variable())
self.assertTrue(m.p.is_variable_type())
self.assertTrue(m.p.is_parameter_type())
self.assertIs(m.p.ctype, ro.UncParam)
def test_equality_one_uncparam(self):
m = pe.ConcreteModel()
m.w = ro.UncParam([0, 1, 2])
m.y = ro.AdjustableVar([0, 1], uncparams=[m.w])
m.cons = pe.Constraint(expr=(sum(m.w[i]
for i in m.w) == sum(2 * m.y[i]
for i in m.y)))
t = LDRAdjustableTransformation()
t.apply_to(m)
self.assertTrue(hasattr(m, 'cons_ldr'))
baseline = set()
for i in m.w:
id1 = id(m.y_w_coef[0, i])
id2 = id(m.y_w_coef[1, i])
if id1 < id2:
baseline.add((id1, id2))
else:
baseline.add((id2, id1))
for c in m.cons_ldr.values():
repn = generate_standard_repn(c.body)
self.assertEqual(repn.constant, 1)
self.assertEqual(len(repn.linear_vars), 2)
self.assertEqual(repn.linear_coefs, (-2, -2))
self.assertEqual(len(repn.quadratic_vars), 0)
id1 = id(repn.linear_vars[0])
id2 = id(repn.linear_vars[1])
if id1 < id2:
self.assertIn((id1, id2), baseline)
else:
self.assertIn((id2, id1), baseline)
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 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 test_simple_adjustable(self):
m = pe.ConcreteModel()
m.w = ro.UncParam([0, 1, 2])
m.y = ro.AdjustableVar(uncparams=[m.w])
m.c = pe.Constraint(expr=m.w[0] + m.y <= 1)
m.o = pe.Objective(expr=m.y + 3, sense=pe.maximize)
t = NominalAdjustableTransformation()
t.apply_to(m)
self.assertTrue(hasattr(m, 'y_nominal'))
self.assertIs(m.y_nominal.ctype, pe.Var)
self.assertTrue(hasattr(m, 'c_nominal'))
repn = generate_standard_repn(m.c_nominal.body)
baseline = set([id(m.w[0]), id(m.y_nominal)])
for x in repn.linear_vars:
self.assertIn(id(x), baseline)
self.assertEqual(repn.linear_coefs, (1, 1))
self.assertEqual(repn.constant, 0)
self.assertEqual(len(repn.quadratic_vars), 0)
self.assertTrue(hasattr(m, 'o_nominal'))
repn = generate_standard_repn(m.o_nominal.expr)
self.assertEqual(len(repn.linear_vars), 1)
self.assertEqual(id(repn.linear_vars[0]), id(m.y_nominal))
self.assertEqual(len(repn.quadratic_vars), 0)
self.assertEqual(len(repn.nonlinear_vars), 0)
self.assertEqual(repn.constant, 3)
def ProductionPlanning(alpha=0.92, warped=True):
import GPy
# Generate data GP
x, y = generate_data(50, 0.03)
# Train GP
kernel = GPy.kern.RBF(input_dim=1, variance=1., lengthscale=1.)
if warped:
gp = GPy.models.WarpedGP(x, y, kernel=kernel, warping_terms=3)
gp.optimize(messages=True)
else:
gp = GPy.models.GPRegression(x, y, kernel=kernel)
gp.optimize(messages=True)
# Pyomo model
m = pe.ConcreteModel()
m.x = pe.Var(range(T), within=pe.NonNegativeReals, bounds=(xmin, xmax))
for i in m.x:
m.x[i].value = (xmin + xmax) / 2
# Uncertainty set
if warped:
m.uncset = ro.uncset.WarpedGPSet(gp, m.x, alpha)
else:
m.uncset = ro.uncset.GPSet(gp, m.x, alpha)
# Uncertain parameter
m.demand = ro.UncParam(range(T), uncset=m.uncset, bounds=(0, 1))
# Uncertain objective
profit = sum(m.x[t] * m.demand[t] for t in range(T))
profit -= sum(cost[t] * m.x[t] for t in range(T))
m.u = pe.Var()
m.profit = pe.Constraint(expr=profit >= m.u)
m.Obj = pe.Objective(expr=m.u, sense=pe.maximize)
# m.Obj = pe.Objective(expr=profit, sense=pe.maximize)
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 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 test_uncparam_has_no_uncset(self):
m = pe.ConcreteModel()
m.w = ro.UncParam(range(3), nominal=(1, 2, 3))
m.x = pe.Var(range(3))
expr = pe.quicksum(m.w[i] * 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_indexed_adjustable(self):
m = pe.ConcreteModel()
m.w = ro.UncParam([0, 1, 2])
m.y = ro.AdjustableVar([0, 1], uncparams=[m.w])
self.assertFalse(m.y[0].is_constant())
self.assertTrue(m.y[1].is_potentially_variable())
self.assertTrue(m.y[0].is_variable_type())
self.assertFalse(m.y[1].is_parameter_type())
self.assertIs(m.y[0].ctype, ro.AdjustableVar)
def test_equality_one_uncparam_cons(self):
m = pe.ConcreteModel()
m.w = ro.UncParam([0, 1, 2])
m.x = pe.Var([0, 1])
m.y = ro.AdjustableVar([0, 1], uncparams=[m.w])
m.cons = pe.Constraint(expr=(sum(
m.w[i] for i in m.w) == sum(2 * m.y[i] for i in m.y) + 1))
t = LDRAdjustableTransformation()
self.assertRaises(ValueError, lambda: t.apply_to(m))
def test_indexed_one_uncparam_ldr(self):
m = pe.ConcreteModel()
m.w = ro.UncParam([0, 1, 2])
m.u = ro.UncParam()
m.y = ro.AdjustableVar([0, 1, 2], uncparams=[m.w])
m.z = ro.AdjustableVar([0, 1], uncparams=[m.w, m.u])
m.cons = pe.Constraint(expr=sum(m.y[i] for i in m.y) <= 1)
t = LDRAdjustableTransformation()
t.apply_to(m)
self.assertTrue(hasattr(m, 'cons_ldr'))
repn = generate_standard_repn(m.cons_ldr.body)
self.assertEqual(len(repn.linear_vars), 0)
self.assertEqual(len(repn.quadratic_vars), 9)
baseline = set(
(id(m.w[i]), id(m.y_w_coef[j, i])) for i in m.w for j in m.y)
for x in repn.quadratic_vars:
self.assertIn((id(x[0]), id(x[1])), baseline)
def test_set_uncparams(self):
m = pe.ConcreteModel()
m.w = ro.UncParam([0, 1, 2])
m.y = ro.AdjustableVar([0, 1], uncparams=[m.w])
m.y[0].set_uncparams([m.w[0], m.w[1]])
self.assertEqual(id(m.y[0].uncparams[0]), id(m.w[0]))
self.assertEqual(id(m.y[0].uncparams[1]), id(m.w[1]))
self.assertEqual(len(m.y[0].uncparams), 2)
self.assertEqual(id(m.y[1].uncparams[0]), id(m.w))
self.assertEqual(len(m.y[1].uncparams), 1)
def test_bounds(self):
m = pe.ConcreteModel()
m.p = ro.UncParam(range(2), nominal=[3, 4], bounds=(0, 1))
m.p.construct()
self.assertEqual(m.p[0].lb, 0)
self.assertEqual(m.p[0].ub, 1)
self.assertEqual(m.p[1].lb, 0)
self.assertEqual(m.p[1].ub, 1)
m.p[0].setlb(-1)
self.assertEqual(m.p[0].lb, -1)
m.p[1].setub(2)
self.assertEqual(m.p[1].ub, 2)
def test_indexed_uncparam(self):
m = pe.ConcreteModel()
m.p = ro.UncParam(range(2), nominal=[3, 4])
m.p.construct()
self.assertEqual(m.p[0].nominal, 3)
self.assertEqual(m.p[1].nominal, 4)
self.assertIs(m.p[0].ctype, ro.UncParam)
self.assertIs(m.p[1].ctype, ro.UncParam)
self.assertIs(m.p.ctype, ro.UncParam)
self.assertFalse(m.p[0].is_constant())
self.assertTrue(m.p[0].is_potentially_variable())
self.assertTrue(m.p[0].is_variable_type())
self.assertTrue(m.p[0].is_parameter_type())
def test_repn(self):
m = pe.ConcreteModel()
m.x = pe.Var([0, 1])
m.z = pe.Var()
m.w = ro.UncParam([0, 1], nominal=(0.5, 0.5))
expr = m.z + m.x[0] * m.w[0] + m.x[1] * m.w[1]
baseline_param = set([id(m.w[i]) for i in m.w])
baseline_vars = set([id(m.x[i]) for i in m.w])
repn = generate_linear_repn(expr)
self.assertEqual(set(id(i) for i in repn.linear_coefs), baseline_vars)
self.assertEqual(set(id(i) for i in repn.linear_vars), baseline_param)
self.assertEqual(id(repn.constant), id(m.z))
def test_nominal_transform(self):
m = pe.ConcreteModel()
m.x = pe.Var()
m.y = pe.Var(range(2))
m.u = ro.UncParam(nominal=3.)
m.w = ro.UncParam(range(2), nominal=[1, 2])
m.c = pe.Constraint(expr=m.y[0] * m.w[0] + m.y[1] * m.w[1] <= 1)
m.o = pe.Objective(expr=m.u**2 * m.x**2)
t = pe.TransformationFactory('romodel.nominal')
t.apply_to(m)
repn = generate_standard_repn(m.c.body)
self.assertEqual(len(repn.linear_vars), 2)
self.assertEqual(len(repn.quadratic_vars), 0)
self.assertIsNone(repn.nonlinear_expr)
baseline = {id(m.y[0]): 1, id(m.y[1]): 2}
for v, c in zip(repn.linear_vars, repn.linear_coefs):
self.assertEqual(baseline[id(v)], c)
repn = generate_standard_repn(m.o.expr, compute_values=False)
self.assertEqual(len(repn.linear_vars), 0)
self.assertEqual(len(repn.quadratic_vars), 1)
self.assertIsNone(repn.nonlinear_expr)
self.assertEqual(repn.quadratic_coefs[0], 3.**2)
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_simple_gp_constant(self):
m = pe.ConcreteModel()
gp, norm = train_warped_gp(20, 0.05)
m.x = pe.Var(range(2))
m.z = pe.Var(range(2))
m.uncset = ro.uncset.WarpedGPSet(gp, {i: [m.z[i]] for i in m.z}, 0.95)
m.w = ro.UncParam(range(2), uncset=m.uncset)
m.c = pe.Constraint(
expr=m.x[0] + m.x[0] * m.w[0] + m.x[1] * m.w[1] <= 1)
t = pe.TransformationFactory('romodel.warpedgp')
t.apply_to(m)
self.assertTrue(hasattr(m, 'c_counterpart'))
self.assertTrue(hasattr(m.c_counterpart, 'y'))
self.assertTrue(hasattr(m.c_counterpart, 'primal'))
self.assertTrue(hasattr(m.c_counterpart, 'stationarity'))
self.assertTrue(hasattr(m.c_counterpart, 'dual'))
self.assertEqual(len(m.c_counterpart.y), 2)
repn = generate_standard_repn(m.c_counterpart.primal.body)
self.assertEqual(repn.constant, 0)
self.assertEqual(len(repn.linear_vars), 1)
self.assertEqual(id(repn.linear_vars[0]), id(m.x[0]))
self.assertEqual(len(repn.quadratic_vars), 2)
baseline = []
for i in range(2):
idx = id(m.x[i])
idy = id(m.c_counterpart.y[i])
if idx <= idy:
baseline.append((idx, idy))
else:
baseline.append((idy, idx))
self.assertEqual(len(repn.quadratic_vars), 2)
for x, y in repn.quadratic_vars:
idx = id(x)
idy = id(y)
if idx <= idy:
self.assertIn((idx, idy), baseline)
else:
self.assertIn((idy, idx), baseline)
self.assertEqual(len(repn.nonlinear_vars), 0)
self.assertEqual(len(m.c_counterpart.stationarity), 2)
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_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_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_nominal(self):
m = pe.ConcreteModel()
m.x = pe.Var([0, 1])
m.w = ro.UncParam([0, 1], nominal=(0.5, 0.5))
# for i in m.w:
# m.w[i].value = 0.5
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)
lb, nominal, ub = m.rc.nominal_constraint_expr()
repn = generate_standard_repn(nominal)
self.assertIsNone(lb)
self.assertEqual(pe.value(ub), 1.0)
self.assertEqual(repn.linear_coefs, (0.5, 0.5))
self.assertEqual(repn.linear_coefs, (0.5, 0.5))
self.assertEqual(set(id(i) for i in repn.linear_vars),
set(id(m.x[j]) for j in m.x))
def test_indexed_adjustable(self):
m = pe.ConcreteModel()
m.w = ro.UncParam([0, 1, 2])
m.y = ro.AdjustableVar(range(2), uncparams=[m.w], bounds=(0, 6))
m.y[1].fixed = True
m.y[1].value = 2
m.y[1].setub(5)
m.y[0].setlb(1)
m.c = pe.Constraint(expr=m.w[0] + m.y[0] + m.y[1] <= 1)
m.o = pe.Objective(expr=m.y[0] - m.y[1] + 3, sense=pe.maximize)
t = NominalAdjustableTransformation()
t.apply_to(m)
self.assertTrue(hasattr(m, 'y_nominal'))
self.assertIs(m.y_nominal.ctype, pe.Var)
self.assertTrue(m.y_nominal[1].fixed)
self.assertEqual(m.y_nominal[1].value, 2)
self.assertEqual(m.y_nominal[0].lb, 1)
self.assertEqual(m.y_nominal[1].lb, 0)
self.assertEqual(m.y_nominal[0].ub, 6)
self.assertEqual(m.y_nominal[1].ub, 5)
self.assertTrue(hasattr(m, 'c_nominal'))
repn = generate_standard_repn(m.c_nominal.body)
self.assertEqual(len(repn.linear_vars), 2)
baseline = set([id(m.w[0]), id(m.y_nominal[0])])
for x in repn.linear_vars:
self.assertIn(id(x), baseline)
self.assertEqual(repn.linear_coefs, (1, 1))
self.assertEqual(repn.constant, m.y_nominal[1])
self.assertEqual(len(repn.quadratic_vars), 0)
self.assertTrue(hasattr(m, 'o_nominal'))
repn = generate_standard_repn(m.o_nominal.expr, compute_values=False)
self.assertEqual(len(repn.linear_vars), 1)
self.assertEqual(id(x), id(repn.linear_vars[0]))
self.assertEqual(len(repn.quadratic_vars), 0)
self.assertEqual(len(repn.nonlinear_vars), 0)
self.assertEqual(repn.constant, 3 - m.y[1])
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)]
for i, j in con_feed_prod:
m = pe.ConcreteModel()
m.cons = pe.ConstraintList()
N = 5
index = list(range(N))
mean = [0.1, 0.3, 0.5, 0.7, 0.4]
# mean = [0.1, 0.3, 0.5, 0.7, 0.4]
# P = np.matrix([])
# U = pro.uncset.Polyhedral(I, mean, P)
# m.r = pro.UncertainParam(I, uncset=U)
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)
for i in index:
m.r[i].value = mean[i]
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)
