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)