def compile_naming_function(keys,
user_name,
dimension=1,
key_format=None,
_default_key_format='_%s',
stringifier=str_flatten_tuple):
# INTERNAL
# builds a naming rule from an input , a dimension, and an optional meta-format
# Makes sure the format string does contain the right number of format slots
assert user_name is not None
if is_string(user_name):
if key_format is None:
used_key_format = _default_key_format
elif is_string(key_format):
# -- make sure some %s is inside, otherwise add it
if '%s' in key_format:
used_key_format = key_format
else:
used_key_format = key_format + '%s'
else: # pragma: no cover
raise DOcplexException(
"key format expects string format or None, got: {0!r}".format(
key_format))
fixed_format_string = fix_format_string(user_name, dimension,
used_key_format)
if 1 == dimension:
return lambda k: fixed_format_string % stringifier(k)
else:
# here keys are tuples of size >= 2
return lambda key_tuple: fixed_format_string % key_tuple
elif is_function(user_name):
return user_name
elif is_iterable(user_name):
# check that the iterable has same len as keys,
# otherwise thereis no more default naming and None cannot appear in CPLEX name arrays
list_names = list(user_name)
if len(list_names) < len(keys):
raise DOcplexException(
"An array of names should have same len as keys, expecting: {0}, go: {1}"
.format(len(keys), len(list_names)))
key_to_names_dict = {k: nm for k, nm in izip(keys, list_names)}
# use a closure
return lambda k: key_to_names_dict[
k] # if k in key_to_names_dict else default_fn()
else:
raise DOcplexException(
'Cannot use this for naming variables: {0!r} - expecting string, function or iterable'
.format(user_name))
def __init__(self,
prioritizer='all',
verbose=False,
precision=default_precision,
override=False,
**kwargs):
self.output_table_customizer = kwargs.get(
'output_processing') # wml tables, internal
self.output_table_property_name = 'relaxations_output'
self.default_output_table_name = 'relaxations.csv'
self.output_table_using_df = True # if pandas is available of course
self._precision = precision
# ---
if hasattr(prioritizer, 'get_priority'):
self._prioritizer = prioritizer
elif prioritizer == 'match':
self._prioritizer = MatchNamePrioritizer(override=override)
elif isinstance(prioritizer, dict):
self._prioritizer = MappingPrioritizer(
priority_mapping=prioritizer, override=override)
elif prioritizer == 'named':
self._prioritizer = NamedPrioritizer()
elif prioritizer is None or prioritizer == 'all':
self._prioritizer = UniformPrioritizer(override=override)
elif is_function(prioritizer):
self._prioritizer = FunctionalPrioritizer(prioritizer,
override=override)
else:
print(
"Cannot deduce a prioritizer from: {0!r} - expecting \"name\"|\"default\"| dict",
prioritizer)
raise TypeError
self._cumulative = True
self._listeners = []
# result data
self._last_relaxation_status = False
self._last_relaxation_objective = -1e+75
self._last_successful_relaxed_priority = Priority.MANDATORY
self._last_relaxation_details = SolveDetails.make_dummy()
self._relaxations = {}
self._verbose = verbose
self._verbose_listener = VerboseRelaxationListener()
if self._verbose:
self.add_listener(self._verbose_listener)
def new_kpi(model, kpi_arg, kpi_name):
# static factory method to build a new concrete instance of KPI
if isinstance(kpi_arg, KPI):
if not kpi_name:
return kpi_arg
else:
cloned = kpi_arg.clone()
cloned.name = kpi_name
return cloned
elif is_function(kpi_arg):
return FunctionalKPI(kpi_arg, model, kpi_name)
else:
# try a linear expr conversion
try:
expr = model._lfactory._to_expr(kpi_arg)
return DecisionKPI(expr, kpi_name)
except DOcplexException:
model.fatal("Cannot interpret this as a KPI: {0!r}. expecting expression, variable or function", kpi_arg)
def __init__(self,
prioritizer='all',
verbose=False,
precision=default_precision,
override=False):
self._precision = precision
# ---
if isinstance(prioritizer, IConstraintPrioritizer):
self._prioritizer = prioritizer
elif prioritizer == 'match':
self._prioritizer = MatchNamePrioritizer(override=override)
elif isinstance(prioritizer, dict):
self._prioritizer = MappingPrioritizer(
priority_mapping=prioritizer, override=override)
elif prioritizer == 'named':
self._prioritizer = NamedPrioritizer()
elif prioritizer is None or prioritizer is 'all':
self._prioritizer = UniformPrioritizer(override=override)
elif is_function(prioritizer):
self._prioritizer = FunctionalPrioritizer(prioritizer,
override=override)
else:
print(
"Cannot deduce a prioritizer from: {0!r} - expecting \"name\"|\"default\"| dict",
prioritizer)
raise TypeError
self._cumulative = True
self._listeners = []
# result data
self._last_relaxation_status = False
self._last_relaxation_objective = -1e+75
self._last_successful_relaxed_priority = Priority.MANDATORY
self._last_relaxation_details = SolveDetails.make_dummy()
self._relaxations = {}
self._verbose = verbose
self._verbose_listener = VerboseRelaxationListener()
if self._verbose:
self.add_listener(self._verbose_listener)
def new_kpi(model, kpi_arg, kpi_name):
# static factory method to build a new concrete instance of KPI
if isinstance(kpi_arg, Expr):
return DecisionKPI(kpi_arg, kpi_name)
elif isinstance(kpi_arg, Var):
return DecisionKPI(kpi_arg, kpi_name)
elif isinstance(kpi_arg, KPI):
if not kpi_name:
return kpi_arg
else:
cloned = kpi_arg.clone()
cloned.name = kpi_name
return cloned
elif is_function(kpi_arg):
return FunctionalKPI(kpi_arg, model, kpi_name)
elif is_number(kpi_arg):
kpi_fn = lambda _: kpi_arg
return FunctionalKPI(kpi_fn, model, kpi_name)
else:
model.fatal(
"Cannot interpret this as a KPI: {0!r}. expecting expression, variable or function",
kpi_arg)
