def typecheck_int(cls,
logger,
arg,
check_math,
accept_negative=True,
caller=None):
if not is_number(arg):
caller_string = resolve_caller_as_string(caller)
logger.fatal("{0}Expecting number, got: {1!r}",
(caller_string, arg))
if check_math:
if math.isnan(arg):
caller_string = resolve_caller_as_string(caller)
logger.fatal("{0}NaN value detected", (caller_string, ))
elif math.isinf(arg):
caller_string = resolve_caller_as_string(caller)
logger.fatal("{0}Infinite value detected", (caller_string, ))
if not is_int(arg):
caller_string = resolve_caller_as_string(caller)
logger.fatal("{0}Expecting integer, got: {1!r}",
(caller_string, arg))
elif not accept_negative and arg < 0:
caller_string = resolve_caller_as_string(caller)
logger.fatal("{0}Expecting positive integer, got: {1!r}",
(caller_string, arg))
def parse(arg, logger=None, default_sense=None):
if isinstance(arg, ObjectiveSense):
return arg
elif is_string(arg):
lower_text = arg.lower()
if lower_text in {"minimize", "min"}:
return ObjectiveSense.Minimize
elif lower_text in {"maximize", "max"}:
return ObjectiveSense.Maximize
elif default_sense:
logger.error(
"Text is not recognized as objective sense: {0}, expecting \"min\" or \"max\" - using default {1:s}",
(arg, default_sense))
return default_sense
elif logger:
logger.fatal("Text is not recognized as objective sense: {0}, expecting ""min"" or ""max", (arg,))
else:
docplex_fatal("Text is not recognized as objective sense: {0}, expecting ""min"" or ""max".format(arg))
elif is_int(arg):
if arg == 1:
return ObjectiveSense.Minimize
elif -1 == arg:
return ObjectiveSense.Maximize
else:
logger.fatal("cannot convert: <{}> to objective sense", (arg,))
elif arg is None:
return default_sense
elif logger:
logger.fatal("cannot convert: <{}> to objective sense", (arg,))
else:
docplex_fatal("cannot convert: <{}> to objective sense".format(arg))
def make_key_seq(self, keys, name):
# INTERNAL Takes as input a candidate keys input and returns a valid key sequence
used_name = name
check_keys = True
used_keys = []
if is_iterable(keys):
if is_pandas_dataframe(keys):
used_keys = keys.index.values
elif has_len(keys):
used_keys = keys
elif is_iterator(keys):
used_keys = list(keys)
else:
# TODO: make a test for this case.
self.fatal(
"Cannot handle iterable var keys: {0!s} : no len() and not an iterator",
keys) # pragma: no cover
elif is_int(keys) and keys >= 0:
# if name is str and we have a size, disable automatic names
used_name = None if name is str else name
used_keys = range(keys)
check_keys = False
else:
self.fatal(
"Unexpected var keys: {0!s}, expecting iterable or integer",
keys) # pragma: no cover
if check_keys and len(
used_keys
): # do not check truth value of used_keys: can be a Series!
self._checker.typecheck_key_seq(used_keys)
return used_name, used_keys
def typecheck_int(self, arg, accept_negative=True, caller=None):
caller_string = "{0}: ".format(caller) if caller is not None else ""
if not is_number(arg):
self.fatal("{0}Expecting number, got: {1!r}", caller_string, arg)
elif not is_int(arg):
self.fatal("{0}Expecting integer, got: {1!r}", caller_string, arg)
elif not accept_negative and arg < 0:
self.fatal("{0}Expecting positive integer, got: {1!r}", caller_string, arg)
def accept_value(self, numeric_value):
# """ Redefines the generic `accept_value` method.
#
# A value is valid if is an integer and belongs to the variable's domain.
#
# Args:
# numeric_value: The numeric value being tested.
#
# Returns:
# True if the value is valid for the type, else False.
# """
return is_int(numeric_value) or numeric_value == int(numeric_value)
def find_parameter(self, key):
if is_int(key):
pred = lambda p: p.cpx_id == key
elif is_string(key):
# eliminate initial '.'
pred = lambda p: p.get_qualified_name(include_root=False) == key
else:
docplex_fatal('Parameters.find() accepts either integer code or path-like name, got: {0!r}'.format(key))
for p in self:
if pred(p):
return p
else:
return None
def load_data(self, *args):
self._check_data_args(args, 2)
self.servers = args[0]
self.users = [TUser(*user_row) for user_row in args[1]]
self.max_processes_per_server = DEFAULT_MAX_PROCESSES_PER_SERVER
if len(args) >= 3:
arg2 = args[2]
if is_int(arg2):
self.max_processes_per_server = arg2
else:
print('* unexpected max process/server arg, not an int: %s'.format(str(arg2)))
return self.is_valid()
def is_discrete(self):
""" Checks if the expression contains only discrete variables and coefficients.
Example:
If X is an integer variable, X, X+1, 2X+3 are discrete
but X+0.3, 1.5X, 2X + 0.7 are not.
Returns:
Boolean: True if the expression contains only discrete variables and coefficients.
"""
self_cst = self._constant
if self_cst != int(self_cst):
# a float constant with integer value is OK
return False
for v, k in self.iter_terms():
if not v.is_discrete() or not is_int(k):
return False
else:
return True
def parse(cls, arg, default_level=INFO):
# INTERNAL
if not arg:
return default_level
elif isinstance(arg, cls):
return arg
elif is_string(arg):
return cls._name2level_map().get(arg.lower(), default_level)
elif is_int(arg):
if arg < 10:
# anything below 10 is INFO
return cls.INFO
elif arg < 100:
return cls.WARNING
elif arg < 1000:
return cls.ERROR
else:
# level fatal prints nothing except fatal errors
return cls.FATAL
else:
raise DOcplexException("Cannot convert this to InfoLevel: {0!r}".format(arg))
def accept_value(self, new_value):
ivalue = int(new_value)
return is_int(ivalue) and self._is_in_range(ivalue, self._min_value,
self._max_value)
def accept_value(self, numeric_value):
if 0 == numeric_value:
return True
return numeric_value >= 0 and (is_int(numeric_value) or numeric_value == int(numeric_value))
def is_discrete(self):
return is_int(self._constant)
def is_discrete(self):
return self._dvar.is_discrete() and is_int(self._coef)
def transform_value(self, new_value):
if is_int(new_value):
return new_value
else:
return int(new_value)
