1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 2 /* */ 3 /* This file is part of the program and library */ 4 /* SCIP --- Solving Constraint Integer Programs */ 5 /* */ 6 /* Copyright (c) 2002-2023 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 type_cons.h 26 * @ingroup TYPEDEFINITIONS 27 * @brief type definitions for constraints and constraint handlers 28 * @author Tobias Achterberg 29 * @author Stefan Heinz 30 * 31 * This file defines the interface for constraint handlers implemented in C. 32 * 33 * - \ref CONS "Instructions for implementing a constraint handler" 34 * - \ref CONSHDLRS "List of available constraint handlers" 35 * - \ref scip::ObjConshdlr "C++ wrapper class" 36 */ 37 38 /** @defgroup DEFPLUGINS_CONS Default constraint handlers 39 * @ingroup DEFPLUGINS 40 * @brief implementation files (.c files) of the default constraint handlers of SCIP 41 */ 42 43 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/ 44 45 #ifndef __SCIP_TYPE_CONS_H__ 46 #define __SCIP_TYPE_CONS_H__ 47 48 #include "scip/def.h" 49 #include "scip/type_lp.h" 50 #include "scip/type_retcode.h" 51 #include "scip/type_result.h" 52 #include "scip/type_var.h" 53 #include "scip/type_sol.h" 54 #include "scip/type_scip.h" 55 #include "scip/type_timing.h" 56 #include "scip/type_heur.h" 57 58 #ifdef __cplusplus 59 extern "C" { 60 #endif 61 62 typedef struct SCIP_Conshdlr SCIP_CONSHDLR; /**< constraint handler for a specific constraint type */ 63 typedef struct SCIP_Cons SCIP_CONS; /**< constraint data structure */ 64 typedef struct SCIP_ConshdlrData SCIP_CONSHDLRDATA; /**< constraint handler data */ 65 typedef struct SCIP_ConsData SCIP_CONSDATA; /**< locally defined constraint type specific data */ 66 typedef struct SCIP_ConsSetChg SCIP_CONSSETCHG; /**< tracks additions and removals of the set of active constraints */ 67 typedef struct SCIP_LinConsStats SCIP_LINCONSSTATS; /**< linear constraint classification statistics used for MIPLIB */ 68 typedef struct SYM_Graph SYM_GRAPH; /**< data to encode a symmetry detection graph */ 69 70 /** linear constraint types recognizable */ 71 enum SCIP_LinConstype 72 { 73 SCIP_LINCONSTYPE_EMPTY = 0, /**< linear constraints with no variables */ 74 SCIP_LINCONSTYPE_FREE = 1, /**< linear constraints with no finite side */ 75 SCIP_LINCONSTYPE_SINGLETON = 2, /**< linear constraints with a single variable */ 76 SCIP_LINCONSTYPE_AGGREGATION = 3, /**< linear constraints of the type \f$ ax + by = c\f$ */ 77 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 */ 78 SCIP_LINCONSTYPE_VARBOUND = 5, /**< linear constraints of the form \f$ ax + by \leq c \, x \in \{0,1\} \f$ */ 79 SCIP_LINCONSTYPE_SETPARTITION = 6, /**< linear constraints of the form \f$ \sum x_i = 1\, x_i \in \{0,1\} \forall i \f$ */ 80 SCIP_LINCONSTYPE_SETPACKING = 7, /**< linear constraints of the form \f$ \sum x_i \leq 1\, x_i \in \{0,1\} \forall i \f$ */ 81 SCIP_LINCONSTYPE_SETCOVERING = 8, /**< linear constraints of the form \f$ \sum x_i \geq 1\, x_i \in \{0,1\} \forall i \f$ */ 82 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$ */ 83 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$ */ 84 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$ */ 85 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$ */ 86 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$ */ 87 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$ */ 88 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$ */ 89 SCIP_LINCONSTYPE_GENERAL = 16 /**< general linear constraints with no special structure */ 90 }; 91 typedef enum SCIP_LinConstype SCIP_LINCONSTYPE; 92 93 #define SCIP_NLINCONSTYPES ((int)SCIP_LINCONSTYPE_GENERAL+1) 94 95 /** copy method for constraint handler plugins (called when SCIP copies plugins) 96 * 97 * If the copy process was one to one, the valid pointer can be set to TRUE. Otherwise, this pointer has to be set to 98 * FALSE. If all problem defining objects (constraint handlers and variable pricers) return valid = TRUE for all 99 * their copying calls, SCIP assumes that it is an overall one to one copy of the original instance. In this case any 100 * reductions made in the copied SCIP instance can be transfered to the original SCIP instance. If the valid pointer is 101 * set to TRUE and it was not a one to one copy, it might happen that optimal solutions are cut off. 102 * 103 * input: 104 * - scip : SCIP main data structure 105 * - conshdlr : the constraint handler itself 106 * - valid : was the copying process valid? 107 */ 108 #define SCIP_DECL_CONSHDLRCOPY(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_Bool* valid) 109 110 /** destructor of constraint handler to free constraint handler data (called when SCIP is exiting) 111 * 112 * input: 113 * - scip : SCIP main data structure 114 * - conshdlr : the constraint handler itself 115 */ 116 #define SCIP_DECL_CONSFREE(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr) 117 118 /** initialization method of constraint handler (called after problem was transformed) 119 * 120 * input: 121 * - scip : SCIP main data structure 122 * - conshdlr : the constraint handler itself 123 * - conss : array of constraints in transformed problem 124 * - nconss : number of constraints in transformed problem 125 */ 126 #define SCIP_DECL_CONSINIT(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) 127 128 /** deinitialization method of constraint handler (called before transformed problem is freed) 129 * 130 * input: 131 * - scip : SCIP main data structure 132 * - conshdlr : the constraint handler itself 133 * - conss : array of constraints in transformed problem 134 * - nconss : number of constraints in transformed problem 135 */ 136 #define SCIP_DECL_CONSEXIT(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) 137 138 /** presolving initialization method of constraint handler (called when presolving is about to begin) 139 * 140 * This method is called when the presolving process is about to begin, even if presolving is turned off. 141 * The constraint handler may use this call to initialize its data structures. 142 * 143 * Necessary modifications that have to be performed even if presolving is turned off should be done here or in the 144 * presolving deinitialization call (SCIP_DECL_CONSEXITPRE()). 145 * 146 * @note Note that the constraint array might contain constraints that were created but not added to the problem. 147 * Constraints that are not added, i.e., for which SCIPconsIsAdded() returns FALSE, cannot be used for problem 148 * reductions. 149 * 150 * input: 151 * - scip : SCIP main data structure 152 * - conshdlr : the constraint handler itself 153 * - conss : array of constraints in transformed problem 154 * - nconss : number of constraints in transformed problem 155 */ 156 #define SCIP_DECL_CONSINITPRE(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) 157 158 /** presolving deinitialization method of constraint handler (called after presolving has been finished) 159 * 160 * This method is called after the presolving has been finished, even if presolving is turned off. 161 * The constraint handler may use this call e.g. to clean up or modify its data structures. 162 * 163 * Necessary modifications that have to be performed even if presolving is turned off should be done here or in the 164 * presolving initialization call (SCIP_DECL_CONSINITPRE()). 165 * 166 * Besides necessary modifications and clean up, no time consuming operations should be performed, especially if the 167 * problem has already been solved. Use the method SCIPgetStatus(), which in this case returns SCIP_STATUS_OPTIMAL, 168 * SCIP_STATUS_INFEASIBLE, SCIP_STATUS_UNBOUNDED, or SCIP_STATUS_INFORUNBD. 169 * 170 * @note Note that the constraint array might contain constraints that were created but not added to the problem. 171 * Constraints that are not added, i.e., for which SCIPconsIsAdded() returns FALSE, cannot be used for problem 172 * reductions. 173 * 174 * input: 175 * - scip : SCIP main data structure 176 * - conshdlr : the constraint handler itself 177 * - conss : final array of constraints in transformed problem 178 * - nconss : final number of constraints in transformed problem 179 */ 180 #define SCIP_DECL_CONSEXITPRE(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) 181 182 /** solving process initialization method of constraint handler (called when branch and bound process is about to begin) 183 * 184 * This method is called when the presolving was finished and the branch and bound process is about to begin. 185 * The constraint handler may use this call to initialize its branch and bound specific data. 186 * 187 * Besides necessary modifications and clean up, no time consuming operations should be performed, especially if the 188 * problem has already been solved. Use the method SCIPgetStatus(), which in this case returns SCIP_STATUS_OPTIMAL, 189 * SCIP_STATUS_INFEASIBLE, SCIP_STATUS_UNBOUNDED, or SCIP_STATUS_INFORUNBD. 190 * 191 * @note Note that the constraint array might contain constraints that were created but not added to the problem. 192 * Constraints that are not added, i.e., for which SCIPconsIsAdded() returns FALSE, cannot be used for problem 193 * reductions. 194 * 195 * input: 196 * - scip : SCIP main data structure 197 * - conshdlr : the constraint handler itself 198 * - conss : array of constraints of the constraint handler 199 * - nconss : number of constraints of the constraint handler 200 */ 201 #define SCIP_DECL_CONSINITSOL(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) 202 203 /** solving process deinitialization method of constraint handler (called before branch and bound process data is freed) 204 * 205 * This method is called before the branch and bound process is freed. 206 * The constraint handler should use this call to clean up its branch and bound data, in particular to release 207 * all LP rows that he has created or captured. 208 * 209 * input: 210 * - scip : SCIP main data structure 211 * - conshdlr : the constraint handler itself 212 * - conss : array of constraints of the constraint handler 213 * - nconss : number of constraints of the constraint handler 214 * - restart : was this exit solve call triggered by a restart? 215 */ 216 #define SCIP_DECL_CONSEXITSOL(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, SCIP_Bool restart) 217 218 /** frees specific constraint data 219 * 220 * @warning There may exist unprocessed events. For example, a variable's bound may have been already changed, but the 221 * corresponding bound change event was not yet processed. 222 * 223 * input: 224 * - scip : SCIP main data structure 225 * - conshdlr : the constraint handler itself 226 * - cons : the constraint belonging to the constraint data 227 * - consdata : pointer to the constraint data to free 228 */ 229 #define SCIP_DECL_CONSDELETE(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SCIP_CONSDATA** consdata) 230 231 /** transforms constraint data into data belonging to the transformed problem 232 * 233 * input: 234 * - scip : SCIP main data structure 235 * - conshdlr : the constraint handler itself 236 * - sourcecons : source constraint to transform 237 * - targetcons : pointer to store created target constraint 238 */ 239 #define SCIP_DECL_CONSTRANS(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* sourcecons, SCIP_CONS** targetcons) 240 241 /** LP initialization method of constraint handler (called before the initial LP relaxation at a node is solved) 242 * 243 * Puts the LP relaxations of all "initial" constraints into the LP. The method should put a canonic LP relaxation 244 * of all given constraints to the LP with calls to SCIPaddRow(). 245 * 246 * @warning It is not guaranteed that the problem is going to be declared infeasible if the infeasible pointer is set 247 * to TRUE. Therefore, it is recommended that users do not end this method prematurely when an infeasiblity 248 * is detected. 249 * 250 * input: 251 * - scip : SCIP main data structure 252 * - conshdlr : the constraint handler itself 253 * - conss : array of constraints to process 254 * - nconss : number of constraints to process 255 * 256 * output: 257 * - infeasible : pointer to store whether an infeasibility was detected while building the LP 258 */ 259 #define SCIP_DECL_CONSINITLP(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, SCIP_Bool* infeasible) 260 261 /** separation method of constraint handler for LP solution 262 * 263 * Separates all constraints of the constraint handler. The method is called in the LP solution loop, 264 * which means that a valid LP solution exists. 265 * 266 * The first nusefulconss constraints are the ones, that are identified to likely be violated. The separation 267 * method should process only the useful constraints in most runs, and only occasionally the remaining 268 * nconss - nusefulconss constraints. 269 * 270 * input: 271 * - scip : SCIP main data structure 272 * - conshdlr : the constraint handler itself 273 * - conss : array of constraints to process 274 * - nconss : number of constraints to process 275 * - nusefulconss : number of useful (non-obsolete) constraints to process 276 * - result : pointer to store the result of the separation call 277 * 278 * possible return values for *result (if more than one applies, the first in the list should be used): 279 * - SCIP_CUTOFF : the node is infeasible in the variable's bounds and can be cut off 280 * - SCIP_CONSADDED : an additional constraint was generated 281 * - SCIP_REDUCEDDOM : a variable's domain was reduced 282 * - SCIP_SEPARATED : a cutting plane was generated 283 * - SCIP_NEWROUND : a cutting plane was generated and a new separation round should immediately start 284 * - SCIP_DIDNOTFIND : the separator searched, but did not find domain reductions, cutting planes, or cut constraints 285 * - SCIP_DIDNOTRUN : the separator was skipped 286 * - SCIP_DELAYED : the separator was skipped, but should be called again 287 */ 288 #define SCIP_DECL_CONSSEPALP(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, \ 289 int nconss, int nusefulconss, SCIP_RESULT* result) 290 291 /** separation method of constraint handler for arbitrary primal solution 292 * 293 * Separates all constraints of the constraint handler. The method is called outside the LP solution loop (e.g., by 294 * a relaxator or a primal heuristic), which means that there is no valid LP solution. 295 * Instead, the method should produce cuts that separate the given solution. 296 * 297 * The first nusefulconss constraints are the ones, that are identified to likely be violated. The separation 298 * method should process only the useful constraints in most runs, and only occasionally the remaining 299 * nconss - nusefulconss constraints. 300 * 301 * input: 302 * - scip : SCIP main data structure 303 * - conshdlr : the constraint handler itself 304 * - conss : array of constraints to process 305 * - nconss : number of constraints to process 306 * - nusefulconss : number of useful (non-obsolete) constraints to process 307 * - sol : primal solution that should be separated 308 * - result : pointer to store the result of the separation call 309 * 310 * possible return values for *result (if more than one applies, the first in the list should be used): 311 * - SCIP_CUTOFF : the node is infeasible in the variable's bounds and can be cut off 312 * - SCIP_CONSADDED : an additional constraint was generated 313 * - SCIP_REDUCEDDOM : a variable's domain was reduced 314 * - SCIP_SEPARATED : a cutting plane was generated 315 * - SCIP_NEWROUND : a cutting plane was generated and a new separation round should immediately start 316 * - SCIP_DIDNOTFIND : the separator searched, but did not find domain reductions, cutting planes, or cut constraints 317 * - SCIP_DIDNOTRUN : the separator was skipped 318 * - SCIP_DELAYED : the separator was skipped, but should be called again 319 */ 320 #define SCIP_DECL_CONSSEPASOL(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, \ 321 int nconss, int nusefulconss, SCIP_SOL* sol, SCIP_RESULT* result) 322 323 /** constraint enforcing method of constraint handler for LP solutions 324 * 325 * The method is called at the end of the node processing loop for a node where the LP was solved. 326 * The LP solution has to be checked for feasibility. If possible, an infeasibility should be resolved by 327 * branching, reducing a variable's domain to exclude the solution or separating the solution with a valid 328 * cutting plane. 329 * 330 * The enforcing methods of the active constraint handlers are called in decreasing order of their enforcing 331 * priorities until the first constraint handler returned with the value SCIP_CUTOFF, SCIP_SEPARATED, 332 * SCIP_REDUCEDDOM, SCIP_CONSADDED, or SCIP_BRANCHED. 333 * The integrality constraint handler has an enforcing priority of zero. A constraint handler which can 334 * (or wants) to enforce its constraints only for integral solutions should have a negative enforcing priority 335 * (e.g. the alldiff-constraint can only operate on integral solutions). 336 * A constraint handler which wants to incorporate its own branching strategy even on non-integral 337 * solutions must have an enforcing priority greater than zero (e.g. the SOS-constraint incorporates 338 * SOS-branching on non-integral solutions). 339 * 340 * The first nusefulconss constraints are the ones, that are identified to likely be violated. The enforcing 341 * method should process the useful constraints first. The other nconss - nusefulconss constraints should only 342 * be enforced, if no violation was found in the useful constraints. 343 * 344 * input: 345 * - scip : SCIP main data structure 346 * - conshdlr : the constraint handler itself 347 * - conss : array of constraints to process 348 * - nconss : number of constraints to process 349 * - nusefulconss : number of useful (non-obsolete) constraints to process 350 * - solinfeasible : was the solution already declared infeasible by a constraint handler? 351 * - result : pointer to store the result of the enforcing call 352 * 353 * possible return values for *result (if more than one applies, the first in the list should be used): 354 * - SCIP_CUTOFF : the node is infeasible in the variable's bounds and can be cut off 355 * - SCIP_CONSADDED : an additional constraint was generated (added constraints must have initial flag = TRUE) 356 * - SCIP_REDUCEDDOM : a variable's domain was reduced 357 * - SCIP_SEPARATED : a cutting plane was generated 358 * - SCIP_SOLVELP : the LP should be solved again because the LP primal feasibility tolerance has been tightened 359 * - SCIP_BRANCHED : no changes were made to the problem, but a branching was applied to resolve an infeasibility 360 * - SCIP_INFEASIBLE : at least one constraint is infeasible, but it was not resolved 361 * - SCIP_FEASIBLE : all constraints of the handler are feasible 362 */ 363 #define SCIP_DECL_CONSENFOLP(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, \ 364 SCIP_Bool solinfeasible, SCIP_RESULT* result) 365 366 /** constraint enforcing method of constraint handler for relaxation solutions 367 * 368 * input: 369 * - scip : SCIP main data structure 370 * - sol : relaxation solution 371 * - conshdlr : the constraint handler itself 372 * - conss : array of constraints to process 373 * - nconss : number of constraints to process 374 * - nusefulconss : number of useful (non-obsolete) constraints to process 375 * - solinfeasible : was the solution already declared infeasible by a constraint handler? 376 * - result : pointer to store the result of the enforcing call 377 * 378 * possible return values for *result (if more than one applies, the first in the list should be used): 379 * - SCIP_CUTOFF : the node is infeasible in the variable's bounds and can be cut off 380 * - SCIP_CONSADDED : an additional constraint was generated (added constraints must have initial flag = TRUE) 381 * - SCIP_REDUCEDDOM : a variable's domain was reduced 382 * - SCIP_SEPARATED : a cutting plane was generated 383 * - SCIP_BRANCHED : no changes were made to the problem, but a branching was applied to resolve an infeasibility 384 * - SCIP_SOLVELP : at least one constraint is infeasible, and this can only be resolved by solving the LP 385 * - SCIP_INFEASIBLE : at least one constraint is infeasible, but it was not resolved 386 * - SCIP_FEASIBLE : all constraints of the handler are feasible 387 */ 388 #define SCIP_DECL_CONSENFORELAX(x) SCIP_RETCODE x (SCIP* scip, SCIP_SOL* sol, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, \ 389 SCIP_Bool solinfeasible, SCIP_RESULT* result) 390 391 /** constraint enforcing method of constraint handler for pseudo solutions 392 * 393 * The method is called at the end of the node processing loop for a node where the LP was not solved. 394 * The pseudo solution has to be checked for feasibility. If possible, an infeasibility should be resolved by 395 * branching, reducing a variable's domain to exclude the solution or adding an additional constraint. 396 * Separation is not possible, since the LP is not processed at the current node. All LP informations like 397 * LP solution, slack values, or reduced costs are invalid and must not be accessed. 398 * 399 * Like in the enforcing method for LP solutions, the enforcing methods of the active constraint handlers are 400 * called in decreasing order of their enforcing priorities until the first constraint handler returned with 401 * the value SCIP_CUTOFF, SCIP_REDUCEDDOM, SCIP_CONSADDED, SCIP_BRANCHED, or SCIP_SOLVELP. 402 * 403 * The first nusefulconss constraints are the ones, that are identified to likely be violated. The enforcing 404 * method should process the useful constraints first. The other nconss - nusefulconss constraints should only 405 * be enforced, if no violation was found in the useful constraints. 406 * 407 * If the pseudo solution's objective value is lower than the lower bound of the node, it cannot be feasible 408 * and the enforcing method may skip it's check and set *result to SCIP_DIDNOTRUN. However, it can also process 409 * its constraints and return any other possible result code. 410 * 411 * input: 412 * - scip : SCIP main data structure 413 * - conshdlr : the constraint handler itself 414 * - conss : array of constraints to process 415 * - nconss : number of constraints to process 416 * - nusefulconss : number of useful (non-obsolete) constraints to process 417 * - solinfeasible : was the solution already declared infeasible by a constraint handler? 418 * - objinfeasible : is the solution infeasible anyway due to violating lower objective bound? 419 * - result : pointer to store the result of the enforcing call 420 * 421 * possible return values for *result (if more than one applies, the first in the list should be used): 422 * - SCIP_CUTOFF : the node is infeasible in the variable's bounds and can be cut off 423 * - SCIP_CONSADDED : an additional constraint was generated 424 * - SCIP_REDUCEDDOM : a variable's domain was reduced 425 * - SCIP_BRANCHED : no changes were made to the problem, but a branching was applied to resolve an infeasibility 426 * - SCIP_SOLVELP : at least one constraint is infeasible, and this can only be resolved by solving the LP 427 * - SCIP_INFEASIBLE : at least one constraint is infeasible, but it was not resolved 428 * - SCIP_FEASIBLE : all constraints of the handler are feasible 429 * - SCIP_DIDNOTRUN : the enforcement was skipped (only possible, if objinfeasible is true) 430 */ 431 #define SCIP_DECL_CONSENFOPS(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, \ 432 SCIP_Bool solinfeasible, SCIP_Bool objinfeasible, SCIP_RESULT* result) 433 434 /** feasibility check method of constraint handler for integral solutions 435 * 436 * The given solution has to be checked for feasibility. 437 * 438 * The check methods of the active constraint handlers are called in decreasing order of their check 439 * priorities until the first constraint handler returned with the result SCIP_INFEASIBLE. 440 * The integrality constraint handler has a check priority of zero. A constraint handler which can 441 * (or wants) to check its constraints only for integral solutions should have a negative check priority 442 * (e.g. the alldiff-constraint can only operate on integral solutions). 443 * A constraint handler which wants to check feasibility even on non-integral solutions must have a 444 * check priority greater than zero (e.g. if the check is much faster than testing all variables for 445 * integrality). 446 * 447 * In some cases, integrality conditions or rows of the current LP don't have to be checked, because their 448 * feasibility is already checked or implicitly given. In these cases, 'checkintegrality' or 449 * 'checklprows' is FALSE. 450 * 451 * If the solution is not NULL, SCIP should also be informed about the constraint violation with a call to 452 * SCIPupdateSolConsViolation() and additionally SCIPupdateSolLPRowViolation() for every row of the constraint's current 453 * representation in the LP relaxation, if any such rows exist. 454 * As a convenience method, SCIPupdateSolLPConsViolation() can be used if the constraint 455 * is represented completely by a set of LP rows, meaning that the current constraint violation is equal to the maximum 456 * of the contraint violations of the corresponding LP rows. 457 * 458 * input: 459 * - scip : SCIP main data structure 460 * - conshdlr : the constraint handler itself 461 * - conss : array of constraints to process 462 * - nconss : number of constraints to process 463 * - sol : the solution to check feasibility for 464 * - checkintegrality: Has integrality to be checked? 465 * - checklprows : Do constraints represented by rows in the current LP have to be checked? 466 * - printreason : Should the reason for the violation be printed? 467 * - completely : Should all violations be checked? 468 * - result : pointer to store the result of the feasibility checking call 469 * 470 * possible return values for *result: 471 * - SCIP_INFEASIBLE : at least one constraint of the handler is infeasible 472 * - SCIP_FEASIBLE : all constraints of the handler are feasible 473 */ 474 #define SCIP_DECL_CONSCHECK(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, SCIP_SOL* sol, \ 475 SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool printreason, SCIP_Bool completely, SCIP_RESULT* result) 476 477 /** domain propagation method of constraint handler 478 * 479 * The first nusefulconss constraints are the ones, that are identified to likely be violated. The propagation 480 * method should process only the useful constraints in most runs, and only occasionally the remaining 481 * nconss - nusefulconss constraints. 482 * 483 * @note if the constraint handler uses dual information in propagation it is nesassary to check via calling 484 * SCIPallowWeakDualReds and SCIPallowStrongDualReds if dual reductions and propgation with the current cutoff bound, resp., 485 * are allowed. 486 * 487 * input: 488 * - scip : SCIP main data structure 489 * - conshdlr : the constraint handler itself 490 * - conss : array of constraints to process 491 * - nconss : number of constraints to process 492 * - nusefulconss : number of useful (non-obsolete) constraints to process 493 * - nmarkedconss : number of constraints which are marked to be definitely propagated 494 * - proptiming : current point in the node solving loop 495 * - result : pointer to store the result of the propagation call 496 * 497 * possible return values for *result: 498 * - SCIP_CUTOFF : the node is infeasible in the variable's bounds and can be cut off 499 * - SCIP_REDUCEDDOM : at least one domain reduction was found 500 * - SCIP_DIDNOTFIND : the propagator searched but did not find any domain reductions 501 * - SCIP_DIDNOTRUN : the propagator was skipped 502 * - SCIP_DELAYED : the propagator was skipped, but should be called again 503 * - SCIP_DELAYNODE : the current node should be postponed (return value only valid for BEFORELP propagation) 504 */ 505 #define SCIP_DECL_CONSPROP(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, \ 506 int nmarkedconss, SCIP_PROPTIMING proptiming, SCIP_RESULT* result) 507 508 /** presolving method of constraint handler 509 * 510 * The presolver should go through the variables and constraints and tighten the domains or 511 * constraints. Each tightening should increase the given total number of changes. 512 * 513 * input: 514 * - scip : SCIP main data structure 515 * - conshdlr : the constraint handler itself 516 * - conss : array of constraints to process 517 * - nconss : number of constraints to process 518 * - nrounds : number of presolving rounds already done 519 * - presoltiming : current presolving timing 520 * - nnewfixedvars : number of variables fixed since the last call to the presolving method 521 * - nnewaggrvars : number of variables aggregated since the last call to the presolving method 522 * - nnewchgvartypes : number of variable type changes since the last call to the presolving method 523 * - nnewchgbds : number of variable bounds tightened since the last call to the presolving method 524 * - nnewholes : number of domain holes added since the last call to the presolving method 525 * - nnewdelconss : number of deleted constraints since the last call to the presolving method 526 * - nnewaddconss : number of added constraints since the last call to the presolving method 527 * - nnewupgdconss : number of upgraded constraints since the last call to the presolving method 528 * - nnewchgcoefs : number of changed coefficients since the last call to the presolving method 529 * - nnewchgsides : number of changed left or right hand sides since the last call to the presolving method 530 * 531 * @note the counters state the changes since the last call including the changes of this presolving method during its 532 * call 533 * 534 * @note if the constraint handler performs dual presolving it is nesassary to check via calling SCIPallowWeakDualReds 535 * and SCIPallowStrongDualReds if dual reductions are allowed. 536 * 537 * input/output: 538 * - nfixedvars : pointer to count total number of variables fixed of all presolvers 539 * - naggrvars : pointer to count total number of variables aggregated of all presolvers 540 * - nchgvartypes : pointer to count total number of variable type changes of all presolvers 541 * - nchgbds : pointer to count total number of variable bounds tightened of all presolvers 542 * - naddholes : pointer to count total number of domain holes added of all presolvers 543 * - ndelconss : pointer to count total number of deleted constraints of all presolvers 544 * - naddconss : pointer to count total number of added constraints of all presolvers 545 * - nupgdconss : pointer to count total number of upgraded constraints of all presolvers 546 * - nchgcoefs : pointer to count total number of changed coefficients of all presolvers 547 * - nchgsides : pointer to count total number of changed left/right hand sides of all presolvers 548 * 549 * output: 550 * - result : pointer to store the result of the presolving call 551 * 552 * possible return values for *result: 553 * - SCIP_UNBOUNDED : at least one variable is not bounded by any constraint in obj. direction -> problem is unbounded 554 * - SCIP_CUTOFF : at least one constraint is infeasible in the variable's bounds -> problem is infeasible 555 * - SCIP_SUCCESS : the presolving method found a reduction 556 * - SCIP_DIDNOTFIND : the presolving method searched, but did not find a presolving change 557 * - SCIP_DIDNOTRUN : the presolving method was skipped 558 * - SCIP_DELAYED : the presolving method was skipped, but should be called again 559 */ 560 #define SCIP_DECL_CONSPRESOL(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nrounds, \ 561 SCIP_PRESOLTIMING presoltiming, int nnewfixedvars, int nnewaggrvars, int nnewchgvartypes, int nnewchgbds, int nnewholes, \ 562 int nnewdelconss, int nnewaddconss, int nnewupgdconss, int nnewchgcoefs, int nnewchgsides, \ 563 int* nfixedvars, int* naggrvars, int* nchgvartypes, int* nchgbds, int* naddholes, \ 564 int* ndelconss, int* naddconss, int* nupgdconss, int* nchgcoefs, int* nchgsides, SCIP_RESULT* result) 565 566 /** propagation conflict resolving method of constraint handler 567 * 568 * This method is called during conflict analysis. If the constraint handler wants to support conflict analysis, 569 * it should call SCIPinferVarLbCons() or SCIPinferVarUbCons() in domain propagation instead of SCIPchgVarLb() or 570 * SCIPchgVarUb() in order to deduce bound changes on variables. 571 * In the SCIPinferVarLbCons() and SCIPinferVarUbCons() calls, the handler provides the constraint, that deduced the 572 * variable's bound change, and an integer value "inferinfo" that can be arbitrarily chosen. 573 * The propagation conflict resolving method can then be implemented, to provide a "reason" for the bound 574 * changes, i.e., the bounds of variables at the time of the propagation, that forced the constraint to set the 575 * conflict variable's bound to its current value. It can use the "inferinfo" tag to identify its own propagation 576 * rule and thus identify the "reason" bounds. The bounds that form the reason of the assignment must then be provided 577 * by calls to SCIPaddConflictLb(), SCIPaddConflictUb(), SCIPaddConflictBd(), SCIPaddConflictRelaxedLb(), 578 * SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), and/or SCIPaddConflictBinvar() in the propagation conflict 579 * resolving method. 580 * 581 * For example, the logicor constraint c = "x or y or z" fixes variable z to TRUE (i.e. changes the lower bound of z 582 * 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 583 * SCIPinferVarLbCons(scip, z, 1.0, c, 0) to apply this assignment (an inference information tag is not needed by the 584 * constraint handler and is set to 0). 585 * In the conflict analysis, the constraint handler may be asked to resolve the lower bound change on z with 586 * constraint c, that was applied at a time given by a bound change index "bdchgidx". 587 * With a call to SCIPgetVarLbAtIndex(scip, z, bdchgidx, TRUE), the handler can find out, that the lower bound of 588 * variable z was set to 1.0 at the given point of time, and should call SCIPaddConflictUb(scip, x, bdchgidx) and 589 * SCIPaddConflictUb(scip, y, bdchgidx) to tell SCIP, that the upper bounds of x and y at this point of time were 590 * the reason for the deduction of the lower bound of z. 591 * 592 * input: 593 * - scip : SCIP main data structure 594 * - conshdlr : the constraint handler itself 595 * - cons : the constraint that deduced the bound change of the conflict variable 596 * - infervar : the conflict variable whose bound change has to be resolved 597 * - inferinfo : the user information passed to the corresponding SCIPinferVarLbCons() or SCIPinferVarUbCons() call 598 * - boundtype : the type of the changed bound (lower or upper bound) 599 * - bdchgidx : the index of the bound change, representing the point of time where the change took place 600 * - relaxedbd : the relaxed bound which is sufficient to be explained 601 * 602 * output: 603 * - result : pointer to store the result of the propagation conflict resolving call 604 * 605 * possible return values for *result: 606 * - SCIP_SUCCESS : the conflicting bound change has been successfully resolved by adding all reason bounds 607 * - SCIP_DIDNOTFIND : the conflicting bound change could not be resolved and has to be put into the conflict set 608 * 609 * @note it is sufficient to explain/resolve the relaxed bound 610 */ 611 #define SCIP_DECL_CONSRESPROP(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, \ 612 SCIP_VAR* infervar, int inferinfo, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX* bdchgidx, SCIP_Real relaxedbd, \ 613 SCIP_RESULT* result) 614 615 /** variable rounding lock method of constraint handler 616 * 617 * This method is called, after a constraint is added or removed from the transformed problem. 618 * It should update the rounding locks of the given type of all associated variables with calls to 619 * SCIPaddVarLocksType(), depending on the way, the variable is involved in the constraint: 620 * - If the constraint may get violated by decreasing the value of a variable, it should call 621 * SCIPaddVarLocksType(scip, var, locktype, nlockspos, nlocksneg), saying that rounding down is 622 * potentially rendering the (positive) constraint infeasible and rounding up is potentially rendering the 623 * negation of the constraint infeasible. 624 * - If the constraint may get violated by increasing the value of a variable, it should call 625 * SCIPaddVarLocksType(scip, var, locktype, nlocksneg, nlockspos), saying that rounding up is 626 * potentially rendering the constraint's negation infeasible and rounding up is potentially rendering the 627 * constraint itself infeasible. 628 * - If the constraint may get violated by changing the variable in any direction, it should call 629 * SCIPaddVarLocksType(scip, var, locktype, nlockspos + nlocksneg, nlockspos + nlocksneg). 630 * 631 * Consider the linear constraint "3x -5y +2z <= 7" as an example. The variable rounding lock method of the 632 * linear constraint handler should call SCIPaddVarLocksType(scip, x, locktype, nlocksneg, nlockspos), 633 * SCIPaddVarLocksType(scip, y, locktype, nlockspos, nlocksneg) and 634 * SCIPaddVarLocksType(scip, z, type, nlocksneg, nlockspos) to tell SCIP, that rounding up of x and z and rounding 635 * down of y can destroy the feasibility of the constraint, while rounding down of x and z and rounding up of y can 636 * destroy the feasibility of the constraint's negation "3x -5y +2z > 7". 637 * A linear constraint "2 <= 3x -5y +2z <= 7" should call 638 * SCIPaddVarLocksType(scip, ..., nlockspos + nlocksneg, nlockspos + nlocksneg) on all variables, since rounding in both 639 * directions of each variable can destroy both the feasibility of the constraint and it's negation 640 * "3x -5y +2z < 2 or 3x -5y +2z > 7". 641 * 642 * If the constraint itself contains other constraints as sub constraints (e.g. the "or" constraint concatenation 643 * "c(x) or d(x)"), the rounding lock methods of these constraints should be called in a proper way. 644 * - If the constraint may get violated by the violation of the sub constraint c, it should call 645 * SCIPaddConsLocksType(scip, c, locktype, nlockspos, nlocksneg), saying that infeasibility of c may lead to 646 * infeasibility of the (positive) constraint, and infeasibility of c's negation (i.e. feasibility of c) may lead 647 * to infeasibility of the constraint's negation (i.e. feasibility of the constraint). 648 * - If the constraint may get violated by the feasibility of the sub constraint c, it should call 649 * SCIPaddConsLocksType(scip, c, locktype, nlocksneg, nlockspos), saying that infeasibility of c may lead to 650 * infeasibility of the constraint's negation (i.e. feasibility of the constraint), and infeasibility of c's negation 651 * (i.e. feasibility of c) may lead to infeasibility of the (positive) constraint. 652 * - If the constraint may get violated by any change in the feasibility of the sub constraint c, it should call 653 * SCIPaddConsLocksType(scip, c, locktype, nlockspos + nlocksneg, nlockspos + nlocksneg). 654 * 655 * Consider the or concatenation "c(x) or d(x)". The variable rounding lock method of the or constraint handler 656 * should call SCIPaddConsLocksType(scip, c, locktype, nlockspos, nlocksneg) and 657 * SCIPaddConsLocksType(scip, d, locktype, nlockspos, nlocksneg) to tell SCIP, that infeasibility of c and d can lead 658 * to infeasibility of "c(x) or d(x)". 659 * 660 * As a second example, consider the equivalence constraint "y <-> c(x)" with variable y and constraint c. The 661 * constraint demands, that y == 1 if and only if c(x) is satisfied. The variable lock method of the corresponding 662 * constraint handler should call SCIPaddVarLocksType(scip, y, locktype, nlockspos + nlocksneg, nlockspos + nlocksneg) and 663 * SCIPaddConsLocksType(scip, c, locktype, nlockspos + nlocksneg, nlockspos + nlocksneg), because any modification to the 664 * value of y or to the feasibility of c can alter the feasibility of the equivalence constraint. 665 * 666 * input: 667 * - scip : SCIP main data structure 668 * - conshdlr : the constraint handler itself 669 * - cons : the constraint that should lock rounding of its variables, or NULL if the constraint handler 670 * does not need constraints 671 * - locktype : type of rounding locks, i.e., SCIP_LOCKTYPE_MODEL or SCIP_LOCKTYPE_CONFLICT 672 * - nlockspos : number of times, the roundings should be locked for the constraint (may be negative) 673 * - nlocksneg : number of times, the roundings should be locked for the constraint's negation (may be negative) 674 */ 675 #define SCIP_DECL_CONSLOCK(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SCIP_LOCKTYPE locktype, int nlockspos, int nlocksneg) 676 677 /** constraint activation notification method of constraint handler 678 * 679 * WARNING! There may exist unprocessed events. For example, a variable's bound may have been already changed, but 680 * the corresponding bound change event was not yet processed. 681 * 682 * This method is always called after a constraint of the constraint handler was activated. The constraint 683 * handler may use this call to update his own (statistical) data. 684 * 685 * input: 686 * - scip : SCIP main data structure 687 * - conshdlr : the constraint handler itself 688 * - cons : the constraint that has been activated 689 */ 690 #define SCIP_DECL_CONSACTIVE(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons) 691 692 /** constraint deactivation notification method of constraint handler 693 * 694 * WARNING! There may exist unprocessed events. For example, a variable's bound may have been already changed, but 695 * the corresponding bound change event was not yet processed. 696 * 697 * This method is always called before a constraint of the constraint handler is deactivated. The constraint 698 * handler may use this call to update his own (statistical) data. 699 * 700 * input: 701 * - scip : SCIP main data structure 702 * - conshdlr : the constraint handler itself 703 * - cons : the constraint that will be deactivated 704 */ 705 #define SCIP_DECL_CONSDEACTIVE(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons) 706 707 /** constraint enabling notification method of constraint handler 708 * 709 * WARNING! There may exist unprocessed events. For example, a variable's bound may have been already changed, but 710 * the corresponding bound change event was not yet processed. 711 * 712 * This method is always called after a constraint of the constraint handler was enabled. The constraint 713 * handler may use this call to update his own (statistical) data. 714 * 715 * input: 716 * - scip : SCIP main data structure 717 * - conshdlr : the constraint handler itself 718 * - cons : the constraint that has been enabled 719 */ 720 #define SCIP_DECL_CONSENABLE(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons) 721 722 /** constraint disabling notification method of constraint handler 723 * 724 * WARNING! There may exist unprocessed events. For example, a variable's bound may have been already changed, but 725 * the corresponding bound change event was not yet processed. 726 * 727 * This method is always called before a constraint of the constraint handler is disabled. The constraint 728 * handler may use this call to update his own (statistical) data. 729 * 730 * input: 731 * - scip : SCIP main data structure 732 * - conshdlr : the constraint handler itself 733 * - cons : the constraint that will be disabled 734 */ 735 #define SCIP_DECL_CONSDISABLE(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons) 736 737 /** variable deletion method of constraint handler 738 * 739 * This method is optinal and only of interest if you are using SCIP as a branch-and-price framework. That means, you 740 * are generating new variables during the search. If you are not doing that just define the function pointer to be 741 * NULL. 742 * 743 * If this method gets implemented you should iterate over all constraints of the constraint handler and delete all 744 * variables that were marked for deletion by SCIPdelVar(). 745 * 746 * input: 747 * - scip : SCIP main data structure 748 * - conshdlr : the constraint handler itself 749 * - conss : array of constraints in transformed problem 750 * - nconss : number of constraints in transformed problem 751 */ 752 #define SCIP_DECL_CONSDELVARS(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) 753 754 /** constraint display method of constraint handler 755 * 756 * The constraint handler can store a representation of the constraint into the given text file. Use the method 757 * SCIPinfoMessage() to push a string into the file stream. 758 * 759 * @note There are several methods which help to display variables. These are SCIPwriteVarName(), SCIPwriteVarsList(), 760 * SCIPwriteVarsLinearsum(), and SCIPwriteVarsPolynomial(). 761 * 762 * input: 763 * - scip : SCIP main data structure 764 * - conshdlr : the constraint handler itself 765 * - cons : the constraint that should be displayed 766 * - file : the text file to store the information into 767 */ 768 #define SCIP_DECL_CONSPRINT(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, FILE* file) 769 770 /** constraint copying method of constraint handler 771 * 772 * The constraint handler can provide a copy method which copies a constraint from one SCIP data structure into an other 773 * SCIP data structure. If a copy of a constraint is created, the constraint has to be captured. (The capture is usually 774 * already done due to the creation of the constraint). 775 * 776 * If the copy process was one to one, the valid pointer can be set to TRUE. Otherwise, you have to set this pointer to 777 * FALSE. In case all problem defining objects (constraint handlers and variable pricers) return a TRUE valid for all 778 * their copying calls, SCIP assumes that it is a overall one to one copy of the original instance. In this case any 779 * reductions made in the copied SCIP instance can be transfered to the original SCIP instance. If the valid pointer is 780 * set to TRUE and it was not a one to one copy, it might happen that optimal solutions are cut off. 781 * 782 * To get a copy of a variable in the target SCIP you should use the function SCIPgetVarCopy(). 783 * 784 * input: 785 * - scip : target SCIP data structure 786 * - cons : pointer to store the created target constraint 787 * - name : name of constraint, or NULL if the name of the source constraint should be used 788 * - sourcescip : source SCIP data structure 789 * - sourceconshdlr : source constraint handler of the source SCIP 790 * - sourcecons : source constraint of the source SCIP 791 * - varmap : a SCIP_HASHMAP mapping variables of the source SCIP to corresponding variables of the target SCIP 792 * - consmap : a SCIP_HASHMAP mapping constraints of the source SCIP to corresponding constraints of the target SCIP 793 * - initial : should the LP relaxation of constraint be in the initial LP? 794 * - separate : should the constraint be separated during LP processing? 795 * - enforce : should the constraint be enforced during node processing? 796 * - check : should the constraint be checked for feasibility? 797 * - propagate : should the constraint be propagated during node processing? 798 * - local : is constraint only valid locally? 799 * - modifiable : is constraint modifiable (subject to column generation)? 800 * - dynamic : is constraint subject to aging? 801 * - removable : should the relaxation be removed from the LP due to aging or cleanup? 802 * - stickingatnode : should the constraint always be kept at the node where it was added, even 803 * if it may be moved to a more global node? 804 * - global : should a global or a local copy be created? 805 * 806 * output: 807 * - valid : pointer to store whether the copying was valid or not 808 */ 809 #define SCIP_DECL_CONSCOPY(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONS** cons, const char* name, \ 810 SCIP* sourcescip, SCIP_CONSHDLR* sourceconshdlr, SCIP_CONS* sourcecons, SCIP_HASHMAP* varmap, SCIP_HASHMAP* consmap, \ 811 SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, \ 812 SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode, \ 813 SCIP_Bool global, SCIP_Bool* valid) 814 815 /** constraint parsing method of constraint handler 816 * 817 * The constraint handler can provide a callback to parse the output created by the display method 818 * (\ref SCIP_DECL_CONSPRINT) and to create a constraint out of it. 819 * 820 * @note For parsing there are several methods which are handy. Have a look at: SCIPparseVarName(), 821 * SCIPparseVarsList(), SCIPparseVarsLinearsum(), SCIPparseVarsPolynomial(), SCIPstrToRealValue(), and 822 * SCIPstrCopySection(). 823 * 824 * input: 825 * - scip : SCIP main data structure 826 * - conshdlr : the constraint handler itself 827 * - cons : pointer to store the created constraint 828 * - name : name of the constraint 829 * - str : string to parse 830 * - initial : should the LP relaxation of constraint be in the initial LP? 831 * - separate : should the constraint be separated during LP processing? 832 * - enforce : should the constraint be enforced during node processing? 833 * - check : should the constraint be checked for feasibility? 834 * - propagate : should the constraint be propagated during node processing? 835 * - local : is constraint only valid locally? 836 * - modifiable : is constraint modifiable (subject to column generation)? 837 * - dynamic : is constraint subject to aging? 838 * - removable : should the relaxation be removed from the LP due to aging or cleanup? 839 * - stickingatnode : should the constraint always be kept at the node where it was added, even 840 * if it may be moved to a more global node? 841 * output: 842 * - success : pointer to store whether the parsing was successful or not 843 */ 844 #define SCIP_DECL_CONSPARSE(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** cons, \ 845 const char* name, const char* str, \ 846 SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, \ 847 SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode, SCIP_Bool* success) 848 849 /** constraint method of constraint handler which returns the variables (if possible) 850 * 851 * The constraint handler can (this callback is optional) provide this callback to return the variables which are 852 * involved in that particular constraint. If this is possible, the variables should be copyied into the variables 853 * array and the success pointers has to be set to TRUE. Otherwise the success has to be set FALSE or the callback 854 * should not be implemented. 855 * 856 * input: 857 * - scip : SCIP main data structure 858 * - conshdlr : the constraint handler itself 859 * - cons : the constraint that should return its variable data 860 * - varssize : available slots in vars array which is needed to check if the array is large enough 861 * 862 * output: 863 * - vars : array to store/copy the involved variables of the constraint 864 * - success : pointer to store whether the variables are successfully copied 865 */ 866 #define SCIP_DECL_CONSGETVARS(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, \ 867 SCIP_VAR** vars, int varssize, SCIP_Bool* success) 868 869 /** constraint method of constraint handler which returns the number of variables (if possible) 870 * 871 * The constraint handler can (this callback is optional) provide this callback to return the number variable which are 872 * involved in that particular constraint. If this is not possible, the success pointers has to be set to FALSE or the 873 * callback should not be implemented. 874 * 875 * input: 876 * - scip : SCIP main data structure 877 * - conshdlr : the constraint handler itself 878 * - cons : constraint for which the number of variables is wanted 879 * 880 * output: 881 * - nvars : pointer to store the number of variables 882 * - success : pointer to store whether the constraint successfully returned the number of variables 883 */ 884 #define SCIP_DECL_CONSGETNVARS(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, \ 885 int* nvars, SCIP_Bool* success) 886 887 /** constraint handler method to suggest dive bound changes during the generic diving algorithm 888 * 889 * This callback is used inside the various diving heuristics of SCIP and does not affect the normal branching of the 890 * actual search. The constraint handler can provide this callback to render the current solution (even more) 891 * infeasible by suggesting one or several variable bound changes. In fact, since diving heuristics do not necessarily 892 * solve LP relaxations at every probing depth, some of the variable local bounds might already be conflicting with the 893 * solution values. The solution is rendered infeasible by determining bound changes that should be applied to the 894 * next explored search node via SCIPaddDiveBoundChange(). An alternative in case that the preferred bound change(s) 895 * were detected infeasible must be provided. 896 * 897 * The constraint handler must take care to only add bound changes that further shrink the variable domain. 898 * 899 * The success pointer must be used to indicate whether the constraint handler succeeded in selecting diving bound 900 * changes. The infeasible pointer should be set to TRUE if the constraint handler found a local infeasibility. If the 901 * constraint handler needs to select between several candidates, it may use the scoring mechanism of the diveset 902 * argument to control its choice. 903 * 904 * This callback is optional. 905 * 906 * @note: @p sol is usually the LP relaxation solution unless the caller of the method, usually a diving heuristic, 907 * does not solve LP relaxations at every depth 908 * 909 * input: 910 * - scip : SCIP main data structure 911 * - conshdlr : the constraint handler itself 912 * - diveset : diving settings for scoring 913 * - sol : current diving solution, usually the LP relaxation solution 914 * 915 * output: 916 * - success : pointer to store whether the constraint handler succeeded to determine dive bound changes 917 * - infeasible : pointer to store whether the constraint handler detected an infeasibility in the local node 918 */ 919 #define SCIP_DECL_CONSGETDIVEBDCHGS(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_DIVESET* diveset, \ 920 SCIP_SOL* sol, SCIP_Bool* success, SCIP_Bool* infeasible) 921 922 /** constraint handler method which returns the permutation symmetry detection graph of a constraint (if possible) 923 * 924 * The constraint handler can (this callback is optional) provide this callback to return a graph that encodes the 925 * permutation symmetries of a constraint. If this is not possible, the success pointer has to be set to FALSE or the 926 * callback should not be implemented. 927 * 928 * input: 929 * - scip : SCIP main data structure 930 * - conshdlr : the constraint handler itself 931 * - cons : constraint for which the symmetry detection graph is requested 932 * 933 * output: 934 * - graph : symmetry detection graph 935 * - success : pointer to store whether the constraint successfully returned the symmetry detection graph 936 */ 937 #define SCIP_DECL_CONSGETPERMSYMGRAPH(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, \ 938 SYM_GRAPH* graph, SCIP_Bool* success) 939 940 /** constraint handler method providing the signed permutation symmetry detection graph of a constraint (if possible) 941 * 942 * The constraint handler can (this callback is optional) provide this callback to return a graph that encodes the 943 * signed permutation symmetries of a constraint. If this is not possible, the success pointer has to be set to FALSE 944 * or the callback should not be implemented. 945 * 946 * input: 947 * - scip : SCIP main data structure 948 * - conshdlr : the constraint handler itself 949 * - cons : constraint for which the symmetry detection graph is requested 950 * 951 * output: 952 * - graph : symmetry detection graph 953 * - success : pointer to store whether the constraint successfully returned the symmetry detection graph 954 */ 955 #define SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, \ 956 SYM_GRAPH* graph, SCIP_Bool* success) 957 958 #ifdef __cplusplus 959 } 960 #endif 961 962 #endif 963