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)