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)