Scippy

SCIP

Solving Constraint Integer Programs

scip_conflict.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 2002-2022 Zuse Institute Berlin */
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 scip_conflict.h
26  * @ingroup PUBLICCOREAPI
27  * @brief public methods for conflict handler plugins and conflict analysis
28  * @author Tobias Achterberg
29  * @author Timo Berthold
30  * @author Thorsten Koch
31  * @author Alexander Martin
32  * @author Marc Pfetsch
33  * @author Kati Wolter
34  * @author Gregor Hendel
35  * @author Leona Gottwald
36  */
37 
38 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
39 
40 #ifndef __SCIP_SCIP_CONFLICT_H__
41 #define __SCIP_SCIP_CONFLICT_H__
42 
43 
44 #include "scip/def.h"
45 #include "scip/type_conflict.h"
46 #include "scip/type_cons.h"
47 #include "scip/type_lp.h"
48 #include "scip/type_result.h"
49 #include "scip/type_retcode.h"
50 #include "scip/type_scip.h"
51 #include "scip/type_tree.h"
52 #include "scip/type_var.h"
53 
54 #ifdef __cplusplus
55 extern "C" {
56 #endif
57 
58 /**@addtogroup PublicConflicthdlrMethods
59  *
60  * @{
61  */
62 
63 /** creates a conflict handler and includes it in SCIP
64  *
65  * @note method has all conflict handler callbacks as arguments and is thus changed every time a new
66  * callback is added
67  * in future releases; consider using SCIPincludeConflicthdlrBasic() and setter functions
68  * if you seek for a method which is less likely to change in future releases
69  */
70 SCIP_EXPORT
72  SCIP* scip, /**< SCIP data structure */
73  const char* name, /**< name of conflict handler */
74  const char* desc, /**< description of conflict handler */
75  int priority, /**< priority of the conflict handler */
76  SCIP_DECL_CONFLICTCOPY((*conflictcopy)), /**< copy method of conflict handler or NULL if you don't want to copy your plugin into sub-SCIPs */
77  SCIP_DECL_CONFLICTFREE((*conflictfree)), /**< destructor of conflict handler */
78  SCIP_DECL_CONFLICTINIT((*conflictinit)), /**< initialize conflict handler */
79  SCIP_DECL_CONFLICTEXIT((*conflictexit)), /**< deinitialize conflict handler */
80  SCIP_DECL_CONFLICTINITSOL((*conflictinitsol)),/**< solving process initialization method of conflict handler */
81  SCIP_DECL_CONFLICTEXITSOL((*conflictexitsol)),/**< solving process deinitialization method of conflict handler */
82  SCIP_DECL_CONFLICTEXEC((*conflictexec)), /**< conflict processing method of conflict handler */
83  SCIP_CONFLICTHDLRDATA* conflicthdlrdata /**< conflict handler data */
84  );
85 
86 /** creates a conflict handler and includes it in SCIP with its most fundamental callbacks. All non-fundamental
87  * (or optional) callbacks as, e.g., init and exit callbacks, will be set to NULL.
88  * Optional callbacks can be set via specific setter functions SCIPsetConflicthdlrCopy(), SCIPsetConflicthdlrFree(),
89  * SCIPsetConflicthdlrInit(), SCIPsetConflicthdlrExit(), SCIPsetConflicthdlrInitsol(),
90  * and SCIPsetConflicthdlrExitsol()
91  *
92  * @note if you want to set all callbacks with a single method call, consider using SCIPincludeConflicthdlr() instead
93  */
94 SCIP_EXPORT
96  SCIP* scip, /**< SCIP data structure */
97  SCIP_CONFLICTHDLR** conflicthdlrptr, /**< reference to a conflict handler pointer, or NULL */
98  const char* name, /**< name of conflict handler */
99  const char* desc, /**< description of conflict handler */
100  int priority, /**< priority of the conflict handler */
101  SCIP_DECL_CONFLICTEXEC((*conflictexec)), /**< conflict processing method of conflict handler */
102  SCIP_CONFLICTHDLRDATA* conflicthdlrdata /**< conflict handler data */
103  );
104 
105 /** set copy method of conflict handler */
106 SCIP_EXPORT
108  SCIP* scip, /**< SCIP data structure */
109  SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
110  SCIP_DECL_CONFLICTCOPY((*conflictcopy)) /**< copy method of conflict handler */
111  );
112 
113 /** set destructor of conflict handler */
114 SCIP_EXPORT
116  SCIP* scip, /**< SCIP data structure */
117  SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
118  SCIP_DECL_CONFLICTFREE((*conflictfree)) /**< destructor of conflict handler */
119  );
120 
121 /** set initialization method of conflict handler */
122 SCIP_EXPORT
124  SCIP* scip, /**< SCIP data structure */
125  SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
126  SCIP_DECL_CONFLICTINIT((*conflictinit)) /**< initialize conflict handler */
127  );
128 
129 /** set deinitialization method of conflict handler */
130 SCIP_EXPORT
132  SCIP* scip, /**< SCIP data structure */
133  SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
134  SCIP_DECL_CONFLICTEXIT((*conflictexit)) /**< deinitialize conflict handler */
135  );
136 
137 /** set solving process initialization method of conflict handler */
138 SCIP_EXPORT
140  SCIP* scip, /**< SCIP data structure */
141  SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
142  SCIP_DECL_CONFLICTINITSOL((*conflictinitsol))/**< solving process initialization method of conflict handler */
143  );
144 
145 /** set solving process deinitialization method of conflict handler */
146 SCIP_EXPORT
148  SCIP* scip, /**< SCIP data structure */
149  SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
150  SCIP_DECL_CONFLICTEXITSOL((*conflictexitsol))/**< solving process deinitialization method of conflict handler */
151  );
152 
153 /** returns the conflict handler of the given name, or NULL if not existing */
154 SCIP_EXPORT
156  SCIP* scip, /**< SCIP data structure */
157  const char* name /**< name of conflict handler */
158  );
159 
160 /** returns the array of currently available conflict handlers */
161 SCIP_EXPORT
163  SCIP* scip /**< SCIP data structure */
164  );
165 
166 /** returns the number of currently available conflict handlers */
167 SCIP_EXPORT
169  SCIP* scip /**< SCIP data structure */
170  );
171 
172 /** sets the priority of a conflict handler */
173 SCIP_EXPORT
175  SCIP* scip, /**< SCIP data structure */
176  SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
177  int priority /**< new priority of the conflict handler */
178  );
179 
180 /** @} */
181 
182 /**@addtogroup PublicConflictMethods
183  *
184  * @{
185  */
186 
187 /** return TRUE if conflict analysis is applicable; In case the function return FALSE there is no need to initialize the
188  * conflict analysis since it will not be applied
189  *
190  * @return return TRUE if conflict analysis is applicable; In case the function return FALSE there is no need to initialize the
191  * conflict analysis since it will not be applied
192  *
193  * @pre This method can be called if SCIP is in one of the following stages:
194  * - \ref SCIP_STAGE_INITPRESOLVE
195  * - \ref SCIP_STAGE_PRESOLVING
196  * - \ref SCIP_STAGE_EXITPRESOLVE
197  * - \ref SCIP_STAGE_SOLVING
198  *
199  * @note SCIP stage does not get changed
200  */
201 SCIP_EXPORT
203  SCIP* scip /**< SCIP data structure */
204  );
205 
206 /** initializes the conflict analysis by clearing the conflict candidate queue; this method must be called before you
207  * enter the conflict variables by calling SCIPaddConflictLb(), SCIPaddConflictUb(), SCIPaddConflictBd(),
208  * SCIPaddConflictRelaxedLb(), SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), or SCIPaddConflictBinvar();
209  *
210  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
211  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
212  *
213  * @pre This method can be called if SCIP is in one of the following stages:
214  * - \ref SCIP_STAGE_PRESOLVING
215  * - \ref SCIP_STAGE_SOLVING
216  *
217  * @note SCIP stage does not get changed
218  */
219 SCIP_EXPORT
221  SCIP* scip, /**< SCIP data structure */
222  SCIP_CONFTYPE conftype, /**< type of conflict */
223  SCIP_Bool iscutoffinvolved /**< is the current cutoff bound involved? */
224  );
225 
226 /** adds lower bound of variable at the time of the given bound change index to the conflict analysis' candidate storage;
227  * this method should be called in one of the following two cases:
228  * 1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictLb() should be called for each lower bound
229  * that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
230  * 2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictLb() should be called
231  * for each lower bound, whose current assignment led to the deduction of the given conflict bound.
232  *
233  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
234  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
235  *
236  * @pre This method can be called if SCIP is in one of the following stages:
237  * - \ref SCIP_STAGE_PRESOLVING
238  * - \ref SCIP_STAGE_SOLVING
239  *
240  * @note SCIP stage does not get changed
241  */
242 SCIP_EXPORT
244  SCIP* scip, /**< SCIP data structure */
245  SCIP_VAR* var, /**< variable whose lower bound should be added to conflict candidate queue */
246  SCIP_BDCHGIDX* bdchgidx /**< bound change index representing time on path to current node, when the
247  * conflicting bound was valid, NULL for current local bound */
248  );
249 
250 /** adds lower bound of variable at the time of the given bound change index to the conflict analysis' candidate storage
251  * with the additional information of a relaxed lower bound; this relaxed lower bound is the one which would be enough
252  * to explain a certain bound change;
253  * this method should be called in one of the following two cases:
254  * 1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictRelaxedLb() should be called for each (relaxed) lower bound
255  * that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
256  * 2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictRelexedLb() should be called
257  * for each (relaxed) lower bound, whose current assignment led to the deduction of the given conflict bound.
258  *
259  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
260  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
261  *
262  * @pre This method can be called if SCIP is in one of the following stages:
263  * - \ref SCIP_STAGE_PRESOLVING
264  * - \ref SCIP_STAGE_SOLVING
265  *
266  * @note SCIP stage does not get changed
267  */
268 SCIP_EXPORT
270  SCIP* scip, /**< SCIP data structure */
271  SCIP_VAR* var, /**< variable whose lower bound should be added to conflict candidate queue */
272  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node, when the
273  * conflicting bound was valid, NULL for current local bound */
274  SCIP_Real relaxedlb /**< the relaxed lower bound */
275  );
276 
277 /** adds upper bound of variable at the time of the given bound change index to the conflict analysis' candidate storage;
278  * this method should be called in one of the following two cases:
279  * 1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictUb() should be called for each upper bound that
280  * led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
281  * 2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictUb() should be called for
282  * each upper bound, whose current assignment led to the deduction of the given conflict bound.
283  *
284  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
285  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
286  *
287  * @pre This method can be called if SCIP is in one of the following stages:
288  * - \ref SCIP_STAGE_PRESOLVING
289  * - \ref SCIP_STAGE_SOLVING
290  *
291  * @note SCIP stage does not get changed
292  */
293 SCIP_EXPORT
295  SCIP* scip, /**< SCIP data structure */
296  SCIP_VAR* var, /**< variable whose upper bound should be added to conflict candidate queue */
297  SCIP_BDCHGIDX* bdchgidx /**< bound change index representing time on path to current node, when the
298  * conflicting bound was valid, NULL for current local bound */
299  );
300 
301 /** adds upper bound of variable at the time of the given bound change index to the conflict analysis' candidate storage
302  * with the additional information of a relaxed upper bound; this relaxed upper bound is the one which would be enough
303  * to explain a certain bound change;
304  * this method should be called in one of the following two cases:
305  * 1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictRelaxedUb() should be called for each (relaxed) upper
306  * bound that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
307  * 2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictRelaxedUb() should be
308  * called for each (relaxed) upper bound, whose current assignment led to the deduction of the given conflict
309  * bound.
310  *
311  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
312  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
313  *
314  * @pre This method can be called if SCIP is in one of the following stages:
315  * - \ref SCIP_STAGE_PRESOLVING
316  * - \ref SCIP_STAGE_SOLVING
317  *
318  * @note SCIP stage does not get changed
319  */
320 SCIP_EXPORT
322  SCIP* scip, /**< SCIP data structure */
323  SCIP_VAR* var, /**< variable whose upper bound should be added to conflict candidate queue */
324  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node, when the
325  * conflicting bound was valid, NULL for current local bound */
326  SCIP_Real relaxedub /**< the relaxed upper bound */
327  );
328 
329 /** adds lower or upper bound of variable at the time of the given bound change index to the conflict analysis' candidate
330  * storage; this method should be called in one of the following two cases:
331  * 1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictBd() should be called for each bound
332  * that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
333  * 2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictBd() should be called
334  * for each bound, whose current assignment led to the deduction of the given conflict bound.
335  *
336  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
337  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
338  *
339  * @pre This method can be called if SCIP is in one of the following stages:
340  * - \ref SCIP_STAGE_PRESOLVING
341  * - \ref SCIP_STAGE_SOLVING
342  *
343  * @note SCIP stage does not get changed
344  */
345 SCIP_EXPORT
347  SCIP* scip, /**< SCIP data structure */
348  SCIP_VAR* var, /**< variable whose upper bound should be added to conflict candidate queue */
349  SCIP_BOUNDTYPE boundtype, /**< the type of the conflicting bound (lower or upper bound) */
350  SCIP_BDCHGIDX* bdchgidx /**< bound change index representing time on path to current node, when the
351  * conflicting bound was valid, NULL for current local bound */
352  );
353 
354 /** adds lower or upper bound of variable at the time of the given bound change index to the conflict analysis'
355  * candidate storage; with the additional information of a relaxed upper bound; this relaxed upper bound is the one
356  * which would be enough to explain a certain bound change;
357  * this method should be called in one of the following two cases:
358  * 1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictRelaxedBd() should be called for each (relaxed)
359  * bound that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
360  * 2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictRelaxedBd() should be
361  * called for each (relaxed) bound, whose current assignment led to the deduction of the given conflict bound.
362  *
363  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
364  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
365  *
366  * @pre This method can be called if SCIP is in one of the following stages:
367  * - \ref SCIP_STAGE_PRESOLVING
368  * - \ref SCIP_STAGE_SOLVING
369  *
370  * @note SCIP stage does not get changed
371  */
372 SCIP_EXPORT
374  SCIP* scip, /**< SCIP data structure */
375  SCIP_VAR* var, /**< variable whose upper bound should be added to conflict candidate queue */
376  SCIP_BOUNDTYPE boundtype, /**< the type of the conflicting bound (lower or upper bound) */
377  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node, when the
378  * conflicting bound was valid, NULL for current local bound */
379  SCIP_Real relaxedbd /**< the relaxed bound */
380  );
381 
382 /** adds changed bound of fixed binary variable to the conflict analysis' candidate storage;
383  * this method should be called in one of the following two cases:
384  * 1. Before calling the SCIPanalyzeConflict() method, SCIPaddConflictBinvar() should be called for each fixed binary
385  * variable that led to the conflict (e.g. the infeasibility of globally or locally valid constraint).
386  * 2. In the propagation conflict resolving method of a constraint handler, SCIPaddConflictBinvar() should be called
387  * for each binary variable, whose current fixing led to the deduction of the given conflict bound.
388  *
389  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
390  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
391  *
392  * @pre This method can be called if SCIP is in one of the following stages:
393  * - \ref SCIP_STAGE_PRESOLVING
394  * - \ref SCIP_STAGE_SOLVING
395  *
396  * @note SCIP stage does not get changed
397  */
398 SCIP_EXPORT
400  SCIP* scip, /**< SCIP data structure */
401  SCIP_VAR* var /**< binary variable whose changed bound should be added to conflict queue */
402  );
403 
404 /** checks if the given variable is already part of the current conflict set or queued for resolving with the same or
405  * even stronger bound
406  *
407  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
408  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
409  *
410  * @pre This method can be called if SCIP is in one of the following stages:
411  * - \ref SCIP_STAGE_PRESOLVING
412  * - \ref SCIP_STAGE_SOLVING
413  *
414  * @note SCIP stage does not get changed
415  */
416 SCIP_EXPORT
418  SCIP* scip, /**< SCIP data structure */
419  SCIP_VAR* var, /**< variable whose upper bound should be added to conflict candidate queue */
420  SCIP_BOUNDTYPE boundtype, /**< the type of the conflicting bound (lower or upper bound) */
421  SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node, when the
422  * conflicting bound was valid, NULL for current local bound */
423  SCIP_Bool* used /**< pointer to store if the variable is already used */
424  );
425 
426 /** returns the conflict lower bound if the variable is present in the current conflict set; otherwise the global lower
427  * bound
428  *
429  * @return returns the conflict lower bound if the variable is present in the current conflict set; otherwise the global lower
430  * bound
431  *
432  * @pre This method can be called if SCIP is in one of the following stages:
433  * - \ref SCIP_STAGE_PRESOLVING
434  * - \ref SCIP_STAGE_SOLVING
435  *
436  * @note SCIP stage does not get changed
437  */
438 SCIP_EXPORT
440  SCIP* scip, /**< SCIP data structure */
441  SCIP_VAR* var /**< problem variable */
442  );
443 
444 /** returns the conflict upper bound if the variable is present in the current conflict set; otherwise minus global
445  * upper bound
446  *
447  * @return returns the conflict upper bound if the variable is present in the current conflict set; otherwise minus global
448  * upper bound
449  *
450  * @pre This method can be called if SCIP is in one of the following stages:
451  * - \ref SCIP_STAGE_PRESOLVING
452  * - \ref SCIP_STAGE_SOLVING
453  *
454  * @note SCIP stage does not get changed
455  */
456 SCIP_EXPORT
458  SCIP* scip, /**< SCIP data structure */
459  SCIP_VAR* var /**< problem variable */
460  );
461 
462 /** analyzes conflict bounds that were added after a call to SCIPinitConflictAnalysis() with calls to
463  * SCIPaddConflictLb(), SCIPaddConflictUb(), SCIPaddConflictBd(), SCIPaddConflictRelaxedLb(),
464  * SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), or SCIPaddConflictBinvar(); on success, calls the conflict
465  * handlers to create a conflict constraint out of the resulting conflict set; the given valid depth must be a depth
466  * level, at which the conflict set defined by calls to SCIPaddConflictLb(), SCIPaddConflictUb(), SCIPaddConflictBd(),
467  * SCIPaddConflictRelaxedLb(), SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), and SCIPaddConflictBinvar() is
468  * valid for the whole subtree; if the conflict was found by a violated constraint, use SCIPanalyzeConflictCons()
469  * instead of SCIPanalyzeConflict() to make sure, that the correct valid depth is used
470  *
471  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
472  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
473  *
474  * @pre This method can be called if SCIP is in one of the following stages:
475  * - \ref SCIP_STAGE_PRESOLVING
476  * - \ref SCIP_STAGE_SOLVING
477  *
478  * @note SCIP stage does not get changed
479  */
480 SCIP_EXPORT
482  SCIP* scip, /**< SCIP data structure */
483  int validdepth, /**< minimal depth level at which the initial conflict set is valid */
484  SCIP_Bool* success /**< pointer to store whether a conflict constraint was created, or NULL */
485  );
486 
487 /** analyzes conflict bounds that were added with calls to SCIPaddConflictLb(), SCIPaddConflictUb(),
488  * SCIPaddConflictBd(), SCIPaddConflictRelaxedLb(), SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), or
489  * SCIPaddConflictBinvar(); on success, calls the conflict handlers to create a conflict constraint out of the
490  * resulting conflict set; the given constraint must be the constraint that detected the conflict, i.e. the constraint
491  * that is infeasible in the local bounds of the initial conflict set (defined by calls to SCIPaddConflictLb(),
492  * SCIPaddConflictUb(), SCIPaddConflictBd(), SCIPaddConflictRelaxedLb(), SCIPaddConflictRelaxedUb(),
493  * SCIPaddConflictRelaxedBd(), and SCIPaddConflictBinvar())
494  *
495  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
496  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
497  *
498  * @pre This method can be called if SCIP is in one of the following stages:
499  * - \ref SCIP_STAGE_PRESOLVING
500  * - \ref SCIP_STAGE_SOLVING
501  *
502  * @note SCIP stage does not get changed
503  */
504 SCIP_EXPORT
506  SCIP* scip, /**< SCIP data structure */
507  SCIP_CONS* cons, /**< constraint that detected the conflict */
508  SCIP_Bool* success /**< pointer to store whether a conflict constraint was created, or NULL */
509  );
510 
511 /**@} */
512 
513 #ifdef __cplusplus
514 }
515 #endif
516 
517 #endif
enum SCIP_BoundType SCIP_BOUNDTYPE
Definition: type_lp.h:59
SCIP_RETCODE SCIPsetConflicthdlrInit(SCIP *scip, SCIP_CONFLICTHDLR *conflicthdlr, SCIP_DECL_CONFLICTINIT((*conflictinit)))
SCIP_RETCODE SCIPaddConflictBinvar(SCIP *scip, SCIP_VAR *var)
SCIP_RETCODE SCIPsetConflicthdlrCopy(SCIP *scip, SCIP_CONFLICTHDLR *conflicthdlr, SCIP_DECL_CONFLICTCOPY((*conflictcopy)))
SCIP_Real SCIPgetConflictVarUb(SCIP *scip, SCIP_VAR *var)
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:63
SCIP_RETCODE SCIPaddConflictUb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx)
SCIP_RETCODE SCIPisConflictVarUsed(SCIP *scip, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool *used)
SCIP_RETCODE SCIPaddConflictRelaxedLb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedlb)
SCIP_RETCODE SCIPinitConflictAnalysis(SCIP *scip, SCIP_CONFTYPE conftype, SCIP_Bool iscutoffinvolved)
SCIP_RETCODE SCIPsetConflicthdlrExit(SCIP *scip, SCIP_CONFLICTHDLR *conflicthdlr, SCIP_DECL_CONFLICTEXIT((*conflictexit)))
type definitions for return codes for SCIP methods
#define SCIP_DECL_CONFLICTEXIT(x)
SCIP_RETCODE SCIPsetConflicthdlrExitsol(SCIP *scip, SCIP_CONFLICTHDLR *conflicthdlr, SCIP_DECL_CONFLICTEXITSOL((*conflictexitsol)))
SCIP_RETCODE SCIPaddConflictLb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx)
SCIP_RETCODE SCIPsetConflicthdlrInitsol(SCIP *scip, SCIP_CONFLICTHDLR *conflicthdlr, SCIP_DECL_CONFLICTINITSOL((*conflictinitsol)))
SCIP_RETCODE SCIPincludeConflicthdlr(SCIP *scip, const char *name, const char *desc, int priority, SCIP_DECL_CONFLICTCOPY((*conflictcopy)), SCIP_DECL_CONFLICTFREE((*conflictfree)), SCIP_DECL_CONFLICTINIT((*conflictinit)), SCIP_DECL_CONFLICTEXIT((*conflictexit)), SCIP_DECL_CONFLICTINITSOL((*conflictinitsol)), SCIP_DECL_CONFLICTEXITSOL((*conflictexitsol)), SCIP_DECL_CONFLICTEXEC((*conflictexec)), SCIP_CONFLICTHDLRDATA *conflicthdlrdata)
Definition: scip_conflict.c:65
type definitions for LP management
SCIP_Bool SCIPisConflictAnalysisApplicable(SCIP *scip)
#define SCIP_DECL_CONFLICTINITSOL(x)
#define SCIP_DECL_CONFLICTEXEC(x)
type definitions for SCIP&#39;s main datastructure
int SCIPgetNConflicthdlrs(SCIP *scip)
SCIP_Real SCIPgetConflictVarLb(SCIP *scip, SCIP_VAR *var)
SCIP_RETCODE SCIPaddConflictRelaxedBd(SCIP *scip, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedbd)
struct SCIP_ConflicthdlrData SCIP_CONFLICTHDLRDATA
Definition: type_conflict.h:49
type definitions for problem variables
#define SCIP_DECL_CONFLICTCOPY(x)
Definition: type_conflict.h:86
SCIP_RETCODE SCIPanalyzeConflictCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *success)
type definitions for conflict analysis
SCIP_CONFLICTHDLR ** SCIPgetConflicthdlrs(SCIP *scip)
#define SCIP_Bool
Definition: def.h:93
SCIP_RETCODE SCIPaddConflictRelaxedUb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedub)
SCIP_RETCODE SCIPaddConflictBd(SCIP *scip, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx)
type definitions for branch and bound tree
SCIP_RETCODE SCIPsetConflicthdlrFree(SCIP *scip, SCIP_CONFLICTHDLR *conflicthdlr, SCIP_DECL_CONFLICTFREE((*conflictfree)))
SCIP_CONFLICTHDLR * SCIPfindConflicthdlr(SCIP *scip, const char *name)
SCIP_RETCODE SCIPincludeConflicthdlrBasic(SCIP *scip, SCIP_CONFLICTHDLR **conflicthdlrptr, const char *name, const char *desc, int priority, SCIP_DECL_CONFLICTEXEC((*conflictexec)), SCIP_CONFLICTHDLRDATA *conflicthdlrdata)
#define SCIP_Real
Definition: def.h:186
result codes for SCIP callback methods
enum SCIP_ConflictType SCIP_CONFTYPE
Definition: type_conflict.h:65
#define SCIP_DECL_CONFLICTINIT(x)
common defines and data types used in all packages of SCIP
#define SCIP_DECL_CONFLICTFREE(x)
Definition: type_conflict.h:94
SCIP_RETCODE SCIPanalyzeConflict(SCIP *scip, int validdepth, SCIP_Bool *success)
SCIP_RETCODE SCIPsetConflicthdlrPriority(SCIP *scip, SCIP_CONFLICTHDLR *conflicthdlr, int priority)
type definitions for constraints and constraint handlers
#define SCIP_DECL_CONFLICTEXITSOL(x)