def _collect_bilinear(self, expr, bilin, quad):
if not expr.is_expression_type():
return
if type(expr) is ProductExpression:
if len(expr._numerator) != 2:
for e in expr._numerator:
self._collect_bilinear(e, bilin, quad)
# No need to check denominator, as this is poly_degree==2
return
if not isinstance(expr._numerator[0], _VarData) or \
not isinstance(expr._numerator[1], _VarData):
raise RuntimeError("Cannot yet handle complex subexpressions")
if expr._numerator[0] is expr._numerator[1]:
quad.append((expr, expr._numerator[0]))
else:
bilin.append((expr, expr._numerator[0], expr._numerator[1]))
return
if type(expr) is PowExpression and value(expr._args[1]) == 2:
# Note: directly testing the value of the exponent above is
# safe: we have already verified that this expression is
# polynominal, so the exponent must be constant.
tmp = ProductExpression()
tmp._numerator = [expr._args[0], expr._args[0]]
tmp._denominator = []
expr._args = (tmp, as_numeric(1)) # THIS CODE DOES NOT WORK
#quad.append( (tmp, tmp._args[0]) )
self._collect_bilinear(tmp, bilin, quad)
return
# All other expression types
for e in expr._args:
self._collect_bilinear(e, bilin, quad)
def __call__(self, *args):
idxs = reversed(six.moves.xrange(len(args)))
for i in idxs:
if type(args[i]) is types.GeneratorType:
args = args[:i] + tuple(args[i]) + args[i+1:]
return _ExternalFunctionExpression( self, tuple(
_external_fcn__clone_if_needed(x) if isinstance(x, _ExpressionBase)
else x if isinstance(x, basestring)
else as_numeric(x)
for x in args ) )
def __init__(self, expr, component=None):
#
# These lines represent in-lining of the
# following constructors:
# - _ExpressionData
# - ComponentData
# - NumericValue
self._component = weakref_ref(component) if (component is not None) \
else None
self._expr = as_numeric(expr) if (expr is not None) else None
def __init__(self, expr, component=None):
#
# These lines represent in-lining of the
# following constructors:
# - _ExpressionData
# - ComponentData
# - NumericValue
self._component = weakref_ref(component) if (component is not None) \
else None
self._expr = as_numeric(expr) if (expr is not None) else None
def substitute_template_with_value(expr):
"""A simple substituter to expand expression for current template
This substituter will replace all _GetItemExpression / IndexTemplate
nodes with the actual _ComponentData based on the current value of
the IndexTamplate(s)
"""
if type(expr) is IndexTemplate:
return as_numeric(expr())
else:
return expr.resolve_template()
def substitute_template_with_value(expr):
"""A simple substituter to expand expression for current template
This substituter will replace all _GetItemExpression / IndexTemplate
nodes with the actual _ComponentData based on the current value of
the IndexTamplate(s)
"""
if type(expr) is IndexTemplate:
return as_numeric(expr())
else:
return expr.resolve_template()
def add(self, var, name=None, rule=None, **kwds):
"""
Add `var` to this Port, casting it to a Pyomo numeric if necessary
Arguments
---------
var
A variable or some `NumericValue` like an expression
name: `str`
Name to associate with this member of the Port
rule: `function`
Function implementing the desired expansion procedure
for this member. `Port.Equality` by default, other
options include `Port.Extensive`. Customs are allowed.
kwds
Keyword arguments that will be passed to rule
"""
if var is not None:
try:
# indexed components are ok, but as_numeric will error on them
# make sure they have this attribute
var.is_indexed()
except AttributeError:
var = as_numeric(var)
if name is None:
name = var.local_name
if name in self.vars and self.vars[name] is not None:
# don't throw warning if replacing an implicit (None) var
logger.warning("Implicitly replacing variable '%s' in Port '%s'.\n"
"To avoid this warning, use Port.remove() first."
% (name, self.name))
self.vars[name] = var
if rule is None:
rule = Port.Equality
if rule is Port.Extensive:
# avoid name collisions
if (name.endswith("_split") or name.endswith("_equality") or
name == "splitfrac"):
raise ValueError(
"Extensive variable '%s' on Port '%s' may not end "
"with '_split' or '_equality'" % (name, self.name))
self._rules[name] = (rule, kwds)
def __init__(self, expr, sense=minimize, component=None):
#
# These lines represent in-lining of the
# following constructors:
# - _ObjectiveData,
# - ActiveComponentData
# - ComponentData
self._component = weakref_ref(component) if (component is not None) \
else None
self._active = True
# don't call set_value or set_sense here (it causes issues with
# SimpleObjective initialization)
self._expr = as_numeric(expr) if (expr is not None) else None
self._sense = sense
if (self._sense != minimize) and \
(self._sense != maximize):
raise ValueError("Objective sense must be set to one of "
"'minimize' (%s) or 'maximize' (%s). Invalid "
"value: %s'" % (minimize, maximize, sense))
def set_value(self, expr):
"""Set the expression on this constraint."""
if expr is None:
self._body = None
self._lower = None
self._upper = None
self._equality = False
return
_expr_type = expr.__class__
if _expr_type is tuple: # or expr_type is list:
#
# Form equality expression
#
if len(expr) == 2:
arg0 = expr[0]
if arg0 is not None:
arg0 = as_numeric(arg0)
arg1 = expr[1]
if arg1 is not None:
arg1 = as_numeric(arg1)
self._equality = True
if arg1 is None or (not arg1._potentially_variable()):
self._lower = self._upper = arg1
self._body = arg0
elif arg0 is None or (not arg0._potentially_variable()):
self._lower = self._upper = arg0
self._body = arg1
else:
with EXPR.bypass_clone_check():
self._lower = self._upper = ZeroConstant
self._body = arg0
self._body -= arg1
#self._body = EXPR.generate_expression_bypassCloneCheck(
# _sub, arg0, arg1)
#
# Form inequality expression
#
elif len(expr) == 3:
arg0 = expr[0]
if arg0 is not None:
arg0 = as_numeric(arg0)
if arg0._potentially_variable():
raise ValueError(
"Constraint '%s' found a 3-tuple (lower,"
" expression, upper) but the lower "
"value was not data or an expression "
"restricted to storage of data." % (self.name))
arg1 = expr[1]
if arg1 is not None:
arg1 = as_numeric(arg1)
arg2 = expr[2]
if arg2 is not None:
arg2 = as_numeric(arg2)
if arg2._potentially_variable():
raise ValueError(
"Constraint '%s' found a 3-tuple (lower,"
" expression, upper) but the upper "
"value was not data or an expression "
"restricted to storage of data." % (self.name))
self._lower = arg0
self._body = arg1
self._upper = arg2
else:
raise ValueError(
"Constructor rule for constraint '%s' returned "
"a tuple of length %d. Expecting a tuple of "
"length 2 or 3:\n"
"Equality: (left, right)\n"
"Inequality: (lower, expression, upper)" %
(self.name, len(expr)))
relational_expr = False
else:
try:
relational_expr = expr.is_relational()
if not relational_expr:
raise ValueError(
"Constraint '%s' does not have a proper "
"value. Found '%s'\nExpecting a tuple or "
"equation. Examples:"
"\n summation(model.costs) == model.income"
"\n (0, model.price[item], 50)" %
(self.name, str(expr)))
except AttributeError:
msg = ("Constraint '%s' does not have a proper "
"value. Found '%s'\nExpecting a tuple or "
"equation. Examples:"
"\n summation(model.costs) == model.income"
"\n (0, model.price[item], 50)" %
(self.name, str(expr)))
if type(expr) is bool:
msg += ("\nNote: constant Boolean expressions "
"are not valid constraint expressions. "
"Some apparently non-constant compound "
"inequalities (e.g. 'expr >= 0 <= 1') "
"can return boolean values; the proper "
"form for compound inequalities is "
"always 'lb <= expr <= ub'.")
raise ValueError(msg)
#
# Special check for chainedInequality errors like "if var <
# 1:" within rules. Catching them here allows us to provide
# the user with better (and more immediate) debugging
# information. We don't want to check earlier because we
# want to provide a specific debugging message if the
# construction rule returned True/False; for example, if the
# user did ( var < 1 > 0 ) (which also results in a non-None
# chainedInequality value)
#
if EXPR.generate_relational_expression.chainedInequality is not None:
raise TypeError(EXPR.chainedInequalityErrorMessage())
#
# Process relational expressions
# (i.e. explicit '==', '<', and '<=')
#
if relational_expr:
if _expr_type is EXPR._EqualityExpression:
# Equality expression: only 2 arguments!
self._equality = True
_args = expr._args
# Explicitly dereference the original arglist (otherwise
# this runs afoul of the getrefcount logic)
expr._args = []
if not _args[1]._potentially_variable():
self._lower = self._upper = _args[1]
self._body = _args[0]
elif not _args[0]._potentially_variable():
self._lower = self._upper = _args[0]
self._body = _args[1]
else:
with EXPR.bypass_clone_check():
self._lower = self._upper = ZeroConstant
self._body = _args[0]
self._body -= _args[1]
#self._body = EXPR.generate_expression_bypassCloneCheck(
# _sub, _args[0], _args[1] )
else:
# Inequality expression: 2 or 3 arguments
if expr._strict:
try:
_strict = any(expr._strict)
except:
_strict = True
if _strict:
#
# We can relax this when:
# (a) we have a need for this
# (b) we have problem writer that
# explicitly handles this
# (c) we make sure that all problem writers
# that don't handle this make it known
# to the user through an error or
# warning
#
raise ValueError(
"Constraint '%s' encountered a strict "
"inequality expression ('>' or '<'). All"
" constraints must be formulated using "
"using '<=', '>=', or '=='." % (self.name))
_args = expr._args
# Explicitly dereference the original arglist (otherwise
# this runs afoul of the getrefcount logic)
expr._args = []
if len(_args) == 3:
if _args[0]._potentially_variable():
raise ValueError(
"Constraint '%s' found a double-sided "
"inequality expression (lower <= "
"expression <= upper) but the lower "
"bound was not data or an expression "
"restricted to storage of data." % (self.name))
if _args[2]._potentially_variable():
raise ValueError(
"Constraint '%s' found a double-sided "\
"inequality expression (lower <= "
"expression <= upper) but the upper "
"bound was not data or an expression "
"restricted to storage of data."
% (self.name))
self._lower = _args[0]
self._body = _args[1]
self._upper = _args[2]
else:
if not _args[1]._potentially_variable():
self._lower = None
self._body = _args[0]
self._upper = _args[1]
elif not _args[0]._potentially_variable():
self._lower = _args[0]
self._body = _args[1]
self._upper = None
else:
with EXPR.bypass_clone_check():
self._lower = None
self._body = _args[0]
self._body -= _args[1]
self._upper = ZeroConstant
#self._body = EXPR.generate_expression_bypassCloneCheck(
# _sub, _args[0], _args[1])
#
# Replace numeric bound values with a NumericConstant object,
# and reset the values to 'None' if they are 'infinite'
#
if (self._lower is not None) and is_constant(self._lower):
val = self._lower()
if not pyutilib.math.is_finite(val):
if val > 0:
raise ValueError(
"Constraint '%s' created with a +Inf lower "
"bound." % (self.name))
self._lower = None
elif bool(val > 0) == bool(val <= 0):
raise ValueError("Constraint '%s' created with a non-numeric "
"lower bound." % (self.name))
if (self._upper is not None) and is_constant(self._upper):
val = self._upper()
if not pyutilib.math.is_finite(val):
if val < 0:
raise ValueError(
"Constraint '%s' created with a -Inf upper "
"bound." % (self.name))
self._upper = None
elif bool(val > 0) == bool(val <= 0):
raise ValueError("Constraint '%s' created with a non-numeric "
"upper bound." % (self.name))
#
# Error check, to ensure that we don't have a constraint that
# doesn't depend on any variables / parameters.
#
# Error check, to ensure that we don't have an equality
# constraint with 'infinite' RHS
#
if self._equality:
if self._lower is None:
raise ValueError("Equality constraint '%s' defined with "
"non-finite term." % (self.name))
assert self._lower is self._upper
def __init__(self, expr=None):
self._expr = as_numeric(expr) if (expr is not None) else None
self._is_owned = True
def set_value(self, expr):
"""Set the expression on this expression."""
self._expr = as_numeric(expr) if (expr is not None) else None
def __init__(self, expr):
self._expr = as_numeric(expr) if (expr is not None) else None
if safe_mode:
self._parent_expr = None
def set_value(self, expr):
"""Set the expression on this expression."""
self._expr = as_numeric(expr) if (expr is not None) else None
def __init__(self, expr=None):
self._expr = as_numeric(expr) if (expr is not None) else None
self._is_owned = True
def _convert_external_setup_without_cleanup(worker, scenario, output_directory,
firststage_var_suffix,
enforce_derived_nonanticipativity,
io_options):
import pyomo.environ
assert os.path.exists(output_directory)
io_options = dict(io_options)
scenario_tree = worker.scenario_tree
reference_model = scenario._instance
rootnode = scenario_tree.findRootNode()
firststage = scenario_tree.stages[0]
secondstage = scenario_tree.stages[1]
constraint_name_buffer = {}
objective_name_buffer = {}
variable_name_buffer = {}
all_constraints = list(con
for con in reference_model.component_data_objects(
Constraint, active=True, descend_into=True))
#
# Check for model annotations
#
stochastic_rhs = locate_annotations(reference_model,
StochasticConstraintBoundsAnnotation,
max_allowed=1)
if len(stochastic_rhs) == 0:
stochastic_rhs = None
stochastic_rhs_entries = {}
empty_rhs_annotation = False
else:
assert len(stochastic_rhs) == 1
stochastic_rhs = stochastic_rhs[0][1]
if stochastic_rhs.has_declarations:
empty_rhs_annotation = False
stochastic_rhs_entries = stochastic_rhs.expand_entries()
stochastic_rhs_entries.sort(
key=lambda x: x[0].getname(True, constraint_name_buffer))
if len(stochastic_rhs_entries) == 0:
raise RuntimeError(
"The %s annotation was declared "
"with external entries but no active Constraint "
"objects were recovered from those entries." %
(StochasticConstraintBoundsAnnotation.__name__))
else:
empty_rhs_annotation = True
stochastic_rhs_entries = tuple(
(con, stochastic_rhs.default) for con in all_constraints)
stochastic_matrix = locate_annotations(reference_model,
StochasticConstraintBodyAnnotation,
max_allowed=1)
if len(stochastic_matrix) == 0:
stochastic_matrix = None
stochastic_matrix_entries = {}
empty_matrix_annotation = False
else:
assert len(stochastic_matrix) == 1
stochastic_matrix = stochastic_matrix[0][1]
if stochastic_matrix.has_declarations:
empty_matrix_annotation = False
stochastic_matrix_entries = stochastic_matrix.expand_entries()
stochastic_matrix_entries.sort(
key=lambda x: x[0].getname(True, constraint_name_buffer))
if len(stochastic_matrix_entries) == 0:
raise RuntimeError(
"The %s annotation was declared "
"with external entries but no active Constraint "
"objects were recovered from those entries." %
(StochasticConstraintBoundsAnnotation.__name__))
else:
empty_matrix_annotation = True
stochastic_matrix_entries = tuple(
(con, stochastic_matrix.default) for con in all_constraints)
stochastic_constraint_ids = set()
stochastic_constraint_ids.update(
id(con) for con, _ in stochastic_rhs_entries)
stochastic_constraint_ids.update(
id(con) for con, _ in stochastic_matrix_entries)
stochastic_objective = locate_annotations(reference_model,
StochasticObjectiveAnnotation,
max_allowed=1)
if len(stochastic_objective) == 0:
stochastic_objective = None
else:
assert len(stochastic_objective) == 1
stochastic_objective = stochastic_objective[0][1]
stochastic_varbounds = locate_annotations(
reference_model, StochasticVariableBoundsAnnotation)
if len(stochastic_varbounds) > 0:
raise ValueError(
"The DDSIP writer does not currently support "
"stochastic variable bounds. Invalid annotation type: %s" %
(StochasticVariableBoundsAnnotation.__name__))
if (stochastic_rhs is None) and \
(stochastic_matrix is None) and \
(stochastic_objective is None):
raise RuntimeError("No stochastic annotations found. DDSIP "
"conversion requires at least one of the following "
"annotation types:\n - %s\n - %s\n - %s" %
(StochasticConstraintBoundsAnnotation.__name__,
StochasticConstraintBodyAnnotation.__name__,
StochasticObjectiveAnnotation.__name__))
assert not hasattr(reference_model, "_repn")
repn_cache = build_repns(reference_model)
assert hasattr(reference_model, "_repn")
assert not reference_model._gen_obj_repn
assert not reference_model._gen_con_repn
# compute values
for block_repns in repn_cache.values():
for repn in block_repns.values():
repn.constant = value(repn.constant)
repn.linear_coefs = [value(c) for c in repn.linear_coefs]
repn.quadratic_coefs = [value(c) for c in repn.quadratic_coefs]
#
# Write the LP file once to obtain the symbol map
#
output_filename = os.path.join(output_directory,
scenario.name + ".lp.setup")
with WriterFactory("lp") as writer:
assert 'column_order' not in io_options
assert 'row_order' not in io_options
output_fname, symbol_map = writer(reference_model, output_filename,
lambda x: True, io_options)
assert output_fname == output_filename
_safe_remove_file(output_filename)
StageToVariableMap = map_variable_stages(
scenario,
scenario_tree,
symbol_map,
enforce_derived_nonanticipativity=enforce_derived_nonanticipativity)
firststage_variable_ids = \
set(id(var) for symbol, var, scenario_tree_id
in StageToVariableMap[firststage.name])
secondstage_variable_ids = \
set(id(var) for symbol, var, scenario_tree_id
in StageToVariableMap[secondstage.name])
StageToConstraintMap = \
map_constraint_stages(
scenario,
scenario_tree,
symbol_map,
stochastic_constraint_ids,
firststage_variable_ids,
secondstage_variable_ids)
secondstage_constraint_ids = \
set(id(con) for symbols, con
in StageToConstraintMap[secondstage.name])
assert len(scenario_tree.stages) == 2
firststage = scenario_tree.stages[0]
secondstage = scenario_tree.stages[1]
#
# Make sure the objective references all first stage variables.
# We do this by directly modifying the _repn of the
# objective which the LP/MPS writer will reference next time we call
# it. In addition, make sure that the first second-stage variable
# in our column ordering also appears in the objective so that
# ONE_VAR_CONSTANT does not get identified as the first
# second-stage variable.
# ** Just do NOT preprocess again until we call the writer **
#
objective_object = scenario._instance_objective
assert objective_object is not None
objective_block = objective_object.parent_block()
objective_repn = repn_cache[id(objective_block)][objective_object]
#
# Create column (variable) ordering maps for LP/MPS files
#
column_order = ComponentMap()
firststage_variable_count = 0
secondstage_variable_count = 0
# first-stage variables
for column_index, (symbol, var, scenario_tree_id) \
in enumerate(StageToVariableMap[firststage.name]):
column_order[var] = column_index
firststage_variable_count += 1
# second-stage variables
for column_index, (symbol, var, scenario_tree_id) \
in enumerate(StageToVariableMap[secondstage.name],
len(column_order)):
column_order[var] = column_index
secondstage_variable_count += 1
# account for the ONE_VAR_CONSTANT second-stage variable
# added by the LP writer
secondstage_variable_count += 1
#
# Create row (constraint) ordering maps for LP/MPS files
#
firststage_constraint_count = 0
secondstage_constraint_count = 0
row_order = ComponentMap()
# first-stage constraints
for row_index, (symbols, con) \
in enumerate(StageToConstraintMap[firststage.name]):
row_order[con] = row_index
firststage_constraint_count += len(symbols)
# second-stage constraints
for row_index, (symbols, con) \
in enumerate(StageToConstraintMap[secondstage.name],
len(row_order)):
row_order[con] = row_index
secondstage_constraint_count += len(symbols)
# account for the ONE_VAR_CONSTANT = 1 second-stage constraint
# added by the LP writer
secondstage_constraint_count += 1
#
# Create a custom labeler that allows DDSIP to identify
# first-stage variables
#
if io_options.pop('symbolic_solver_labels', False):
_labeler = TextLabeler()
else:
_labeler = NumericLabeler('x')
labeler = lambda x: _labeler(x) + \
(""
if ((not isinstance(x, _VarData)) or \
(id(x) not in firststage_variable_ids)) else \
firststage_var_suffix)
#
# Write the ordered LP/MPS file
#
output_filename = os.path.join(output_directory, scenario.name + ".lp")
symbols_filename = os.path.join(output_directory,
scenario.name + ".lp.symbols")
with WriterFactory("lp") as writer:
assert 'column_order' not in io_options
assert 'row_order' not in io_options
assert 'labeler' not in io_options
assert 'force_objective_constant' not in io_options
io_options['column_order'] = column_order
io_options['row_order'] = row_order
io_options['force_objective_constant'] = True
io_options['labeler'] = labeler
output_fname, symbol_map = writer(reference_model, output_filename,
lambda x: True, io_options)
assert output_fname == output_filename
# write the lp file symbol paired with the scenario
# tree id for each variable in the root node
with open(symbols_filename, "w") as f:
st_symbol_map = reference_model._ScenarioTreeSymbolMap
lines = []
for id_ in sorted(rootnode._variable_ids):
var = st_symbol_map.bySymbol[id_]
if not var.is_expression_type():
lp_label = symbol_map.byObject[id(var)]
lines.append("%s %s\n" % (lp_label, id_))
f.writelines(lines)
# re-generate these maps as the LP/MPS symbol map
# is likely different
StageToVariableMap = map_variable_stages(
scenario,
scenario_tree,
symbol_map,
enforce_derived_nonanticipativity=enforce_derived_nonanticipativity)
StageToConstraintMap = map_constraint_stages(scenario, scenario_tree,
symbol_map,
stochastic_constraint_ids,
firststage_variable_ids,
secondstage_variable_ids)
# generate a few data structures that are used
# when writing the .sc files
constraint_symbols = ComponentMap(
(con, symbols) for stage_name in StageToConstraintMap
for symbols, con in StageToConstraintMap[stage_name])
#
# Write the body of the .sc files
#
modified_constraint_lb = ComponentMap()
modified_constraint_ub = ComponentMap()
#
# Stochastic RHS
#
# **NOTE: In the code that follows we assume the LP
# writer always moves constraint body
# constants to the rhs and that the lower part
# of any range constraints are written before
# the upper part.
#
stochastic_rhs_count = 0
with open(os.path.join(output_directory, scenario.name + ".rhs.sc.struct"),
'w') as f_rhs_struct:
with open(os.path.join(output_directory, scenario.name + ".rhs.sc"),
'w') as f_rhs:
scenario_probability = scenario.probability
rhs_struct_template = " %s\n"
rhs_template = " %.17g\n"
f_rhs.write("scen\n%.17g\n" %
(_no_negative_zero(scenario_probability)))
if stochastic_rhs is not None:
for con, include_bound in stochastic_rhs_entries:
assert isinstance(con, _ConstraintData)
if not empty_rhs_annotation:
# verify that this constraint was
# flagged by PySP or the user as second-stage
if id(con) not in secondstage_constraint_ids:
raise RuntimeError(
"The constraint %s has been declared "
"in the %s annotation but it was not identified as "
"a second-stage constraint. To correct this issue, "
"remove the constraint from this annotation." %
(con.name,
StochasticConstraintBoundsAnnotation.__name__)
)
constraint_repn = \
repn_cache[id(con.parent_block())][con]
if not constraint_repn.is_linear():
raise RuntimeError(
"Only linear constraints are "
"accepted for conversion to DDSIP format. "
"Constraint %s is not linear." % (con.name))
body_constant = constraint_repn.constant
# We are going to rewrite the core problem file
# with all stochastic values set to zero. This will
# allow an easy test for missing user annotations.
constraint_repn.constant = 0
if body_constant is None:
body_constant = 0.0
symbols = constraint_symbols[con]
assert len(symbols) > 0
for con_label in symbols:
if con_label.startswith('c_e_') or \
con_label.startswith('c_l_'):
assert (include_bound is True) or \
(include_bound[0] is True)
stochastic_rhs_count += 1
f_rhs_struct.write(rhs_struct_template %
(con_label))
f_rhs.write(rhs_template %
(_no_negative_zero(
value(con.lower) - \
value(body_constant))))
# We are going to rewrite the core problem file
# with all stochastic values set to zero. This will
# allow an easy test for missing user annotations.
modified_constraint_lb[con] = con.lower
con._lower = _deterministic_check_constant
if con_label.startswith('c_e_'):
modified_constraint_ub[con] = con.upper
con._upper = _deterministic_check_constant
elif con_label.startswith('r_l_'):
if (include_bound is True) or \
(include_bound[0] is True):
stochastic_rhs_count += 1
f_rhs_struct.write(rhs_struct_template %
(con_label))
f_rhs.write(rhs_template %
(_no_negative_zero(
value(con.lower) - \
value(body_constant))))
# We are going to rewrite the core problem file
# with all stochastic values set to zero. This will
# allow an easy test for missing user annotations.
modified_constraint_lb[con] = con.lower
con._lower = _deterministic_check_constant
elif con_label.startswith('c_u_'):
assert (include_bound is True) or \
(include_bound[1] is True)
stochastic_rhs_count += 1
f_rhs_struct.write(rhs_struct_template %
(con_label))
f_rhs.write(rhs_template %
(_no_negative_zero(
value(con.upper) - \
value(body_constant))))
# We are going to rewrite the core problem file
# with all stochastic values set to zero. This will
# allow an easy test for missing user annotations.
modified_constraint_ub[con] = con.upper
con._upper = _deterministic_check_constant
elif con_label.startswith('r_u_'):
if (include_bound is True) or \
(include_bound[1] is True):
stochastic_rhs_count += 1
f_rhs_struct.write(rhs_struct_template %
(con_label))
f_rhs.write(rhs_template %
(_no_negative_zero(
value(con.upper) - \
value(body_constant))))
# We are going to rewrite the core problem file
# with all stochastic values set to zero. This will
# allow an easy test for missing user annotations.
modified_constraint_ub[con] = con.upper
con._upper = _deterministic_check_constant
else:
assert False
#
# Stochastic Matrix
#
stochastic_matrix_count = 0
with open(
os.path.join(output_directory,
scenario.name + ".matrix.sc.struct"),
'w') as f_mat_struct:
with open(os.path.join(output_directory, scenario.name + ".matrix.sc"),
'w') as f_mat:
scenario_probability = scenario.probability
matrix_struct_template = " %s %s\n"
matrix_template = " %.17g\n"
f_mat.write("scen\n")
if stochastic_matrix is not None:
for con, var_list in stochastic_matrix_entries:
assert isinstance(con, _ConstraintData)
if not empty_matrix_annotation:
# verify that this constraint was
# flagged by PySP or the user as second-stage
if id(con) not in secondstage_constraint_ids:
raise RuntimeError(
"The constraint %s has been declared "
"in the %s annotation but it was not identified as "
"a second-stage constraint. To correct this issue, "
"remove the constraint from this annotation." %
(con.name,
StochasticConstraintBodyAnnotation.__name__))
constraint_repn = \
repn_cache[id(con.parent_block())][con]
if not constraint_repn.is_linear():
raise RuntimeError(
"Only linear constraints are "
"accepted for conversion to DDSIP format. "
"Constraint %s is not linear." % (con.name))
assert len(constraint_repn.linear_vars) > 0
if var_list is None:
var_list = constraint_repn.linear_vars
assert len(var_list) > 0
symbols = constraint_symbols[con]
# sort the variable list by the column ordering
# so that we have deterministic output
var_list = list(var_list)
var_list.sort(key=lambda _v: column_order[_v])
new_coefs = list(constraint_repn.linear_coefs)
for var in var_list:
assert isinstance(var, _VarData)
assert not var.fixed
var_coef = None
for i, (_var, coef) in enumerate(
zip(constraint_repn.linear_vars,
constraint_repn.linear_coefs)):
if _var is var:
var_coef = coef
# We are going to rewrite with core problem file
# with all stochastic values set to zero. This will
# allow an easy test for missing user annotations.
new_coefs[i] = _deterministic_check_value
break
if var_coef is None:
raise RuntimeError(
"The coefficient for variable %s has "
"been marked as stochastic in constraint %s using "
"the %s annotation, but the variable does not appear"
" in the canonical constraint expression." %
(var.name, con.name,
StochasticConstraintBodyAnnotation.__name__))
var_label = symbol_map.byObject[id(var)]
for con_label in symbols:
stochastic_matrix_count += 1
f_mat_struct.write(matrix_struct_template %
(con_label, var_label))
f_mat.write(matrix_template %
(_no_negative_zero(value(var_coef))))
constraint_repn.linear_coefs = tuple(new_coefs)
#
# Stochastic Objective
#
stochastic_cost_count = 0
with open(
os.path.join(output_directory, scenario.name + ".cost.sc.struct"),
'w') as f_obj_struct:
with open(os.path.join(output_directory, scenario.name + ".cost.sc"),
'w') as f_obj:
obj_struct_template = " %s\n"
obj_template = " %.17g\n"
f_obj.write("scen\n")
if stochastic_objective is not None:
if stochastic_objective.has_declarations:
sorted_values = stochastic_objective.expand_entries()
assert len(sorted_values) <= 1
if len(sorted_values) == 0:
raise RuntimeError(
"The %s annotation was declared "
"with external entries but no active Objective "
"objects were recovered from those entries." %
(StochasticObjectiveAnnotation.__name__))
obj, (objective_variables, include_constant) = \
sorted_values[0]
assert obj is objective_object
else:
objective_variables, include_constant = \
stochastic_objective.default
if not objective_repn.is_linear():
raise RuntimeError(
"Only linear stochastic objectives are "
"accepted for conversion to DDSIP format. "
"Objective %s is not linear." %
(objective_object.name))
if objective_variables is None:
objective_variables = objective_repn.linear_vars
stochastic_objective_label = symbol_map.byObject[id(
objective_object)]
# sort the variable list by the column ordering
# so that we have deterministic output
objective_variables = list(objective_variables)
objective_variables.sort(key=lambda _v: column_order[_v])
assert (len(objective_variables) > 0) or include_constant
new_coefs = list(objective_repn.linear_coefs)
for var in objective_variables:
assert isinstance(var, _VarData)
var_coef = None
for i, (_var, coef) in enumerate(
zip(objective_repn.linear_vars,
objective_repn.linear_coefs)):
if _var is var:
var_coef = coef
# We are going to rewrite the core problem file
# with all stochastic values set to zero. This will
# allow an easy test for missing user annotations.
new_coefs[i] = _deterministic_check_value
break
if var_coef is None:
raise RuntimeError(
"The coefficient for variable %s has "
"been marked as stochastic in objective %s using "
"the %s annotation, but the variable does not appear"
" in the canonical objective expression." %
(var.name, objective_object.name,
StochasticObjectiveAnnotation.__name__))
var_label = symbol_map.byObject[id(var)]
stochastic_cost_count += 1
f_obj_struct.write(obj_struct_template % (var_label))
f_obj.write(obj_template %
(_no_negative_zero(value(var_coef))))
objective_repn.linear_coefs = tuple(new_coefs)
if include_constant:
obj_constant = objective_repn.constant
# We are going to rewrite the core problem file
# with all stochastic values set to zero. This will
# allow an easy test for missing user annotations.
objective_repn.constant = _deterministic_check_value
if obj_constant is None:
obj_constant = 0.0
stochastic_cost_count += 1
f_obj_struct.write(obj_struct_template %
("ONE_VAR_CONSTANT"))
f_obj.write(obj_template %
(_no_negative_zero(obj_constant)))
#
# Write the deterministic part of the LP/MPS-file to its own
# file for debugging purposes
#
reference_model_name = reference_model.name
reference_model._name = "ZeroStochasticData"
det_output_filename = os.path.join(output_directory,
scenario.name + ".lp.det")
with WriterFactory("lp") as writer:
output_fname, symbol_map = writer(reference_model, det_output_filename,
lambda x: True, io_options)
assert output_fname == det_output_filename
reference_model._name = reference_model_name
# reset bounds on any constraints that were modified
for con, lower in iteritems(modified_constraint_lb):
con._lower = as_numeric(lower)
for con, upper in iteritems(modified_constraint_ub):
con._upper = as_numeric(upper)
return (firststage_variable_count, secondstage_variable_count,
firststage_constraint_count, secondstage_constraint_count,
stochastic_cost_count, stochastic_rhs_count,
stochastic_matrix_count)
def __init__(self, expr):
self._expr = as_numeric(expr) if (expr is not None) else None
if safe_mode:
self._parent_expr = None
def set_value(self, expr):
"""Set the expression on this constraint."""
if expr is None:
self._body = None
self._lower = None
self._upper = None
self._equality = False
return
_expr_type = expr.__class__
if _expr_type is tuple: # or expr_type is list:
#
# Form equality expression
#
if len(expr) == 2:
arg0 = expr[0]
if arg0 is not None:
arg0 = as_numeric(arg0)
arg1 = expr[1]
if arg1 is not None:
arg1 = as_numeric(arg1)
self._equality = True
if arg1 is None or (not arg1._potentially_variable()):
self._lower = self._upper = arg1
self._body = arg0
elif arg0 is None or (not arg0._potentially_variable()):
self._lower = self._upper = arg0
self._body = arg1
else:
self._lower = self._upper = ZeroConstant
self._body = EXPR.generate_expression_bypassCloneCheck(
_sub, arg0, arg1)
#
# Form inequality expression
#
elif len(expr) == 3:
arg0 = expr[0]
if arg0 is not None:
arg0 = as_numeric(arg0)
if arg0._potentially_variable():
raise ValueError(
"Constraint '%s' found a 3-tuple (lower,"
" expression, upper) but the lower "
"value was not data or an expression "
"restricted to storage of data."
% (self.name))
arg1 = expr[1]
if arg1 is not None:
arg1 = as_numeric(arg1)
arg2 = expr[2]
if arg2 is not None:
arg2 = as_numeric(arg2)
if arg2._potentially_variable():
raise ValueError(
"Constraint '%s' found a 3-tuple (lower,"
" expression, upper) but the upper "
"value was not data or an expression "
"restricted to storage of data."
% (self.name))
self._lower = arg0
self._body = arg1
self._upper = arg2
else:
raise ValueError(
"Constructor rule for constraint '%s' returned "
"a tuple of length %d. Expecting a tuple of "
"length 2 or 3:\n"
"Equality: (left, right)\n"
"Inequality: (lower, expression, upper)"
% (self.name, len(expr)))
relational_expr = False
else:
try:
relational_expr = expr.is_relational()
if not relational_expr:
raise ValueError(
"Constraint '%s' does not have a proper "
"value. Found '%s'\nExpecting a tuple or "
"equation. Examples:"
"\n summation(model.costs) == model.income"
"\n (0, model.price[item], 50)"
% (self.name, str(expr)))
except AttributeError:
msg = ("Constraint '%s' does not have a proper "
"value. Found '%s'\nExpecting a tuple or "
"equation. Examples:"
"\n summation(model.costs) == model.income"
"\n (0, model.price[item], 50)"
% (self.name, str(expr)))
if type(expr) is bool:
msg += ("\nNote: constant Boolean expressions "
"are not valid constraint expressions. "
"Some apparently non-constant compound "
"inequalities (e.g. 'expr >= 0 <= 1') "
"can return boolean values; the proper "
"form for compound inequalities is "
"always 'lb <= expr <= ub'.")
raise ValueError(msg)
#
# Special check for chainedInequality errors like "if var <
# 1:" within rules. Catching them here allows us to provide
# the user with better (and more immediate) debugging
# information. We don't want to check earlier because we
# want to provide a specific debugging message if the
# construction rule returned True/False; for example, if the
# user did ( var < 1 > 0 ) (which also results in a non-None
# chainedInequality value)
#
if EXPR.generate_relational_expression.chainedInequality is not None:
raise TypeError(EXPR.chainedInequalityErrorMessage())
#
# Process relational expressions
# (i.e. explicit '==', '<', and '<=')
#
if relational_expr:
if _expr_type is EXPR._EqualityExpression:
# Equality expression: only 2 arguments!
self._equality = True
_args = expr._args
# Explicitly dereference the original arglist (otherwise
# this runs afoul of the getrefcount logic)
expr._args = []
if not _args[1]._potentially_variable():
self._lower = self._upper = _args[1]
self._body = _args[0]
elif not _args[0]._potentially_variable():
self._lower = self._upper = _args[0]
self._body = _args[1]
else:
self._lower = self._upper = ZeroConstant
self._body = EXPR.generate_expression_bypassCloneCheck(
_sub, _args[0], _args[1] )
else:
# Inequality expression: 2 or 3 arguments
if expr._strict:
try:
_strict = any(expr._strict)
except:
_strict = True
if _strict:
#
# We can relax this when:
# (a) we have a need for this
# (b) we have problem writer that
# explicitly handles this
# (c) we make sure that all problem writers
# that don't handle this make it known
# to the user through an error or
# warning
#
raise ValueError(
"Constraint '%s' encountered a strict "
"inequality expression ('>' or '<'). All"
" constraints must be formulated using "
"using '<=', '>=', or '=='."
% (self.name))
_args = expr._args
# Explicitly dereference the original arglist (otherwise
# this runs afoul of the getrefcount logic)
expr._args = []
if len(_args) == 3:
if _args[0]._potentially_variable():
raise ValueError(
"Constraint '%s' found a double-sided "
"inequality expression (lower <= "
"expression <= upper) but the lower "
"bound was not data or an expression "
"restricted to storage of data."
% (self.name))
if _args[2]._potentially_variable():
raise ValueError(
"Constraint '%s' found a double-sided "\
"inequality expression (lower <= "
"expression <= upper) but the upper "
"bound was not data or an expression "
"restricted to storage of data."
% (self.name))
self._lower = _args[0]
self._body = _args[1]
self._upper = _args[2]
else:
if not _args[1]._potentially_variable():
self._lower = None
self._body = _args[0]
self._upper = _args[1]
elif not _args[0]._potentially_variable():
self._lower = _args[0]
self._body = _args[1]
self._upper = None
else:
self._lower = None
self._body = EXPR.generate_expression_bypassCloneCheck(
_sub, _args[0], _args[1])
self._upper = ZeroConstant
#
# Replace numeric bound values with a NumericConstant object,
# and reset the values to 'None' if they are 'infinite'
#
if (self._lower is not None) and is_constant(self._lower):
val = self._lower()
if not pyutilib.math.is_finite(val):
if val > 0:
raise ValueError(
"Constraint '%s' created with a +Inf lower "
"bound." % (self.name))
self._lower = None
elif bool(val > 0) == bool(val <= 0):
raise ValueError(
"Constraint '%s' created with a non-numeric "
"lower bound." % (self.name))
if (self._upper is not None) and is_constant(self._upper):
val = self._upper()
if not pyutilib.math.is_finite(val):
if val < 0:
raise ValueError(
"Constraint '%s' created with a -Inf upper "
"bound." % (self.name))
self._upper = None
elif bool(val > 0) == bool(val <= 0):
raise ValueError(
"Constraint '%s' created with a non-numeric "
"upper bound." % (self.name))
#
# Error check, to ensure that we don't have a constraint that
# doesn't depend on any variables / parameters.
#
# Error check, to ensure that we don't have an equality
# constraint with 'infinite' RHS
#
if self._equality:
if self._lower is None:
raise ValueError(
"Equality constraint '%s' defined with "
"non-finite term." % (self.name))
assert self._lower is self._upper
def _write_equations_section(self, model, output_file, all_blocks_list,
active_components_data_var, symbol_map,
labeler, create_symbol_func,
create_symbols_func, alias_symbol_func,
object_symbol_dictionary,
output_fixed_variable_bounds,
skip_trivial_constraints, sorter):
referenced_variable_ids = set()
def _skip_trivial(constraint_data):
if skip_trivial_constraints:
if constraint_data._linear_canonical_form:
repn = constraint_data.canonical_form()
if (repn.variables is None) or \
(len(repn.variables) == 0):
return True
elif isinstance(constraint_data, LinearCanonicalRepn):
repn = constraint_data
if (repn.variables is None) or \
(len(repn.variables) == 0):
return True
else:
if constraint_data.body.polynomial_degree() == 0:
return True
return False
#
# Check for active suffixes to export
#
if isinstance(model, IBlockStorage):
suffix_gen = lambda b: pyomo.core.kernel.component_suffix.\
export_suffix_generator(b,
active=True,
return_key=True,
descend_into=False)
else:
suffix_gen = lambda b: pyomo.core.base.suffix.\
active_export_suffix_generator(b)
r_o_eqns = []
c_eqns = []
l_eqns = []
branching_priorities_suffixes = []
for block in all_blocks_list:
for name, suffix in suffix_gen(block):
if name == 'branching_priorities':
branching_priorities_suffixes.append(suffix)
elif name == 'constraint_types':
for constraint_data, constraint_type in iteritems(suffix):
if not _skip_trivial(constraint_data):
if constraint_type.lower() == 'relaxationonly':
r_o_eqns.append(constraint_data)
elif constraint_type.lower() == 'convex':
c_eqns.append(constraint_data)
elif constraint_type.lower() == 'local':
l_eqns.append(constraint_data)
else:
raise ValueError(
"A suffix '%s' contained an invalid value: %s\n"
"Choices are: [relaxationonly, convex, local]"
% (suffix.name, constraint_type))
else:
raise ValueError(
"The BARON writer can not export suffix with name '%s'. "
"Either remove it from block '%s' or deactivate it." %
(block.name, name))
non_standard_eqns = r_o_eqns + c_eqns + l_eqns
# GAH 1/5/15: Substituting all non-alphanumeric characters for underscore
# in labeler so this manual update should no longer be needed
#
# If the text labeler is used, correct the labels to be
# baron-allowed variable names
# Change '(' and ')' to '__'
# This way, for simple variable names like 'x(1_2)' --> 'x__1_2__'
# FIXME: 7/21/14 This may break if users give variable names
# with two or more underscores together
#if symbolic_solver_labels:
# for key,label in iteritems(object_symbol_dictionary):
# label = label.replace('(','___')
# object_symbol_dictionary[key] = label.replace(')','__')
#
# EQUATIONS
#
#Equation Declaration
n_roeqns = len(r_o_eqns)
n_ceqns = len(c_eqns)
n_leqns = len(l_eqns)
eqns = []
# Alias the constraints by declaration order since Baron does not
# include the constraint names in the solution file. It is important
# that this alias not clash with any real constraint labels, hence
# the use of the ".c<integer>" template. It is not possible to declare
# a component having this type of name when using standard syntax.
# There are ways to do it, but it is unlikely someone will.
order_counter = 0
alias_template = ".c%d"
output_file.write('EQUATIONS ')
output_file.write("c_e_FIX_ONE_VAR_CONST__")
order_counter += 1
for block in all_blocks_list:
for constraint_data in block.component_data_objects(
Constraint, active=True, sort=sorter, descend_into=False):
if (not constraint_data.has_lb()) and \
(not constraint_data.has_ub()):
assert not constraint_data.equality
continue # non-binding, so skip
if (not _skip_trivial(constraint_data)) and \
(constraint_data not in non_standard_eqns):
eqns.append(constraint_data)
con_symbol = \
create_symbol_func(symbol_map, constraint_data, labeler)
assert not con_symbol.startswith('.')
assert con_symbol != "c_e_FIX_ONE_VAR_CONST__"
alias_symbol_func(symbol_map, constraint_data,
alias_template % order_counter)
output_file.write(", " + str(con_symbol))
order_counter += 1
output_file.write(";\n\n")
if n_roeqns > 0:
output_file.write('RELAXATION_ONLY_EQUATIONS ')
for i, constraint_data in enumerate(r_o_eqns):
con_symbol = create_symbol_func(symbol_map, constraint_data,
labeler)
assert not con_symbol.startswith('.')
assert con_symbol != "c_e_FIX_ONE_VAR_CONST__"
alias_symbol_func(symbol_map, constraint_data,
alias_template % order_counter)
if i == n_roeqns - 1:
output_file.write(str(con_symbol) + ';\n\n')
else:
output_file.write(str(con_symbol) + ', ')
order_counter += 1
if n_ceqns > 0:
output_file.write('CONVEX_EQUATIONS ')
for i, constraint_data in enumerate(c_eqns):
con_symbol = create_symbol_func(symbol_map, constraint_data,
labeler)
assert not con_symbol.startswith('.')
assert con_symbol != "c_e_FIX_ONE_VAR_CONST__"
alias_symbol_func(symbol_map, constraint_data,
alias_template % order_counter)
if i == n_ceqns - 1:
output_file.write(str(con_symbol) + ';\n\n')
else:
output_file.write(str(con_symbol) + ', ')
order_counter += 1
if n_leqns > 0:
output_file.write('LOCAL_EQUATIONS ')
for i, constraint_data in enumerate(l_eqns):
con_symbol = create_symbol_func(symbol_map, constraint_data,
labeler)
assert not con_symbol.startswith('.')
assert con_symbol != "c_e_FIX_ONE_VAR_CONST__"
alias_symbol_func(symbol_map, constraint_data,
alias_template % order_counter)
if i == n_leqns - 1:
output_file.write(str(con_symbol) + ';\n\n')
else:
output_file.write(str(con_symbol) + ', ')
order_counter += 1
# Create a dictionary of baron variable names to match to the
# strings that constraint.to_string() prints. An important
# note is that the variable strings are padded by spaces so
# that whole variable names are recognized, and simple
# variable names are not identified inside longer names.
# Example: ' x[1] ' -> ' x3 '
#FIXME: 7/18/14 CLH: This may cause mistakes if spaces in
# variable names are allowed
if isinstance(model, IBlockStorage):
mutable_param_gen = lambda b: \
b.components(ctype=Param,
descend_into=False)
else:
def mutable_param_gen(b):
for param in block.component_objects(Param):
if param._mutable and param.is_indexed():
param_data_iter = \
(param_data for index, param_data
in iteritems(param))
elif not param.is_indexed():
param_data_iter = iter([param])
else:
param_data_iter = iter([])
for param_data in param_data_iter:
yield param_data
vstring_to_var_dict = {}
vstring_to_bar_dict = {}
pstring_to_bar_dict = {}
_val_template = ' %' + self._precision_string + ' '
for block in all_blocks_list:
for var_data in active_components_data_var[id(block)]:
variable_stream = StringIO()
var_data.to_string(ostream=variable_stream, verbose=False)
variable_string = variable_stream.getvalue()
variable_string = ' ' + variable_string + ' '
vstring_to_var_dict[variable_string] = var_data
if output_fixed_variable_bounds or (not var_data.fixed):
vstring_to_bar_dict[variable_string] = \
' '+object_symbol_dictionary[id(var_data)]+' '
else:
assert var_data.value is not None
vstring_to_bar_dict[variable_string] = \
(_val_template % (var_data.value,))
for param_data in mutable_param_gen(block):
param_stream = StringIO()
param_data.to_string(ostream=param_stream, verbose=False)
param_string = param_stream.getvalue()
param_string = ' ' + param_string + ' '
pstring_to_bar_dict[param_string] = \
(_val_template % (param_data(),))
# Equation Definition
string_template = '%' + self._precision_string
output_file.write('c_e_FIX_ONE_VAR_CONST__: ONE_VAR_CONST__ == 1;\n')
for constraint_data in itertools.chain(eqns, r_o_eqns, c_eqns, l_eqns):
#########################
#CLH: The section below is kind of a hack-y way to use
# the expr.to_string function to print
# expressions. A stream is created, writen to, and
# then the string is recovered and stored in
# eqn_body. Then the variable names are converted
# to match the variable names that are used in the
# bar file.
# Fill in the body of the equation
body_string_buffer = StringIO()
if constraint_data.body is None:
continue
as_numeric(constraint_data.body).to_string(
ostream=body_string_buffer, verbose=False)
eqn_body = body_string_buffer.getvalue()
# First, pad the equation so that if there is a
# variable name at the start or end of the equation,
# it can still be identified as padded with spaces.
# Second, change pyomo's ** to baron's ^, also with
# padding so that variable can always be found with
# space around them
# Third, add more padding around multiplication. Pyomo
# already has spaces between variable on variable
# multiplication, but not for constants on variables
eqn_body = ' ' + eqn_body + ' '
eqn_body = eqn_body.replace('**', ' ^ ')
eqn_body = eqn_body.replace('*', ' * ')
#
# FIXME: The following block of code is extremely inefficient.
# We are looping through every parameter and variable in
# the model each time we write a constraint expression.
#
################################################
vnames = [(variable_string, bar_string) for variable_string,
bar_string in iteritems(vstring_to_bar_dict)
if variable_string in eqn_body]
for variable_string, bar_string in vnames:
var_data = vstring_to_var_dict[variable_string]
if output_fixed_variable_bounds or (not var_data.fixed):
referenced_variable_ids.add(id(var_data))
eqn_body = eqn_body.replace(variable_string, bar_string)
for param_string, bar_string in iteritems(pstring_to_bar_dict):
eqn_body = eqn_body.replace(param_string, bar_string)
################################################
if len(vnames) == 0:
assert not skip_trivial_constraints
eqn_body += "+ 0 * ONE_VAR_CONST__ "
# 7/29/14 CLH:
#FIXME: Baron doesn't handle many of the
# intrinsic_functions available in pyomo. The
# error message given by baron is also very
# weak. Either a function here to re-write
# unallowed expressions or a way to track solver
# capability by intrinsic_expression would be
# useful.
##########################
con_symbol = object_symbol_dictionary[id(constraint_data)]
output_file.write(str(con_symbol) + ': ')
# Fill in the left and right hand side (constants) of
# the equations
# Equality constraint
if constraint_data.equality:
eqn_lhs = ''
eqn_rhs = ' == ' + \
str(string_template
% self._get_bound(constraint_data.upper))
# Greater than constraint
elif not constraint_data.has_ub():
eqn_rhs = ' >= ' + \
str(string_template
% self._get_bound(constraint_data.lower))
eqn_lhs = ''
# Less than constraint
elif not constraint_data.has_lb():
eqn_rhs = ' <= ' + \
str(string_template
% self._get_bound(constraint_data.upper))
eqn_lhs = ''
# Double-sided constraint
elif constraint_data.has_lb() and \
constraint_data.has_ub():
eqn_lhs = str(string_template
% self._get_bound(constraint_data.lower)) + \
' <= '
eqn_rhs = ' <= ' + \
str(string_template
% self._get_bound(constraint_data.upper))
eqn_string = eqn_lhs + eqn_body + eqn_rhs + ';\n'
output_file.write(eqn_string)
#
# OBJECTIVE
#
output_file.write("\nOBJ: ")
n_objs = 0
for block in all_blocks_list:
for objective_data in block.component_data_objects(
Objective, active=True, sort=sorter, descend_into=False):
n_objs += 1
if n_objs > 1:
raise ValueError(
"The BARON writer has detected multiple active "
"objective functions on model %s, but "
"currently only handles a single objective." %
(model.name))
# create symbol
create_symbol_func(symbol_map, objective_data, labeler)
alias_symbol_func(symbol_map, objective_data,
"__default_objective__")
if objective_data.is_minimizing():
output_file.write("minimize ")
else:
output_file.write("maximize ")
#FIXME 7/18/14 See above, constraint writing
# section. Will cause problems if there
# are spaces in variables
# Similar to the constraints section above, the
# objective is generated from the expr.to_string
# function.
obj_stream = StringIO()
objective_data.expr.to_string(ostream=obj_stream,
verbose=False)
obj_string = ' ' + obj_stream.getvalue() + ' '
obj_string = obj_string.replace('**', ' ^ ')
obj_string = obj_string.replace('*', ' * ')
#
# FIXME: The following block of code is extremely inefficient.
# We are looping through every parameter and variable in
# the model each time we write an expression.
#
################################################
vnames = [(variable_string, bar_string) for variable_string,
bar_string in iteritems(vstring_to_bar_dict)
if variable_string in obj_string]
for variable_string, bar_string in vnames:
var_data = var_data = vstring_to_var_dict[variable_string]
if output_fixed_variable_bounds or (not var_data.fixed):
referenced_variable_ids.add(id(var_data))
obj_string = obj_string.replace(variable_string,
bar_string)
for param_string, bar_string in iteritems(pstring_to_bar_dict):
obj_string = obj_string.replace(param_string, bar_string)
################################################
output_file.write(obj_string + ";\n\n")
return referenced_variable_ids, branching_priorities_suffixes
def _convert_external_setup_without_cleanup(
worker,
scenario,
output_directory,
firststage_var_suffix,
enforce_derived_nonanticipativity,
io_options):
import pyomo.environ
assert os.path.exists(output_directory)
io_options = dict(io_options)
scenario_tree = worker.scenario_tree
reference_model = scenario._instance
rootnode = scenario_tree.findRootNode()
firststage = scenario_tree.stages[0]
secondstage = scenario_tree.stages[1]
constraint_name_buffer = {}
objective_name_buffer = {}
variable_name_buffer = {}
all_constraints = list(
con for con in reference_model.component_data_objects(
Constraint,
active=True,
descend_into=True))
#
# Check for model annotations
#
stochastic_rhs = locate_annotations(
reference_model,
StochasticConstraintBoundsAnnotation,
max_allowed=1)
if len(stochastic_rhs) == 0:
stochastic_rhs = None
stochastic_rhs_entries = {}
empty_rhs_annotation = False
else:
assert len(stochastic_rhs) == 1
stochastic_rhs = stochastic_rhs[0][1]
if stochastic_rhs.has_declarations:
empty_rhs_annotation = False
stochastic_rhs_entries = stochastic_rhs.expand_entries()
stochastic_rhs_entries.sort(
key=lambda x: x[0].getname(True, constraint_name_buffer))
if len(stochastic_rhs_entries) == 0:
raise RuntimeError(
"The %s annotation was declared "
"with external entries but no active Constraint "
"objects were recovered from those entries."
% (StochasticConstraintBoundsAnnotation.__name__))
else:
empty_rhs_annotation = True
stochastic_rhs_entries = tuple((con, stochastic_rhs.default)
for con in all_constraints)
stochastic_matrix = locate_annotations(
reference_model,
StochasticConstraintBodyAnnotation,
max_allowed=1)
if len(stochastic_matrix) == 0:
stochastic_matrix = None
stochastic_matrix_entries = {}
empty_matrix_annotation = False
else:
assert len(stochastic_matrix) == 1
stochastic_matrix = stochastic_matrix[0][1]
if stochastic_matrix.has_declarations:
empty_matrix_annotation = False
stochastic_matrix_entries = stochastic_matrix.expand_entries()
stochastic_matrix_entries.sort(
key=lambda x: x[0].getname(True, constraint_name_buffer))
if len(stochastic_matrix_entries) == 0:
raise RuntimeError(
"The %s annotation was declared "
"with external entries but no active Constraint "
"objects were recovered from those entries."
% (StochasticConstraintBoundsAnnotation.__name__))
else:
empty_matrix_annotation = True
stochastic_matrix_entries = tuple((con,stochastic_matrix.default)
for con in all_constraints)
stochastic_constraint_ids = set()
stochastic_constraint_ids.update(id(con) for con,_
in stochastic_rhs_entries)
stochastic_constraint_ids.update(id(con) for con,_
in stochastic_matrix_entries)
stochastic_objective = locate_annotations(
reference_model,
StochasticObjectiveAnnotation,
max_allowed=1)
if len(stochastic_objective) == 0:
stochastic_objective = None
else:
assert len(stochastic_objective) == 1
stochastic_objective = stochastic_objective[0][1]
stochastic_varbounds = locate_annotations(
reference_model,
StochasticVariableBoundsAnnotation)
if len(stochastic_varbounds) > 0:
raise ValueError(
"The DDSIP writer does not currently support "
"stochastic variable bounds. Invalid annotation type: %s"
% (StochasticVariableBoundsAnnotation.__name__))
if (stochastic_rhs is None) and \
(stochastic_matrix is None) and \
(stochastic_objective is None):
raise RuntimeError(
"No stochastic annotations found. DDSIP "
"conversion requires at least one of the following "
"annotation types:\n - %s\n - %s\n - %s"
% (StochasticConstraintBoundsAnnotation.__name__,
StochasticConstraintBodyAnnotation.__name__,
StochasticObjectiveAnnotation.__name__))
assert not hasattr(reference_model, "_repn")
repn_cache = build_repns(reference_model)
assert hasattr(reference_model, "_repn")
assert not reference_model._gen_obj_repn
assert not reference_model._gen_con_repn
# compute values
for block_repns in repn_cache.values():
for repn in block_repns.values():
repn.constant = value(repn.constant)
repn.linear_coefs = [value(c) for c in repn.linear_coefs]
repn.quadratic_coefs = [value(c) for c in repn.quadratic_coefs]
#
# Write the LP file once to obtain the symbol map
#
output_filename = os.path.join(output_directory,
scenario.name+".lp.setup")
with WriterFactory("lp") as writer:
assert 'column_order' not in io_options
assert 'row_order' not in io_options
output_fname, symbol_map = writer(reference_model,
output_filename,
lambda x: True,
io_options)
assert output_fname == output_filename
_safe_remove_file(output_filename)
StageToVariableMap = map_variable_stages(
scenario,
scenario_tree,
symbol_map,
enforce_derived_nonanticipativity=enforce_derived_nonanticipativity)
firststage_variable_ids = \
set(id(var) for symbol, var, scenario_tree_id
in StageToVariableMap[firststage.name])
secondstage_variable_ids = \
set(id(var) for symbol, var, scenario_tree_id
in StageToVariableMap[secondstage.name])
StageToConstraintMap = \
map_constraint_stages(
scenario,
scenario_tree,
symbol_map,
stochastic_constraint_ids,
firststage_variable_ids,
secondstage_variable_ids)
secondstage_constraint_ids = \
set(id(con) for symbols, con
in StageToConstraintMap[secondstage.name])
assert len(scenario_tree.stages) == 2
firststage = scenario_tree.stages[0]
secondstage = scenario_tree.stages[1]
#
# Make sure the objective references all first stage variables.
# We do this by directly modifying the _repn of the
# objective which the LP/MPS writer will reference next time we call
# it. In addition, make sure that the first second-stage variable
# in our column ordering also appears in the objective so that
# ONE_VAR_CONSTANT does not get identified as the first
# second-stage variable.
# ** Just do NOT preprocess again until we call the writer **
#
objective_object = scenario._instance_objective
assert objective_object is not None
objective_block = objective_object.parent_block()
objective_repn = repn_cache[id(objective_block)][objective_object]
#
# Create column (variable) ordering maps for LP/MPS files
#
column_order = ComponentMap()
firststage_variable_count = 0
secondstage_variable_count = 0
# first-stage variables
for column_index, (symbol, var, scenario_tree_id) \
in enumerate(StageToVariableMap[firststage.name]):
column_order[var] = column_index
firststage_variable_count += 1
# second-stage variables
for column_index, (symbol, var, scenario_tree_id) \
in enumerate(StageToVariableMap[secondstage.name],
len(column_order)):
column_order[var] = column_index
secondstage_variable_count += 1
# account for the ONE_VAR_CONSTANT second-stage variable
# added by the LP writer
secondstage_variable_count += 1
#
# Create row (constraint) ordering maps for LP/MPS files
#
firststage_constraint_count = 0
secondstage_constraint_count = 0
row_order = ComponentMap()
# first-stage constraints
for row_index, (symbols, con) \
in enumerate(StageToConstraintMap[firststage.name]):
row_order[con] = row_index
firststage_constraint_count += len(symbols)
# second-stage constraints
for row_index, (symbols, con) \
in enumerate(StageToConstraintMap[secondstage.name],
len(row_order)):
row_order[con] = row_index
secondstage_constraint_count += len(symbols)
# account for the ONE_VAR_CONSTANT = 1 second-stage constraint
# added by the LP writer
secondstage_constraint_count += 1
#
# Create a custom labeler that allows DDSIP to identify
# first-stage variables
#
if io_options.pop('symbolic_solver_labels', False):
_labeler = TextLabeler()
else:
_labeler = NumericLabeler('x')
labeler = lambda x: _labeler(x) + \
(""
if ((not isinstance(x, _VarData)) or \
(id(x) not in firststage_variable_ids)) else \
firststage_var_suffix)
#
# Write the ordered LP/MPS file
#
output_filename = os.path.join(output_directory,
scenario.name+".lp")
symbols_filename = os.path.join(output_directory,
scenario.name+".lp.symbols")
with WriterFactory("lp") as writer:
assert 'column_order' not in io_options
assert 'row_order' not in io_options
assert 'labeler' not in io_options
assert 'force_objective_constant' not in io_options
io_options['column_order'] = column_order
io_options['row_order'] = row_order
io_options['force_objective_constant'] = True
io_options['labeler'] = labeler
output_fname, symbol_map = writer(reference_model,
output_filename,
lambda x: True,
io_options)
assert output_fname == output_filename
# write the lp file symbol paired with the scenario
# tree id for each variable in the root node
with open(symbols_filename, "w") as f:
st_symbol_map = reference_model._ScenarioTreeSymbolMap
lines = []
for id_ in sorted(rootnode._variable_ids):
var = st_symbol_map.bySymbol[id_]
if not var.is_expression_type():
lp_label = symbol_map.byObject[id(var)]
lines.append("%s %s\n" % (lp_label, id_))
f.writelines(lines)
# re-generate these maps as the LP/MPS symbol map
# is likely different
StageToVariableMap = map_variable_stages(
scenario,
scenario_tree,
symbol_map,
enforce_derived_nonanticipativity=enforce_derived_nonanticipativity)
StageToConstraintMap = map_constraint_stages(
scenario,
scenario_tree,
symbol_map,
stochastic_constraint_ids,
firststage_variable_ids,
secondstage_variable_ids)
# generate a few data structures that are used
# when writing the .sc files
constraint_symbols = ComponentMap(
(con, symbols) for stage_name in StageToConstraintMap
for symbols, con in StageToConstraintMap[stage_name])
#
# Write the body of the .sc files
#
modified_constraint_lb = ComponentMap()
modified_constraint_ub = ComponentMap()
#
# Stochastic RHS
#
# **NOTE: In the code that follows we assume the LP
# writer always moves constraint body
# constants to the rhs and that the lower part
# of any range constraints are written before
# the upper part.
#
stochastic_rhs_count = 0
with open(os.path.join(output_directory,
scenario.name+".rhs.sc.struct"),'w') as f_rhs_struct:
with open(os.path.join(output_directory,
scenario.name+".rhs.sc"),'w') as f_rhs:
scenario_probability = scenario.probability
rhs_struct_template = " %s\n"
rhs_template = " %.17g\n"
f_rhs.write("scen\n%.17g\n"
% (_no_negative_zero(scenario_probability)))
if stochastic_rhs is not None:
for con, include_bound in stochastic_rhs_entries:
assert isinstance(con, _ConstraintData)
if not empty_rhs_annotation:
# verify that this constraint was
# flagged by PySP or the user as second-stage
if id(con) not in secondstage_constraint_ids:
raise RuntimeError(
"The constraint %s has been declared "
"in the %s annotation but it was not identified as "
"a second-stage constraint. To correct this issue, "
"remove the constraint from this annotation."
% (con.name,
StochasticConstraintBoundsAnnotation.__name__))
constraint_repn = \
repn_cache[id(con.parent_block())][con]
if not constraint_repn.is_linear():
raise RuntimeError("Only linear constraints are "
"accepted for conversion to DDSIP format. "
"Constraint %s is not linear."
% (con.name))
body_constant = constraint_repn.constant
# We are going to rewrite the core problem file
# with all stochastic values set to zero. This will
# allow an easy test for missing user annotations.
constraint_repn.constant = 0
if body_constant is None:
body_constant = 0.0
symbols = constraint_symbols[con]
assert len(symbols) > 0
for con_label in symbols:
if con_label.startswith('c_e_') or \
con_label.startswith('c_l_'):
assert (include_bound is True) or \
(include_bound[0] is True)
stochastic_rhs_count += 1
f_rhs_struct.write(rhs_struct_template % (con_label))
f_rhs.write(rhs_template %
(_no_negative_zero(
value(con.lower) - \
value(body_constant))))
# We are going to rewrite the core problem file
# with all stochastic values set to zero. This will
# allow an easy test for missing user annotations.
modified_constraint_lb[con] = con.lower
con._lower = _deterministic_check_constant
if con_label.startswith('c_e_'):
modified_constraint_ub[con] = con.upper
con._upper = _deterministic_check_constant
elif con_label.startswith('r_l_') :
if (include_bound is True) or \
(include_bound[0] is True):
stochastic_rhs_count += 1
f_rhs_struct.write(rhs_struct_template % (con_label))
f_rhs.write(rhs_template %
(_no_negative_zero(
value(con.lower) - \
value(body_constant))))
# We are going to rewrite the core problem file
# with all stochastic values set to zero. This will
# allow an easy test for missing user annotations.
modified_constraint_lb[con] = con.lower
con._lower = _deterministic_check_constant
elif con_label.startswith('c_u_'):
assert (include_bound is True) or \
(include_bound[1] is True)
stochastic_rhs_count += 1
f_rhs_struct.write(rhs_struct_template % (con_label))
f_rhs.write(rhs_template %
(_no_negative_zero(
value(con.upper) - \
value(body_constant))))
# We are going to rewrite the core problem file
# with all stochastic values set to zero. This will
# allow an easy test for missing user annotations.
modified_constraint_ub[con] = con.upper
con._upper = _deterministic_check_constant
elif con_label.startswith('r_u_'):
if (include_bound is True) or \
(include_bound[1] is True):
stochastic_rhs_count += 1
f_rhs_struct.write(rhs_struct_template % (con_label))
f_rhs.write(rhs_template %
(_no_negative_zero(
value(con.upper) - \
value(body_constant))))
# We are going to rewrite the core problem file
# with all stochastic values set to zero. This will
# allow an easy test for missing user annotations.
modified_constraint_ub[con] = con.upper
con._upper = _deterministic_check_constant
else:
assert False
#
# Stochastic Matrix
#
stochastic_matrix_count = 0
with open(os.path.join(output_directory,
scenario.name+".matrix.sc.struct"),'w') as f_mat_struct:
with open(os.path.join(output_directory,
scenario.name+".matrix.sc"),'w') as f_mat:
scenario_probability = scenario.probability
matrix_struct_template = " %s %s\n"
matrix_template = " %.17g\n"
f_mat.write("scen\n")
if stochastic_matrix is not None:
for con, var_list in stochastic_matrix_entries:
assert isinstance(con, _ConstraintData)
if not empty_matrix_annotation:
# verify that this constraint was
# flagged by PySP or the user as second-stage
if id(con) not in secondstage_constraint_ids:
raise RuntimeError(
"The constraint %s has been declared "
"in the %s annotation but it was not identified as "
"a second-stage constraint. To correct this issue, "
"remove the constraint from this annotation."
% (con.name,
StochasticConstraintBodyAnnotation.__name__))
constraint_repn = \
repn_cache[id(con.parent_block())][con]
if not constraint_repn.is_linear():
raise RuntimeError("Only linear constraints are "
"accepted for conversion to DDSIP format. "
"Constraint %s is not linear."
% (con.name))
assert len(constraint_repn.linear_vars) > 0
if var_list is None:
var_list = constraint_repn.linear_vars
assert len(var_list) > 0
symbols = constraint_symbols[con]
# sort the variable list by the column ordering
# so that we have deterministic output
var_list = list(var_list)
var_list.sort(key=lambda _v: column_order[_v])
new_coefs = list(constraint_repn.linear_coefs)
for var in var_list:
assert isinstance(var, _VarData)
assert not var.fixed
var_coef = None
for i, (_var, coef) in enumerate(zip(constraint_repn.linear_vars,
constraint_repn.linear_coefs)):
if _var is var:
var_coef = coef
# We are going to rewrite with core problem file
# with all stochastic values set to zero. This will
# allow an easy test for missing user annotations.
new_coefs[i] = _deterministic_check_value
break
if var_coef is None:
raise RuntimeError(
"The coefficient for variable %s has "
"been marked as stochastic in constraint %s using "
"the %s annotation, but the variable does not appear"
" in the canonical constraint expression."
% (var.name,
con.name,
StochasticConstraintBodyAnnotation.__name__))
var_label = symbol_map.byObject[id(var)]
for con_label in symbols:
stochastic_matrix_count += 1
f_mat_struct.write(matrix_struct_template
% (con_label, var_label))
f_mat.write(matrix_template
% (_no_negative_zero(value(var_coef))))
constraint_repn.linear_coefs = tuple(new_coefs)
#
# Stochastic Objective
#
stochastic_cost_count = 0
with open(os.path.join(output_directory,
scenario.name+".cost.sc.struct"),'w') as f_obj_struct:
with open(os.path.join(output_directory,
scenario.name+".cost.sc"),'w') as f_obj:
obj_struct_template = " %s\n"
obj_template = " %.17g\n"
f_obj.write("scen\n")
if stochastic_objective is not None:
if stochastic_objective.has_declarations:
sorted_values = stochastic_objective.expand_entries()
assert len(sorted_values) <= 1
if len(sorted_values) == 0:
raise RuntimeError(
"The %s annotation was declared "
"with external entries but no active Objective "
"objects were recovered from those entries."
% (StochasticObjectiveAnnotation.__name__))
obj, (objective_variables, include_constant) = \
sorted_values[0]
assert obj is objective_object
else:
objective_variables, include_constant = \
stochastic_objective.default
if not objective_repn.is_linear():
raise RuntimeError("Only linear stochastic objectives are "
"accepted for conversion to DDSIP format. "
"Objective %s is not linear."
% (objective_object.name))
if objective_variables is None:
objective_variables = objective_repn.linear_vars
stochastic_objective_label = symbol_map.byObject[id(objective_object)]
# sort the variable list by the column ordering
# so that we have deterministic output
objective_variables = list(objective_variables)
objective_variables.sort(key=lambda _v: column_order[_v])
assert (len(objective_variables) > 0) or include_constant
new_coefs = list(objective_repn.linear_coefs)
for var in objective_variables:
assert isinstance(var, _VarData)
var_coef = None
for i, (_var, coef) in enumerate(zip(objective_repn.linear_vars,
objective_repn.linear_coefs)):
if _var is var:
var_coef = coef
# We are going to rewrite the core problem file
# with all stochastic values set to zero. This will
# allow an easy test for missing user annotations.
new_coefs[i] = _deterministic_check_value
break
if var_coef is None:
raise RuntimeError(
"The coefficient for variable %s has "
"been marked as stochastic in objective %s using "
"the %s annotation, but the variable does not appear"
" in the canonical objective expression."
% (var.name,
objective_object.name,
StochasticObjectiveAnnotation.__name__))
var_label = symbol_map.byObject[id(var)]
stochastic_cost_count += 1
f_obj_struct.write(obj_struct_template % (var_label))
f_obj.write(obj_template
% (_no_negative_zero(value(var_coef))))
objective_repn.linear_coefs = tuple(new_coefs)
if include_constant:
obj_constant = objective_repn.constant
# We are going to rewrite the core problem file
# with all stochastic values set to zero. This will
# allow an easy test for missing user annotations.
objective_repn.constant = _deterministic_check_value
if obj_constant is None:
obj_constant = 0.0
stochastic_cost_count += 1
f_obj_struct.write(obj_struct_template % ("ONE_VAR_CONSTANT"))
f_obj.write(obj_template % (_no_negative_zero(obj_constant)))
#
# Write the deterministic part of the LP/MPS-file to its own
# file for debugging purposes
#
reference_model_name = reference_model.name
reference_model._name = "ZeroStochasticData"
det_output_filename = os.path.join(output_directory,
scenario.name+".lp.det")
with WriterFactory("lp") as writer:
output_fname, symbol_map = writer(reference_model,
det_output_filename,
lambda x: True,
io_options)
assert output_fname == det_output_filename
reference_model._name = reference_model_name
# reset bounds on any constraints that were modified
for con, lower in iteritems(modified_constraint_lb):
con._lower = as_numeric(lower)
for con, upper in iteritems(modified_constraint_ub):
con._upper = as_numeric(upper)
return (firststage_variable_count,
secondstage_variable_count,
firststage_constraint_count,
secondstage_constraint_count,
stochastic_cost_count,
stochastic_rhs_count,
stochastic_matrix_count)