if arg.__class__ is _ProductExpression:
_substitute_vars(arg._numerator, var)
_substitute_vars(arg._denominator, var)
else:
_substitute_vars(arg._args, var)
elif isinstance(arg, _ConnectorValue):
v = arg.vars[var]
if v.is_expression():
v = v.clone()
args[idx] = _substitute_var(v, var)
elif isinstance(arg, VarList):
args[idx] = arg.add()
for var in ref.vars.iterkeys():
if var in skip:
continue
if constraint.body.is_expression():
c = _substitute_var(constraint.body.clone(), var)
else:
c = _substitute_var(constraint.body, var)
if constraint.equality:
cList.append( ( c, constraint.upper ) )
else:
cList.append( ( constraint.lower, c, constraint.upper ) )
transform = ConnectorExpander()
register_component(Connector, "A bundle of variables that can be manipilated together.")
class AbstractModel(Model):
"""
An abstract optimization model that defers construction of
components.
"""
def __init__(self, *args, **kwds):
Model.__init__(self, *args, **kwds)
#
# Create a Model and record all the default attributes, methods, etc.
# These will be assumes to be the set of illegal component names.
#
# Note that creating a Model will result in a warning, so we will
# (arbitrarily) choose a ConcreteModel as the definitive list of
# reserved names.
#
Model._Block_reserved_words = set(dir(ConcreteModel()))
register_component(
Model, 'Model objects can be used as a component of other models.')
register_component(
ConcreteModel,
'A concrete optimization model that does not defer construction of components.'
)
register_component(
AbstractModel,
'An abstract optimization model that defers construction of components.')
_init = _LinearMatrixConstraintData
self._data = tuple(
_init(i, component=self) for i in xrange(len(self._range_types)))
#
# Override some IndexedComponent methods
#
def __getitem__(self, key):
return self._data[key]
def __len__(self):
return self._data.__len__()
def __iter__(self):
return iter(i for i in xrange(len(self)))
#
# Remove methods that allow modifying this constraint
#
def add(self, index, expr):
raise NotImplementedError
def __delitem__(self):
raise NotImplementedError
register_component(MatrixConstraint,
"A set of constraint expressions in Ax=b form.")
"""Evaluating the numeric value of parameter '%s' before the Param has been
constructed (there is currently no value to return).""" %
self.cname(True))
def set_value(self, value):
if self._constructed and not self._mutable:
raise TypeError(
"""Attempting to set the value of the immutable parameter %s after the
parameter has been constructed. If you intend to change the value of
this parameter dynamically, please declare the parameter as mutable
[i.e., Param(mutable=True)]""" % (self.cname(True), ))
self[None] = value
def is_constant(self):
"""
Returns False because this is not a constant in an expression.
"""
return self._constructed and not self._mutable
class IndexedParam(Param):
def __call__(self, exception=True):
"""Compute the value of the parameter"""
if exception:
msg = 'Cannot compute the value of an array of parameters'
raise TypeError(msg)
register_component(Param,
"Parameter data that is used to define a model instance.")
class SubModel(SimpleBlock):
def __init__(self, *args, **kwargs):
"""Constructor"""
#
# Collect kwargs for SubModel
#
_rule = kwargs.pop('rule', None )
_fixed = kwargs.pop('fixed', None )
_var = kwargs.pop('var', None ) # Not documented
#
# Initialize the SimpleBlock
#
kwargs.setdefault('ctype', SubModel)
SimpleBlock.__init__(self, *args, **kwargs)
#
# Initialize from kwargs
#
self._rule = _rule
if isinstance(_fixed, Component):
self._fixed = [_fixed]
else:
self._fixed = _fixed
if isinstance(_var, Component):
self._var = [_var]
else:
self._var = _var
register_component(SubModel, "A submodel in a bilevel program")
Check to see if all the ContinuousSets this derivative is taken with
respect to have been discretized.
"""
for i in self._wrt:
if 'scheme' not in i.get_discretization_info():
return False
return True
def get_state_var(self):
return self._sVar
def get_derivative_expression(self):
"""
Returns the current discretization expression for this derivative or creates
an access function to its StateVar the first time this method is called.
The expression gets built up as the discretization transformations are
sequentially applied to each ContinuousSet in the model.
"""
try:
return self._expr
except:
self._expr = create_access_function(self._sVar)
return self._expr
def set_derivative_expression(self, expr):
self._expr = expr
register_component(DerivativeVar,
"Derivative of a State variable in a DAE model.")
Test if the specified element in this set.
"""
try:
x = element - self._start_val
if x % self._step_val != 0:
#
# If we are doing floating-point arithmetic, there is a
# chance that we are seeing roundoff error...
#
if math.fabs((x + 1e-7) % self._step_val) > 2e-7:
return False
if element < self._bounds[0] or element > self._bounds[1]:
return False
except:
#
# This exception is triggered when type(element) is not int or float.
#
return False
#
# Now see if the element if filtered or invalid.
#
if self.filter is not None and not self.filter(element):
return False
if self.validate is not None and not self.validate(self, element):
return False
return True
register_component(RangeSet, "A sequence of numeric values. RangeSet(start,end,step) is a sequence starting a value 'start', and increasing in values by 'step' until a value greater than or equal to 'end' is reached.")
IndexedComponent.__init__(self, *args, **kwd)
#
if not type(self._rule) is types.FunctionType:
raise ValueError("BuildCheck must have an 'rule' option specified whose value is a function")
def _pprint(self):
return ([], None, None, None)
def construct(self, data=None):
""" Apply the rule to construct values in this set """
if __debug__ and logger.isEnabledFor(logging.DEBUG): #pragma:nocover
logger.debug("Constructing Check, name="+self.name)
#
if self._constructed: #pragma:nocover
return
self._constructed=True
#
if None in self._index:
# Scalar component
res = self._rule(self._parent())
if not res:
raise ValueError("BuildCheck %r identified error" % self.name)
else:
# Indexed component
for index in self._index:
res = apply_indexed_rule(self, self._rule, self._parent(), index)
if not res:
raise ValueError("BuildCheck %r identified error with index %r" % (self.name, str(index)))
register_component(BuildCheck, "A component that performs tests during model construction. The action rule is applied to every index value.")
logger.warning(
"DEPRECATION WARNING: Suffix.extractValues() is replaced "
" with the dict-interface method Suffix.items().")
# As implemented by MutableMapping
return list(self.items())
#
# Override a few methods to make sure the ActiveComponent versions are
# called. We can't just switch the inheritance order due to
# complications with __setstate__
#
def pprint(self, *args, **kwds):
return ActiveComponent.pprint(self, *args, **kwds)
def __str__(self):
return ActiveComponent.__str__(self)
#
# Override NotImplementedError messages on ComponentMap base class
#
def __eq__(self, other):
raise NotImplementedError("Suffix components are not comparable")
def __ne__(self, other):
raise NotImplementedError("Suffix components are not comparable")
register_component(Suffix, "Declare a container for extraneous model data")
return False
setlist = []
if self.dim() == 1:
setlist =[self.index_set(),]
else:
setlist = self._implicit_subsets
for i in setlist:
if i.type() is ContinuousSet:
if 'scheme' not in i.get_discretization_info():
return False
return True
#
# Leaving this method for backward compatibility reasons
# Note: It allows adding members outside of self._index.
# This has always been the case. Not sure there is
# any reason to maintain a reference to a separate
# index set if we allow this.
#
def add(self, index, expr):
"""Add an expression with a given index."""
if (type(expr) is tuple) and \
(expr == Expression.Skip):
return None
cdata = _GeneralExpressionData(expr, component=self)
self._data[index] = cdata
return cdata
register_component(Integral, "Integral Expression in a DAE model.")
"instead of ObjectiveList.End")
if (expr.__class__ is tuple) and \
(expr == ObjectiveList.End):
return
self.add(expr, sense=_init_sense)
else:
for expr in _generator:
if expr is None:
raise ValueError("Objective generator returned None "
"instead of ObjectiveList.End")
if (expr.__class__ is tuple) and \
(expr == ObjectiveList.End):
return
self.add(expr, sense=_init_sense)
def add(self, expr, sense=minimize):
"""Add an objective to the list."""
cdata = self._check_skip_add(self._nobjectives + 1, expr)
self._nobjectives += 1
self._index.add(self._nobjectives)
if cdata is not None:
cdata.set_sense(sense)
self._data[self._nobjectives] = cdata
return cdata
register_component(Objective, "Expressions that are minimized or maximized.")
register_component(ObjectiveList, "A list of objective expressions.")
def is_fully_discretized(self):
"""
Check to see if all the ContinuousSets this derivative is taken with
respect to have been discretized.
"""
for i in self._wrt:
if 'scheme' not in i.get_discretization_info():
return False
return True
def get_state_var(self):
return self._sVar
def get_derivative_expression(self):
"""
Returns the current discretization expression for this derivative or creates
an access function to its StateVar the first time this method is called.
The expression gets built up as the discretization transformations are
sequentially applied to each ContinuousSet in the model.
"""
try:
return self._expr
except:
self._expr = create_access_function(self._sVar)
return self._expr
def set_derivative_expression(self,expr):
self._expr = expr
register_component(DerivativeVar, "Derivative of a State variable in a DAE model.")
"""
logger.warning("DEPRECATION WARNING: Suffix.extractValues() is replaced "
" with the dict-interface method Suffix.items().")
# As implemented by MutableMapping
return list(self.items())
#
# Override a few methods to make sure the ActiveComponent versions are
# called. We can't just switch the inheritance order due to
# complications with __setstate__
#
def pprint(self, *args, **kwds):
return ActiveComponent.pprint(self, *args, **kwds)
def __str__(self):
return ActiveComponent.__str__(self)
#
# Override NotImplementedError messages on ComponentMap base class
#
def __eq__(self, other):
raise NotImplementedError("Suffix components are not comparable")
def __ne__(self, other):
raise NotImplementedError("Suffix components are not comparable")
register_component(Suffix, "Declare a container for extraneous model data")
if exception:
raise ValueError( """Evaluating the numeric value of parameter '%s' before the Param has been
constructed (there is currently no value to return).""" % self.name )
def set_value(self, value):
if self._constructed and not self._mutable:
raise TypeError(
"""Attempting to set the value of the immutable parameter %s after the
parameter has been constructed. If you intend to change the value of
this parameter dynamically, please declare the parameter as mutable
[i.e., Param(mutable=True)]""" % (self.name,))
self[None] = value
def is_constant(self):
"""
Returns False because this is not a constant in an expression.
"""
return self._constructed and not self._mutable
class IndexedParam(Param):
def __call__(self, exception=True):
"""Compute the value of the parameter"""
if exception:
msg = 'Cannot compute the value of an array of parameters'
raise TypeError(msg)
register_component(Param, "Parameter data that is used to define a model instance.")
_init = _LinearMatrixConstraintData
self._data = tuple(_init(i, component=self)
for i in xrange(len(self._range_types)))
#
# Override some IndexedComponent methods
#
def __getitem__(self, key):
return self._data[key]
def __len__(self):
return self._data.__len__()
def __iter__(self):
return iter(i for i in xrange(len(self)))
#
# Remove methods that allow modifying this constraint
#
def add(self, index, expr):
raise NotImplementedError
def __delitem__(self):
raise NotImplementedError
register_component(MatrixConstraint,
"A set of constraint expressions in Ax=b form.")
if not val is None:
ostream.write("\t"+str(val)+'\n')
ostream.write("\t\tType="+str(self._data[val].level)+'\n')
ostream.write("\t\tWeight : Variable\n")
for var, weight in self._data[val].get_items():
ostream.write("\t\t"+str(weight)+' : '+var.cname(True)+'\n')
# Since this class derives from Component and Component.__getstate__
# just packs up the entire __dict__ into the state dict, there s
# nothing special that we need to do here. We will just defer to the
# super() get/set state. Since all of our get/set state methods
# rely on super() to traverse the MRO, this will automatically pick
# up both the Component and Data base classes.
class SimpleSOSConstraint(SOSConstraint, _SOSConstraintData):
def __init__(self, *args, **kwd):
_SOSConstraintData.__init__(self, self)
SOSConstraint.__init__(self, *args, **kwd)
class IndexedSOSConstraint(SOSConstraint):
def __init__(self, *args, **kwds):
super(IndexedSOSConstraint,self).__init__(*args, **kwds)
register_component(SOSConstraint, "SOS constraint expressions.")
def _pprint(self):
return ([
("Size", len(self)),
("Index", self._index if self.is_indexed() else None),
("Active", self.active),
], None, None, None)
def construct(self, data=None):
""" Apply the rule to construct values in this set """
if __debug__ and logger.isEnabledFor(logging.DEBUG): #pragma:nocover
logger.debug("Constructing Action, name=" + self.name)
#
if self._constructed: #pragma:nocover
return
self._constructed = True
#
if not self.is_indexed():
# Scalar component
self._rule(self._parent())
else:
# Indexed component
for index in self._index:
apply_indexed_rule(self, self._rule, self._parent(), index)
register_component(
BuildAction,
"A component that performs arbitrary actions during model construction. The action rule is applied to every index value."
)
"ConstraintList '%s': rule returned None "
"instead of ConstraintList.End" % (self.name,) )
if (expr.__class__ is tuple) and \
(expr == ConstraintList.End):
return
self.add(expr)
else:
for expr in _generator:
if expr is None:
raise ValueError(
"ConstraintList '%s': generator returned None "
"instead of ConstraintList.End" % (self.name,) )
if (expr.__class__ is tuple) and \
(expr == ConstraintList.End):
return
self.add(expr)
def add(self, expr):
"""Add a constraint with an implicit index."""
cdata = self._check_skip_add(self._nconstraints + 1, expr)
self._nconstraints += 1
self._index.add(self._nconstraints)
if cdata is not None:
self._data[self._nconstraints] = cdata
return cdata
register_component(Constraint, "General constraint expressions.")
register_component(ConstraintList, "A list of constraint expressions.")
(expr == ObjectiveList.End):
return
self.add(expr, sense=_init_sense)
else:
for expr in _generator:
if expr is None:
raise ValueError(
"Objective generator returned None "
"instead of ObjectiveList.End")
if (expr.__class__ is tuple) and \
(expr == ObjectiveList.End):
return
self.add(expr, sense=_init_sense)
def add(self, expr, sense=minimize):
"""Add an objective to the list."""
cdata = self._check_skip_add(self._nobjectives + 1, expr)
self._nobjectives += 1
self._index.add(self._nobjectives)
if cdata is not None:
cdata.set_sense(sense)
self._data[self._nobjectives] = cdata
return cdata
register_component(Objective,
"Expressions that are minimized or maximized.")
register_component(ObjectiveList,
"A list of objective expressions.")
Returns
-------
:py:class:`Var<pyomo.environ.Var>`
"""
return self._sVar
def get_derivative_expression(self):
"""
Returns the current discretization expression for this derivative or
creates an access function to its :py:class:`Var` the first time
this method is called. The expression gets built up as the
discretization transformations are sequentially applied to each
:py:class:`ContinuousSet` in the model.
"""
try:
return self._expr
except:
self._expr = create_access_function(self._sVar)
return self._expr
def set_derivative_expression(self, expr):
""" Sets``_expr``, an expression representing the discretization
equations linking the :class:`DerivativeVar` to its state
:class:`Var`
"""
self._expr = expr
register_component(DerivativeVar,
"Derivative of a Var in a DAE model.")
raise ValueError("Unknown model transformation '%s'" % name)
return xfrm.apply_to(self, **kwds)
class ConcreteModel(Model):
"""
A concrete optimization model that does not defer construction of
components.
"""
def __init__(self, *args, **kwds):
kwds['concrete'] = True
Model.__init__(self, *args, **kwds)
class AbstractModel(Model):
"""
An abstract optimization model that defers construction of
components.
"""
def __init__(self, *args, **kwds):
Model.__init__(self, *args, **kwds)
register_component(Model, 'Model objects can be used as a component of other models.')
register_component(ConcreteModel, 'A concrete optimization model that does not defer construction of components.')
register_component(AbstractModel, 'An abstract optimization model that defers construction of components.')
ostream.write("\n")
for val in self._data:
if not val is None:
ostream.write("\t" + str(val) + '\n')
ostream.write("\t\tType=" + str(self._data[val].level) + '\n')
ostream.write("\t\tWeight : Variable\n")
for var, weight in self._data[val].get_items():
ostream.write("\t\t" + str(weight) + ' : ' + var.name + '\n')
# Since this class derives from Component and Component.__getstate__
# just packs up the entire __dict__ into the state dict, there s
# nothing special that we need to do here. We will just defer to the
# super() get/set state. Since all of our get/set state methods
# rely on super() to traverse the MRO, this will automatically pick
# up both the Component and Data base classes.
class SimpleSOSConstraint(SOSConstraint, _SOSConstraintData):
def __init__(self, *args, **kwd):
_SOSConstraintData.__init__(self, self)
SOSConstraint.__init__(self, *args, **kwd)
class IndexedSOSConstraint(SOSConstraint):
def __init__(self, *args, **kwds):
super(IndexedSOSConstraint, self).__init__(*args, **kwds)
register_component(SOSConstraint, "SOS constraint expressions.")
#
# Since this class derives from Component and Component.__getstate__
# just packs up the entire __dict__ into the state dict, we do not
# need to define the __getstate__ or __setstate__ methods.
# We just defer to the super() get/set state. Since all of our
# get/set state methods rely on super() to traverse the MRO, this
# will automatically pick up both the Component and Data base classes.
#
class IndexedConnector(Connector):
"""An array of connectors"""
pass
register_component(
Connector, "A bundle of variables that can be manipilated together.")
class ConnectorExpander(Plugin):
implements(IPyomoScriptModifyInstance)
def apply(self, **kwds):
instance = kwds.pop('instance')
xform = TransformationFactory('core.expand_connectors')
xform.apply_to(instance, **kwds)
return instance
transform = ConnectorExpander()
setlist = [
self.index_set(),
]
else:
setlist = self._implicit_subsets
for i in setlist:
if i.type() is ContinuousSet:
if 'scheme' not in i.get_discretization_info():
return False
return True
#
# Leaving this method for backward compatibility reasons
# Note: It allows adding members outside of self._index.
# This has always been the case. Not sure there is
# any reason to maintain a reference to a separate
# index set if we allow this.
#
def add(self, index, expr):
"""Add an expression with a given index."""
if (type(expr) is tuple) and \
(expr == Expression.Skip):
return None
cdata = _GeneralExpressionData(expr, component=self)
self._data[index] = cdata
return cdata
register_component(Integral, "Integral Expression in a DAE model.")
free=unfix
class VarList(IndexedVar):
"""
Variable-length indexed variable objects used to construct Pyomo models.
"""
def __init__(self, **kwds):
kwds['dense'] = False
args = (Set(),)
self._nvars = 0
IndexedVar.__init__(self, *args, **kwds)
def construct(self, data=None):
"""Construct this component."""
if __debug__ and logger.isEnabledFor(logging.DEBUG):
logger.debug("Constructing variable list %s",self.cname(True))
IndexedVar.construct(self, data)
def add(self):
"""Add a variable to this list."""
self._nvars += 1
self._index.add(self._nvars)
vardata = self._data[self._nvars] = _GeneralVarData(Reals, component=self)
self._initialize_members([self._nvars])
return vardata
register_component(Var, "Decision variables.")
register_component(VarList, "List of decision variables.")
def construct(self, data=None):
""" Apply the rule to construct values in this set """
if __debug__ and logger.isEnabledFor(logging.DEBUG): #pragma:nocover
logger.debug("Constructing Check, name=" + self.name)
#
if self._constructed: #pragma:nocover
return
self._constructed = True
#
if None in self._index:
# Scalar component
res = self._rule(self._parent())
if not res:
raise ValueError("BuildCheck %r identified error" % self.name)
else:
# Indexed component
for index in self._index:
res = apply_indexed_rule(self, self._rule, self._parent(),
index)
if not res:
raise ValueError(
"BuildCheck %r identified error with index %r" %
(self.name, str(index)))
register_component(
BuildCheck,
"A component that performs tests during model construction. The action rule is applied to every index value."
)
try:
x = element - self._start_val
if x % self._step_val != 0:
#
# If we are doing floating-point arithmetic, there is a
# chance that we are seeing roundoff error...
#
if math.fabs((x + 1e-7) % self._step_val) > 2e-7:
return False
if element < self._bounds[0] or element > self._bounds[1]:
return False
except:
#
# This exception is triggered when type(element) is not int or float.
#
return False
#
# Now see if the element if filtered or invalid.
#
if self.filter is not None and not self.filter(element):
return False
if self.validate is not None and not self.validate(self, element):
return False
return True
register_component(
RangeSet,
"A sequence of numeric values. RangeSet(start,end,step) is a sequence starting a value 'start', and increasing in values by 'step' until a value greater than or equal to 'end' is reached."
)
class VarList(IndexedVar):
"""
Variable-length indexed variable objects used to construct Pyomo models.
"""
def __init__(self, **kwds):
kwds['dense'] = False
args = (Set(),)
self._nvars = 0
IndexedVar.__init__(self, *args, **kwds)
def construct(self, data=None):
"""Construct this component."""
if __debug__ and logger.isEnabledFor(logging.DEBUG):
logger.debug("Constructing variable list %s", self.name)
IndexedVar.construct(self, data)
def add(self):
"""Add a variable to this list."""
self._nvars += 1
self._index.add(self._nvars)
vardata = self._data[self._nvars] = \
_GeneralVarData(domain=self._domain_init_value,
component=self)
self._initialize_members([self._nvars])
return vardata
register_component(Var, "Decision variables.")
register_component(VarList, "List of decision variables.")
(self.name, ))
if (expr.__class__ is tuple) and \
(expr == ConstraintList.End):
return
self.add(expr)
else:
for expr in _generator:
if expr is None:
raise ValueError(
"ConstraintList '%s': generator returned None "
"instead of ConstraintList.End" % (self.name, ))
if (expr.__class__ is tuple) and \
(expr == ConstraintList.End):
return
self.add(expr)
def add(self, expr):
"""Add a constraint with an implicit index."""
cdata = self._check_skip_add(self._nconstraints + 1, expr)
self._nconstraints += 1
self._index.add(self._nconstraints)
if cdata is not None:
self._data[self._nconstraints] = cdata
return cdata
register_component(Constraint, "General constraint expressions.")
register_component(ConstraintList, "A list of constraint expressions.")
if (type(expr) is tuple) and \
(expr == Expression.Skip):
raise ValueError(
"Expression.Skip can not be assigned "
"to an Expression that is not indexed: %s"
% (self.name))
self.set_value(expr)
return self
class IndexedExpression(Expression):
#
# Leaving this method for backward compatibility reasons
# Note: It allows adding members outside of self._index.
# This has always been the case. Not sure there is
# any reason to maintain a reference to a separate
# index set if we allow this.
#
def add(self, index, expr):
"""Add an expression with a given index."""
if (type(expr) is tuple) and \
(expr == Expression.Skip):
return None
cdata = _GeneralExpressionData(expr, component=self)
self._data[index] = cdata
return cdata
register_component(
Expression,
"Named expressions that can be used in other expressions.")
if (type(expr) is tuple) and \
(expr == Expression.Skip):
raise ValueError("Expression.Skip can not be assigned "
"to an Expression that is not indexed: %s" %
(self.name))
self.set_value(expr)
return self
class IndexedExpression(Expression):
#
# Leaving this method for backward compatibility reasons
# Note: It allows adding members outside of self._index.
# This has always been the case. Not sure there is
# any reason to maintain a reference to a separate
# index set if we allow this.
#
def add(self, index, expr):
"""Add an expression with a given index."""
if (type(expr) is tuple) and \
(expr == Expression.Skip):
return None
cdata = _GeneralExpressionData(expr, component=self)
self._data[index] = cdata
return cdata
register_component(Expression,
"Named expressions that can be used in other expressions.")
#
if not type(self._rule) is types.FunctionType:
raise ValueError("BuildAction must have an 'rule' option specified whose value is a function")
def _pprint(self):
return ([("Size", len(self)),
("Index", self._index \
if self._index != UnindexedComponent_set else None),
("Active", self.active),]
, None, None, None)
def construct(self, data=None):
""" Apply the rule to construct values in this set """
if __debug__ and logger.isEnabledFor(logging.DEBUG): #pragma:nocover
logger.debug("Constructing Action, name="+self.name)
#
if self._constructed: #pragma:nocover
return
self._constructed=True
#
if None in self._index:
# Scalar component
self._rule(self._parent())
else:
# Indexed component
for index in self._index:
apply_indexed_rule(self, self._rule, self._parent(), index)
register_component(BuildAction, "A component that performs arbitrary actions during model construction. The action rule is applied to every index value.")
