SCIP Doxygen Documentation
 
Loading...
Searching...
No Matches
conflict_graphanalysis.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-2025 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 conflict_graphanalysis.h
26 * @ingroup OTHER_CFILES
27 * @brief methods and datastructures for conflict analysis
28 * @author Tobias Achterberg
29 * @author Timo Berthold
30 * @author Stefan Heinz
31 * @author Marc Pfetsch
32 * @author Michael Winkler
33 * @author Jakob Witzig
34 *
35 * This file implements a conflict analysis method like the one used in modern
36 * SAT solvers like zchaff. The algorithm works as follows:
37 *
38 * Given is a set of bound changes that are not allowed being applied simultaneously, because they
39 * render the current node infeasible (e.g. because a single constraint is infeasible in the these
40 * bounds, or because the LP relaxation is infeasible). The goal is to deduce a clause on variables
41 * -- a conflict clause -- representing the "reason" for this conflict, i.e., the branching decisions
42 * or the deductions (applied e.g. in domain propagation) that lead to the conflict. This clause can
43 * then be added to the constraint set to help cutting off similar parts of the branch and bound
44 * tree, that would lead to the same conflict. A conflict clause can also be generated, if the
45 * conflict was detected by a locally valid constraint. In this case, the resulting conflict clause
46 * is also locally valid in the same depth as the conflict detecting constraint. If all involved
47 * variables are binary, a linear (set covering) constraint can be generated, otherwise a bound
48 * disjunction constraint is generated. Details are given in
49 *
50 * Tobias Achterberg, Conflict Analysis in Mixed Integer Programming@n
51 * Discrete Optimization, 4, 4-20 (2007)
52 *
53 * See also @ref CONF. Here is an outline of the algorithm:
54 *
55 * -# Put all the given bound changes to a priority queue, which is ordered,
56 * such that the bound change that was applied last due to branching or deduction
57 * is at the top of the queue. The variables in the queue are always active
58 * problem variables. Because binary variables are preferred over general integer
59 * variables, integer variables are put on the priority queue prior to the binary
60 * variables. Create an empty conflict set.
61 * -# Remove the top bound change b from the priority queue.
62 * -# Perform the following case distinction:
63 * -# If the remaining queue is non-empty, and bound change b' (the one that is now
64 * on the top of the queue) was applied at the same depth level as b, and if
65 * b was a deduction with known inference reason, and if the inference constraint's
66 * valid depth is smaller or equal to the conflict detecting constraint's valid
67 * depth:
68 * - Resolve bound change b by asking the constraint that inferred the
69 * bound change to put all the bound changes on the priority queue, that
70 * lead to the deduction of b.
71 * Note that these bound changes have at most the same inference depth
72 * level as b, and were deduced earlier than b.
73 * -# Otherwise, the bound change b was a branching decision or a deduction with
74 * missing inference reason, or the inference constraint's validity is more local
75 * than the one of the conflict detecting constraint.
76 * - If a the bound changed corresponds to a binary variable, add it or its
77 * negation to the conflict set, depending on which of them is currently fixed to
78 * FALSE (i.e., the conflict set consists of literals that cannot be FALSE
79 * altogether at the same time).
80 * - Otherwise put the bound change into the conflict set.
81 * Note that if the bound change was a branching, all deduced bound changes
82 * remaining in the priority queue have smaller inference depth level than b,
83 * since deductions are always applied after the branching decisions. However,
84 * there is the possibility, that b was a deduction, where the inference
85 * reason was not given or the inference constraint was too local.
86 * With this lack of information, we must treat the deduced bound change like
87 * a branching, and there may exist other deduced bound changes of the same
88 * inference depth level in the priority queue.
89 * -# If priority queue is non-empty, goto step 2.
90 * -# The conflict set represents the conflict clause saying that at least one
91 * of the conflict variables must take a different value. The conflict set is then passed
92 * to the conflict handlers, that may create a corresponding constraint (e.g. a logicor
93 * constraint or bound disjunction constraint) out of these conflict variables and
94 * add it to the problem.
95 *
96 * If all deduced bound changes come with (global) inference information, depending on
97 * the conflict analyzing strategy, the resulting conflict set has the following property:
98 * - 1-FirstUIP: In the depth level where the conflict was found, at most one variable
99 * assigned at that level is member of the conflict set. This conflict variable is the
100 * first unique implication point of its depth level (FUIP).
101 * - All-FirstUIP: For each depth level, at most one variable assigned at that level is
102 * member of the conflict set. This conflict variable is the first unique implication
103 * point of its depth level (FUIP).
104 *
105 * The user has to do the following to get the conflict analysis running in its
106 * current implementation:
107 * - A constraint handler or propagator supporting the conflict analysis must implement
108 * the CONSRESPROP/PROPRESPROP call, that processes a bound change inference b and puts all
109 * the reason bounds leading to the application of b with calls to
110 * SCIPaddConflictBound() on the conflict queue (algorithm step 3.(a)).
111 * - If the current bounds lead to a deduction of a bound change (e.g. in domain
112 * propagation), a constraint handler should call SCIPinferVarLbCons() or
113 * SCIPinferVarUbCons(), thus providing the constraint that inferred the bound change.
114 * A propagator should call SCIPinferVarLbProp() or SCIPinferVarUbProp() instead,
115 * thus providing a pointer to itself.
116 * - If (in the current bounds) an infeasibility is detected, the constraint handler or
117 * propagator should
118 * 1. call SCIPinitConflictAnalysis() to initialize the conflict queue,
119 * 2. call SCIPaddConflictBound() for each bound that lead to the conflict,
120 * 3. call SCIPanalyzeConflictCons() or SCIPanalyzeConflict() to analyze the conflict
121 * and add an appropriate conflict constraint.
122 */
123
124/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
125
126#ifndef __SCIP_CONFLICT_GRAPHANALYSIS_H__
127#define __SCIP_CONFLICT_GRAPHANALYSIS_H__
128
129#include "scip/def.h"
130#include "scip/type_cuts.h"
131#include "scip/type_conflict.h"
132#include "scip/type_reopt.h"
133#include "scip/type_implics.h"
134#include "scip/type_set.h"
135#include "scip/type_stat.h"
136#include "scip/type_lp.h"
137#include "lpi/type_lpi.h"
138#include "scip/type_branch.h"
139#include "scip/type_mem.h"
140#include "scip/type_var.h"
141#include "scip/type_prob.h"
142#include "scip/type_event.h"
143#include "scip/type_message.h"
144#include <string.h>
145#if defined(_WIN32) || defined(_WIN64)
146#else
147#include <strings.h> /*lint --e{766}*/
148#endif
149
150#ifdef __cplusplus
151extern "C" {
152#endif
153
154/** creates an empty conflict set */
156 SCIP_CONFLICTSET** conflictset, /**< pointer to store the conflict set */
157 BMS_BLKMEM* blkmem /**< block memory of transformed problem */
158 );
159
160/** frees a conflict set */
162 SCIP_CONFLICTSET** conflictset, /**< pointer to the conflict set */
163 BMS_BLKMEM* blkmem /**< block memory of transformed problem */
164 );
165
166/** copies the given conflict handler to a new scip */
168 SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
169 SCIP_SET* set /**< SCIP_SET of SCIP to copy to */
170 );
171
172/** creates a conflict handler */
174 SCIP_CONFLICTHDLR** conflicthdlr, /**< pointer to conflict handler data structure */
175 SCIP_SET* set, /**< global SCIP settings */
176 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
177 BMS_BLKMEM* blkmem, /**< block memory for parameter settings */
178 const char* name, /**< name of conflict handler */
179 const char* desc, /**< description of conflict handler */
180 int priority, /**< priority of the conflict handler */
181 SCIP_DECL_CONFLICTCOPY((*conflictcopy)), /**< copy method of conflict handler or NULL if you don't want to copy your plugin into sub-SCIPs */
182 SCIP_DECL_CONFLICTFREE((*conflictfree)), /**< destructor of conflict handler */
183 SCIP_DECL_CONFLICTINIT((*conflictinit)), /**< initialize conflict handler */
184 SCIP_DECL_CONFLICTEXIT((*conflictexit)), /**< deinitialize conflict handler */
185 SCIP_DECL_CONFLICTINITSOL((*conflictinitsol)),/**< solving process initialization method of conflict handler */
186 SCIP_DECL_CONFLICTEXITSOL((*conflictexitsol)),/**< solving process deinitialization method of conflict handler */
187 SCIP_DECL_CONFLICTEXEC((*conflictexec)), /**< conflict processing method of conflict handler */
188 SCIP_CONFLICTHDLRDATA* conflicthdlrdata /**< conflict handler data */
189 );
190
191/** calls destructor and frees memory of conflict handler */
193 SCIP_CONFLICTHDLR** conflicthdlr, /**< pointer to conflict handler data structure */
194 SCIP_SET* set /**< global SCIP settings */
195 );
196
197/** calls init method of conflict handler */
199 SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
200 SCIP_SET* set /**< global SCIP settings */
201 );
202
203/** calls exit method of conflict handler */
205 SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
206 SCIP_SET* set /**< global SCIP settings */
207 );
208
209/** informs conflict handler that the branch and bound process is being started */
211 SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
212 SCIP_SET* set /**< global SCIP settings */
213 );
214
215/** informs conflict handler that the branch and bound process data is being freed */
217 SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
218 SCIP_SET* set /**< global SCIP settings */
219 );
220
221/** calls execution method of conflict handler */
223 SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
224 SCIP_SET* set, /**< global SCIP settings */
225 SCIP_NODE* node, /**< node to add conflict constraint to */
226 SCIP_NODE* validnode, /**< node at which the constraint is valid */
227 SCIP_BDCHGINFO** bdchginfos, /**< bound change resembling the conflict set */
228 SCIP_Real* relaxedbds, /**< array with relaxed bounds which are efficient to create a valid conflict */
229 int nbdchginfos, /**< number of bound changes in the conflict set */
230 SCIP_CONFTYPE conftype, /**< type of the conflict */
231 SCIP_Bool usescutoffbound, /**< depends the conflict on the cutoff bound? */
232 SCIP_Bool resolved, /**< was the conflict set already used to create a constraint? */
233 SCIP_RESULT* result /**< pointer to store the result of the callback method */
234 );
235
236/** sets priority of conflict handler */
238 SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
239 SCIP_SET* set, /**< global SCIP settings */
240 int priority /**< new priority of the conflict handler */
241 );
242
243/** set copy method of conflict handler */
245 SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
246 SCIP_DECL_CONFLICTCOPY((*conflictcopy)) /**< copy method of the conflict handler */
247 );
248
249/** set destructor of conflict handler */
251 SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
252 SCIP_DECL_CONFLICTFREE((*conflictfree)) /**< destructor of conflict handler */
253 );
254
255/** set initialization method of conflict handler */
257 SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
258 SCIP_DECL_CONFLICTINIT((*conflictinit)) /**< initialization method conflict handler */
259 );
260
261/** set deinitialization method of conflict handler */
263 SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
264 SCIP_DECL_CONFLICTEXIT((*conflictexit)) /**< deinitialization method conflict handler */
265 );
266
267/** set solving process initialization method of conflict handler */
269 SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
270 SCIP_DECL_CONFLICTINITSOL((*conflictinitsol))/**< solving process initialization method of conflict handler */
271 );
272
273/** set solving process deinitialization method of conflict handler */
275 SCIP_CONFLICTHDLR* conflicthdlr, /**< conflict handler */
276 SCIP_DECL_CONFLICTEXITSOL((*conflictexitsol))/**< solving process deinitialization method of conflict handler */
277 );
278
279/** enables or disables all clocks of \p conflicthdlr, depending on the value of the flag */
281 SCIP_CONFLICTHDLR* conflicthdlr, /**< the conflict handler for which all clocks should be enabled or disabled */
282 SCIP_Bool enable /**< should the clocks of the conflict handler be enabled? */
283 );
284
285/** return TRUE if conflict analysis is applicable; In case the function return FALSE there is no need to initialize the
286 * conflict analysis since it will not be applied
287 */
289 SCIP_SET* set /**< global SCIP settings */
290 );
291
292/** creates a temporary bound change information object that is destroyed after the conflict sets are flushed */
294 SCIP_CONFLICT* conflict, /**< conflict analysis data */
295 BMS_BLKMEM* blkmem, /**< block memory */
296 SCIP_SET* set, /**< global SCIP settings */
297 SCIP_VAR* var, /**< active variable that changed the bounds */
298 SCIP_BOUNDTYPE boundtype, /**< type of bound for var: lower or upper bound */
299 SCIP_Real oldbound, /**< old value for bound */
300 SCIP_Real newbound, /**< new value for bound */
301 SCIP_BDCHGINFO** bdchginfo /**< pointer to store bound change information */
302 );
303
304
305/*
306 * Conflict LP Bound Changes
307 */
308
309
310/** calculates the maximal size of conflict sets to be used */
312 SCIP_SET* set, /**< global SCIP settings */
313 SCIP_PROB* prob /**< problem data */
314 );
315
316/** undoes bound changes on variables, still leaving the given infeasibility proof valid */
318 SCIP_SET* set, /**< global SCIP settings */
319 SCIP_PROB* prob, /**< problem data */
320 int currentdepth, /**< current depth in the tree */
321 SCIP_Real* proofcoefs, /**< coefficients in infeasibility proof */
322 SCIP_Real prooflhs, /**< left hand side of proof */
323 SCIP_Real* proofact, /**< current activity of proof */
324 SCIP_Real* curvarlbs, /**< current lower bounds of active problem variables */
325 SCIP_Real* curvarubs, /**< current upper bounds of active problem variables */
326 int* lbchginfoposs, /**< positions of currently active lower bound change information in variables' arrays */
327 int* ubchginfoposs, /**< positions of currently active upper bound change information in variables' arrays */
328 SCIP_LPBDCHGS* oldlpbdchgs, /**< old LP bound changes used for reset the LP bound change, or NULL */
329 SCIP_LPBDCHGS* relaxedlpbdchgs, /**< relaxed LP bound changes used for reset the LP bound change, or NULL */
330 SCIP_Bool* resolve, /**< pointer to store whether the changed LP should be resolved again, or NULL */
331 SCIP_LPI* lpi /**< pointer to LPi to access infinity of LP solver; necessary to set correct values */
332 );
333
334/** applies conflict analysis starting with given bound changes, that could not be undone during previous
335 * infeasibility analysis
336 */
338 SCIP_CONFLICT* conflict, /**< conflict analysis data */
339 BMS_BLKMEM* blkmem, /**< block memory of transformed problem */
340 SCIP_SET* set, /**< global SCIP settings */
341 SCIP_STAT* stat, /**< problem statistics */
342 SCIP_PROB* prob, /**< problem data */
343 SCIP_TREE* tree, /**< branch and bound tree */
344 SCIP_Bool diving, /**< are we in strong branching or diving mode? */
345 int* lbchginfoposs, /**< positions of currently active lower bound change information in variables' arrays */
346 int* ubchginfoposs, /**< positions of currently active upper bound change information in variables' arrays */
347 int* nconss, /**< pointer to store the number of generated conflict constraints */
348 int* nliterals, /**< pointer to store the number of literals in generated conflict constraints */
349 int* nreconvconss, /**< pointer to store the number of generated reconvergence constraints */
350 int* nreconvliterals /**< pointer to store the number of literals generated reconvergence constraints */
351 );
352
353/** initializes the propagation conflict analysis by clearing the conflict candidate queue */
355 SCIP_CONFLICT* conflict, /**< conflict analysis data */
356 SCIP_SET* set, /**< global SCIP settings */
357 SCIP_STAT* stat, /**< problem statistics */
358 SCIP_PROB* prob, /**< problem data */
359 SCIP_CONFTYPE conftype, /**< type of the conflict */
360 SCIP_Bool usescutoffbound /**< depends the conflict on a cutoff bound? */
361 );
362
363/** adds variable's bound to conflict candidate queue */
365 SCIP_CONFLICT* conflict, /**< conflict analysis data */
366 BMS_BLKMEM* blkmem, /**< block memory */
367 SCIP_SET* set, /**< global SCIP settings */
368 SCIP_STAT* stat, /**< dynamic problem statistics */
369 SCIP_VAR* var, /**< problem variable */
370 SCIP_BOUNDTYPE boundtype, /**< type of bound that was changed: lower or upper bound */
371 SCIP_BDCHGIDX* bdchgidx /**< bound change index (time stamp of bound change), or NULL for current time */
372 );
373
374/** adds variable's bound to conflict candidate queue with the additional information of a relaxed bound */
376 SCIP_CONFLICT* conflict, /**< conflict analysis data */
377 BMS_BLKMEM* blkmem, /**< block memory */
378 SCIP_SET* set, /**< global SCIP settings */
379 SCIP_STAT* stat, /**< dynamic problem statistics */
380 SCIP_VAR* var, /**< problem variable */
381 SCIP_BOUNDTYPE boundtype, /**< type of bound that was changed: lower or upper bound */
382 SCIP_BDCHGIDX* bdchgidx, /**< bound change index (time stamp of bound change), or NULL for current time */
383 SCIP_Real relaxedbd /**< the relaxed bound */
384 );
385
386/** checks if the given variable is already part of the current conflict set or queued for resolving with the same or
387 * even stronger bound
388 */
390 SCIP_CONFLICT* conflict, /**< conflict analysis data */
391 SCIP_VAR* var, /**< problem variable */
392 SCIP_SET* set, /**< global SCIP settings */
393 SCIP_BOUNDTYPE boundtype, /**< type of bound for which the score should be increased */
394 SCIP_BDCHGIDX* bdchgidx, /**< bound change index (time stamp of bound change), or NULL for current time */
395 SCIP_Bool* used /**< pointer to store if the variable is already used */
396 );
397
398/** returns the conflict lower bound if the variable is present in the current conflict set; otherwise the global lower
399 * bound
400 */
402 SCIP_CONFLICT* conflict, /**< conflict analysis data */
403 SCIP_VAR* var /**< problem variable */
404 );
405
406/** returns the conflict upper bound if the variable is present in the current conflict set; otherwise the global upper
407 * bound
408 */
410 SCIP_CONFLICT* conflict, /**< conflict analysis data */
411 SCIP_VAR* var /**< problem variable */
412 );
413
414/** try to find a subset of changed bounds leading to an infeasible LP
415 *
416 * 1. call undoBdchgsDualfarkas() or undoBdchgsDualsol()
417 * -> update lb/ubchginfoposs arrays
418 * -> store additional changes in bdchg and curvarlbs/ubs arrays
419 * -> apply additional changes to the LPI
420 * 2. (optional) if additional bound changes were undone:
421 * -> resolve LP
422 * -> goto 1.
423 * 3. redo all bound changes in the LPI to restore the LPI to its original state
424 * 4. analyze conflict
425 * -> put remaining changed bounds (see lb/ubchginfoposs arrays) into starting conflict set
426 */
428 SCIP_CONFLICT* conflict, /**< conflict data */
429 SCIP_SET* set, /**< global SCIP settings */
430 SCIP_STAT* stat, /**< problem statistics */
431 SCIP_PROB* origprob, /**< original problem */
432 SCIP_PROB* transprob, /**< transformed problem */
433 SCIP_TREE* tree, /**< branch and bound tree */
434 SCIP_REOPT* reopt, /**< reoptimization data */
435 SCIP_LP* lp, /**< LP data */
436 SCIP_LPI* lpi, /**< LPI data */
437 BMS_BLKMEM* blkmem, /**< block memory */
438 SCIP_Real* proofcoefs, /**< coefficients in the proof constraint */
439 SCIP_Real* prooflhs, /**< lhs of the proof constraint */
440 SCIP_Real* proofactivity, /**< maximal activity of the proof constraint */
441 SCIP_Real* curvarlbs, /**< current lower bounds of active problem variables */
442 SCIP_Real* curvarubs, /**< current upper bounds of active problem variables */
443 int* lbchginfoposs, /**< positions of currently active lower bound change information in variables' arrays */
444 int* ubchginfoposs, /**< positions of currently active upper bound change information in variables' arrays */
445 int* iterations, /**< pointer to store the total number of LP iterations used */
446 SCIP_Bool marklpunsolved, /**< whether LP should be marked unsolved after analysis (needed for strong branching) */
447 SCIP_Bool* dualproofsuccess, /**< pointer to store success result of dual proof analysis */
448 SCIP_Bool* valid /**< pointer to store whether the result is still a valid proof */
449 );
450
451#ifdef __cplusplus
452}
453#endif
454
455#endif
void SCIPconflictsetFree(SCIP_CONFLICTSET **conflictset, BMS_BLKMEM *blkmem)
void SCIPconflicthdlrEnableOrDisableClocks(SCIP_CONFLICTHDLR *conflicthdlr, SCIP_Bool enable)
SCIP_RETCODE conflictCreateTmpBdchginfo(SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_Real oldbound, SCIP_Real newbound, SCIP_BDCHGINFO **bdchginfo)
SCIP_RETCODE SCIPconflictAnalyzeRemainingBdchgs(SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_TREE *tree, SCIP_Bool diving, int *lbchginfoposs, int *ubchginfoposs, int *nconss, int *nliterals, int *nreconvconss, int *nreconvliterals)
SCIP_RETCODE SCIPconflicthdlrCreate(SCIP_CONFLICTHDLR **conflicthdlr, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, 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)
void SCIPconflicthdlrSetExitsol(SCIP_CONFLICTHDLR *conflicthdlr,)
SCIP_RETCODE SCIPconflicthdlrExit(SCIP_CONFLICTHDLR *conflicthdlr, SCIP_SET *set)
void SCIPconflicthdlrSetFree(SCIP_CONFLICTHDLR *conflicthdlr,)
int conflictCalcMaxsize(SCIP_SET *set, SCIP_PROB *prob)
void SCIPconflicthdlrSetPriority(SCIP_CONFLICTHDLR *conflicthdlr, SCIP_SET *set, int priority)
SCIP_RETCODE SCIPconflictAddBound(SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx)
SCIP_RETCODE SCIPconflicthdlrFree(SCIP_CONFLICTHDLR **conflicthdlr, SCIP_SET *set)
void SCIPconflicthdlrSetCopy(SCIP_CONFLICTHDLR *conflicthdlr,)
SCIP_RETCODE SCIPconflicthdlrExitsol(SCIP_CONFLICTHDLR *conflicthdlr, SCIP_SET *set)
SCIP_Bool SCIPconflictApplicable(SCIP_SET *set)
SCIP_RETCODE SCIPrunBoundHeuristic(SCIP_CONFLICT *conflict, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *origprob, SCIP_PROB *transprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_LPI *lpi, BMS_BLKMEM *blkmem, SCIP_Real *proofcoefs, SCIP_Real *prooflhs, SCIP_Real *proofactivity, SCIP_Real *curvarlbs, SCIP_Real *curvarubs, int *lbchginfoposs, int *ubchginfoposs, int *iterations, SCIP_Bool marklpunsolved, SCIP_Bool *dualproofsuccess, SCIP_Bool *valid)
SCIP_RETCODE SCIPconflictAddRelaxedBound(SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedbd)
SCIP_Real SCIPconflictGetVarUb(SCIP_CONFLICT *conflict, SCIP_VAR *var)
SCIP_RETCODE SCIPconflicthdlrCopyInclude(SCIP_CONFLICTHDLR *conflicthdlr, SCIP_SET *set)
SCIP_RETCODE SCIPundoBdchgsProof(SCIP_SET *set, SCIP_PROB *prob, int currentdepth, SCIP_Real *proofcoefs, SCIP_Real prooflhs, SCIP_Real *proofact, SCIP_Real *curvarlbs, SCIP_Real *curvarubs, int *lbchginfoposs, int *ubchginfoposs, SCIP_LPBDCHGS *oldlpbdchgs, SCIP_LPBDCHGS *relaxedlpbdchgs, SCIP_Bool *resolve, SCIP_LPI *lpi)
void SCIPconflicthdlrSetExit(SCIP_CONFLICTHDLR *conflicthdlr,)
SCIP_RETCODE SCIPconflictIsVarUsed(SCIP_CONFLICT *conflict, SCIP_VAR *var, SCIP_SET *set, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool *used)
SCIP_RETCODE SCIPconflictsetCreate(SCIP_CONFLICTSET **conflictset, BMS_BLKMEM *blkmem)
SCIP_RETCODE SCIPconflictInit(SCIP_CONFLICT *conflict, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_CONFTYPE conftype, SCIP_Bool usescutoffbound)
SCIP_RETCODE SCIPconflicthdlrExec(SCIP_CONFLICTHDLR *conflicthdlr, SCIP_SET *set, SCIP_NODE *node, SCIP_NODE *validnode, SCIP_BDCHGINFO **bdchginfos, SCIP_Real *relaxedbds, int nbdchginfos, SCIP_CONFTYPE conftype, SCIP_Bool usescutoffbound, SCIP_Bool resolved, SCIP_RESULT *result)
void SCIPconflicthdlrSetInit(SCIP_CONFLICTHDLR *conflicthdlr,)
SCIP_RETCODE SCIPconflicthdlrInitsol(SCIP_CONFLICTHDLR *conflicthdlr, SCIP_SET *set)
SCIP_RETCODE SCIPconflicthdlrInit(SCIP_CONFLICTHDLR *conflicthdlr, SCIP_SET *set)
SCIP_Real SCIPconflictGetVarLb(SCIP_CONFLICT *conflict, SCIP_VAR *var)
void SCIPconflicthdlrSetInitsol(SCIP_CONFLICTHDLR *conflicthdlr,)
common defines and data types used in all packages of SCIP
#define SCIP_Bool
Definition def.h:91
#define SCIP_Real
Definition def.h:172
SCIP_VAR * var
struct BMS_BlkMem BMS_BLKMEM
Definition memory.h:437
type definitions for branching rules
type definitions for conflict analysis
struct SCIP_Conflicthdlr SCIP_CONFLICTHDLR
#define SCIP_DECL_CONFLICTEXIT(x)
#define SCIP_DECL_CONFLICTCOPY(x)
struct SCIP_ConflictSet SCIP_CONFLICTSET
struct SCIP_Conflict SCIP_CONFLICT
#define SCIP_DECL_CONFLICTEXEC(x)
#define SCIP_DECL_CONFLICTINITSOL(x)
#define SCIP_DECL_CONFLICTFREE(x)
struct SCIP_LPBdChgs SCIP_LPBDCHGS
#define SCIP_DECL_CONFLICTINIT(x)
enum SCIP_ConflictType SCIP_CONFTYPE
struct SCIP_ConflicthdlrData SCIP_CONFLICTHDLRDATA
#define SCIP_DECL_CONFLICTEXITSOL(x)
type definitions for cuts
type definitions for managing events
type definitions for implications, variable bounds, and cliques
type definitions for LP management
struct SCIP_Lp SCIP_LP
Definition type_lp.h:110
enum SCIP_BoundType SCIP_BOUNDTYPE
Definition type_lp.h:59
type definitions for specific LP solvers interface
struct SCIP_LPi SCIP_LPI
Definition type_lpi.h:106
type definitions for block memory pools and memory buffers
type definitions for message output methods
struct SCIP_Messagehdlr SCIP_MESSAGEHDLR
type definitions for storing and manipulating the main problem
struct SCIP_Prob SCIP_PROB
Definition type_prob.h:52
type definitions for collecting reoptimization information
struct SCIP_Reopt SCIP_REOPT
Definition type_reopt.h:39
enum SCIP_Result SCIP_RESULT
Definition type_result.h:61
enum SCIP_Retcode SCIP_RETCODE
type definitions for global SCIP settings
struct SCIP_Set SCIP_SET
Definition type_set.h:71
type definitions for problem statistics
struct SCIP_Stat SCIP_STAT
Definition type_stat.h:69
struct SCIP_Node SCIP_NODE
Definition type_tree.h:63
struct SCIP_Tree SCIP_TREE
Definition type_tree.h:65
type definitions for problem variables
struct SCIP_Var SCIP_VAR
Definition type_var.h:119
struct SCIP_BdChgIdx SCIP_BDCHGIDX
Definition type_var.h:107
struct SCIP_BdChgInfo SCIP_BDCHGINFO
Definition type_var.h:108