def cbLazy(self, con):
"""
Parameters
----------
con: pyomo.core.base.constraint._GeneralConstraintData
The lazy constraint to add
"""
if not con.active:
raise ValueError('cbLazy expected an active constraint.')
if is_fixed(con.body):
raise ValueError('cbLazy expected a non-trival constraint')
gurobi_expr, referenced_vars = self._get_expr_from_pyomo_expr(con.body, self._max_constraint_degree)
if con.has_lb():
if con.has_ub():
raise ValueError('Range constraints are not supported in cbLazy.')
if not is_fixed(con.lower):
raise ValueError('Lower bound of constraint {0} is not constant.'.format(con))
if con.has_ub():
if not is_fixed(con.upper):
raise ValueError('Upper bound of constraint {0} is not constant.'.format(con))
if con.equality:
self._solver_model.cbLazy(lhs=gurobi_expr, sense=self._gurobipy.GRB.EQUAL,
rhs=value(con.lower))
elif con.has_lb() and (value(con.lower) > -float('inf')):
self._solver_model.cbLazy(lhs=gurobi_expr, sense=self._gurobipy.GRB.GREATER_EQUAL,
rhs=value(con.lower))
elif con.has_ub() and (value(con.upper) < float('inf')):
self._solver_model.cbLazy(lhs=gurobi_expr, sense=self._gurobipy.GRB.LESS_EQUAL,
rhs=value(con.upper))
else:
raise ValueError('Constraint does not have a lower or an upper bound {0} \n'.format(con))
def test_is_fixed(self):
v = variable()
self.assertEqual(v.is_fixed(), False)
self.assertEqual(is_fixed(v), False)
self.assertEqual(v.fixed, False)
self.assertEqual(v.value, None)
v.value = 1.0
self.assertEqual(v.is_fixed(), False)
self.assertEqual(is_fixed(v), False)
self.assertEqual(v.fixed, False)
self.assertEqual(v.value, 1.0)
v.fix()
self.assertEqual(v.is_fixed(), True)
self.assertEqual(is_fixed(v), True)
self.assertEqual(v.fixed, True)
self.assertEqual(v.value, 1.0)
v.value = None
self.assertEqual(v.is_fixed(), True)
self.assertEqual(is_fixed(v), True)
self.assertEqual(v.fixed, True)
self.assertEqual(v.value, None)
v.free()
self.assertEqual(v.is_fixed(), False)
self.assertEqual(is_fixed(v), False)
self.assertEqual(v.fixed, False)
self.assertEqual(v.value, None)
def test_is_fixed(self):
v = variable()
self.assertEqual(v.is_fixed(), False)
self.assertEqual(is_fixed(v), False)
self.assertEqual(v.fixed, False)
self.assertEqual(v.value, None)
v.value = 1.0
self.assertEqual(v.is_fixed(), False)
self.assertEqual(is_fixed(v), False)
self.assertEqual(v.fixed, False)
self.assertEqual(v.value, 1.0)
v.fix()
self.assertEqual(v.is_fixed(), True)
self.assertEqual(is_fixed(v), True)
self.assertEqual(v.fixed, True)
self.assertEqual(v.value, 1.0)
v.value = None
self.assertEqual(v.is_fixed(), True)
self.assertEqual(is_fixed(v), True)
self.assertEqual(v.fixed, True)
self.assertEqual(v.value, None)
v.free()
self.assertEqual(v.is_fixed(), False)
self.assertEqual(is_fixed(v), False)
self.assertEqual(v.fixed, False)
self.assertEqual(v.value, None)
def test_is_fixed(self):
p = parameter()
self.assertEqual(p.is_fixed(), True)
self.assertEqual(is_fixed(p), True)
p.value = 1.0
self.assertEqual(p.is_fixed(), True)
self.assertEqual(is_fixed(p), True)
def test_is_fixed(self):
p = parameter()
self.assertEqual(p.is_fixed(), True)
self.assertEqual(is_fixed(p), True)
p.value = 1.0
self.assertEqual(p.is_fixed(), True)
self.assertEqual(is_fixed(p), True)
def test_is_fixed(self):
f = functional_value()
self.assertEqual(f.is_fixed(), True)
self.assertEqual(is_fixed(f), True)
f.fn = lambda: 2
self.assertEqual(f.is_fixed(), True)
self.assertEqual(is_fixed(f), True)
def test_is_fixed(self):
f = functional_value()
self.assertEqual(f.is_fixed(), True)
self.assertEqual(is_fixed(f), True)
f.fn = lambda: 2
self.assertEqual(f.is_fixed(), True)
self.assertEqual(is_fixed(f), True)
def _add_constraint(self, con):
if not con.active:
return None
if is_fixed(con.body):
if self._skip_trivial_constraints:
return None
conname = self._symbol_map.getSymbol(con, self._labeler)
if con._linear_canonical_form:
xpress_expr, referenced_vars = self._get_expr_from_pyomo_repn(
con.canonical_form(), self._max_constraint_degree)
else:
xpress_expr, referenced_vars = self._get_expr_from_pyomo_expr(
con.body, self._max_constraint_degree)
if con.has_lb():
if not is_fixed(con.lower):
raise ValueError("Lower bound of constraint {0} "
"is not constant.".format(con))
if con.has_ub():
if not is_fixed(con.upper):
raise ValueError("Upper bound of constraint {0} "
"is not constant.".format(con))
if con.equality:
xpress_con = xpress.constraint(body=xpress_expr,
sense=xpress.eq,
rhs=value(con.lower),
name=conname)
elif con.has_lb() and con.has_ub():
xpress_con = xpress.constraint(body=xpress_expr,
sense=xpress.range,
lb=value(con.lower),
ub=value(con.upper),
name=conname)
self._range_constraints.add(xpress_con)
elif con.has_lb():
xpress_con = xpress.constraint(body=xpress_expr,
sense=xpress.geq,
rhs=value(con.lower),
name=conname)
elif con.has_ub():
xpress_con = xpress.constraint(body=xpress_expr,
sense=xpress.leq,
rhs=value(con.upper),
name=conname)
else:
raise ValueError("Constraint does not have a lower "
"or an upper bound: {0} \n".format(con))
self._solver_model.addConstraint(xpress_con)
for var in referenced_vars:
self._referenced_variables[var] += 1
self._vars_referenced_by_con[con] = referenced_vars
self._pyomo_con_to_solver_con_map[con] = xpress_con
self._solver_con_to_pyomo_con_map[xpress_con] = con
def test_is_fixed(self):
v = variable()
e = noclone(v + 1)
self.assertEqual(e.is_fixed(), False)
self.assertEqual(is_fixed(e), False)
v.fix()
self.assertEqual(e.is_fixed(), True)
self.assertEqual(is_fixed(e), True)
e = noclone(parameter())
self.assertEqual(e.is_fixed(), True)
self.assertEqual(is_fixed(e), True)
def test_is_fixed(self):
v = variable()
e = noclone(v + 1)
self.assertEqual(e.is_fixed(), False)
self.assertEqual(is_fixed(e), False)
v.fix()
self.assertEqual(e.is_fixed(), True)
self.assertEqual(is_fixed(e), True)
e = noclone(parameter())
self.assertEqual(e.is_fixed(), True)
self.assertEqual(is_fixed(e), True)
def visiting_potential_leaf(self, node):
if node.__class__ in nonpyomo_leaf_types:
self.bnds_dict[node] = (node, node)
return True, None
if node.is_variable_type():
if node.is_fixed():
lb = value(node.value)
ub = lb
else:
lb = value(node.lb)
ub = value(node.ub)
if lb is None:
lb = -math.inf
if ub is None:
ub = math.inf
self.bnds_dict[node] = (lb, ub)
return True, None
if not node.is_expression_type():
assert is_fixed(node)
val = value(node)
self.bnds_dict[node] = (val, val)
return True, None
return False, None
def _ftoa(val):
if val is None:
return val
if type(val) not in native_numeric_types:
if is_fixed(val):
val = value(val)
else:
raise ValueError("non-fixed bound or weight: " + str(exp))
a = _ftoa_precision_str % val
i = len(a)
while i > 1:
try:
if float(a[:i - 1]) == val:
i -= 1
else:
break
except:
break
if i == len(a):
logger.warning(
"converting %s to string resulted in loss of precision" % val)
#if a.startswith('1.57'):
# raise RuntimeError("wtf %s %s, %s" % ( val, a, i))
return a[:i]
def test_is_fixed(self):
e = self._ctype_factory()
self.assertEqual(e.is_fixed(), True)
self.assertEqual(is_fixed(e), True)
e.expr = 1
self.assertEqual(e.is_fixed(), True)
self.assertEqual(is_fixed(e), True)
v = variable()
v.value = 2
e.expr = v + 1
self.assertEqual(e.is_fixed(), False)
self.assertEqual(is_fixed(e), False)
v.fix()
self.assertEqual(e.is_fixed(), True)
self.assertEqual(is_fixed(e), True)
self.assertEqual(e(), 3)
def test_is_fixed(self):
e = self._ctype_factory()
self.assertEqual(e.is_fixed(), True)
self.assertEqual(is_fixed(e), True)
e.expr = 1
self.assertEqual(e.is_fixed(), True)
self.assertEqual(is_fixed(e), True)
v = variable()
v.value = 2
e.expr = v + 1
self.assertEqual(e.is_fixed(), False)
self.assertEqual(is_fixed(e), False)
v.fix()
self.assertEqual(e.is_fixed(), True)
self.assertEqual(is_fixed(e), True)
self.assertEqual(e(), 3)
def visiting_potential_leaf(self, node):
if node.__class__ in nonpyomo_leaf_types:
self.bnds_dict[node] = (node, node)
return True, None
if node.is_variable_type():
if node.is_fixed():
lb = value(node.value)
ub = lb
else:
lb = value(node.lb)
ub = value(node.ub)
if lb is None:
lb = -math.inf
if ub is None:
ub = math.inf
self.bnds_dict[node] = (lb, ub)
return True, None
if not node.is_expression_type():
assert is_fixed(node)
val = value(node)
self.bnds_dict[node] = (val, val)
return True, None
return False, None
def _add_constraint(self, con):
if not con.active:
return None
if is_fixed(con.body):
if self._skip_trivial_constraints:
return None
conname = self._symbol_map.getSymbol(con, self._labeler)
if con._linear_canonical_form:
mosek_expr, referenced_vars = self._get_expr_from_pyomo_repn(
con.canonical_form(), self._max_constraint_degree)
else:
mosek_expr, referenced_vars = self._get_expr_from_pyomo_expr(
con.body, self._max_constraint_degree)
self._solver_model.appendcons(1)
con_index = self._solver_model.getnumcon() - 1
con_type, ub, lb = self.set_con_bounds(con, mosek_expr[2])
if con.has_lb():
if not is_fixed(con.lower):
raise ValueError("Lower bound of constraint {0} "
"is not constant.".format(con))
if con.has_ub():
if not is_fixed(con.upper):
raise ValueError("Upper bound of constraint {0} "
"is not constant.".format(con))
self._solver_model.putarow(con_index, mosek_expr[1], mosek_expr[0])
self._solver_model.putqconk(con_index, mosek_expr[4], mosek_expr[5],
mosek_expr[3])
self._solver_model.putconbound(con_index, con_type, lb, ub)
self._solver_model.putconname(con_index, conname)
for var in referenced_vars:
self._referenced_variables[var] += 1
self._vars_referenced_by_con[con] = referenced_vars
self._pyomo_con_to_solver_con_map[con] = con_index
self._solver_con_to_pyomo_con_map[con_index] = con
def _ub(self):
if self._body is not None:
bound = self._upper
elif self._expr is None:
return None
else:
bound = self._expr.arg(2)
if not is_fixed(bound):
raise ValueError(
"Constraint '%s' is a Ranged Inequality with a "
"variable %s bound. Cannot normalize the "
"constraint or send it to a solver." %
(self.name, 'upper'))
return bound
def test_is_fixed(self):
e = self._ctype_factory()
self.assertEqual(e.is_fixed(), True)
self.assertEqual(is_fixed(e), True)
e.expr = 1
self.assertEqual(e.is_fixed(), True)
self.assertEqual(is_fixed(e), True)
p = parameter()
e.expr = p**2
self.assertEqual(e.is_fixed(), True)
self.assertEqual(is_fixed(e), True)
a = self._ctype_factory()
e.expr = (a * p)**2 / (p + 5)
self.assertEqual(e.is_fixed(), True)
self.assertEqual(is_fixed(e), True)
a.expr = 2.0
p.value = 5.0
self.assertEqual(e.is_fixed(), True)
self.assertEqual(is_fixed(e), True)
self.assertEqual(e(), 10.0)
v = variable()
with self.assertRaises(ValueError):
e.expr = v + 1
def test_is_fixed(self):
e = self._ctype_factory()
self.assertEqual(e.is_fixed(), True)
self.assertEqual(is_fixed(e), True)
e.expr = 1
self.assertEqual(e.is_fixed(), True)
self.assertEqual(is_fixed(e), True)
p = parameter()
e.expr = p**2
self.assertEqual(e.is_fixed(), True)
self.assertEqual(is_fixed(e), True)
a = self._ctype_factory()
e.expr = (a*p)**2/(p + 5)
self.assertEqual(e.is_fixed(), True)
self.assertEqual(is_fixed(e), True)
a.expr = 2.0
p.value = 5.0
self.assertEqual(e.is_fixed(), True)
self.assertEqual(is_fixed(e), True)
self.assertEqual(e(), 10.0)
v = variable()
with self.assertRaises(ValueError):
e.expr = v + 1
def ftoa(val):
if val is None:
return val
#
# Basic checking, including conversion of *fixed* Pyomo types to floats
if type(val) in native_numeric_types:
_val = val
else:
if is_fixed(val):
_val = value(val)
else:
raise ValueError(
"Converting non-fixed bound or value to string: %s" % (val, ))
#
# Convert to string
a = _ftoa_precision_str % _val
#
# Remove unnecessary least significant digits. While not strictly
# necessary, this helps keep the emitted string consistent between
# python versions by simplifying things like "1.0000000000001" to
# "1".
i = len(a)
try:
while i > 1:
if float(a[:i - 1]) == _val:
i -= 1
else:
break
except:
pass
#
# It is important to issue a warning if the conversion loses
# precision (as the emitted model is not exactly what the user
# specified)
if i == len(a) and float(a) != _val:
logger.warning(
"Converting %s to string resulted in loss of precision" % val)
#
return a[:i]
def _add_constraint(self, con):
if not con.active:
return None
if is_fixed(con.body):
if self._skip_trivial_constraints:
return None
conname = self._symbol_map.getSymbol(con, self._labeler)
if con._linear_canonical_form:
gurobi_expr, referenced_vars = self._get_expr_from_pyomo_repn(
con.canonical_form(),
self._max_constraint_degree)
#elif isinstance(con, LinearCanonicalRepn):
# gurobi_expr, referenced_vars = self._get_expr_from_pyomo_repn(
# con,
# self._max_constraint_degree)
else:
gurobi_expr, referenced_vars = self._get_expr_from_pyomo_expr(
con.body,
self._max_constraint_degree)
if con.has_lb():
if not is_fixed(con.lower):
raise ValueError("Lower bound of constraint {0} "
"is not constant.".format(con))
if con.has_ub():
if not is_fixed(con.upper):
raise ValueError("Upper bound of constraint {0} "
"is not constant.".format(con))
if con.equality:
gurobipy_con = self._solver_model.addConstr(lhs=gurobi_expr,
sense=self._gurobipy.GRB.EQUAL,
rhs=value(con.lower),
name=conname)
elif con.has_lb() and con.has_ub():
gurobipy_con = self._solver_model.addRange(gurobi_expr,
value(con.lower),
value(con.upper),
name=conname)
self._range_constraints.add(con)
elif con.has_lb():
gurobipy_con = self._solver_model.addConstr(lhs=gurobi_expr,
sense=self._gurobipy.GRB.GREATER_EQUAL,
rhs=value(con.lower),
name=conname)
elif con.has_ub():
gurobipy_con = self._solver_model.addConstr(lhs=gurobi_expr,
sense=self._gurobipy.GRB.LESS_EQUAL,
rhs=value(con.upper),
name=conname)
else:
raise ValueError("Constraint does not have a lower "
"or an upper bound: {0} \n".format(con))
for var in referenced_vars:
self._referenced_variables[var] += 1
self._vars_referenced_by_con[con] = referenced_vars
self._pyomo_con_to_solver_con_map[con] = gurobipy_con
self._solver_con_to_pyomo_con_map[gurobipy_con] = con
self._needs_updated = True
def is_fixed(self):
"""A boolean indicating whether this expression is fixed."""
return is_fixed(self._expr)
def is_fixed(self):
"""A boolean indicating whether this expression is fixed."""
return is_fixed(self._expr)
def _add_constraint(self, con):
if not con.active:
return None
if is_fixed(con.body):
if self._skip_trivial_constraints:
return None
conname = self._symbol_map.getSymbol(con, self._labeler)
if con._linear_canonical_form:
cplex_expr, referenced_vars = self._get_expr_from_pyomo_repn(
con.canonical_form(),
self._max_constraint_degree)
else:
cplex_expr, referenced_vars = self._get_expr_from_pyomo_expr(
con.body,
self._max_constraint_degree)
if con.has_lb():
if not is_fixed(con.lower):
raise ValueError("Lower bound of constraint {0} "
"is not constant.".format(con))
if con.has_ub():
if not is_fixed(con.upper):
raise ValueError("Upper bound of constraint {0} "
"is not constant.".format(con))
if con.equality:
my_sense = 'E'
my_rhs = [value(con.lower) - cplex_expr.offset]
my_range = []
elif con.has_lb() and con.has_ub():
my_sense = 'R'
lb = value(con.lower)
ub = value(con.upper)
my_rhs = [ub - cplex_expr.offset]
my_range = [lb - ub]
self._range_constraints.add(con)
elif con.has_lb():
my_sense = 'G'
my_rhs = [value(con.lower) - cplex_expr.offset]
my_range = []
elif con.has_ub():
my_sense = 'L'
my_rhs = [value(con.upper) - cplex_expr.offset]
my_range = []
else:
raise ValueError("Constraint does not have a lower "
"or an upper bound: {0} \n".format(con))
if len(cplex_expr.q_coefficients) == 0:
self._solver_model.linear_constraints.add(
lin_expr=[[cplex_expr.variables,
cplex_expr.coefficients]],
senses=my_sense,
rhs=my_rhs,
range_values=my_range,
names=[conname])
else:
if my_sense == 'R':
raise ValueError("The CPLEXDirect interface does not "
"support quadratic range constraints: "
"{0}".format(con))
self._solver_model.quadratic_constraints.add(
lin_expr=[cplex_expr.variables,
cplex_expr.coefficients],
quad_expr=[cplex_expr.q_variables1,
cplex_expr.q_variables2,
cplex_expr.q_coefficients],
sense=my_sense,
rhs=my_rhs[0],
name=conname)
for var in referenced_vars:
self._referenced_variables[var] += 1
self._vars_referenced_by_con[con] = referenced_vars
self._pyomo_con_to_solver_con_map[con] = conname
self._solver_con_to_pyomo_con_map[conname] = con
def _add_constraint(self, con):
if not con.active:
return None
if is_fixed(con.body):
if self._skip_trivial_constraints:
return None
conname = self._symbol_map.getSymbol(con, self._labeler)
if con._linear_canonical_form:
gurobi_expr, referenced_vars = self._get_expr_from_pyomo_repn(
con.canonical_form(),
self._max_constraint_degree)
#elif isinstance(con, LinearCanonicalRepn):
# gurobi_expr, referenced_vars = self._get_expr_from_pyomo_repn(
# con,
# self._max_constraint_degree)
else:
gurobi_expr, referenced_vars = self._get_expr_from_pyomo_expr(
con.body,
self._max_constraint_degree)
if con.has_lb():
if not is_fixed(con.lower):
raise ValueError("Lower bound of constraint {0} "
"is not constant.".format(con))
if con.has_ub():
if not is_fixed(con.upper):
raise ValueError("Upper bound of constraint {0} "
"is not constant.".format(con))
if con.equality:
gurobipy_con = self._solver_model.addConstr(lhs=gurobi_expr,
sense=self._gurobipy.GRB.EQUAL,
rhs=value(con.lower),
name=conname)
elif con.has_lb() and con.has_ub():
gurobipy_con = self._solver_model.addRange(gurobi_expr,
value(con.lower),
value(con.upper),
name=conname)
self._range_constraints.add(con)
elif con.has_lb():
gurobipy_con = self._solver_model.addConstr(lhs=gurobi_expr,
sense=self._gurobipy.GRB.GREATER_EQUAL,
rhs=value(con.lower),
name=conname)
elif con.has_ub():
gurobipy_con = self._solver_model.addConstr(lhs=gurobi_expr,
sense=self._gurobipy.GRB.LESS_EQUAL,
rhs=value(con.upper),
name=conname)
else:
raise ValueError("Constraint does not have a lower "
"or an upper bound: {0} \n".format(con))
for var in referenced_vars:
self._referenced_variables[var] += 1
self._vars_referenced_by_con[con] = referenced_vars
self._pyomo_con_to_solver_con_map[con] = gurobipy_con
self._solver_con_to_pyomo_con_map[gurobipy_con] = con
def _add_constraint(self, con):
if not con.active:
return None
if is_fixed(con.body):
if self._skip_trivial_constraints:
return None
conname = self._symbol_map.getSymbol(con, self._labeler)
mosek_expr = None
referenced_vars = None
cone_type = None
cone_param = 0
cone_members = None
if con._linear_canonical_form:
mosek_expr, referenced_vars = self._get_expr_from_pyomo_repn(
con.canonical_form(), self._max_constraint_degree)
elif isinstance(con, _ConicBase):
cone_type, cone_param, cone_members = \
self._get_cone_data(con)
if cone_type is not None:
assert cone_members is not None
referenced_vars = ComponentSet(cone_members)
else:
logger.warning("Cone %s was not recognized by Mosek" %
(str(con)))
# the cone was not recognized, treat
# it like a standard constraint, which
# will in all likelihood lead to Mosek
# reporting a helpful error message
assert mosek_expr is None
if (mosek_expr is None) and (cone_type is None):
mosek_expr, referenced_vars = \
self._get_expr_from_pyomo_expr(
con.body,
self._max_constraint_degree)
assert referenced_vars is not None
if mosek_expr is not None:
assert cone_type is None
self._solver_model.appendcons(1)
con_index = self._solver_model.getnumcon() - 1
con_type, ub, lb = self.set_con_bounds(con, mosek_expr[2])
if con.has_lb():
if not is_fixed(con.lower):
raise ValueError("Lower bound of constraint {0} "
"is not constant.".format(con))
if con.has_ub():
if not is_fixed(con.upper):
raise ValueError("Upper bound of constraint {0} "
"is not constant.".format(con))
self._solver_model.putarow(con_index, mosek_expr[1], mosek_expr[0])
self._solver_model.putqconk(con_index, mosek_expr[4],
mosek_expr[5], mosek_expr[3])
self._solver_model.putconbound(con_index, con_type, lb, ub)
self._solver_model.putconname(con_index, conname)
self._pyomo_con_to_solver_con_map[con] = con_index
self._solver_con_to_pyomo_con_map[con_index] = con
else:
assert cone_type is not None
members = [
self._pyomo_var_to_solver_var_map[v_] for v_ in cone_members
]
self._solver_model.appendcone(cone_type, cone_param, members)
cone_index = self._solver_model.getnumcone() - 1
self._solver_model.putconename(cone_index, conname)
self._pyomo_cone_to_solver_cone_map[con] = cone_index
self._solver_cone_to_pyomo_cone_map[cone_index] = con
for var in referenced_vars:
self._referenced_variables[var] += 1
self._vars_referenced_by_con[con] = referenced_vars
def _get_bound(exp):
if exp is None:
return None
if is_fixed(exp):
return value(exp)
raise ValueError("non-fixed bound or weight: " + str(exp))
def _get_bound(exp):
if exp is None:
return None
if is_fixed(exp):
return value(exp)
raise ValueError("non-fixed bound or weight: " + str(exp))
def _add_constraint(self, con, lin_con_data=None):
if not con.active:
return None
if self._skip_trivial_constraints and is_fixed(con.body):
return None
conname = self._symbol_map.getSymbol(con, self._labeler)
if con._linear_canonical_form:
cplex_expr, referenced_vars = self._get_expr_from_pyomo_repn(
con.canonical_form(), self._max_constraint_degree)
else:
cplex_expr, referenced_vars = self._get_expr_from_pyomo_expr(
con.body, self._max_constraint_degree)
if con.has_lb() and not is_fixed(con.lower):
raise ValueError(
"Lower bound of constraint {0} is not constant.".format(con))
if con.has_ub() and not is_fixed(con.upper):
raise ValueError(
"Upper bound of constraint {0} is not constant.".format(con))
range_ = 0.0
if con.equality:
sense = "E"
rhs = value(con.lower) - cplex_expr.offset
elif con.has_lb() and con.has_ub():
sense = "R"
lb = value(con.lower)
ub = value(con.upper)
rhs = ub - cplex_expr.offset
range_ = lb - ub
self._range_constraints.add(con)
elif con.has_lb():
sense = "G"
rhs = value(con.lower) - cplex_expr.offset
elif con.has_ub():
sense = "L"
rhs = value(con.upper) - cplex_expr.offset
else:
raise ValueError("Constraint does not have a lower "
"or an upper bound: {0} \n".format(con))
if len(cplex_expr.q_coefficients) == 0:
cplex_lin_con_data = (_LinearConstraintData(self._solver_model)
if lin_con_data is None else lin_con_data)
cplex_lin_con_data.add(cplex_expr, sense, rhs, range_, conname)
if lin_con_data is None:
cplex_lin_con_data.store_in_cplex()
else:
if sense == 'R':
raise ValueError("The CPLEXDirect interface does not "
"support quadratic range constraints: "
"{0}".format(con))
self._solver_model.quadratic_constraints.add(
lin_expr=[cplex_expr.variables, cplex_expr.coefficients],
quad_expr=[
cplex_expr.q_variables1, cplex_expr.q_variables2,
cplex_expr.q_coefficients
],
sense=sense,
rhs=rhs,
name=conname)
for var in referenced_vars:
self._referenced_variables[var] += 1
self._vars_referenced_by_con[con] = referenced_vars
self._pyomo_con_to_solver_con_map[con] = conname
self._solver_con_to_pyomo_con_map[conname] = con
def _add_constraint(self, con):
if not con.active:
return None
if is_fixed(con.body):
if self._skip_trivial_constraints:
return None
conname = self._symbol_map.getSymbol(con, self._labeler)
if con._linear_canonical_form:
cplex_expr, referenced_vars = self._get_expr_from_pyomo_repn(
con.canonical_form(),
self._max_constraint_degree)
else:
cplex_expr, referenced_vars = self._get_expr_from_pyomo_expr(
con.body,
self._max_constraint_degree)
if con.has_lb():
if not is_fixed(con.lower):
raise ValueError("Lower bound of constraint {0} "
"is not constant.".format(con))
if con.has_ub():
if not is_fixed(con.upper):
raise ValueError("Upper bound of constraint {0} "
"is not constant.".format(con))
if con.equality:
my_sense = 'E'
my_rhs = [value(con.lower) - cplex_expr.offset]
my_range = []
elif con.has_lb() and con.has_ub():
my_sense = 'R'
lb = value(con.lower)
ub = value(con.upper)
my_rhs = [ub - cplex_expr.offset]
my_range = [lb - ub]
self._range_constraints.add(con)
elif con.has_lb():
my_sense = 'G'
my_rhs = [value(con.lower) - cplex_expr.offset]
my_range = []
elif con.has_ub():
my_sense = 'L'
my_rhs = [value(con.upper) - cplex_expr.offset]
my_range = []
else:
raise ValueError("Constraint does not have a lower "
"or an upper bound: {0} \n".format(con))
if len(cplex_expr.q_coefficients) == 0:
self._solver_model.linear_constraints.add(
lin_expr=[[cplex_expr.variables,
cplex_expr.coefficients]],
senses=my_sense,
rhs=my_rhs,
range_values=my_range,
names=[conname])
else:
if my_sense == 'R':
raise ValueError("The CPLEXDirect interface does not "
"support quadratic range constraints: "
"{0}".format(con))
self._solver_model.quadratic_constraints.add(
lin_expr=[cplex_expr.variables,
cplex_expr.coefficients],
quad_expr=[cplex_expr.q_variables1,
cplex_expr.q_variables2,
cplex_expr.q_coefficients],
sense=my_sense,
rhs=my_rhs[0],
name=conname)
for var in referenced_vars:
self._referenced_variables[var] += 1
self._vars_referenced_by_con[con] = referenced_vars
self._pyomo_con_to_solver_con_map[con] = conname
self._solver_con_to_pyomo_con_map[conname] = con
def _relax_root_to_leaf_ProductExpression(node, relaxation_side_map):
arg1, arg2 = node.args
if is_fixed(arg1):
relaxation_side_map[arg1] = RelaxationSide.BOTH
if isinstance(arg1, numeric_expr.ProductExpression): # see Pyomo issue #1147
arg1_arg1 = arg1.args[0]
arg1_arg2 = arg1.args[1]
try:
arg1_arg1_val = pe.value(arg1_arg1)
except ValueError:
arg1_arg1_val = None
try:
arg1_arg2_val = pe.value(arg1_arg2)
except ValueError:
arg1_arg2_val = None
if arg1_arg1_val == 0 or arg1_arg2_val == 0:
arg1_val = 0
else:
arg1_val = pe.value(arg1)
else:
arg1_val = pe.value(arg1)
if arg1_val >= 0:
relaxation_side_map[arg2] = relaxation_side_map[node]
else:
if relaxation_side_map[node] == RelaxationSide.UNDER:
relaxation_side_map[arg2] = RelaxationSide.OVER
elif relaxation_side_map[node] == RelaxationSide.OVER:
relaxation_side_map[arg2] = RelaxationSide.UNDER
else:
relaxation_side_map[arg2] = RelaxationSide.BOTH
elif is_fixed(arg2):
relaxation_side_map[arg2] = RelaxationSide.BOTH
if isinstance(arg2, numeric_expr.ProductExpression): # see Pyomo issue #1147
arg2_arg1 = arg2.args[0]
arg2_arg2 = arg2.args[1]
try:
arg2_arg1_val = pe.value(arg2_arg1)
except ValueError:
arg2_arg1_val = None
try:
arg2_arg2_val = pe.value(arg2_arg2)
except ValueError:
arg2_arg2_val = None
if arg2_arg1_val == 0 or arg2_arg2_val == 0:
arg2_val = 0
else:
arg2_val = pe.value(arg2)
else:
arg2_val = pe.value(arg2)
if arg2_val >= 0:
relaxation_side_map[arg1] = relaxation_side_map[node]
else:
if relaxation_side_map[node] == RelaxationSide.UNDER:
relaxation_side_map[arg1] = RelaxationSide.OVER
elif relaxation_side_map[node] == RelaxationSide.OVER:
relaxation_side_map[arg1] = RelaxationSide.UNDER
else:
relaxation_side_map[arg1] = RelaxationSide.BOTH
else:
relaxation_side_map[arg1] = RelaxationSide.BOTH
relaxation_side_map[arg2] = RelaxationSide.BOTH
