def encode_linear_constraints(cls, solution, was_solved):
n = []
model = solution.model
if was_solved:
duals = []
try:
if not model._solved_as_mip():
duals = model.dual_values(model.iter_linear_constraints())
except DOcplexException as dex:
# in some cases, cplex may change the problem type at solve time.
if "not available for integer" not in str(dex):
# ignore "not available for integer problems error, raise others.
raise
slacks = model.slack_values(model.iter_linear_constraints())
else:
duals = []
slacks = []
model.warning(
"Model has not been solved, no dual and slack values are printed"
)
for (ct, d, s) in izip_longest(model.iter_linear_constraints(),
duals,
slacks,
fillvalue=None):
c = {"name": ct.name, "index": ct.index}
if s:
c["slack"] = s
if d:
c["dual"] = d
n.append(c)
return n
def _new_constraint_block2(self, cts, ctnames):
posted_cts = []
prepfn = self._model._prepare_constraint
checker = self._checker
check_trivials = checker.check_trivial_constraints()
if is_string(ctnames):
from docplex.mp.utils import _AutomaticSymbolGenerator
# no separator added, use a terminal "_" if need be
ctnames = _AutomaticSymbolGenerator(ctnames)
for ct, ctname in izip_longest(
cts, ctnames): # use izip_longest so as not to forget any ct
if ct is None: # izip stops
break
checker.typecheck_linear_constraint(ct, accept_range=False)
checker.typecheck_string(ctname,
accept_none=True,
accept_empty=False,
caller="Model.add_constraints()")
if prepfn(ct, ctname, check_for_trivial_ct=check_trivials):
posted_cts.append(ct)
self._post_constraint_block(posted_cts)
return posted_cts
def encode_variables(self, sol, was_solved):
model = sol.model
n = []
if was_solved:
try:
reduced_costs = [] if model._solved_as_mip() else model.reduced_costs(model.iter_variables())
except DOcplexException as dex:
if "not available for integer" in str(dex):
reduced_costs = []
else:
raise
else:
reduced_costs = []
model.warning("Model has not been solved, no reduced costs are printed")
keep_zeros = sol._keep_zeros
if self.keep_zeros:
keep_zeros = keep_zeros or self.keep_zeros
for (dvar, rc) in izip_longest(model.iter_variables(),
reduced_costs,
fillvalue=None):
if not dvar.is_generated(): # 38934
value = sol._get_var_value(dvar)
if keep_zeros or value:
v = {"index": "{}".format(dvar.index),
"name": dvar.name,
"value": "{}".format(value)}
if rc is not None:
v["reducedCost"] = rc
n.append(v)
return n
def print_many_solutions(cls,
sol_seq,
out,
use_lp_names,
write_level,
effort_level=None):
osa = OutputStreamAdapter(out)
osa.write(cls.mst_header)
cls.print_signature(out, write_level)
# <CPLEXSolutions version="1.0">
osa.write(cls.many_solution_start_tag)
osa.write("\n")
efforts = [EffortLevel.Auto]
if effort_level is None:
pass
elif is_iterable(effort_level):
efforts = effort_level
else:
efforts = [effort_level]
for sol, effort in izip_longest(sol_seq,
efforts,
fillvalue=EffortLevel.Auto):
cls.print_one_solution(sol,
out,
print_header=False,
use_lp_names=use_lp_names,
write_level=write_level,
effort_level=effort)
# <CPLEXSolutions version="1.0">
osa.write(cls.many_solution_end_tag)
osa.write("\n")
def encode_quadratic_constraints(cls, solution):
n = []
model = solution.model
duals = []
# RTC#37375
# if not model._solves_as_mip():
# duals = model.dual_values(model.iter_quadratic_constraints())
slacks = []
was_solved = model._has_solution()
if was_solved:
slacks = model.slack_values(model.iter_quadratic_constraints())
for (ct, d, s) in izip_longest(model.iter_quadratic_constraints(),
duals,
slacks,
fillvalue=None):
# basis status is not yet supported
c = {"name": ct.name, "index": ct.index}
if s:
c["slack"] = s
if d:
c["dual"] = d
n.append(c)
return n
