type_cons.h
Go to the documentation of this file.
34 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
53 typedef struct SCIP_Conshdlr SCIP_CONSHDLR; /**< constraint handler for a specific constraint type */
56 typedef struct SCIP_ConsData SCIP_CONSDATA; /**< locally defined constraint type specific data */
57 typedef struct SCIP_ConsSetChg SCIP_CONSSETCHG; /**< tracks additions and removals of the set of active constraints */
58 typedef struct SCIP_LinConsStats SCIP_LINCONSSTATS; /**< linear constraint classification statistics used for MIPLIB */
67 SCIP_LINCONSTYPE_PRECEDENCE = 4, /**< linear constraints of the type \f$ a x - a y \leq b\f$ where \f$x\f$ and \f$y\f$ must have the same type */
68 SCIP_LINCONSTYPE_VARBOUND = 5, /**< linear constraints of the form \f$ ax + by \leq c \, x \in \{0,1\} \f$ */
69 SCIP_LINCONSTYPE_SETPARTITION = 6, /**< linear constraints of the form \f$ \sum x_i = 1\, x_i \in \{0,1\} \forall i \f$ */
70 SCIP_LINCONSTYPE_SETPACKING = 7, /**< linear constraints of the form \f$ \sum x_i \leq 1\, x_i \in \{0,1\} \forall i \f$ */
71 SCIP_LINCONSTYPE_SETCOVERING = 8, /**< linear constraints of the form \f$ \sum x_i \geq 1\, x_i \in \{0,1\} \forall i \f$ */
72 SCIP_LINCONSTYPE_CARDINALITY = 9, /**< linear constraints of the form \f$ \sum x_i = k\, x_i \in \{0,1\} \forall i, \, k\geq 2 \f$ */
73 SCIP_LINCONSTYPE_INVKNAPSACK = 10, /**< linear constraints of the form \f$ \sum x_i \leq b\, x_i \in \{0,1\} \forall i, \, b\in \mathbb{n} \geq 2 \f$ */
74 SCIP_LINCONSTYPE_EQKNAPSACK = 11, /**< linear constraints of the form \f$ \sum a_i x_i = b\, x_i \in \{0,1\} \forall i, \, b\in \mathbb{n} \geq 2 \f$ */
75 SCIP_LINCONSTYPE_BINPACKING = 12, /**< linear constraints of the form \f$ \sum a_i x_i + a x \leq a\, x, x_i \in \{0,1\} \forall i, \, a\in \mathbb{n} \geq 2 \f$ */
76 SCIP_LINCONSTYPE_KNAPSACK = 13, /**< linear constraints of the form \f$ \sum a_k x_k \leq b\, x_i \in \{0,1\} \forall i, \, b\in \mathbb{n} \geq 2 \f$ */
77 SCIP_LINCONSTYPE_INTKNAPSACK = 14, /**< linear constraints of the form \f$ \sum a_k x_k \leq b\, x_i \in \mathbb{Z} \forall i, \, b\in \mathbb{n} \f$ */
78 SCIP_LINCONSTYPE_MIXEDBINARY = 15, /**< linear constraints of the form \f$ \sum a_k x_k + \sum p_j s_j \leq/= b\, x_i \in \{0,1\} \forall i, s_j \in \text{ cont. } \forall j\f$ */
87 * If the copy process was one to one, the valid pointer can be set to TRUE. Otherwise, this pointer has to be set to
88 * FALSE. If all problem defining objects (constraint handlers and variable pricers) return valid = TRUE for all
89 * their copying calls, SCIP assumes that it is an overall one to one copy of the original instance. In this case any
90 * reductions made in the copied SCIP instance can be transfered to the original SCIP instance. If the valid pointer is
91 * set to TRUE and it was not a one to one copy, it might happen that optimal solutions are cut off.
98 #define SCIP_DECL_CONSHDLRCOPY(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_Bool* valid)
100 /** destructor of constraint handler to free constraint handler data (called when SCIP is exiting)
116 #define SCIP_DECL_CONSINIT(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss)
126 #define SCIP_DECL_CONSEXIT(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss)
128 /** presolving initialization method of constraint handler (called when presolving is about to begin)
130 * This method is called when the presolving process is about to begin, even if presolving is turned off.
133 * Necessary modifications that have to be performed even if presolving is turned off should be done here or in the
136 * @note Note that the constraint array might contain constraints that were created but not added to the problem.
137 * Constraints that are not added, i.e., for which SCIPconsIsAdded() returns FALSE, cannot be used for problem
146 #define SCIP_DECL_CONSINITPRE(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss)
148 /** presolving deinitialization method of constraint handler (called after presolving has been finished)
150 * This method is called after the presolving has been finished, even if presolving is turned off.
153 * Necessary modifications that have to be performed even if presolving is turned off should be done here or in the
156 * Besides necessary modifications and clean up, no time consuming operations should be performed, especially if the
157 * problem has already been solved. Use the method SCIPgetStatus(), which in this case returns SCIP_STATUS_OPTIMAL,
160 * @note Note that the constraint array might contain constraints that were created but not added to the problem.
161 * Constraints that are not added, i.e., for which SCIPconsIsAdded() returns FALSE, cannot be used for problem
170 #define SCIP_DECL_CONSEXITPRE(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss)
172 /** solving process initialization method of constraint handler (called when branch and bound process is about to begin)
174 * This method is called when the presolving was finished and the branch and bound process is about to begin.
177 * Besides necessary modifications and clean up, no time consuming operations should be performed, especially if the
178 * problem has already been solved. Use the method SCIPgetStatus(), which in this case returns SCIP_STATUS_OPTIMAL,
181 * @note Note that the constraint array might contain constraints that were created but not added to the problem.
182 * Constraints that are not added, i.e., for which SCIPconsIsAdded() returns FALSE, cannot be used for problem
191 #define SCIP_DECL_CONSINITSOL(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss)
193 /** solving process deinitialization method of constraint handler (called before branch and bound process data is freed)
196 * The constraint handler should use this call to clean up its branch and bound data, in particular to release
206 #define SCIP_DECL_CONSEXITSOL(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, SCIP_Bool restart)
210 * @warning There may exist unprocessed events. For example, a variable's bound may have been already changed, but the
219 #define SCIP_DECL_CONSDELETE(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SCIP_CONSDATA** consdata)
229 #define SCIP_DECL_CONSTRANS(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* sourcecons, SCIP_CONS** targetcons)
231 /** LP initialization method of constraint handler (called before the initial LP relaxation at a node is solved)
233 * Puts the LP relaxations of all "initial" constraints into the LP. The method should put a canonic LP relaxation
236 * @warning It is not guaranteed that the problem is going to be declared infeasible if the infeasible pointer is set
237 * to TRUE. Therefore, it is recommended that users do not end this method prematurely when an infeasiblity
249 #define SCIP_DECL_CONSINITLP(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, SCIP_Bool* infeasible)
253 * Separates all constraints of the constraint handler. The method is called in the LP solution loop,
256 * The first nusefulconss constraints are the ones, that are identified to likely be violated. The separation
257 * method should process only the useful constraints in most runs, and only occasionally the remaining
268 * possible return values for *result (if more than one applies, the first in the list should be used):
273 * - SCIP_NEWROUND : a cutting plane was generated and a new separation round should immediately start
274 * - SCIP_DIDNOTFIND : the separator searched, but did not find domain reductions, cutting planes, or cut constraints
278 #define SCIP_DECL_CONSSEPALP(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, \
283 * Separates all constraints of the constraint handler. The method is called outside the LP solution loop (e.g., by
287 * The first nusefulconss constraints are the ones, that are identified to likely be violated. The separation
288 * method should process only the useful constraints in most runs, and only occasionally the remaining
300 * possible return values for *result (if more than one applies, the first in the list should be used):
305 * - SCIP_NEWROUND : a cutting plane was generated and a new separation round should immediately start
306 * - SCIP_DIDNOTFIND : the separator searched, but did not find domain reductions, cutting planes, or cut constraints
310 #define SCIP_DECL_CONSSEPASOL(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, \
315 * The method is called at the end of the node processing loop for a node where the LP was solved.
316 * The LP solution has to be checked for feasibility. If possible, an infeasibility should be resolved by
317 * branching, reducing a variable's domain to exclude the solution or separating the solution with a valid
320 * The enforcing methods of the active constraint handlers are called in decreasing order of their enforcing
321 * priorities until the first constraint handler returned with the value SCIP_CUTOFF, SCIP_SEPARATED,
323 * The integrality constraint handler has an enforcing priority of zero. A constraint handler which can
324 * (or wants) to enforce its constraints only for integral solutions should have a negative enforcing priority
326 * A constraint handler which wants to incorporate its own branching strategy even on non-integral
327 * solutions must have an enforcing priority greater than zero (e.g. the SOS-constraint incorporates
330 * The first nusefulconss constraints are the ones, that are identified to likely be violated. The enforcing
331 * method should process the useful constraints first. The other nconss - nusefulconss constraints should only
343 * possible return values for *result (if more than one applies, the first in the list should be used):
348 * - SCIP_SOLVELP : the LP should be solved again because the LP primal feasibility tolerance has been tightened
349 * - SCIP_BRANCHED : no changes were made to the problem, but a branching was applied to resolve an infeasibility
353 #define SCIP_DECL_CONSENFOLP(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, \
368 * possible return values for *result (if more than one applies, the first in the list should be used):
373 * - SCIP_BRANCHED : no changes were made to the problem, but a branching was applied to resolve an infeasibility
374 * - SCIP_SOLVELP : at least one constraint is infeasible, and this can only be resolved by solving the LP
379 #define SCIP_DECL_CONSENFORELAX(x) SCIP_RETCODE x (SCIP* scip, SCIP_SOL* sol, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, \
384 * The method is called at the end of the node processing loop for a node where the LP was not solved.
385 * The pseudo solution has to be checked for feasibility. If possible, an infeasibility should be resolved by
386 * branching, reducing a variable's domain to exclude the solution or adding an additional constraint.
387 * Separation is not possible, since the LP is not processed at the current node. All LP informations like
390 * Like in the enforcing method for LP solutions, the enforcing methods of the active constraint handlers are
391 * called in decreasing order of their enforcing priorities until the first constraint handler returned with
394 * The first nusefulconss constraints are the ones, that are identified to likely be violated. The enforcing
395 * method should process the useful constraints first. The other nconss - nusefulconss constraints should only
398 * If the pseudo solution's objective value is lower than the lower bound of the node, it cannot be feasible
399 * and the enforcing method may skip it's check and set *result to SCIP_DIDNOTRUN. However, it can also process
412 * possible return values for *result (if more than one applies, the first in the list should be used):
416 * - SCIP_BRANCHED : no changes were made to the problem, but a branching was applied to resolve an infeasibility
417 * - SCIP_SOLVELP : at least one constraint is infeasible, and this can only be resolved by solving the LP
422 #define SCIP_DECL_CONSENFOPS(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, \
429 * The check methods of the active constraint handlers are called in decreasing order of their check
431 * The integrality constraint handler has a check priority of zero. A constraint handler which can
432 * (or wants) to check its constraints only for integral solutions should have a negative check priority
434 * A constraint handler which wants to check feasibility even on non-integral solutions must have a
435 * check priority greater than zero (e.g. if the check is much faster than testing all variables for
438 * In some cases, integrality conditions or rows of the current LP don't have to be checked, because their
442 * If the solution is not NULL, SCIP should also be informed about the constraint violation with a call to
443 * SCIPupdateSolConsViolation() and additionally SCIPupdateSolLPRowViolation() for every row of the constraint's current
446 * is represented completely by a set of LP rows, meaning that the current constraint violation is equal to the maximum
465 #define SCIP_DECL_CONSCHECK(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, SCIP_SOL* sol, \
466 SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool printreason, SCIP_Bool completely, SCIP_RESULT* result)
470 * The first nusefulconss constraints are the ones, that are identified to likely be violated. The propagation
471 * method should process only the useful constraints in most runs, and only occasionally the remaining
474 * @note if the constraint handler uses dual information in propagation it is nesassary to check via calling
475 * SCIPallowWeakDualReds and SCIPallowStrongDualReds if dual reductions and propgation with the current cutoff bound, resp.,
494 * - SCIP_DELAYNODE : the current node should be postponed (return value only valid for BEFORELP propagation)
496 #define SCIP_DECL_CONSPROP(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, \
513 * - nnewchgvartypes : number of variable type changes since the last call to the presolving method
514 * - nnewchgbds : number of variable bounds tightened since the last call to the presolving method
520 * - nnewchgsides : number of changed left or right hand sides since the last call to the presolving method
522 * @note the counters state the changes since the last call including the changes of this presolving method during its
525 * @note if the constraint handler performs dual presolving it is nesassary to check via calling SCIPallowWeakDualReds
538 * - nchgsides : pointer to count total number of changed left/right hand sides of all presolvers
544 * - SCIP_UNBOUNDED : at least one variable is not bounded by any constraint in obj. direction -> problem is unbounded
545 * - SCIP_CUTOFF : at least one constraint is infeasible in the variable's bounds -> problem is infeasible
551 #define SCIP_DECL_CONSPRESOL(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nrounds, \
552 SCIP_PRESOLTIMING presoltiming, int nnewfixedvars, int nnewaggrvars, int nnewchgvartypes, int nnewchgbds, int nnewholes, \
555 int* ndelconss, int* naddconss, int* nupgdconss, int* nchgcoefs, int* nchgsides, SCIP_RESULT* result)
559 * This method is called during conflict analysis. If the constraint handler wants to support conflict analysis,
560 * it should call SCIPinferVarLbCons() or SCIPinferVarUbCons() in domain propagation instead of SCIPchgVarLb() or
562 * In the SCIPinferVarLbCons() and SCIPinferVarUbCons() calls, the handler provides the constraint, that deduced the
564 * The propagation conflict resolving method can then be implemented, to provide a "reason" for the bound
565 * changes, i.e., the bounds of variables at the time of the propagation, that forced the constraint to set the
566 * conflict variable's bound to its current value. It can use the "inferinfo" tag to identify its own propagation
567 * rule and thus identify the "reason" bounds. The bounds that form the reason of the assignment must then be provided
568 * by calls to SCIPaddConflictLb(), SCIPaddConflictUb(), SCIPaddConflictBd(), SCIPaddConflictRelaxedLb(),
569 * SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), and/or SCIPaddConflictBinvar() in the propagation conflict
572 * For example, the logicor constraint c = "x or y or z" fixes variable z to TRUE (i.e. changes the lower bound of z
573 * to 1.0), if both, x and y, are assigned to FALSE (i.e. if the upper bounds of these variables are 0.0). It uses
574 * SCIPinferVarLbCons(scip, z, 1.0, c, 0) to apply this assignment (an inference information tag is not needed by the
576 * In the conflict analysis, the constraint handler may be asked to resolve the lower bound change on z with
578 * With a call to SCIPgetVarLbAtIndex(scip, z, bdchgidx, TRUE), the handler can find out, that the lower bound of
579 * variable z was set to 1.0 at the given point of time, and should call SCIPaddConflictUb(scip, x, bdchgidx) and
580 * SCIPaddConflictUb(scip, y, bdchgidx) to tell SCIP, that the upper bounds of x and y at this point of time were
588 * - inferinfo : the user information passed to the corresponding SCIPinferVarLbCons() or SCIPinferVarUbCons() call
590 * - bdchgidx : the index of the bound change, representing the point of time where the change took place
597 * - SCIP_SUCCESS : the conflicting bound change has been successfully resolved by adding all reason bounds
598 * - SCIP_DIDNOTFIND : the conflicting bound change could not be resolved and has to be put into the conflict set
602 #define SCIP_DECL_CONSRESPROP(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, \
603 SCIP_VAR* infervar, int inferinfo, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX* bdchgidx, SCIP_Real relaxedbd, \
609 * It should update the rounding locks of the given type of all associated variables with calls to
613 * potentially rendering the (positive) constraint infeasible and rounding up is potentially rendering the
617 * potentially rendering the constraint's negation infeasible and rounding up is potentially rendering the
619 * - If the constraint may get violated by changing the variable in any direction, it should call
622 * Consider the linear constraint "3x -5y +2z <= 7" as an example. The variable rounding lock method of the
623 * linear constraint handler should call SCIPaddVarLocksType(scip, x, locktype, nlocksneg, nlockspos),
625 * SCIPaddVarLocksType(scip, z, type, nlocksneg, nlockspos) to tell SCIP, that rounding up of x and z and rounding
626 * down of y can destroy the feasibility of the constraint, while rounding down of x and z and rounding up of y can
629 * SCIPaddVarLocksType(scip, ..., nlockspos + nlocksneg, nlockspos + nlocksneg) on all variables, since rounding in both
630 * directions of each variable can destroy both the feasibility of the constraint and it's negation
633 * If the constraint itself contains other constraints as sub constraints (e.g. the "or" constraint concatenation
634 * "c(x) or d(x)"), the rounding lock methods of these constraints should be called in a proper way.
636 * SCIPaddConsLocksType(scip, c, locktype, nlockspos, nlocksneg), saying that infeasibility of c may lead to
637 * infeasibility of the (positive) constraint, and infeasibility of c's negation (i.e. feasibility of c) may lead
639 * - If the constraint may get violated by the feasibility of the sub constraint c, it should call
640 * SCIPaddConsLocksType(scip, c, locktype, nlocksneg, nlockspos), saying that infeasibility of c may lead to
641 * infeasibility of the constraint's negation (i.e. feasibility of the constraint), and infeasibility of c's negation
643 * - If the constraint may get violated by any change in the feasibility of the sub constraint c, it should call
646 * Consider the or concatenation "c(x) or d(x)". The variable rounding lock method of the or constraint handler
648 * SCIPaddConsLocksType(scip, d, locktype, nlockspos, nlocksneg) to tell SCIP, that infeasibility of c and d can lead
651 * As a second example, consider the equivalence constraint "y <-> c(x)" with variable y and constraint c. The
652 * constraint demands, that y == 1 if and only if c(x) is satisfied. The variable lock method of the corresponding
653 * constraint handler should call SCIPaddVarLocksType(scip, y, locktype, nlockspos + nlocksneg, nlockspos + nlocksneg) and
654 * SCIPaddConsLocksType(scip, c, locktype, nlockspos + nlocksneg, nlockspos + nlocksneg), because any modification to the
655 * value of y or to the feasibility of c can alter the feasibility of the equivalence constraint.
660 * - cons : the constraint that should lock rounding of its variables, or NULL if the constraint handler
663 * - nlockspos : number of times, the roundings should be locked for the constraint (may be negative)
664 * - nlocksneg : number of times, the roundings should be locked for the constraint's negation (may be negative)
666 #define SCIP_DECL_CONSLOCK(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SCIP_LOCKTYPE locktype, int nlockspos, int nlocksneg)
670 * WARNING! There may exist unprocessed events. For example, a variable's bound may have been already changed, but
673 * This method is always called after a constraint of the constraint handler was activated. The constraint
681 #define SCIP_DECL_CONSACTIVE(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons)
685 * WARNING! There may exist unprocessed events. For example, a variable's bound may have been already changed, but
688 * This method is always called before a constraint of the constraint handler is deactivated. The constraint
696 #define SCIP_DECL_CONSDEACTIVE(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons)
700 * WARNING! There may exist unprocessed events. For example, a variable's bound may have been already changed, but
703 * This method is always called after a constraint of the constraint handler was enabled. The constraint
711 #define SCIP_DECL_CONSENABLE(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons)
715 * WARNING! There may exist unprocessed events. For example, a variable's bound may have been already changed, but
718 * This method is always called before a constraint of the constraint handler is disabled. The constraint
726 #define SCIP_DECL_CONSDISABLE(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons)
730 * This method is optinal and only of interest if you are using SCIP as a branch-and-price framework. That means, you
731 * are generating new variables during the search. If you are not doing that just define the function pointer to be
734 * If this method gets implemented you should iterate over all constraints of the constraint handler and delete all
743 #define SCIP_DECL_CONSDELVARS(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss)
747 * The constraint handler can store a representation of the constraint into the given text file. Use the method
750 * @note There are several methods which help to display variables. These are SCIPwriteVarName(), SCIPwriteVarsList(),
759 #define SCIP_DECL_CONSPRINT(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, FILE* file)
763 * The constraint handler can provide a copy method which copies a constraint from one SCIP data structure into an other
764 * SCIP data structure. If a copy of a constraint is created, the constraint has to be captured. (The capture is usually
767 * If the copy process was one to one, the valid pointer can be set to TRUE. Otherwise, you have to set this pointer to
768 * FALSE. In case all problem defining objects (constraint handlers and variable pricers) return a TRUE valid for all
769 * their copying calls, SCIP assumes that it is a overall one to one copy of the original instance. In this case any
770 * reductions made in the copied SCIP instance can be transfered to the original SCIP instance. If the valid pointer is
771 * set to TRUE and it was not a one to one copy, it might happen that optimal solutions are cut off.
782 * - varmap : a SCIP_HASHMAP mapping variables of the source SCIP to corresponding variables of the target SCIP
783 * - consmap : a SCIP_HASHMAP mapping constraints of the source SCIP to corresponding constraints of the target SCIP
801 SCIP* sourcescip, SCIP_CONSHDLR* sourceconshdlr, SCIP_CONS* sourcecons, SCIP_HASHMAP* varmap, SCIP_HASHMAP* consmap, \
802 SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, \
803 SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode, \
808 * The constraint handler can provide a callback to parse the output created by the display method
811 * @note For parsing there are several methods which are handy. Have a look at: SCIPparseVarName(),
812 * SCIPparseVarsList(), SCIPparseVarsLinearsum(), SCIPparseVarsPolynomial(), SCIPstrToRealValue(), and
835 #define SCIP_DECL_CONSPARSE(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** cons, \
837 SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, \
838 SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode, SCIP_Bool* success)
842 * The constraint handler can (this callback is optional) provide this callback to return the variables which are
843 * involved in that particular constraint. If this is possible, the variables should be copyied into the variables
844 * array and the success pointers has to be set to TRUE. Otherwise the success has to be set FALSE or the callback
851 * - varssize : available slots in vars array which is needed to check if the array is large enough
857 #define SCIP_DECL_CONSGETVARS(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, \
862 * The constraint handler can (this callback is optional) provide this callback to return the number variable which are
863 * involved in that particular constraint. If this is not possible, the success pointers has to be set to FALSE or the
873 * - success : pointer to store whether the constraint successfully returned the number of variables
875 #define SCIP_DECL_CONSGETNVARS(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, \
880 * This callback is used inside the various diving heuristics of SCIP and does not affect the normal branching of the
881 * actual search. The constraint handler can provide this callback to render the current solution (even more)
882 * infeasible by suggesting one or several variable bound changes. In fact, since diving heuristics do not necessarily
883 * solve LP relaxations at every probing depth, some of the variable local bounds might already be conflicting with the
884 * solution values. The solution is rendered infeasible by determining bound changes that should be applied to the
885 * next explored search node via SCIPaddDiveBoundChange(). An alternative in case that the preferred bound change(s)
888 * The constraint handler must take care to only add bound changes that further shrink the variable domain.
890 * The success pointer must be used to indicate whether the constraint handler succeeded in selecting diving bound
891 * changes. The infeasible pointer should be set to TRUE if the constraint handler found a local infeasibility. If the
892 * constraint handler needs to select between several candidates, it may use the scoring mechanism of the diveset
897 * @note: @p sol is usually the LP relaxation solution unless the caller of the method, usually a diving heuristic,
907 * - success : pointer to store whether the constraint handler succeeded to determine dive bound changes
908 * - infeasible : pointer to store whether the constraint handler detected an infeasibility in the local node
910 #define SCIP_DECL_CONSGETDIVEBDCHGS(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_DIVESET* diveset, \
Definition: struct_cons.h:280
Definition: type_cons.h:77
timing definitions for SCIP
Definition: type_cons.h:73
Definition: type_cons.h:79
Definition: type_cons.h:71
type definitions for return codes for SCIP methods
Definition: type_cons.h:76
type definitions for LP management
Definition: type_cons.h:64
Definition: type_cons.h:66
Definition: struct_cons.h:37
type definitions for primal heuristics
Definition: struct_cons.h:117
type definitions for SCIP's main datastructure
Definition: type_cons.h:72
type definitions for problem variables
Definition: type_cons.h:63
Definition: type_cons.h:68
Definition: type_cons.h:78
type definitions for storing primal CIP solutions
Definition: type_cons.h:67
Definition: type_cons.h:74
Definition: type_cons.h:75
Definition: type_cons.h:69
Definition: struct_cons.h:106
result codes for SCIP callback methods
Definition: type_cons.h:65
common defines and data types used in all packages of SCIP
Definition: type_cons.h:70