def build_sparse_linear_model_and_solve(cls, nb_vars, var_lbs, var_ubs, var_types, var_names, nb_rows, cts_sparse_coefs, objsense, costs, solution_maker=make_solution, **transform_params): cpx = cls.create_cplex() # varlist = mdl.continuous_var_list(var_count, lb=var_lbs, ub=var_ubs, name=var_names) cls.create_column_vars(cpx, nb_vars, var_lbs, var_ubs, var_types, var_names) var_indices = list(range(nb_vars)) cpx_linexprs = [([], []) for _ in range(nb_rows)] cpx_rhss = [0.] * nb_rows for coef, row, col in cts_sparse_coefs: if col >= nb_vars: cpx_rhss[row] = float(coef) elif coef: cpx_row = cpx_linexprs[row] # int() conversio nis mandatory here # as sparse matrices contain numpy int types -> cause cplex to crash cpx_row[0].append(int(col)) cpx_row[1].append(float(coef)) ctsense = ComparisonType.parse(transform_params.get('sense', 'le')) cpx_senses = ctsense.cplex_code * nb_rows #fast_add_linear(cpx, cpx_linexprs, cpx_senses, cpx_rhss, names=[]) cpx.linear_constraints.add(cpx_linexprs, cpx_senses, cpx_rhss, names=[]) if costs is not None: # set linear objective for all variables. fcosts = [float(k) for k in costs] static_fast_set_linear_obj(cpx, var_indices, fcosts) cpx.objective.set_sense(objsense.cplex_coef) # here we go to solve... return cls._solve(cpx, var_names, solution_maker=solution_maker, **transform_params)
def set_linear_constraint_sense(self, ct, arg_newsense): new_sense = ComparisonType.parse(arg_newsense) if new_sense != ct.sense: self._engine.update_constraint(ct, UpdateEvent.LinearConstraintType, new_sense) ct._internal_set_sense(new_sense)
def set_quadratic_constraint_sense(self, qct, arg_newsense): new_sense = ComparisonType.parse(arg_newsense) if new_sense != qct.sense: self._engine.update_constraint(qct, UpdateEvent.LinearConstraintType, new_sense) qct._internal_set_sense(new_sense)
def is_satisfied(self, solution, tolerance=1e-6): left_value = self._left_expr._get_solution_value(solution) right_value = self._right_expr._get_solution_value(solution) return ComparisonType.almost_compare(left_value, self._ctsense, right_value, eps=tolerance)
def vector_compare(self, lhss, rhss, sense): l_lhs = self._to_list(lhss, caller='Model.vector.compare') l_rhs = self._to_list(rhss, caller='Model.vector.compare') if len(l_lhs) != len(l_rhs): self.fatal( 'Model.vector_compare() got sequences with different length, left: {0}, right: {1}' .format(len(l_lhs), len(l_rhs))) ctsense = ComparisonType.parse(sense) return self._aggregator.vector_compare(l_lhs, l_rhs, ctsense)
def build_matrix_linear_model_and_solve(cls, var_count, var_lbs, var_ubs, var_types, var_names, cts_mat, rhs, objsense, costs, cast_to_float, solution_maker=make_solution, **transform_params): adapter = cls.create_cplex_adapter() cpx = adapter.cpx if cast_to_float: print("-- all numbers will be cast to float") else: print("-- no cast to float is performed") cls.create_column_vars(cpx, var_count, var_lbs, var_ubs, var_types, var_names) var_indices = list(range(var_count)) gen_rows = ModelAggregator.generate_rows(cts_mat) cpx_rows = [] if cast_to_float: for row in gen_rows: # need this step as cplex may crash with np types. frow = [float(k) for k in row] cpx_rows.append([var_indices, frow]) else: cpx_rows = [[var_indices, row] for row in gen_rows] nb_rows = len(cpx_rows) if nb_rows: ctsense = ComparisonType.parse(transform_params.get('sense', 'le')) cpx_senses = ctsense.cplex_code * nb_rows cpx_rhss = [float(r) for r in rhs] if cast_to_float else rhs adapter.add_linear(cpx, cpx_rows, cpx_senses, cpx_rhss, names=[]) if costs is not None: # set linear objective for all variables. fcosts = [float(k) for k in costs] adapter.static_fast_set_linear_obj(cpx, var_indices, fcosts) cpx.objective.set_sense(objsense.cplex_coef) # here we go to solve... return cls._solve(cpx, var_names, solution_maker=solution_maker, **transform_params)
def as_constraint_from_symbol(self, op_symbol): self_var = self.var var_lb = self.var.lb op = ComparisonType.cplex_ctsense_to_python_op(op_symbol) ct = op(self_var, var_lb) return ct
def new_binary_constraint(self, lhs, sense, rhs, name=None): ctsense = ComparisonType.parse(sense) return self._new_binary_constraint(lhs, ctsense, rhs, name)
def read(cls, filename, model_name=None, verbose=False, model_class=None, **kwargs): """ Reads a model from a CPLEX export file. Accepts all formats exported by CPLEX: LP, SAV, MPS. If an error occurs while reading the file, the message of the exception is printed and the function returns None. Args: filename: The file to read. model_name: An optional name for the newly created model. If None, the model name will be the path basename. verbose: An optional flag to print informative messages, default is False. model_class: An optional class type; must be a subclass of Model. The returned model is built using this model_class and the keyword arguments kwargs, if any. By default, the model is class is `Model` (see kwargs: A dict of keyword-based arguments that are used when creating the model instance. Example: `m = read_model("c:/temp/foo.mps", model_name="docplex_foo", solver_agent="docloud", output_level=100)` Returns: An instance of Model, or None if an exception is raised. See Also: :class:`docplex.mp.model.Model` """ if not os.path.exists(filename): raise IOError("* file not found: {0}".format(filename)) # extract basename if model_name: name_to_use = model_name else: basename = os.path.basename(filename) if '.' not in filename: raise RuntimeError( 'ModelReader.read_model(): path has no extension: {}'. format(filename)) dotpos = basename.find(".") if dotpos > 0: name_to_use = basename[:dotpos] else: # pragma: no cover name_to_use = basename model_class = model_class or Model if 0 == os.stat(filename).st_size: print("* file is empty: {0} - exiting".format(filename)) return model_class(name=name_to_use, **kwargs) if verbose: print("-> CPLEX starts reading file: {0}".format(filename)) cpx_adapter = cls._read_cplex(filename) cpx = cpx_adapter.cpx if verbose: print("<- CPLEX finished reading file: {0}".format(filename)) if not cpx: # pragma: no cover return None final_output_level = kwargs.get("output_level", "info") debug_read = kwargs.get("debug", False) try: # force no tck if 'checker' in kwargs: final_checker = kwargs['checker'] else: final_checker = 'default' # build the model with no checker, then restore final_checker in the end. kwargs['checker'] = 'off' ignore_names = kwargs.get('ignore_names', False) # ------------- mdl = model_class(name=name_to_use, **kwargs) lfactory = mdl._lfactory qfactory = mdl._qfactory mdl.set_quiet() # output level set to ERROR vartype_cont = mdl.continuous_vartype vartype_map = { 'B': mdl.binary_vartype, 'I': mdl.integer_vartype, 'C': mdl.continuous_vartype, 'S': mdl.semicontinuous_vartype } # 1 upload variables cpx_nb_vars = cpx.variables.get_num() def make_constant_expr(k): if k: return lfactory._new_safe_constant_expr(k) else: return lfactory.new_zero_expr() if verbose: print("-- uploading {0} variables...".format(cpx_nb_vars)) cpx_var_names = [] if ignore_names else cls._safe_call_get_names( cpx_adapter, cpx.variables.get_names) if cpx._is_MIP(): cpx_vartypes = [ vartype_map.get(cpxt, vartype_cont) for cpxt in cpx.variables.get_types() ] else: cpx_vartypes = [vartype_cont] * cpx_nb_vars cpx_var_lbs = cpx.variables.get_lower_bounds() cpx_var_ubs = cpx.variables.get_upper_bounds() # map from cplex variable indices to docplex's # use to skip range vars # cplex : [x, Rg1, y] -> {0:0, 2: 1} if cpx_var_names: model_varnames = cpx_var_names else: model_varnames = [None] * cpx_nb_vars model_lbs = cpx_var_lbs model_ubs = cpx_var_ubs model_types = cpx_vartypes # vars model_vars = lfactory.new_multitype_var_list( cpx_nb_vars, model_types, model_lbs, model_ubs, model_varnames) # inverse map from indices to docplex vars cpx_var_index_to_docplex = { v: model_vars[v] for v in range(cpx_nb_vars) } # 2. upload linear constraints and ranges (mixed in cplex) cpx_linearcts = cpx.linear_constraints nb_linear_cts = cpx_linearcts.get_num() # all_rows1 = cpx_linearcts.get_rows() all_rows = cpx_adapter.fast_get_rows(cpx) all_rhs = cpx_linearcts.get_rhs() all_senses = cpx_linearcts.get_senses() all_range_values = cpx_linearcts.get_range_values() cpx_ctnames = [] if ignore_names else cls._safe_call_get_names( cpx_adapter, cpx_linearcts.get_names) deferred_cts = [] if verbose: print("-- uploading {0} linear constraints...".format( nb_linear_cts)) for c in range(nb_linear_cts): row = all_rows[c] sense = all_senses[c] rhs = all_rhs[c] ctname = cpx_ctnames[c] if cpx_ctnames else None range_val = all_range_values[c] indices, coefs = row expr = cls._make_expr_from_varmap_coefs( lfactory, cpx_var_index_to_docplex, indices, coefs) if sense == 'R': # rangeval can be negative !!! issue 52 if range_val >= 0: range_lb = rhs range_ub = rhs + range_val else: range_ub = rhs range_lb = rhs + range_val rgct = mdl.range_constraint(lb=range_lb, ub=range_ub, expr=expr, rng_name=ctname) deferred_cts.append(rgct) else: op = cls.parse_sense(sense) rhs_expr = make_constant_expr(rhs) ct = LinearConstraint(mdl, expr, op, rhs_expr, ctname) deferred_cts.append(ct) if deferred_cts: # add constraint as a block lfactory._post_constraint_block(posted_cts=deferred_cts) # 3. upload Quadratic constraints cpx_quadraticcts = cpx.quadratic_constraints nb_quadratic_cts = cpx_quadraticcts.get_num() if nb_quadratic_cts: all_rhs = cpx_quadraticcts.get_rhs() all_linear_nb_non_zeros = cpx_quadraticcts.get_linear_num_nonzeros( ) all_linear_components = cpx_quadraticcts.get_linear_components( ) all_quadratic_nb_non_zeros = cpx_quadraticcts.get_quad_num_nonzeros( ) all_quadratic_components = cpx_quadraticcts.get_quadratic_components( ) all_senses = cpx_quadraticcts.get_senses() cpx_ctnames = [] if ignore_names else cls._safe_call_get_names( cpx_adapter, cpx_quadraticcts.get_names) for c in range(nb_quadratic_cts): rhs = all_rhs[c] linear_nb_non_zeros = all_linear_nb_non_zeros[c] linear_component = all_linear_components[c] quadratic_nb_non_zeros = all_quadratic_nb_non_zeros[c] quadratic_component = all_quadratic_components[c] sense = all_senses[c] ctname = cpx_ctnames[c] if cpx_ctnames else None if linear_nb_non_zeros > 0: indices, coefs = linear_component.unpack() # linexpr = mdl._aggregator._scal_prod((cpx_var_index_to_docplex[idx] for idx in indices), coefs) linexpr = cls._make_expr_from_varmap_coefs( lfactory, cpx_var_index_to_docplex, indices, coefs) else: linexpr = None if quadratic_nb_non_zeros > 0: qfactory = mdl._qfactory ind1, ind2, coefs = quadratic_component.unpack() quads = qfactory.term_dict_type() for idx1, idx2, coef in izip(ind1, ind2, coefs): quads[VarPair( cpx_var_index_to_docplex[idx1], cpx_var_index_to_docplex[idx2])] = coef else: # pragma: no cover # should not happen, but who knows quads = None quad_expr = mdl._aggregator._quad_factory.new_quad( quads=quads, linexpr=linexpr, safe=True) op = ComparisonType.cplex_ctsense_to_python_op(sense) ct = op(quad_expr, rhs) mdl.add_constraint(ct, ctname) # 4. upload indicators cpx_indicators = cpx.indicator_constraints nb_indicators = cpx_indicators.get_num() if nb_indicators: all_ind_names = [] if ignore_names else cls._safe_call_get_names( cpx_adapter, cpx_indicators.get_names) all_ind_bvars = cpx_indicators.get_indicator_variables() all_ind_rhs = cpx_indicators.get_rhs() all_ind_linearcts = cpx_indicators.get_linear_components() all_ind_senses = cpx_indicators.get_senses() all_ind_complemented = cpx_indicators.get_complemented() all_ind_types = cpx_indicators.get_types() ind_equiv_type = 3 for i in range(nb_indicators): ind_bvar = all_ind_bvars[i] ind_name = all_ind_names[i] if all_ind_names else None ind_rhs = all_ind_rhs[i] ind_linear = all_ind_linearcts[i] # SparsePair(ind, val) ind_sense = all_ind_senses[i] ind_complemented = all_ind_complemented[i] ind_type = all_ind_types[i] # 1 . check the bvar is ok ind_bvar = cpx_var_index_to_docplex[ind_bvar] # each var appears once ind_linexpr = cls._build_linear_expr_from_sparse_pair( lfactory, cpx_var_index_to_docplex, ind_linear) op = ComparisonType.cplex_ctsense_to_python_op(ind_sense) ind_lct = op(ind_linexpr, ind_rhs) if ind_type == ind_equiv_type: logct = lfactory.new_equivalence_constraint( ind_bvar, ind_lct, true_value=1 - ind_complemented, name=ind_name) else: logct = lfactory.new_indicator_constraint( ind_bvar, ind_lct, true_value=1 - ind_complemented, name=ind_name) mdl.add(logct) # 5. upload Piecewise linear constraints try: cpx_pwl = cpx.pwl_constraints cpx_pwl_defs = cpx_pwl.get_definitions() pwl_fallback_names = [""] * cpx_pwl.get_num() cpx_pwl_names = pwl_fallback_names if ignore_names else cls._safe_call_get_names( cpx_adapter, cpx_pwl.get_names, pwl_fallback_names) for (vary_idx, varx_idx, preslope, postslope, breakx, breaky), pwl_name in izip(cpx_pwl_defs, cpx_pwl_names): varx = cpx_var_index_to_docplex.get(varx_idx, None) vary = cpx_var_index_to_docplex.get(vary_idx, None) breakxy = [(brkx, brky) for brkx, brky in zip(breakx, breaky)] pwl_func = mdl.piecewise(preslope, breakxy, postslope, name=pwl_name) pwl_expr = mdl._lfactory.new_pwl_expr( pwl_func, varx, 0, add_counter_suffix=False, resolve=False) pwl_expr._f_var = vary pwl_expr._ensure_resolved() except AttributeError: # pragma: no cover pass # Do not check for PWLs if Cplex version does not support them # 6. upload objective # noinspection PyPep8 try: cpx_multiobj = cpx.multiobj except AttributeError: # pragma: no cover # pre-12.9 version cpx_multiobj = None if cpx_multiobj is None or cpx_multiobj.get_num() <= 1: cpx_obj = cpx.objective cpx_sense = cpx_obj.get_sense() cpx_all_lin_obj_coeffs = cpx_obj.get_linear() all_obj_vars = [] all_obj_coefs = [] for v in range(cpx_nb_vars): if v in cpx_var_index_to_docplex: obj_coeff = cpx_all_lin_obj_coeffs[v] all_obj_coefs.append(obj_coeff) all_obj_vars.append(cpx_var_index_to_docplex[v]) # obj_expr = mdl._aggregator._scal_prod(all_obj_vars, all_obj_coefs) obj_expr = cls._make_expr_from_vars_coefs( mdl, all_obj_vars, all_obj_coefs) if cpx_obj.get_num_quadratic_variables() > 0: cpx_all_quad_cols_coeffs = cpx_obj.get_quadratic() quads = qfactory.term_dict_type() for v, col_coefs in izip(cpx_var_index_to_docplex, cpx_all_quad_cols_coeffs): var1 = cpx_var_index_to_docplex[v] indices, coefs = col_coefs.unpack() for idx, coef in izip(indices, coefs): vp = VarPair(var1, cpx_var_index_to_docplex[idx]) quads[vp] = quads.get(vp, 0) + coef / 2 obj_expr += qfactory.new_quad(quads=quads, linexpr=None) obj_expr += cpx.objective.get_offset() is_maximize = cpx_sense == cpx_adapter.cplex_module._internal._subinterfaces.ObjSense.maximize if is_maximize: mdl.maximize(obj_expr) else: mdl.minimize(obj_expr) else: # we have multiple objective nb_multiobjs = cpx_multiobj.get_num() exprs = [0] * nb_multiobjs priorities = [1] * nb_multiobjs weights = [1] * nb_multiobjs abstols = [0] * nb_multiobjs reltols = [0] * nb_multiobjs names = cpx_multiobj.get_names() for m in range(nb_multiobjs): (obj_coeffs, obj_offset, weight, prio, abstol, reltol) = cpx_multiobj.get_definition(m) obj_expr = cls._make_expr_from_coef_vector( mdl, cpx_var_index_to_docplex, obj_coeffs, obj_offset) exprs[m] = obj_expr priorities[m] = prio weights[m] = weight abstols[m] = abstol reltols[m] = reltol sense = cpx_multiobj.get_sense() mdl.set_multi_objective(sense, exprs, priorities, weights, abstols, reltols, names) # upload sos cpx_sos = cpx.SOS cpx_sos_num = cpx_sos.get_num() if cpx_sos_num > 0: cpx_sos_types = cpx_sos.get_types() cpx_sos_indices = cpx_sos.get_sets() cpx_sos_names = cpx_sos.get_names() if not cpx_sos_names: cpx_sos_names = [None] * cpx_sos_num for sostype, sos_sparse, sos_name in izip( cpx_sos_types, cpx_sos_indices, cpx_sos_names): sos_var_indices = sos_sparse.ind sos_weights = sos_sparse.val isostype = int(sostype) sos_vars = [ cpx_var_index_to_docplex[var_ix] for var_ix in sos_var_indices ] mdl.add_sos(dvars=sos_vars, sos_arg=isostype, name=sos_name, weights=sos_weights) # upload lazy constraints cpx_linear_advanced = cpx.linear_constraints.advanced cpx_lazyct_num = cpx_linear_advanced.get_num_lazy_constraints() if cpx_lazyct_num: print( "WARNING: found {0} lazy constraints that cannot be uploaded to DOcplex" .format(cpx_lazyct_num)) mdl.output_level = final_output_level if final_checker: # need to restore checker mdl.set_checker(final_checker) except cpx_adapter.CplexError as cpx_e: # pragma: no cover print("* CPLEX error: {0!s} reading file {1}".format( cpx_e, filename)) mdl = None if debug_read: raise except ModelReaderError as mre: # pragma: no cover print("! Model reader error: {0!s} while reading file {1}".format( mre, filename)) mdl = None if debug_read: raise except DOcplexException as doe: # pragma: no cover print("! Internal DOcplex error: {0!s} while reading file {1}". format(doe, filename)) mdl = None if debug_read: raise # except Exception as any_e: # pragma: no cover # print("Internal exception raised: {0} msg={1!s} while reading file '{2}'".format(type(any_e), any_e, filename)) # mdl = None # if debug_read: # raise finally: # clean up CPLEX instance... cpx.end() return mdl
def read_model(self, filename, model_name=None, verbose=False, model_class=None, **kwargs): """ Reads a model from a CPLEX export file. Accepts all formats exported by CPLEX: LP, SAV, MPS. If an error occurs while reading the file, the message of the exception is printed and the function returns None. Args: filename: The file to read. model_name: An optional name for the newly created model. If None, the model name will be the path basename. verbose: An optional flag to print informative messages, default is False. model_class: An optional class type; must be a subclass of Model. The returned model is built using this model_class and the keyword arguments kwargs, if any. By default, the model is class is `Model` (see kwargs: A dict of keyword-based arguments that are used when creating the model instance. Example: `m = read_model("c:/temp/foo.mps", model_name="docplex_foo", solver_agent="docloud", output_level=100)` Returns: An instance of Model, or None if an exception is raised. See Also: :class:`docplex.mp.model.Model` """ if not Cplex: # pragma: no cover raise RuntimeError( "ModelReader.read_model() requires CPLEX runtime.") if not os.path.exists(filename): raise IOError("* file not found: {0}".format(filename)) # extract basename if model_name: name_to_use = model_name else: basename = os.path.basename(filename) dotpos = basename.find(".") if dotpos > 0: name_to_use = basename[:dotpos] else: name_to_use = basename model_class = model_class or Model if 0 == os.stat(filename).st_size: print("* file is empty: {0} - exiting".format(filename)) return model_class(name=name_to_use, **kwargs) # print("-> start reading file: {0}".format(filename)) cpx = self._cplex_read(filename, verbose=verbose) if not cpx: # pragma: no cover return None range_map = {} final_output_level = kwargs.get("output_level", "info") debug_read = kwargs.get("debug", False) try: # force no tck if 'checker' in kwargs: final_checker = kwargs['checker'] else: final_checker = 'default' # build the model with no checker, then restore final_checker in the end. kwargs['checker'] = 'off' # ------------- mdl = model_class(name=name_to_use, **kwargs) lfactory = mdl._lfactory qfactory = mdl._qfactory mdl.set_quiet() # output level set to ERROR vartype_cont = mdl.continuous_vartype vartype_map = { 'B': mdl.binary_vartype, 'I': mdl.integer_vartype, 'C': mdl.continuous_vartype, 'S': mdl.semicontinuous_vartype } # 1 upload variables cpx_nb_vars = cpx.variables.get_num() cpx_var_names = self._safe_call_get_names(cpx.variables) if cpx._is_MIP(): cpx_vartypes = [ vartype_map.get(cpxt, vartype_cont) for cpxt in cpx.variables.get_types() ] else: cpx_vartypes = [vartype_cont] * cpx_nb_vars cpx_var_lbs = cpx.variables.get_lower_bounds() cpx_var_ubs = cpx.variables.get_upper_bounds() # map from cplex variable indices to docplex's # use to skip range vars # cplex : [x, Rg1, y] -> {0:0, 2: 1} var_index_map = {} d = 0 model_varnames = [] model_lbs = [] model_ubs = [] model_types = [] for v in range(cpx_nb_vars): varname = cpx_var_names[v] if cpx_var_names else None if varname and varname.startswith("Rg"): # generated var for ranges range_map[v] = self._RangeData(var_index=v, var_name=varname, ub=cpx_var_ubs[v]) else: # docplex_var = lfactory.new_var(vartype, lb, ub, varname) var_index_map[v] = d model_varnames.append(varname) model_types.append(cpx_vartypes[v]) model_lbs.append(cpx_var_lbs[v]) model_ubs.append(cpx_var_ubs[v]) d += 1 # vars model_vars = lfactory.new_multitype_var_list( d, model_types, model_lbs, model_ubs, model_varnames) cpx_var_index_to_docplex = { v: model_vars[var_index_map[v]] for v in var_index_map.keys() } # 2. upload linear constraints and ranges (mixed in cplex) cpx_linearcts = cpx.linear_constraints nb_linear_cts = cpx_linearcts.get_num() all_rows = cpx_linearcts.get_rows() all_rhs = cpx_linearcts.get_rhs() all_senses = cpx_linearcts.get_senses() all_range_values = cpx_linearcts.get_range_values() cpx_ctnames = self._safe_call_get_names(cpx_linearcts) has_range = range_map or any(s == "R" for s in all_senses) deferred_cts = [] for c in range(nb_linear_cts): row = all_rows[c] sense = all_senses[c] rhs = all_rhs[c] ctname = cpx_ctnames[c] if cpx_ctnames else None range_val = all_range_values[c] indices = row.ind coefs = row.val range_data = None if not has_range: expr = mdl._aggregator._scal_prod( (cpx_var_index_to_docplex[idx] for idx in indices), coefs) op = ComparisonType.parse(sense) ct = lfactory._new_binary_constraint(lhs=expr, rhs=rhs, sense=op) ct.name = ctname deferred_cts.append(ct) else: expr = lfactory.linear_expr() rcoef = 1 for idx, koef in izip(indices, coefs): var = cpx_var_index_to_docplex.get(idx, None) if var: expr._add_term(var, koef) elif idx in range_map: # this is a range: coeff must be 1 or -1 abscoef = koef if koef >= 0 else -koef rcoef = koef assert abscoef == 1, "range var has coef different from 1: {}".format( koef) assert range_data is None, "range_data is not None: {0!s}".format( range_data) # cannot use two range vars range_data = range_map[idx] else: # pragma: no cover # this is an internal error. raise ModelReaderError( "ERROR: index not in var map or range map: {0}" .format(idx)) if range_data: label = ctname or 'c#%d' % (c + 1) if sense not in "EL": # pragma: no cover raise ModelReaderError( "{0} range sense is not E: {1!s}".format( label, sense)) if rcoef < 0: # -1 actually rng_lb = rhs rng_ub = rhs + range_data.ub elif rcoef > 0: # koef is 1 here rng_lb = rhs - range_data.ub rng_ub = rhs else: # pragma: no cover raise ModelReaderError( "unexpected range coef: {}".format(rcoef)) mdl.add_range(lb=rng_lb, expr=expr, ub=rng_ub, rng_name=ctname) else: if sense == 'R': # range min is rangeval range_lb = rhs range_ub = rhs + range_val mdl.add_range(lb=range_lb, ub=range_ub, expr=expr, rng_name=ctname) else: op = ComparisonType.cplex_ctsense_to_python_op( sense) ct = op(expr, rhs) mdl.add_constraint(ct, ctname) if deferred_cts: # add constraint as a block lfactory._post_constraint_block(posted_cts=deferred_cts) # 3. upload Quadratic constraints cpx_quadraticcts = cpx.quadratic_constraints nb_quadratic_cts = cpx_quadraticcts.get_num() all_rhs = cpx_quadraticcts.get_rhs() all_linear_nb_non_zeros = cpx_quadraticcts.get_linear_num_nonzeros( ) all_linear_components = cpx_quadraticcts.get_linear_components() all_quadratic_nb_non_zeros = cpx_quadraticcts.get_quad_num_nonzeros( ) all_quadratic_components = cpx_quadraticcts.get_quadratic_components( ) all_senses = cpx_quadraticcts.get_senses() cpx_ctnames = self._safe_call_get_names(cpx_quadraticcts) for c in range(nb_quadratic_cts): rhs = all_rhs[c] linear_nb_non_zeros = all_linear_nb_non_zeros[c] linear_component = all_linear_components[c] quadratic_nb_non_zeros = all_quadratic_nb_non_zeros[c] quadratic_component = all_quadratic_components[c] sense = all_senses[c] ctname = cpx_ctnames[c] if cpx_ctnames else None if linear_nb_non_zeros > 0: indices, coefs = linear_component.unpack() linexpr = mdl._aggregator._scal_prod( (cpx_var_index_to_docplex[idx] for idx in indices), coefs) else: linexpr = None if quadratic_nb_non_zeros > 0: qfactory = mdl._qfactory ind1, ind2, coefs = quadratic_component.unpack() quads = qfactory.term_dict_type() for idx1, idx2, coef in izip(ind1, ind2, coefs): quads[VarPair(cpx_var_index_to_docplex[idx1], cpx_var_index_to_docplex[idx2])] = coef else: # pragma: no cover # should not happen, but who knows quads = None quad_expr = mdl._aggregator._quad_factory.new_quad( quads=quads, linexpr=linexpr, safe=True) op = ComparisonType.cplex_ctsense_to_python_op(sense) ct = op(quad_expr, rhs) mdl.add_constraint(ct, ctname) # 4. upload indicators cpx_indicators = cpx.indicator_constraints nb_indicators = cpx_indicators.get_num() all_ind_names = self._safe_call_get_names(cpx_indicators) all_ind_bvars = cpx_indicators.get_indicator_variables() all_ind_rhs = cpx_indicators.get_rhs() all_ind_linearcts = cpx_indicators.get_linear_components() all_ind_senses = cpx_indicators.get_senses() all_ind_complemented = cpx_indicators.get_complemented() lfactory = mdl._lfactory for i in range(nb_indicators): ind_bvar = all_ind_bvars[i] ind_name = all_ind_names[i] if all_ind_names else None ind_rhs = all_ind_rhs[i] ind_linear = all_ind_linearcts[i] # SparsePair(ind, val) ind_sense = all_ind_senses[i] ind_complemented = all_ind_complemented[i] # 1 . check the bvar is ok ind_bvar = cpx_var_index_to_docplex[ind_bvar] # each var appears once ind_linexpr = self._build_linear_expr_from_sparse_pair( lfactory, cpx_var_index_to_docplex, ind_linear) op = ComparisonType.cplex_ctsense_to_python_op(ind_sense) ind_ct = op(ind_linexpr, ind_rhs) indct = lfactory.new_indicator_constraint(ind_bvar, ind_ct, active_value=1 - ind_complemented, name=ind_name) mdl.add(indct) # 5. upload Piecewise linear constraints try: cpx_pwl = cpx.pwl_constraints cpx_pwl_defs = cpx_pwl.get_definitions() pwl_fallback_names = [""] * cpx_pwl.get_num() cpx_pwl_names = self._safe_call_get_names( cpx_pwl, pwl_fallback_names) for (vary_idx, varx_idx, preslope, postslope, breakx, breaky), pwl_name in izip(cpx_pwl_defs, cpx_pwl_names): varx = cpx_var_index_to_docplex.get(varx_idx, None) vary = cpx_var_index_to_docplex.get(vary_idx, None) breakxy = [(brkx, brky) for brkx, brky in zip(breakx, breaky)] pwl_func = mdl.piecewise(preslope, breakxy, postslope, name=pwl_name) pwl_expr = mdl._lfactory.new_pwl_expr( pwl_func, varx, 0, add_counter_suffix=False, resolve=False) pwl_expr._f_var = vary pwl_expr._ensure_resolved() except AttributeError: # pragma: no cover pass # Do not check for PWLs if Cplex version does not support them # 6. upload objective cpx_obj = cpx.objective cpx_sense = cpx_obj.get_sense() cpx_all_lin_obj_coeffs = cpx_obj.get_linear() # noinspection PyPep8 all_obj_vars = [] all_obj_coefs = [] for v in range(cpx_nb_vars): if v in cpx_var_index_to_docplex: obj_coeff = cpx_all_lin_obj_coeffs[v] all_obj_coefs.append(obj_coeff) all_obj_vars.append(cpx_var_index_to_docplex[v]) # obj_expr._add_term(idx_to_var_map[v], cpx_all_obj_coeffs[v]) obj_expr = mdl._aggregator._scal_prod(all_obj_vars, all_obj_coefs) if cpx_obj.get_num_quadratic_variables() > 0: cpx_all_quad_cols_coeffs = cpx_obj.get_quadratic() quads = qfactory.term_dict_type() for v, col_coefs in izip(cpx_var_index_to_docplex, cpx_all_quad_cols_coeffs): var1 = cpx_var_index_to_docplex[v] indices, coefs = col_coefs.unpack() for idx, coef in izip(indices, coefs): vp = VarPair(var1, cpx_var_index_to_docplex[idx]) quads[vp] = quads.get(vp, 0) + coef / 2 obj_expr += qfactory.new_quad(quads=quads, linexpr=None) obj_expr += cpx.objective.get_offset() is_maximize = cpx_sense == ObjSense.maximize if is_maximize: mdl.maximize(obj_expr) else: mdl.minimize(obj_expr) # upload sos cpx_sos = cpx.SOS cpx_sos_num = cpx_sos.get_num() if cpx_sos_num > 0: cpx_sos_types = cpx_sos.get_types() cpx_sos_indices = cpx_sos.get_sets() cpx_sos_names = cpx_sos.get_names() if not cpx_sos_names: cpx_sos_names = [None] * cpx_sos_num for sostype, sos_sparse, sos_name in izip( cpx_sos_types, cpx_sos_indices, cpx_sos_names): sos_var_indices = sos_sparse.ind isostype = int(sostype) sos_vars = [ cpx_var_index_to_docplex[var_ix] for var_ix in sos_var_indices ] mdl.add_sos(dvars=sos_vars, sos_arg=isostype, name=sos_name) # upload lazy constraints cpx_linear_advanced = cpx.linear_constraints.advanced cpx_lazyct_num = cpx_linear_advanced.get_num_lazy_constraints() if cpx_lazyct_num: print( "WARNING: found {0} lazy constraints that cannot be uploaded to DOcplex" .format(cpx_lazyct_num)) mdl.output_level = final_output_level if final_checker: # need to restore checker mdl.set_checker(final_checker) except CplexError as cpx_e: # pragma: no cover print("* CPLEX error: {0!s} reading file {1}".format( cpx_e, filename)) mdl = None if debug_read: raise except ModelReaderError as mre: # pragma: no cover print("! Model reader error: {0!s} while reading file {1}".format( mre, filename)) mdl = None if debug_read: raise except DOcplexException as doe: # pragma: no cover print("! Internal DOcplex error: {0!s} while reading file {1}". format(doe, filename)) mdl = None if debug_read: raise except Exception as any_e: # pragma: no cover print("Internal exception raised: {0!s} while reading file {1}". format(any_e, filename)) mdl = None if debug_read: raise finally: # clean up CPLEX instance... del cpx return mdl
def matrix_constraints(self, coef_mat, dvars, rhs, sense='le'): """ Creates a list of linear constraints from a matrix of coefficients, a sequence of variables, and a sequence of numbers. This method returns the list of constraints built from A.X <op> B where A is the coefficient matrix (of size (M,N)), X is the variable sequence (size N), and B is the sequence of right-hand side values (of size M). <op> is the comparison operator that defines the sense of the constraint. By default, this generates a 'less-than-or-equal' constraint. Example: `Model.scal_prod_vars_triple([x, y], [z, t], [2, 3])` returns the expression `2xz + 3yt`. :param coef_mat: A matrix of coefficients with M rows and N columns. This argument accepts either a list of lists of numbers, a `numpy` array with size (M,N), or a `scipy` sparse matrix. :param dvars: An ordered sequence of decision variables: accepts a Python list, `numpy` array, or a `pandas` series. The size of the sequence must match the number of columns in the matrix. :param rhs: A sequence of numbers: accepts a Python list, a `numpy` array, or a `pandas` series. The size of the sequence must match the number of rows in the matrix. :param sense: A constraint sense \; accepts either a value of type `ComparisonType` or a string (e.g 'le', 'eq', 'ge'). :returns: A list of linear constraints. Example: If A is a matrix of coefficients with 2 rows and 3 columns:: A = [[1, 2, 3], [4, 5, 6]], X = [x, y, z] where x, y, and z are decision variables (size 3), and B = [100, 200], a sequence of numbers (size 2), then:: `mdl.matrix_constraint(A, X, B, 'GE')` returns a list of two constraints [(x + 2y+3z <= 100), (4x + 5y +6z <= 200)]. Note: If the dimensions of the matrix and variables or of the matrix and number sequence do not match, an error is raised. """ checker = self._checker if is_pandas_dataframe(coef_mat) or is_numpy_matrix( coef_mat) or is_scipy_sparse(coef_mat): nb_rows, nb_cols = coef_mat.shape else: # a sequence of sequences a_mat = list(coef_mat) nb_rows = len(a_mat) nb_cols = None try: shared_len = None for r in a_mat: checker.check_ordered_sequence(r, 'matrix_constraints') r_len = len(r) if shared_len is None: shared_len = r_len elif r_len != shared_len: self.fatal( 'All columns should have same length found {0} != {1}' .format(shared_len, r_len)) nb_cols = shared_len if shared_len is not None else 0 except AttributeError: self.fatal('All columns should have a len()') s_dvars = self._to_list(dvars, caller='Model.matrix-constraints()') s_rhs = self._to_list(rhs, caller='Model.matrix-constraints()') # check checker.typecheck_var_seq(s_dvars) for k in s_rhs: checker.typecheck_num(k) op = ComparisonType.parse(sense) # --- # check dimensions and whether to transpose or not. # --- nb_rhs = len(s_rhs) nb_vars = len(s_dvars) if (nb_rows, nb_cols) != (nb_rhs, nb_vars): self.fatal( 'Dimension error, matrix is ({0},{1}), expecting ({3}, {2})'. format(nb_rows, nb_cols, nb_vars, nb_rhs)) if is_scipy_sparse(coef_mat): return self._aggregator._sparse_matrix_constraints( coef_mat, s_dvars, s_rhs, op) else: return self._aggregator._matrix_constraints( coef_mat, s_dvars, s_rhs, op)
def get_constraint(self): var_ub = self.get_ub() op = ComparisonType.cplex_ctsense_to_python_op('L') ct = op(self.get_var(), var_ub) return ct
def is_satisfied(self, solution, tolerance): expr_value = self._input_var._get_solution_value(solution) y_value = solution._get_var_value(self._y) computed_f_expr_value = self._pwl_func.evaluate(expr_value) return ComparisonType.almost_equal(y_value, computed_f_expr_value, tolerance)
def is_satisfied(self, solution, tolerance=1e-6): is_ct_satisfied = self._linear_ct.is_satisfied(solution, tolerance) binary_value = solution.get_value(self._binary_var) expected_value = self._active_value if is_ct_satisfied else 1 - self._active_value return ComparisonType.almost_equal(binary_value, expected_value, tolerance)