Scippy

SCIP

Solving Constraint Integer Programs

cons_indicator.h
Go to the documentation of this file.
1/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2/* */
3/* This file is part of the program and library */
4/* SCIP --- Solving Constraint Integer Programs */
5/* */
6/* Copyright (c) 2002-2024 Zuse Institute Berlin (ZIB) */
7/* */
8/* Licensed under the Apache License, Version 2.0 (the "License"); */
9/* you may not use this file except in compliance with the License. */
10/* You may obtain a copy of the License at */
11/* */
12/* http://www.apache.org/licenses/LICENSE-2.0 */
13/* */
14/* Unless required by applicable law or agreed to in writing, software */
15/* distributed under the License is distributed on an "AS IS" BASIS, */
16/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */
17/* See the License for the specific language governing permissions and */
18/* limitations under the License. */
19/* */
20/* You should have received a copy of the Apache-2.0 license */
21/* along with SCIP; see the file LICENSE. If not visit scipopt.org. */
22/* */
23/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
24
25/**@file cons_indicator.h
26 * @ingroup CONSHDLRS
27 * @brief constraint handler for indicator constraints
28 * @author Marc Pfetsch
29 *
30 */
31
32/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
33
34#ifndef __SCIP_CONS_INDICATOR_H__
35#define __SCIP_CONS_INDICATOR_H__
36
37
38#include "scip/def.h"
39#include "scip/type_cons.h"
40#include "scip/type_lp.h"
41#include "scip/type_retcode.h"
42#include "scip/type_scip.h"
43#include "scip/type_sol.h"
44#include "scip/type_var.h"
45
46#ifdef __cplusplus
47extern "C" {
48#endif
49
50/** creates the handler for indicator constraints and includes it in SCIP
51 *
52 * @ingroup ConshdlrIncludes
53 * */
54SCIP_EXPORT
55SCIP_RETCODE SCIPincludeConshdlrIndicator(
56 SCIP* scip /**< SCIP data structure */
57 );
58
59/**@addtogroup CONSHDLRS
60 *
61 * @{
62 *
63 * @name Indicator Constraints
64 *
65 * @{
66 *
67 * An indicator constraint is given by a binary variable \f$z\f$ and an inequality \f$ax \leq
68 * b\f$. It states that if \f$z = 1\f$ then \f$ax \leq b\f$ holds.
69 *
70 * This constraint is handled by adding a slack variable \f$s:\; ax - s \leq b\f$ with \f$s \geq
71 * 0\f$. The constraint is enforced by fixing \f$s\f$ to 0 if \f$z = 1\f$.
72 *
73 * @note The constraint only implements an implication not an equivalence, i.e., it does not ensure
74 * that \f$z = 1\f$ if \f$ax \leq b\f$ or equivalently if \f$s = 0\f$ holds.
75 *
76 * This constraint is equivalent to a linear constraint \f$ax - s \leq b\f$ and an SOS1 constraint on
77 * \f$z\f$ and \f$s\f$ (at most one should be nonzero). In the indicator context we can, however,
78 * separate more inequalities.
79 */
80
81/** creates and captures an indicator constraint
82 *
83 * @note @a binvar is checked to be binary only later. This enables a change of the type in
84 * procedures reading an instance.
85 *
86 * @note the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()
87 */
88SCIP_EXPORT
89SCIP_RETCODE SCIPcreateConsIndicator(
90 SCIP* scip, /**< SCIP data structure */
91 SCIP_CONS** cons, /**< pointer to hold the created constraint (indicator or quadratic) */
92 const char* name, /**< name of constraint */
93 SCIP_VAR* binvar, /**< binary indicator variable (or NULL) */
94 int nvars, /**< number of variables in the inequality */
95 SCIP_VAR** vars, /**< array with variables of inequality (or NULL) */
96 SCIP_Real* vals, /**< values of variables in inequality (or NULL) */
97 SCIP_Real rhs, /**< rhs of the inequality */
98 SCIP_Bool initial, /**< should the LP relaxation of constraint be in the initial LP? Usually set to TRUE. */
99 SCIP_Bool separate, /**< should the constraint be separated during LP processing?
100 * Usually set to TRUE. */
101 SCIP_Bool enforce, /**< should the constraint be enforced during node processing?
102 * TRUE for model constraints, FALSE for additional, redundant constraints. */
103 SCIP_Bool check, /**< should the constraint be checked for feasibility?
104 * TRUE for model constraints, FALSE for additional, redundant constraints. */
105 SCIP_Bool propagate, /**< should the constraint be propagated during node processing?
106 * Usually set to TRUE. */
107 SCIP_Bool local, /**< is constraint only valid locally?
108 * Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints. */
109 SCIP_Bool dynamic, /**< is constraint subject to aging?
110 * Usually set to FALSE. Set to TRUE for own cuts which
111 * are separated as constraints. */
112 SCIP_Bool removable, /**< should the relaxation be removed from the LP due to aging or cleanup?
113 * Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'. */
114 SCIP_Bool stickingatnode /**< should the constraint always be kept at the node where it was added, even
115 * if it may be moved to a more global node?
116 * Usually set to FALSE. Set to TRUE to for constraints that represent node data. */
117 );
118
119/** creates and captures an indicator constraint in its most basic version, i. e., all constraint flags are set to their
120 * basic value as explained for the method SCIPcreateConsIndicator(); all flags can be set via
121 * SCIPsetConsFLAGNAME-methods in scip.h
122 *
123 * @see SCIPcreateConsIndicator() for information about the basic constraint flag configuration
124 *
125 * @note the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()
126 */
127SCIP_EXPORT
128SCIP_RETCODE SCIPcreateConsBasicIndicator(
129 SCIP* scip, /**< SCIP data structure */
130 SCIP_CONS** cons, /**< pointer to hold the created constraint (indicator or quadratic) */
131 const char* name, /**< name of constraint */
132 SCIP_VAR* binvar, /**< binary indicator variable (or NULL) */
133 int nvars, /**< number of variables in the inequality */
134 SCIP_VAR** vars, /**< array with variables of inequality (or NULL) */
135 SCIP_Real* vals, /**< values of variables in inequality (or NULL) */
136 SCIP_Real rhs /**< rhs of the inequality */
137 );
138
139/** creates and captures a indicator constraint in a more generic version.
140 *
141 * The key difference from SCIPcreateConsIndicator() is the activeone and lessthanineq Booleans.
142 * If \f$z = o\f$, with \f$o\f$ the activeone flag, then:
143 * if lessthanineq then \f$a^T x \leq b\f$ holds, else the passed vectors are assumed to be of the form \f$a^T x \geq b\f$.
144 * The underlying linear constraint is always created as a less-than inequality.
145 */
146SCIP_EXPORT
147SCIP_RETCODE SCIPcreateConsIndicatorGeneric(
148 SCIP* scip, /**< SCIP data structure */
149 SCIP_CONS** cons, /**< pointer to hold the created constraint (indicator or quadratic) */
150 const char* name, /**< name of constraint */
151 SCIP_VAR* binvar, /**< binary indicator variable (or NULL) */
152 int nvars, /**< number of variables in the inequality */
153 SCIP_VAR** vars, /**< array with variables of inequality (or NULL) */
154 SCIP_Real* vals, /**< values of variables in inequality (or NULL) */
155 SCIP_Real rhs, /**< rhs of the inequality */
156 SCIP_Bool activeone, /**< is the constraint active when the binary is 1? */
157 SCIP_Bool lessthanineq, /**< is the linear constraint a less than RHS (TRUE) or greater than RHS (FALSE)? */
158 SCIP_Bool initial, /**< should the LP relaxation of constraint be in the initial LP? Usually set to TRUE. */
159 SCIP_Bool separate, /**< should the constraint be separated during LP processing?
160 * Usually set to TRUE. */
161 SCIP_Bool enforce, /**< should the constraint be enforced during node processing?
162 * TRUE for model constraints, FALSE for additional, redundant constraints. */
163 SCIP_Bool check, /**< should the constraint be checked for feasibility?
164 * TRUE for model constraints, FALSE for additional, redundant constraints. */
165 SCIP_Bool propagate, /**< should the constraint be propagated during node processing?
166 * Usually set to TRUE. */
167 SCIP_Bool local, /**< is constraint only valid locally?
168 * Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints. */
169 SCIP_Bool dynamic, /**< is constraint subject to aging?
170 * Usually set to FALSE. Set to TRUE for own cuts which
171 * are separated as constraints. */
172 SCIP_Bool removable, /**< should the relaxation be removed from the LP due to aging or cleanup?
173 * Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'. */
174 SCIP_Bool stickingatnode /**< should the constraint always be kept at the node where it was added, even
175 * if it may be moved to a more global node?
176 * Usually set to FALSE. Set to TRUE to for constraints that represent node data. */
177 );
178
179/** creates and captures an indicator constraint with given linear constraint and slack variable
180 *
181 * @note @a binvar is checked to be binary only later. This enables a change of the type in
182 * procedures reading an instance.
183 *
184 * @note we assume that @a slackvar actually appears in @a lincons and we also assume that it takes
185 * the role of a slack variable!
186 *
187 * @note the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()
188 */
189SCIP_EXPORT
190SCIP_RETCODE SCIPcreateConsIndicatorLinCons(
191 SCIP* scip, /**< SCIP data structure */
192 SCIP_CONS** cons, /**< pointer to hold the created constraint */
193 const char* name, /**< name of constraint */
194 SCIP_VAR* binvar, /**< binary indicator variable */
195 SCIP_CONS* lincons, /**< linear constraint */
196 SCIP_VAR* slackvar, /**< slack variable */
197 SCIP_Bool initial, /**< should the LP relaxation of constraint be in the initial LP? Usually set to TRUE. */
198 SCIP_Bool separate, /**< should the constraint be separated during LP processing?
199 * Usually set to TRUE. */
200 SCIP_Bool enforce, /**< should the constraint be enforced during node processing?
201 * TRUE for model constraints, FALSE for additional, redundant constraints. */
202 SCIP_Bool check, /**< should the constraint be checked for feasibility?
203 * TRUE for model constraints, FALSE for additional, redundant constraints. */
204 SCIP_Bool propagate, /**< should the constraint be propagated during node processing?
205 * Usually set to TRUE. */
206 SCIP_Bool local, /**< is constraint only valid locally?
207 * Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints. */
208 SCIP_Bool dynamic, /**< is constraint subject to aging?
209 * Usually set to FALSE. Set to TRUE for own cuts which
210 * are separated as constraints. */
211 SCIP_Bool removable, /**< should the relaxation be removed from the LP due to aging or cleanup?
212 * Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'. */
213 SCIP_Bool stickingatnode /**< should the constraint always be kept at the node where it was added, even
214 * if it may be moved to a more global node?
215 * Usually set to FALSE. Set to TRUE to for constraints that represent node data. */
216 );
217
218/** creates and captures an indicator constraint with given linear constraint and slack variable
219 * in a generic version, i. e., with a flag activeone indicating whether the constraint is active on
220 * value 1 or 0 of the binary variable.
221
222 * @note @a binvar is checked to be binary only later. This enables a change of the type in
223 * procedures reading an instance.
224 *
225 * @note we assume that @a slackvar actually appears in @a lincons and we also assume that it takes
226 * the role of a slack variable!
227 *
228 * @note the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()
229 *
230 * @see SCIPcreateConsIndicatorLinCons() for information about the basic constraint flag configuration
231 */
232SCIP_EXPORT
233SCIP_RETCODE SCIPcreateConsIndicatorGenericLinCons(
234 SCIP* scip, /**< SCIP data structure */
235 SCIP_CONS** cons, /**< pointer to hold the created constraint */
236 const char* name, /**< name of constraint */
237 SCIP_VAR* binvar, /**< binary indicator variable */
238 SCIP_CONS* lincons, /**< linear constraint */
239 SCIP_VAR* slackvar, /**< slack variable */
240 SCIP_Bool activeone, /**< is the constraint active when the binary is 1? */
241 SCIP_Bool initial, /**< should the LP relaxation of constraint be in the initial LP? Usually set to TRUE. */
242 SCIP_Bool separate, /**< should the constraint be separated during LP processing?
243 * Usually set to TRUE. */
244 SCIP_Bool enforce, /**< should the constraint be enforced during node processing?
245 * TRUE for model constraints, FALSE for additional, redundant constraints. */
246 SCIP_Bool check, /**< should the constraint be checked for feasibility?
247 * TRUE for model constraints, FALSE for additional, redundant constraints. */
248 SCIP_Bool propagate, /**< should the constraint be propagated during node processing?
249 * Usually set to TRUE. */
250 SCIP_Bool local, /**< is constraint only valid locally?
251 * Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints. */
252 SCIP_Bool dynamic, /**< is constraint subject to aging?
253 * Usually set to FALSE. Set to TRUE for own cuts which
254 * are separated as constraints. */
255 SCIP_Bool removable, /**< should the relaxation be removed from the LP due to aging or cleanup?
256 * Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'. */
257 SCIP_Bool stickingatnode /**< should the constraint always be kept at the node where it was added, even
258 * if it may be moved to a more global node?
259 * Usually set to FALSE. Set to TRUE to for constraints that represent node data. */
260 );
261
262/** creates and captures an indicator constraint with given linear constraint and slack variable
263 * in its most basic version, i. e., all constraint flags are set to their basic value as explained for the
264 * method SCIPcreateConsIndicator(); all flags can be set via SCIPsetConsFLAGNAME-methods in scip.h
265
266 * @note @a binvar is checked to be binary only later. This enables a change of the type in
267 * procedures reading an instance.
268 *
269 * @note we assume that @a slackvar actually appears in @a lincons and we also assume that it takes
270 * the role of a slack variable!
271 *
272 * @note the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()
273 *
274 * @see SCIPcreateConsIndicatorLinCons() for information about the basic constraint flag configuration
275 *
276 * @note the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()
277 */
278SCIP_EXPORT
279SCIP_RETCODE SCIPcreateConsBasicIndicatorLinCons(
280 SCIP* scip, /**< SCIP data structure */
281 SCIP_CONS** cons, /**< pointer to hold the created constraint */
282 const char* name, /**< name of constraint */
283 SCIP_VAR* binvar, /**< binary indicator variable */
284 SCIP_CONS* lincons, /**< linear constraint */
285 SCIP_VAR* slackvar /**< slack variable */
286 );
287
288/** creates and captures an indicator constraint with given linear constraint in a generic version, i. e., with a flag
289 * activeone indicating whether the constraint is active on value 1 or 0 of the binary variable; no slack variable is
290 * specified
291
292 * @note @a binvar is checked to be binary only later. This enables a change of the type in
293 * procedures reading an instance.
294 *
295 * @note The linear constraint has to be single sided only, i.e., either rhs or lhs have to be infinite.
296 *
297 * @note the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()
298 *
299 * @see SCIPcreateConsIndicatorLinCons() for information about the basic constraint flag configuration
300 */
301SCIP_EXPORT
302SCIP_RETCODE SCIPcreateConsIndicatorGenericLinConsPure(
303 SCIP* scip, /**< SCIP data structure */
304 SCIP_CONS** cons, /**< pointer to hold the created constraint */
305 const char* name, /**< name of constraint */
306 SCIP_VAR* binvar, /**< binary indicator variable */
307 SCIP_CONS* lincons, /**< linear constraint */
308 SCIP_Bool activeone, /**< is the constraint active when the binary is 1? */
309 SCIP_Bool initial, /**< should the LP relaxation of constraint be in the initial LP? Usually set to TRUE. */
310 SCIP_Bool separate, /**< should the constraint be separated during LP processing?
311 * Usually set to TRUE. */
312 SCIP_Bool enforce, /**< should the constraint be enforced during node processing?
313 * TRUE for model constraints, FALSE for additional, redundant constraints. */
314 SCIP_Bool check, /**< should the constraint be checked for feasibility?
315 * TRUE for model constraints, FALSE for additional, redundant constraints. */
316 SCIP_Bool propagate, /**< should the constraint be propagated during node processing?
317 * Usually set to TRUE. */
318 SCIP_Bool local, /**< is constraint only valid locally?
319 * Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints. */
320 SCIP_Bool dynamic, /**< is constraint subject to aging?
321 * Usually set to FALSE. Set to TRUE for own cuts which
322 * are separated as constraints. */
323 SCIP_Bool removable, /**< should the relaxation be removed from the LP due to aging or cleanup?
324 * Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'. */
325 SCIP_Bool stickingatnode /**< should the constraint always be kept at the node where it was added, even
326 * if it may be moved to a more global node?
327 * Usually set to FALSE. Set to TRUE to for constraints that represent node data. */
328 );
329
330/** creates and captures an indicator constraint with given linear constraint; no slack variable is specified
331 *
332 * @note @a binvar is checked to be binary only later. This enables a change of the type in
333 * procedures reading an instance.
334 *
335 * @note The linear constraint has to be single sided only, i.e., either rhs or lhs have to be infinite.
336 *
337 * @note the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()
338 */
339SCIP_EXPORT
340SCIP_RETCODE SCIPcreateConsIndicatorLinConsPure(
341 SCIP* scip, /**< SCIP data structure */
342 SCIP_CONS** cons, /**< pointer to hold the created constraint */
343 const char* name, /**< name of constraint */
344 SCIP_VAR* binvar, /**< binary indicator variable */
345 SCIP_CONS* lincons, /**< linear constraint */
346 SCIP_Bool initial, /**< should the LP relaxation of constraint be in the initial LP? Usually set to TRUE. */
347 SCIP_Bool separate, /**< should the constraint be separated during LP processing?
348 * Usually set to TRUE. */
349 SCIP_Bool enforce, /**< should the constraint be enforced during node processing?
350 * TRUE for model constraints, FALSE for additional, redundant constraints. */
351 SCIP_Bool check, /**< should the constraint be checked for feasibility?
352 * TRUE for model constraints, FALSE for additional, redundant constraints. */
353 SCIP_Bool propagate, /**< should the constraint be propagated during node processing?
354 * Usually set to TRUE. */
355 SCIP_Bool local, /**< is constraint only valid locally?
356 * Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints. */
357 SCIP_Bool dynamic, /**< is constraint subject to aging?
358 * Usually set to FALSE. Set to TRUE for own cuts which
359 * are separated as constraints. */
360 SCIP_Bool removable, /**< should the relaxation be removed from the LP due to aging or cleanup?
361 * Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'. */
362 SCIP_Bool stickingatnode /**< should the constraint always be kept at the node where it was added, even
363 * if it may be moved to a more global node?
364 * Usually set to FALSE. Set to TRUE to for constraints that represent node data. */
365 );
366
367/** adds variable to the inequality of the indicator constraint */
368SCIP_EXPORT
369SCIP_RETCODE SCIPaddVarIndicator(
370 SCIP* scip, /**< SCIP data structure */
371 SCIP_CONS* cons, /**< indicator constraint */
372 SCIP_VAR* var, /**< variable to add to the inequality */
373 SCIP_Real val /**< value of variable */
374 );
375
376/** gets the linear constraint corresponding to the indicator constraint (may be NULL) */
377SCIP_EXPORT
378SCIP_CONS* SCIPgetLinearConsIndicator(
379 SCIP_CONS* cons /**< indicator constraint */
380 );
381
382/** sets the linear constraint corresponding to the indicator constraint (may be NULL) */
383SCIP_EXPORT
384SCIP_RETCODE SCIPsetLinearConsIndicator(
385 SCIP* scip, /**< SCIP data structure */
386 SCIP_CONS* cons, /**< indicator constraint */
387 SCIP_CONS* lincons /**< linear constraint */
388 );
389
390/** sets binary indicator variable for indicator constraint */
391SCIP_EXPORT
392SCIP_RETCODE SCIPsetBinaryVarIndicator(
393 SCIP* scip, /**< SCIP data structure */
394 SCIP_CONS* cons, /**< indicator constraint */
395 SCIP_VAR* binvar /**< binary variable to add to the inequality */
396 );
397
398/** gets activation value of an indicator constraint, TRUE for active on 1, FALSE for active on 0 */
399SCIP_EXPORT
400SCIP_Bool SCIPgetActiveOnIndicator(
401 SCIP_CONS* cons /**< indicator constraint */
402 );
403
404/** gets binary variable corresponding to indicator constraint. Returns the negative of the original binary variable if activeone was set to false */
405SCIP_EXPORT
406SCIP_VAR* SCIPgetBinaryVarIndicator(
407 SCIP_CONS* cons /**< indicator constraint */
408 );
409
410/** similar to SCIPgetBinaryVarIndicator but returns the original binary variable passed by the user. */
411SCIP_EXPORT
412SCIP_VAR* SCIPgetBinaryVarIndicatorGeneric(
413 SCIP_CONS* cons /**< indicator constraint */
414 );
415
416/** gets slack variable corresponding to indicator constraint */
417SCIP_EXPORT
418SCIP_VAR* SCIPgetSlackVarIndicator(
419 SCIP_CONS* cons /**< indicator constraint */
420 );
421
422/** sets upper bound for slack variable corresponding to indicator constraint
423 *
424 * Use with care if you know that the maximal violation of the corresponding constraint is at most @p ub. This bound
425 * might be improved automatically during the solution process.
426 *
427 * @pre This method should only be called if SCIP is in one of the following stages:
428 * - \ref SCIP_STAGE_INIT
429 * - \ref SCIP_STAGE_PROBLEM
430 */
431SCIP_EXPORT
432SCIP_RETCODE SCIPsetSlackVarUb(
433 SCIP* scip, /**< SCIP data structure */
434 SCIP_CONS* cons, /**< indicator constraint */
435 SCIP_Real ub /**< upper bound for slack variable */
436 );
437
438/** checks whether indicator constraint is violated w.r.t. sol */
439SCIP_EXPORT
440SCIP_Bool SCIPisViolatedIndicator(
441 SCIP* scip, /**< SCIP data structure */
442 SCIP_CONS* cons, /**< indicator constraint */
443 SCIP_SOL* sol /**< solution, or NULL to use current node's solution */
444 );
445
446/** based on values of other variables, computes slack and binary variable to turn constraint feasible */
447SCIP_EXPORT
448SCIP_RETCODE SCIPmakeIndicatorFeasible(
449 SCIP* scip, /**< SCIP data structure */
450 SCIP_CONS* cons, /**< indicator constraint */
451 SCIP_SOL* sol, /**< solution */
452 SCIP_Bool* changed /**< pointer to store whether the solution has been changed */
453 );
454
455/** based on values of other variables, computes slack and binary variable to turn all constraints feasible */
456SCIP_EXPORT
457SCIP_RETCODE SCIPmakeIndicatorsFeasible(
458 SCIP* scip, /**< SCIP data structure */
459 SCIP_CONSHDLR* conshdlr, /**< indicator constraint handler */
460 SCIP_SOL* sol, /**< solution */
461 SCIP_Bool* changed /**< pointer to store whether the solution has been changed */
462 );
463
464/** adds additional linear constraint that is not connected with an indicator constraint, but can be used for separation */
465SCIP_EXPORT
466SCIP_RETCODE SCIPaddLinearConsIndicator(
467 SCIP* scip, /**< SCIP data structure */
468 SCIP_CONSHDLR* conshdlr, /**< indicator constraint handler */
469 SCIP_CONS* lincons /**< linear constraint */
470 );
471
472/** adds additional globally valid row that is not connected with an indicator constraint, but can be used for separation */
473SCIP_EXPORT
474SCIP_RETCODE SCIPaddRowIndicator(
475 SCIP* scip, /**< SCIP data structure */
476 SCIP_CONSHDLR* conshdlr, /**< indicator constraint handler */
477 SCIP_ROW* row /**< row to add */
478 );
479
480/** @} */
481
482/** @} */
483
484#ifdef __cplusplus
485}
486#endif
487
488#endif
def.h
common defines and data types used in all packages of SCIP
SCIP_Bool
#define SCIP_Bool
Definition: def.h:91
SCIP_Real
#define SCIP_Real
Definition: def.h:172
SCIPcreateConsIndicatorGenericLinConsPure
SCIP_RETCODE SCIPcreateConsIndicatorGenericLinConsPure(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *binvar, SCIP_CONS *lincons, SCIP_Bool activeone, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)
Definition: cons_indicator.c:8500
SCIPcreateConsIndicatorLinCons
SCIP_RETCODE SCIPcreateConsIndicatorLinCons(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *binvar, SCIP_CONS *lincons, SCIP_VAR *slackvar, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)
Definition: cons_indicator.c:8420
SCIPcreateConsBasicIndicator
SCIP_RETCODE SCIPcreateConsBasicIndicator(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *binvar, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Real rhs)
Definition: cons_indicator.c:8231
SCIPgetBinaryVarIndicatorGeneric
SCIP_VAR * SCIPgetBinaryVarIndicatorGeneric(SCIP_CONS *cons)
Definition: cons_indicator.c:8914
SCIPsetSlackVarUb
SCIP_RETCODE SCIPsetSlackVarUb(SCIP *scip, SCIP_CONS *cons, SCIP_Real ub)
Definition: cons_indicator.c:9042
SCIPaddRowIndicator
SCIP_RETCODE SCIPaddRowIndicator(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_ROW *row)
Definition: cons_indicator.c:9377
SCIPcreateConsIndicatorGeneric
SCIP_RETCODE SCIPcreateConsIndicatorGeneric(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *binvar, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Real rhs, SCIP_Bool activeone, SCIP_Bool lessthanineq, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)
Definition: cons_indicator.c:7941
SCIPaddLinearConsIndicator
SCIP_RETCODE SCIPaddLinearConsIndicator(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *lincons)
Definition: cons_indicator.c:9345
SCIPsetLinearConsIndicator
SCIP_RETCODE SCIPsetLinearConsIndicator(SCIP *scip, SCIP_CONS *cons, SCIP_CONS *lincons)
Definition: cons_indicator.c:8811
SCIPcreateConsIndicator
SCIP_RETCODE SCIPcreateConsIndicator(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *binvar, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Real rhs, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)
Definition: cons_indicator.c:7900
SCIPcreateConsIndicatorGenericLinCons
SCIP_RETCODE SCIPcreateConsIndicatorGenericLinCons(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *binvar, SCIP_CONS *lincons, SCIP_VAR *slackvar, SCIP_Bool activeone, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)
Definition: cons_indicator.c:8264
SCIPcreateConsBasicIndicatorLinCons
SCIP_RETCODE SCIPcreateConsBasicIndicatorLinCons(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *binvar, SCIP_CONS *lincons, SCIP_VAR *slackvar)
Definition: cons_indicator.c:8469
SCIPmakeIndicatorsFeasible
SCIP_RETCODE SCIPmakeIndicatorsFeasible(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_SOL *sol, SCIP_Bool *changed)
Definition: cons_indicator.c:9298
SCIPgetBinaryVarIndicator
SCIP_VAR * SCIPgetBinaryVarIndicator(SCIP_CONS *cons)
Definition: cons_indicator.c:8898
SCIPgetSlackVarIndicator
SCIP_VAR * SCIPgetSlackVarIndicator(SCIP_CONS *cons)
Definition: cons_indicator.c:9017
SCIPgetLinearConsIndicator
SCIP_CONS * SCIPgetLinearConsIndicator(SCIP_CONS *cons)
Definition: cons_indicator.c:8794
SCIPsetBinaryVarIndicator
SCIP_RETCODE SCIPsetBinaryVarIndicator(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *binvar)
Definition: cons_indicator.c:8936
SCIPmakeIndicatorFeasible
SCIP_RETCODE SCIPmakeIndicatorFeasible(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Bool *changed)
Definition: cons_indicator.c:9123
SCIPcreateConsIndicatorLinConsPure
SCIP_RETCODE SCIPcreateConsIndicatorLinConsPure(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *binvar, SCIP_CONS *lincons, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)
Definition: cons_indicator.c:8726
SCIPisViolatedIndicator
SCIP_Bool SCIPisViolatedIndicator(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol)
Definition: cons_indicator.c:9068
SCIPaddVarIndicator
SCIP_RETCODE SCIPaddVarIndicator(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real val)
Definition: cons_indicator.c:8759
SCIPgetActiveOnIndicator
SCIP_Bool SCIPgetActiveOnIndicator(SCIP_CONS *cons)
Definition: cons_indicator.c:8881
SCIPincludeConshdlrIndicator
SCIP_RETCODE SCIPincludeConshdlrIndicator(SCIP *scip)
Definition: cons_indicator.c:7626
SCIP_Cons
Definition: struct_cons.h:47
SCIP_Conshdlr
Definition: struct_cons.h:127
SCIP_Row
Definition: struct_lp.h:202
SCIP_Sol
Definition: struct_sol.h:74
SCIP_Var
Definition: struct_var.h:208
type_cons.h
type definitions for constraints and constraint handlers
type_lp.h
type definitions for LP management
type_retcode.h
type definitions for return codes for SCIP methods
SCIP_RETCODE
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:63
type_scip.h
type definitions for SCIP's main datastructure
type_sol.h
type definitions for storing primal CIP solutions
type_var.h
type definitions for problem variables