def _generate_model(self):
self.model = pmo.block()
model = self.model
model._name = self.description
model.a1 = pmo.parameter(value=1.0)
model.a2 = pmo.parameter_dict(
{1: pmo.parameter(value=1.0)})
model.a3 = pmo.parameter(value=1.0)
model.a4 = pmo.parameter_dict(
{1: pmo.parameter(value=1.0)})
model.x = pmo.variable(domain=NonNegativeReals)
model.y = pmo.variable(domain=NonNegativeReals)
model.z1 = pmo.variable()
model.z2 = pmo.variable()
model.dummy_expr1 = pmo.expression(model.a1*model.a2[1])
model.dummy_expr2 = pmo.expression(model.y/model.a3*model.a4[1])
model.inactive_obj = pmo.objective(
model.x + 3.0*model.y + 1.0 + model.z1 - model.z2)
model.inactive_obj.deactivate()
model.p = pmo.parameter(value=0.0)
model.obj = pmo.objective(model.p + model.inactive_obj)
model.c1 = pmo.constraint(model.dummy_expr1 <= pmo.noclone(model.dummy_expr2))
model.c2 = pmo.constraint((2.0, model.x/model.a3 - model.y, 10))
model.c3 = pmo.constraint((0, model.z1 + 1, 10))
model.c4 = pmo.constraint((-10, model.z2 + 1, 0))
def _generate_model(self):
self.model = pmo.block()
model = self.model
model._name = self.description
model.neg1 = pmo.parameter(value=-1.0)
model.pos1 = pmo.parameter(value=1.0)
model.s = list(range(1,13))
model.x = pmo.variable_dict(
(i, pmo.variable()) for i in model.s)
model.x[1].lb = model.neg1
model.x[1].ub = model.pos1
model.x[2].lb = model.neg1
model.x[2].ub = model.pos1
model.obj = pmo.objective(sum(model.x[i]*((-1)**(i))
for i in model.s),
sense=pmo.maximize)
model.c = pmo.constraint_dict()
model.c[3] = pmo.constraint(model.x[3]>=-1.)
model.c[4] = pmo.constraint(model.x[4]<=1.)
model.c[5] = pmo.constraint(model.x[5]==-1.)
model.c[6] = pmo.constraint(model.x[6]==-1.)
model.c[7] = pmo.constraint(model.x[7]==1.)
model.c[8] = pmo.constraint(model.x[8]==1.)
model.c[9] = pmo.constraint((model.neg1,model.x[9],model.neg1))
model.c[10] = pmo.constraint((-1.,model.x[10],-1.))
model.c[11] = pmo.constraint((1.,model.x[11],1.))
model.c[12] = pmo.constraint((1.,model.x[12],1.))
model.c_inactive = pmo.constraint_dict()
# to make the variable used in the constraint match the name
model.c_inactive[3] = pmo.constraint(model.x[3]>=-2.)
model.c_inactive[4] = pmo.constraint(model.x[4]<=2.)
def __init__(
self,
interval_set,
params: dict,
):
super().__init__()
## Setup
self.id = params["name"]
self.objective_terms = {}
# Need to reference interval set in coupling method, either need to add it to class or pass it to function.
self.interval_set = interval_set
self.component_element_ids = params[
"component_element_names"] # resources or other collections
## Parameters
self.import_limit = aml.parameter(
params["import_limit"]) # assume positive
self.export_limit = aml.parameter(params["export_limit"])
## Expressions/Variables
# Should we define net_export as a variable and set equal later - allows to define upper and lower bounds here
# or should it be an expression here, and we reconstruct constraints later whenever we add elements - i.e. the coupling aspect of the problem
# It really depends on how the model is "constructed" - one option is to define everything as constructor functions that are called when the model is constructed, but order of construction matters here!
# If we define as a variable, then we decouple them.
self.net_export = aml.variable_dict()
for interval in interval_set:
self.net_export[interval] = aml.variable(lb=-self.import_limit,
ub=self.export_limit)
def _generate_model(self):
self.model = pmo.block()
model = self.model
model._name = self.description
model.neg1 = pmo.parameter(value=-1.0)
model.pos1 = pmo.parameter(value=1.0)
model.s = list(range(1, 13))
model.x = pmo.create_variable_dict(keys=model.s)
model.x[1].lb = model.neg1
model.x[1].ub = model.pos1
model.x[2].lb = model.neg1
model.x[2].ub = model.pos1
model.obj = pmo.objective(sum(model.x[i] * ((-1)**(i))
for i in model.s),
sense=pmo.maximize)
model.c = pmo.constraint_dict()
model.c[3] = pmo.constraint(model.x[3] >= -1.)
model.c[4] = pmo.constraint(model.x[4] <= 1.)
model.c[5] = pmo.constraint(model.x[5] == -1.)
model.c[6] = pmo.constraint(model.x[6] == -1.)
model.c[7] = pmo.constraint(model.x[7] == 1.)
model.c[8] = pmo.constraint(model.x[8] == 1.)
model.c[9] = pmo.constraint((model.neg1, model.x[9], model.neg1))
model.c[10] = pmo.constraint((-1., model.x[10], -1.))
model.c[11] = pmo.constraint((1., model.x[11], 1.))
model.c[12] = pmo.constraint((1., model.x[12], 1.))
model.c_inactive = pmo.constraint_dict()
# to make the variable used in the constraint match the name
model.c_inactive[3] = pmo.constraint(model.x[3] >= -2.)
model.c_inactive[4] = pmo.constraint(model.x[4] <= 2.)
def _generate_model(self):
self.model = pmo.block()
model = self.model
model._name = self.description
model.a1 = pmo.parameter(value=1.0)
model.a2 = pmo.parameter_dict({1: pmo.parameter(value=1.0)})
model.a3 = pmo.parameter(value=1.0)
model.a4 = pmo.parameter_dict({1: pmo.parameter(value=1.0)})
model.x = pmo.variable(domain=NonNegativeReals)
model.y = pmo.variable(domain=NonNegativeReals)
model.z1 = pmo.variable()
model.z2 = pmo.variable()
model.dummy_expr1 = pmo.expression(model.a1 * model.a2[1])
model.dummy_expr2 = pmo.expression(model.y / model.a3 * model.a4[1])
model.inactive_obj = pmo.objective(model.x + 3.0 * model.y + 1.0 +
model.z1 - model.z2)
model.inactive_obj.deactivate()
model.p = pmo.parameter(value=0.0)
model.obj = pmo.objective(model.p + model.inactive_obj)
model.c1 = pmo.constraint(
model.dummy_expr1 <= pmo.noclone(model.dummy_expr2))
model.c2 = pmo.constraint((2.0, model.x / model.a3 - model.y, 10))
model.c3 = pmo.constraint((0, model.z1 + 1, 10))
model.c4 = pmo.constraint((-10, model.z2 + 1, 0))
def _generate_model(self):
self.model = pmo.block()
model = self.model
model._name = self.description
model.a = pmo.parameter(value=1.0)
model.x = pmo.variable(domain=NonNegativeReals)
model.y = pmo.variable(domain=Binary)
model.obj = pmo.objective(model.x**2 + 3.0*model.y**2)
model.c1 = pmo.constraint(model.a <= model.y)
model.c2 = pmo.constraint((2.0, model.x/model.a - model.y, 10))
def test_type_hack(self):
for obj in [pmo.variable(),
pmo.constraint(),
pmo.objective(),
pmo.expression(),
pmo.parameter(),
pmo.suffix(),
pmo.sos([]),
pmo.block()]:
ctype = obj.ctype
self.assertIs(obj.__class__._ctype, ctype)
self.assertIs(obj.type(), ctype)
def _generate_model(self):
self.model = pmo.block()
model = self.model
model._name = self.description
model.a = pmo.parameter(value=1.0)
model.x = pmo.variable(domain=NonNegativeReals)
model.y = pmo.variable(domain=Binary)
model.obj = pmo.objective(model.x + 3.0*model.y)
model.c1 = pmo.constraint(model.a <= model.y)
model.c2 = pmo.constraint((2.0, model.x/model.a - model.y, 10))
def _generate_model(self):
self.model = pmo.block()
model = self.model
model._name = self.description
model.f = pmo.variable()
model.x = pmo.variable(lb=1,ub=3)
model.fi = pmo.parameter_dict()
model.fi[1] = pmo.parameter(value=1.0)
model.fi[2] = pmo.parameter(value=2.0)
model.fi[3] = pmo.parameter(value=0.0)
model.xi = pmo.parameter_dict()
model.xi[1] = pmo.parameter(value=1.0)
model.xi[2] = pmo.parameter(value=2.0)
model.xi[3] = pmo.parameter(value=3.0)
model.p = pmo.variable(domain=NonNegativeReals)
model.n = pmo.variable(domain=NonNegativeReals)
model.lmbda = pmo.variable_dict(
(i, pmo.variable()) for i in range(1,4))
model.obj = pmo.objective(model.p+model.n)
model.c1 = pmo.constraint_dict()
model.c1[1] = pmo.constraint((0.0, model.lmbda[1], 1.0))
model.c1[2] = pmo.constraint((0.0, model.lmbda[2], 1.0))
model.c1[3] = pmo.constraint(0.0 <= model.lmbda[3])
model.c2 = pmo.sos2(model.lmbda.values())
model.c3 = pmo.constraint(sum(model.lmbda.values()) == 1)
model.c4 = pmo.constraint(model.f==sum(model.fi[i]*model.lmbda[i]
for i in model.lmbda))
model.c5 = pmo.constraint(model.x==sum(model.xi[i]*model.lmbda[i]
for i in model.lmbda))
model.x.fix(2.75)
# Make an empty SOS constraint
model.c6 = pmo.sos2([])
def test_type_hack(self):
for obj in [
pmo.variable(),
pmo.constraint(),
pmo.objective(),
pmo.expression(),
pmo.parameter(),
pmo.suffix(),
pmo.sos([]),
pmo.block()
]:
ctype = obj.ctype
self.assertIs(obj.__class__._ctype, ctype)
self.assertIs(obj.type(), ctype)
def test_iter_component_kernel(self):
model = pmo.block()
model.x = pmo.variable_list(pmo.variable(value=0) for _ in [1, 2, 3])
model.z = pmo.variable(value=0)
model.con = pmo.constraint_dict(
(i, pmo.constraint(expr=model.x[i - 1] + model.z == i))
for i in [1, 2, 3])
model.zcon = pmo.constraint(expr=model.z >= model.x[2])
model.param_t = pmo.parameter_tuple(
pmo.parameter(value=36) for _ in [1, 2, 3])
model.param = pmo.parameter(value=42)
self.assertSameComponents(list(iter_component(model.x)), list(model.x))
self.assertSameComponents(list(iter_component(model.z)), [model.z])
self.assertSameComponents(list(iter_component(model.con)),
list(model.con.values()))
self.assertSameComponents(list(iter_component(model.zcon)),
[model.zcon])
self.assertSameComponents(list(iter_component(model.param_t)),
list(model.param_t))
self.assertSameComponents(list(iter_component(model.param)),
[model.param])
def _generate_model(self):
self.model = None
self.model = pmo.block()
model = self.model
model._name = self.description
model.a = pmo.parameter(value=1.0)
model.x = pmo.variable(domain=NonNegativeReals)
model.y = pmo.variable(domain=NonNegativeReals)
model.inactive_obj = pmo.objective(model.y)
model.inactive_obj.deactivate()
model.obj = pmo.objective(model.x**2 + 3.0 * model.inactive_obj**2 +
1.0)
model.c1 = pmo.constraint(model.a <= model.y)
model.c2 = pmo.constraint(2.0 <= model.x / model.a - model.y <= 10)
def _generate_model(self):
self.model = pmo.block()
model = self.model
model._name = self.description
model.b = pmo.block()
model.B = pmo.block_dict((i, pmo.block()) for i in range(1, 4))
model.a = pmo.parameter(value=1.0)
model.b.x = pmo.variable(lb=0)
model.B[1].x = pmo.variable(lb=0)
model.obj = pmo.objective(expr=model.b.x + 3.0 * model.B[1].x)
model.obj.deactivate()
model.B[2].c = pmo.constraint(expr=-model.B[1].x <= -model.a)
model.B[2].obj = pmo.objective(expr=model.b.x + 3.0 * model.B[1].x + 2)
model.B[3].c = pmo.constraint(
expr=2.0 <= model.b.x / model.a - model.B[1].x <= 10)
def _generate_model(self):
self.model = pmo.block()
model = self.model
model._name = self.description
model.b = pmo.block()
model.B = pmo.block_dict((i, pmo.block())
for i in range(1,4))
model.a = pmo.parameter(value=1.0)
model.b.x = pmo.variable(lb=0)
model.B[1].x = pmo.variable(lb=0)
model.obj = pmo.objective(expr=model.b.x + 3.0*model.B[1].x)
model.obj.deactivate()
model.B[2].c = pmo.constraint(expr=-model.B[1].x <= -model.a)
model.B[2].obj = pmo.objective(expr=model.b.x + 3.0*model.B[1].x + 2)
model.B[3].c = pmo.constraint(expr=(2.0, model.b.x/model.a - model.B[1].x, 10))
def _generate_model(self):
self.model = pmo.block()
model = self.model
model._name = self.description
model.a = pmo.parameter(value=0.1)
model.x = pmo.variable(domain=NonNegativeReals)
model.y = pmo.variable_dict()
model.y[1] = pmo.variable(domain=NonNegativeReals)
model.y[2] = pmo.variable(domain=NonNegativeReals)
model.obj = pmo.objective(model.x + model.y[1]+2*model.y[2])
model.c1 = pmo.constraint(model.a <= model.y[2])
model.c2 = pmo.constraint((2.0, model.x, 10.0))
model.c3 = pmo.sos1(model.y.values())
model.c4 = pmo.constraint(sum(model.y.values()) == 1)
# Make an empty SOS constraint
model.c5 = pmo.sos1([])
def _generate_model(self):
self.model = pmo.block()
model = self.model
model._name = self.description
model.a = pmo.parameter(value=0.1)
model.x = pmo.variable(domain=NonNegativeReals)
model.y = pmo.variable_dict()
model.y[1] = pmo.variable(domain=NonNegativeReals)
model.y[2] = pmo.variable(domain=NonNegativeReals)
model.obj = pmo.objective(model.x + model.y[1] + 2 * model.y[2])
model.c1 = pmo.constraint(model.a <= model.y[2])
model.c2 = pmo.constraint(2.0 <= model.x <= 10.0)
model.c3 = pmo.sos1(model.y.values())
model.c4 = pmo.constraint(sum(model.y.values()) == 1)
# Make an empty SOS constraint
model.c5 = pmo.sos1([])
# re-validate the function after changing inputs
# (will raise PiecewiseValidationError when validation fails)
p.validate()
# evaluate the function
assert p(1) == 1
assert p(1.5) == 1.5
assert p(2) == 2
assert p(2.5) == 1.5
assert p(3) == 1
assert p(2.5) == 1.5
assert p(4) == 2
breakpoints = [
pmo.parameter(1),
pmo.parameter(2),
pmo.parameter(3),
pmo.parameter(None)
]
values = [
pmo.parameter(1),
pmo.parameter(2),
pmo.parameter(1),
pmo.parameter(None)
]
p = pmo.piecewise(breakpoints,
values,
input=x,
output=y,
repn='sos2',
p.output.expr = q
# re-validate the function after changing inputs
# (will raise PiecewiseValidationError when validation fails)
p.validate()
# evaluate the function
assert p(1) == 1
assert p(1.5) == 1.5
assert p(2) == 2
assert p(2.5) == 1.5
assert p(3) == 1
assert p(2.5) == 1.5
assert p(4) == 2
breakpoints = [pmo.parameter(1),
pmo.parameter(2),
pmo.parameter(3),
pmo.parameter(None)]
values = [pmo.parameter(1),
pmo.parameter(2),
pmo.parameter(1),
pmo.parameter(None)]
p = pmo.piecewise(breakpoints,
values,
input=x,
output=y,
repn='sos2',
bound='eq',
validate=False)
NUM_WORKERS = len(costs)
NUM_TASKS = len(costs[0])
# Define the model
model = pmo.block()
# Create the sets
model.set_workers = range(NUM_WORKERS)
model.set_tasks = range(NUM_TASKS)
# Create the parameters
model.param_cost = pmo.parameter_dict()
for _worker in model.set_workers:
for _task in model.set_tasks:
model.param_cost[(_worker,
_task)] = pmo.parameter(costs[_worker][_task])
# Create the variables
model.var_x = pmo.variable_dict()
for _worker in model.set_workers:
for _task in model.set_tasks:
model.var_x[(_worker, _task)] = pmo.variable(domain=pmo.Binary)
# Create the constraints
## Each worker is assigned to at most 1 task
model.con_worker = pmo.constraint_list()
for _worker in model.set_workers:
model.con_worker.append(
pmo.constraint(
sum(model.var_x[(_worker, _task)]
for _task in model.set_tasks) <= 1))
7, 0, 30, 22, 80, 94, 11, 81, 70, 64, 59, 18, 0, 36, 3, 8, 15, 42, 9, 0,
42, 47, 52, 32, 26, 48, 55, 6, 29, 84, 2, 4, 18, 56, 7, 29, 93, 44, 71,
3, 86, 66, 31, 65, 0, 79, 20, 65, 52, 13]
capacities = 850
model = pmo.block()
# Create the sets
model.set_labels = range(len(values))
# Create the parameters
model.param_label_value = pmo.parameter_dict()
model.param_label_weight = pmo.parameter_dict()
for i in model.set_labels:
model.param_label_value[i] = pmo.parameter(values[i])
model.param_label_weight[i] = pmo.parameter(weights[i])
# Create the variables
model.var_pack = pmo.variable_dict()
for i in model.set_labels:
model.var_pack[i] = pmo.variable(domain=pmo.Binary)
# Create the constraints
model.con_capacity = pmo.constraint(sum(model.var_pack[i] * weights[i] for i in model.set_labels) <= capacities)
# Create the objective
model.obj = pmo.objective(sum(model.var_pack[i] * values[i] for i in model.set_labels), sense=pmo.maximize)
# Solve
opt = pmo.SolverFactory('cplex')
import pyomo.kernel as pmo
#
# Blocks
#
# define a simple optimization model
b = pmo.block()
b.x = pmo.variable()
b.c = pmo.constraint(expr=b.x >= 1)
b.o = pmo.objective(expr=b.x)
# define an optimization model with indexed containers
b = pmo.block()
b.p = pmo.parameter()
b.plist = pmo.parameter_list(pmo.parameter() for i in range(10))
b.pdict = pmo.parameter_dict(
((i, j), pmo.parameter()) for i in range(10) for j in range(10))
b.x = pmo.variable()
b.xlist = pmo.variable_list(pmo.variable() for i in range(10))
b.xdict = pmo.variable_dict(
((i, j), pmo.variable()) for i in range(10) for j in range(10))
b.c = pmo.constraint(b.x >= 1)
b.clist = pmo.constraint_list(
pmo.constraint(b.xlist[i] >= i) for i in range(10))
b.cdict = pmo.constraint_dict(((i, j), pmo.constraint(b.xdict[i, j] >= i * j))
for i in range(10) for j in range(10))
def __init__(self, p, input=None):
super(Widget, self).__init__()
self.p = pmo.parameter(value=p)
self.input = pmo.expression(expr=input)
self.output = pmo.variable()
self.c = pmo.constraint(self.output == self.input**2 / self.p)
p.output.expr = q
# re-validate the function after changing inputs
# (will raise PiecewiseValidationError when validation fails)
p.validate()
# evaluate the function
assert p(1) == 1
assert p(1.5) == 1.5
assert p(2) == 2
assert p(2.5) == 1.5
assert p(3) == 1
assert p(2.5) == 1.5
assert p(4) == 2
breakpoints = [pmo.parameter(1),
pmo.parameter(2),
pmo.parameter(3),
pmo.parameter(None)]
values = [pmo.parameter(1),
pmo.parameter(2),
pmo.parameter(1),
pmo.parameter(None)]
p = pmo.piecewise(breakpoints,
values,
input=x,
output=y,
repn='sos2',
bound='eq',
validate=False)
import pyomo.kernel as pmo # # Mutable parameters # p = pmo.parameter() assert p.value == None p = pmo.parameter(value=2) assert p.value == 2 p.value = 4 assert p.value == 4 assert pmo.value(p**2) == 16 assert pmo.value(p - 1) == 3 v = pmo.variable() c = pmo.constraint(p-1 <= v <= p+1) assert pmo.value(c.lb) == 3 assert pmo.value(c.ub) == 5 p.value = -1 assert pmo.value(c.lb) == -2 assert pmo.value(c.ub) == 0
def __init__(
self,
interval_set,
params: dict,
):
super().__init__()
## Setup
# self.id = uuid4()
self.id = params["name"]
self.objective_terms = {}
## Parameters
self.maxMW = aml.parameter(params["maxMW"])
self.minMW = aml.parameter(params["minMW"])
self.max_ramp = aml.parameter(params["max_ramp"])
self.marginal_cost = aml.parameter(params["marginal_cost"])
self.initial_commit = aml.parameter(params["initial_commit"])
## Variables
self.output = aml.variable_dict()
for interval in interval_set:
self.output[interval] = aml.variable(lb=0, ub=self.maxMW)
self.commit = aml.variable_dict()
for interval in interval_set:
self.commit[interval] = aml.variable(domain=aml.Binary)
## Expressions - this is where we define a common interface for model resource elements
# Note in Optopy we have to have a generic and dynamic common interface for market products, different time indices, etc.
# Will just use net_export as an interface for now
self.net_export = aml.expression_dict()
for interval in interval_set:
self.net_export[interval] = aml.expression(expr=self.output)
## Constraints
# Can express constraints abstractly (lhs, rhs, body, ub, lb, etc.) or with interpreted syntax - see below
self.con_output_commit_upper_bound = aml.constraint_dict()
for interval in interval_set:
# body_expr = self.output[interval] - self.commit[interval] * self.maxMW
# self.con_output_commit_upper_bound[interval] = aml.constraint(body=body_expr, ub=0)
self.con_output_commit_upper_bound[interval] = aml.constraint(
self.output[interval] -
self.commit[interval] * self.maxMW <= 0)
self.con_output_commit_lower_bound = aml.constraint_dict()
for interval in interval_set:
# body_expr = self.commit[interval] * self.minMW - self.output[interval]
# self.con_output_commit_lower_bound[interval] = aml.constraint(body=body_expr, ub=0)
self.con_output_commit_lower_bound[interval] = aml.constraint(
self.commit[interval] * self.minMW -
self.output[interval] <= 0)
# todo Add constraints/costs for ramping, min up, min down, startup/shutdown costs, etc.
## Objective Terms
# Unclear whether this expression object needs to be added to block/model - may be enough just to have it in the objective
self.interval_cost = aml.expression_dict()
for interval in interval_set:
self.interval_cost[interval] = aml.expression(
self.marginal_cost * self.output[interval])
self.objective_terms["total_cost"] = sum(self.interval_cost[interval]
for interval in interval_set)
def test_call(self):
g = PiecewiseLinearFunction([1], [0])
f = TransformedPiecewiseLinearFunction(
g, require_bounded_input_variable=False)
self.assertTrue(f.parent is None)
self.assertEqual(f.ctype, IBlock)
self.assertEqual(f(1), 0)
self.assertIs(type(f(1)), float)
with self.assertRaises(ValueError):
f(0.9)
with self.assertRaises(ValueError):
f(1.1)
g = PiecewiseLinearFunction([1, 2], [0, 4])
f = TransformedPiecewiseLinearFunction(
g, require_bounded_input_variable=False)
self.assertTrue(f.parent is None)
self.assertEqual(f.ctype, IBlock)
self.assertEqual(f(1), 0)
self.assertIs(type(f(1)), float)
self.assertEqual(f(1.5), 2)
self.assertIs(type(f(1.5)), float)
self.assertEqual(f(2), 4)
self.assertIs(type(f(2)), float)
with self.assertRaises(ValueError):
f(0.9)
with self.assertRaises(ValueError):
f(2.1)
# step function
g = PiecewiseLinearFunction([1, 1], [0, 1])
f = TransformedPiecewiseLinearFunction(
g, require_bounded_input_variable=False)
self.assertTrue(f.parent is None)
self.assertEqual(f.ctype, IBlock)
self.assertEqual(f(1), 0)
self.assertIs(type(f(1)), float)
with self.assertRaises(ValueError):
f(0.9)
with self.assertRaises(ValueError):
f(1.1)
g = PiecewiseLinearFunction([1, 2, 3], [1, 2, 1])
f = TransformedPiecewiseLinearFunction(
g, require_bounded_input_variable=False)
self.assertTrue(f.parent is None)
self.assertEqual(f.ctype, IBlock)
self.assertEqual(f(1), 1)
self.assertIs(type(f(1)), float)
self.assertEqual(f(1.5), 1.5)
self.assertIs(type(f(1.5)), float)
self.assertEqual(f(2), 2)
self.assertIs(type(f(2)), float)
self.assertEqual(f(2.5), 1.5)
self.assertIs(type(f(2.5)), float)
self.assertEqual(f(3), 1)
self.assertIs(type(f(3)), float)
with self.assertRaises(ValueError):
f(0.9)
with self.assertRaises(ValueError):
f(3.1)
# step function
g = PiecewiseLinearFunction([1, 2, 2, 3], [1, 2, 3, 4])
f = TransformedPiecewiseLinearFunction(
g, require_bounded_input_variable=False)
self.assertTrue(f.parent is None)
self.assertEqual(f.ctype, IBlock)
self.assertEqual(f(1), 1)
self.assertIs(type(f(1)), float)
self.assertEqual(f(1.5), 1.5)
self.assertIs(type(f(1.5)), float)
self.assertEqual(f(2), 2) # lower semicontinuous
self.assertIs(type(f(2)), float)
self.assertEqual(f(2.5), 3.5)
self.assertIs(type(f(2.5)), float)
self.assertEqual(f(3), 4)
self.assertIs(type(f(3)), float)
with self.assertRaises(ValueError):
f(0.9)
with self.assertRaises(ValueError):
f(3.1)
# another step function
g = PiecewiseLinearFunction([1, 1, 2, 3], [1, 2, 3, 4],
equal_slopes_tolerance=-1)
f = TransformedPiecewiseLinearFunction(
g, require_bounded_input_variable=False, equal_slopes_tolerance=-1)
self.assertTrue(f.parent is None)
self.assertEqual(f.ctype, IBlock)
self.assertEqual(f(1), 1)
self.assertEqual(f(1.5), 2.5)
self.assertEqual(f(2), 3) # lower semicontinuous
self.assertEqual(f(2.5), 3.5)
self.assertEqual(f(3), 4)
with self.assertRaises(ValueError):
f(0.9)
with self.assertRaises(ValueError):
f(3.1)
# another step function
g = PiecewiseLinearFunction([1, 2, 3, 3], [1, 2, 3, 4],
equal_slopes_tolerance=-1)
f = TransformedPiecewiseLinearFunction(
g, require_bounded_input_variable=False, equal_slopes_tolerance=-1)
self.assertTrue(f.parent is None)
self.assertEqual(f.ctype, IBlock)
self.assertEqual(f(1), 1)
self.assertEqual(f(1.5), 1.5)
self.assertEqual(f(2), 2)
self.assertEqual(f(2.5), 2.5)
self.assertEqual(f(3), 3) # lower semicontinuous
with self.assertRaises(ValueError):
f(0.9)
with self.assertRaises(ValueError):
f(3.1)
# another step function using parameters
g = PiecewiseLinearFunction([
pmo.parameter(1),
pmo.parameter(1),
pmo.parameter(2),
pmo.parameter(3)
], [
pmo.parameter(1),
pmo.parameter(2),
pmo.parameter(3),
pmo.parameter(4)
],
equal_slopes_tolerance=-1)
f = TransformedPiecewiseLinearFunction(
g, require_bounded_input_variable=False, equal_slopes_tolerance=-1)
self.assertTrue(f.parent is None)
self.assertEqual(f.ctype, IBlock)
self.assertEqual(f(1), 1)
self.assertEqual(f(1.5), 2.5)
self.assertEqual(f(2), 3) # lower semicontinuous
self.assertEqual(f(2.5), 3.5)
self.assertEqual(f(3), 4)
with self.assertRaises(ValueError):
f(0.9)
with self.assertRaises(ValueError):
f(3.1)
# another step function
g = PiecewiseLinearFunction([1, 1, 2, 3, 4], [1, 2, 3, 4, 5],
equal_slopes_tolerance=-1)
f = TransformedPiecewiseLinearFunction(
g, require_bounded_input_variable=False, equal_slopes_tolerance=-1)
self.assertTrue(f.parent is None)
self.assertEqual(f.ctype, IBlock)
self.assertEqual(f(1), 1) # lower semicontinuous
self.assertEqual(f(1.5), 2.5)
self.assertEqual(f(2), 3)
self.assertEqual(f(2.5), 3.5)
self.assertEqual(f(3), 4)
self.assertEqual(f(3.5), 4.5)
self.assertEqual(f(4), 5)
with self.assertRaises(ValueError):
f(0.9)
with self.assertRaises(ValueError):
f(4.1)
# another step function
g = PiecewiseLinearFunction([1, 2, 2, 3, 4], [1, 2, 3, 4, 5],
equal_slopes_tolerance=-1)
f = TransformedPiecewiseLinearFunction(
g, require_bounded_input_variable=False, equal_slopes_tolerance=-1)
self.assertTrue(f.parent is None)
self.assertEqual(f.ctype, IBlock)
self.assertEqual(f(1), 1)
self.assertEqual(f(1.5), 1.5)
self.assertEqual(f(2), 2) # lower semicontinuous
self.assertEqual(f(2.5), 3.5)
self.assertEqual(f(3), 4)
self.assertEqual(f(3.5), 4.5)
self.assertEqual(f(4), 5)
with self.assertRaises(ValueError):
f(0.9)
with self.assertRaises(ValueError):
f(4.1)
# another step function
g = PiecewiseLinearFunction([1, 2, 3, 3, 4], [1, 2, 3, 4, 5],
equal_slopes_tolerance=-1)
f = TransformedPiecewiseLinearFunction(
g, require_bounded_input_variable=False, equal_slopes_tolerance=-1)
self.assertTrue(f.parent is None)
self.assertEqual(f.ctype, IBlock)
self.assertEqual(f(1), 1)
self.assertEqual(f(1.5), 1.5)
self.assertEqual(f(2), 2)
self.assertEqual(f(2.5), 2.5)
self.assertEqual(f(3), 3) # lower semicontinuous
self.assertEqual(f(3.5), 4.5)
self.assertEqual(f(4), 5)
with self.assertRaises(ValueError):
f(0.9)
with self.assertRaises(ValueError):
f(4.1)
# another step function
g = PiecewiseLinearFunction([1, 2, 3, 4, 4], [1, 2, 3, 4, 5],
equal_slopes_tolerance=-1)
f = TransformedPiecewiseLinearFunction(
g, require_bounded_input_variable=False, equal_slopes_tolerance=-1)
self.assertTrue(f.parent is None)
self.assertEqual(f.ctype, IBlock)
self.assertEqual(f(1), 1)
self.assertEqual(f(1.5), 1.5)
self.assertEqual(f(2), 2)
self.assertEqual(f(2.5), 2.5)
self.assertEqual(f(3), 3)
self.assertEqual(f(3.5), 3.5)
self.assertEqual(f(4), 4) # lower semicontinuous
with self.assertRaises(ValueError):
f(0.9)
with self.assertRaises(ValueError):
f(4.1)
# another step function
g = PiecewiseLinearFunction([1, 2, 3, 4, 5], [1, 2, 3, 4, 5],
equal_slopes_tolerance=-1)
f = TransformedPiecewiseLinearFunction(
g, require_bounded_input_variable=False, equal_slopes_tolerance=-1)
self.assertTrue(f.parent is None)
self.assertEqual(f.ctype, IBlock)
self.assertEqual(f(1), 1)
self.assertEqual(f(1.5), 1.5)
self.assertEqual(f(2), 2)
self.assertEqual(f(2.5), 2.5)
self.assertEqual(f(3), 3)
self.assertEqual(f(3.5), 3.5)
self.assertEqual(f(4), 4)
self.assertEqual(f(4.5), 4.5)
self.assertEqual(f(5), 5)
with self.assertRaises(ValueError):
f(0.9)
with self.assertRaises(ValueError):
f(5.1)
assert s.weights == (1, 2, 3) assert len(s.variables) == 3 assert v1 in s assert v2 in s assert v3 in s # # Specifying weights # # using known values s = pmo.sos([v1, v2], weights=[1.2, 2.5]) assert s.weights == (1.2, 2.5) # using paramters p = pmo.parameter_list(pmo.parameter() for i in range(2)) s = pmo.sos([v1, v2], weights=[p[0]**2, p[1]**2]) assert len(s.weights) == 2 p[0].value = 1 p[1].value = 2 assert tuple(pmo.value(w) for w in s.weights) == (1, 4) # using data expressions d = pmo.expression_list(pmo.data_expression() for i in range(2)) s = pmo.sos([v1, v2], weights=d) assert len(s.weights) == 2 d[0].expr = p[0] + 1 d[1].expr = p[0] + p[1] assert tuple(pmo.value(w) for w in s.weights) == (2, 3) #
# @ConcreteModels
m = pmo.block()
m.b = pmo.block()
# @ConcreteModels
# @Sets_1
m.s = [1, 2]
# @Sets_1
# @Sets_2
# [0,1,2]
m.q = range(3)
# @Sets_2
# @Parameters_single
m.p = pmo.parameter(0)
# @Parameters_single
# @Parameters_dict
# pd[1] = 0, pd[2] = 1
m.pd = pmo.parameter_dict()
for k, i in enumerate(m.s):
m.pd[i] = pmo.parameter(k)
# @Parameters_dict
# @Parameters_list
# uses 0-based indexing
# pl[0] = 0, pl[0] = 1, ...
m.pl = pmo.parameter_list()
for j in m.q:
m.pl.append(pmo.parameter(j))
assert len(s.variables) == 3
assert v1 in s
assert v2 in s
assert v3 in s
#
# Specifying weights
#
# using known values
s = pmo.sos([v1,v2], weights=[1.2,2.5])
assert s.weights == (1.2,2.5)
# using paramters
p = pmo.parameter_list(
pmo.parameter() for i in range(2))
s = pmo.sos([v1,v2], weights=[p[0]**2, p[1]**2])
assert len(s.weights) == 2
p[0].value = 1
p[1].value = 2
assert tuple(pmo.value(w) for w in s.weights) == (1, 4)
# using data expressions
d = pmo.expression_list(
pmo.data_expression() for i in range(2))
s = pmo.sos([v1,v2], weights=d)
assert len(s.weights) == 2
d[0].expr = p[0] + 1
d[1].expr = p[0] + p[1]
assert tuple(pmo.value(w) for w in s.weights) == (2, 3)
# @Sets_1
m.s = [1,2]
# @Sets_1
# @Sets_2
# [0,1,2]
m.q = range(3)
# @Sets_2
# @Parameters_single
m.p = pmo.parameter(0)
# @Parameters_single
# @Parameters_dict
# pd[1] = 0, pd[2] = 1
m.pd = pmo.parameter_dict()
for k,i in enumerate(m.s):
m.pd[i] = pmo.parameter(k)
# @Parameters_dict
# @Parameters_list
# uses 0-based indexing
# pl[0] = 0, pl[0] = 1, ...
m.pl = pmo.parameter_list()
for j in m.q: