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