SCIP Doxygen Documentation
 
Loading...
Searching...
No Matches
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 (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 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
55extern "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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
163 SCIP* scip /**< SCIP data structure */
164 );
165
166/** returns the number of currently available conflict handlers */
169 SCIP* scip /**< SCIP data structure */
170 );
171
172/** sets the priority of a conflict handler */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
439SCIP_Real SCIPgetConflictVarLb(
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 */
457SCIP_Real SCIPgetConflictVarUb(
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 */
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 */
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
common defines and data types used in all packages of SCIP
SCIP_RETCODE SCIPaddConflictLb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx)
SCIP_RETCODE SCIPinitConflictAnalysis(SCIP *scip, SCIP_CONFTYPE conftype, SCIP_Bool iscutoffinvolved)
SCIP_RETCODE SCIPaddConflictRelaxedBd(SCIP *scip, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedbd)
SCIP_RETCODE SCIPaddConflictUb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx)
SCIP_RETCODE SCIPaddConflictRelaxedLb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedlb)
SCIP_RETCODE SCIPanalyzeConflict(SCIP *scip, int validdepth, SCIP_Bool *success)
SCIP_RETCODE SCIPisConflictVarUsed(SCIP *scip, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool *used)
SCIP_RETCODE SCIPaddConflictBd(SCIP *scip, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx)
SCIP_RETCODE SCIPaddConflictRelaxedUb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedub)
SCIP_Bool SCIPisConflictAnalysisApplicable(SCIP *scip)
SCIP_Real SCIPgetConflictVarUb(SCIP *scip, SCIP_VAR *var)
SCIP_RETCODE SCIPaddConflictBinvar(SCIP *scip, SCIP_VAR *var)
SCIP_Real SCIPgetConflictVarLb(SCIP *scip, SCIP_VAR *var)
SCIP_RETCODE SCIPanalyzeConflictCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *success)
SCIP_CONFLICTHDLR ** SCIPgetConflicthdlrs(SCIP *scip)
SCIP_RETCODE SCIPsetConflicthdlrInit(SCIP *scip, SCIP_CONFLICTHDLR *conflicthdlr,)
SCIP_RETCODE SCIPsetConflicthdlrInitsol(SCIP *scip, SCIP_CONFLICTHDLR *conflicthdlr,)
int SCIPgetNConflicthdlrs(SCIP *scip)
SCIP_RETCODE SCIPsetConflicthdlrFree(SCIP *scip, SCIP_CONFLICTHDLR *conflicthdlr,)
SCIP_RETCODE SCIPsetConflicthdlrExitsol(SCIP *scip, SCIP_CONFLICTHDLR *conflicthdlr,)
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)
SCIP_RETCODE SCIPsetConflicthdlrPriority(SCIP *scip, SCIP_CONFLICTHDLR *conflicthdlr, int priority)
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)
SCIP_RETCODE SCIPsetConflicthdlrExit(SCIP *scip, SCIP_CONFLICTHDLR *conflicthdlr,)
SCIP_RETCODE SCIPsetConflicthdlrCopy(SCIP *scip, SCIP_CONFLICTHDLR *conflicthdlr,)
SCIP_VAR * var
type definitions for conflict analysis
#define SCIP_DECL_CONFLICTEXIT(x)
#define SCIP_DECL_CONFLICTCOPY(x)
#define SCIP_DECL_CONFLICTEXEC(x)
#define SCIP_DECL_CONFLICTINITSOL(x)
#define SCIP_DECL_CONFLICTFREE(x)
#define SCIP_DECL_CONFLICTINIT(x)
enum SCIP_ConflictType SCIP_CONFTYPE
struct SCIP_ConflicthdlrData SCIP_CONFLICTHDLRDATA
#define SCIP_DECL_CONFLICTEXITSOL(x)
type definitions for constraints and constraint handlers
type definitions for LP management
enum SCIP_BoundType SCIP_BOUNDTYPE
Definition type_lp.h:59
result codes for SCIP callback methods
type definitions for return codes for SCIP methods
enum SCIP_Retcode SCIP_RETCODE
type definitions for SCIP's main datastructure
type definitions for branch and bound tree
type definitions for problem variables