Scippy

SCIP

Solving Constraint Integer Programs

type_cons.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 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
59extern "C" {
60#endif
61
62typedef struct SCIP_Conshdlr SCIP_CONSHDLR; /**< constraint handler for a specific constraint type */
63typedef struct SCIP_Cons SCIP_CONS; /**< constraint data structure */
64typedef struct SCIP_ConshdlrData SCIP_CONSHDLRDATA; /**< constraint handler data */
65typedef struct SCIP_ConsData SCIP_CONSDATA; /**< locally defined constraint type specific data */
66typedef struct SCIP_ConsSetChg SCIP_CONSSETCHG; /**< tracks additions and removals of the set of active constraints */
67typedef struct SCIP_LinConsStats SCIP_LINCONSSTATS; /**< linear constraint classification statistics used for MIPLIB */
68typedef struct SYM_Graph SYM_GRAPH; /**< data to encode a symmetry detection graph */
69
70/** linear constraint types recognizable */
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};
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
common defines and data types used in all packages of SCIP
struct SCIP_ConshdlrData SCIP_CONSHDLRDATA
Definition: type_cons.h:64
SCIP_LinConstype
Definition: type_cons.h:72
@ SCIP_LINCONSTYPE_BINPACKING
Definition: type_cons.h:85
@ SCIP_LINCONSTYPE_VARBOUND
Definition: type_cons.h:78
@ SCIP_LINCONSTYPE_EMPTY
Definition: type_cons.h:73
@ SCIP_LINCONSTYPE_INVKNAPSACK
Definition: type_cons.h:83
@ SCIP_LINCONSTYPE_PRECEDENCE
Definition: type_cons.h:77
@ SCIP_LINCONSTYPE_AGGREGATION
Definition: type_cons.h:76
@ SCIP_LINCONSTYPE_MIXEDBINARY
Definition: type_cons.h:88
@ SCIP_LINCONSTYPE_SINGLETON
Definition: type_cons.h:75
@ SCIP_LINCONSTYPE_SETCOVERING
Definition: type_cons.h:81
@ SCIP_LINCONSTYPE_EQKNAPSACK
Definition: type_cons.h:84
@ SCIP_LINCONSTYPE_FREE
Definition: type_cons.h:74
@ SCIP_LINCONSTYPE_KNAPSACK
Definition: type_cons.h:86
@ SCIP_LINCONSTYPE_SETPARTITION
Definition: type_cons.h:79
@ SCIP_LINCONSTYPE_INTKNAPSACK
Definition: type_cons.h:87
@ SCIP_LINCONSTYPE_SETPACKING
Definition: type_cons.h:80
@ SCIP_LINCONSTYPE_GENERAL
Definition: type_cons.h:89
@ SCIP_LINCONSTYPE_CARDINALITY
Definition: type_cons.h:82
struct SCIP_ConsData SCIP_CONSDATA
Definition: type_cons.h:65
enum SCIP_LinConstype SCIP_LINCONSTYPE
Definition: type_cons.h:91
type definitions for primal heuristics
type definitions for LP management
result codes for SCIP callback methods
type definitions for return codes for SCIP methods
type definitions for SCIP's main datastructure
type definitions for storing primal CIP solutions
timing definitions for SCIP
type definitions for problem variables