SCIP

Solving Constraint Integer Programs

conflict_graphanalysis.c File Reference

Detailed Description

methods and datastructures for conflict analysis

This file implements a conflict analysis method like the one used in modern SAT solvers like zchaff. The algorithm works as follows:

Given is a set of bound changes that are not allowed being applied simultaneously, because they render the current node infeasible (e.g. because a single constraint is infeasible in the these bounds, or because the LP relaxation is infeasible). The goal is to deduce a clause on variables – a conflict clause – representing the "reason" for this conflict, i.e., the branching decisions or the deductions (applied e.g. in domain propagation) that lead to the conflict. This clause can then be added to the constraint set to help cutting off similar parts of the branch and bound tree, that would lead to the same conflict. A conflict clause can also be generated, if the conflict was detected by a locally valid constraint. In this case, the resulting conflict clause is also locally valid in the same depth as the conflict detecting constraint. If all involved variables are binary, a linear (set covering) constraint can be generated, otherwise a bound disjunction constraint is generated. Details are given in

Tobias Achterberg, Conflict Analysis in Mixed Integer Programming
Discrete Optimization, 4, 4-20 (2007)

See also How to use conflict analysis. Here is an outline of the algorithm:

1. Put all the given bound changes to a priority queue, which is ordered, such that the bound change that was applied last due to branching or deduction is at the top of the queue. The variables in the queue are always active problem variables. Because binary variables are preferred over general integer variables, integer variables are put on the priority queue prior to the binary variables. Create an empty conflict set.
2. Remove the top bound change b from the priority queue.
3. Perform the following case distinction:
1. If the remaining queue is non-empty, and bound change b' (the one that is now on the top of the queue) was applied at the same depth level as b, and if b was a deduction with known inference reason, and if the inference constraint's valid depth is smaller or equal to the conflict detecting constraint's valid depth:
• Resolve bound change b by asking the constraint that inferred the bound change to put all the bound changes on the priority queue, that lead to the deduction of b. Note that these bound changes have at most the same inference depth level as b, and were deduced earlier than b.
2. Otherwise, the bound change b was a branching decision or a deduction with missing inference reason, or the inference constraint's validity is more local than the one of the conflict detecting constraint.
• If a the bound changed corresponds to a binary variable, add it or its negation to the conflict set, depending on which of them is currently fixed to FALSE (i.e., the conflict set consists of literals that cannot be FALSE altogether at the same time).
• Otherwise put the bound change into the conflict set. Note that if the bound change was a branching, all deduced bound changes remaining in the priority queue have smaller inference depth level than b, since deductions are always applied after the branching decisions. However, there is the possibility, that b was a deduction, where the inference reason was not given or the inference constraint was too local. With this lack of information, we must treat the deduced bound change like a branching, and there may exist other deduced bound changes of the same inference depth level in the priority queue.
4. If priority queue is non-empty, goto step 2.
5. The conflict set represents the conflict clause saying that at least one of the conflict variables must take a different value. The conflict set is then passed to the conflict handlers, that may create a corresponding constraint (e.g. a logicor constraint or bound disjunction constraint) out of these conflict variables and add it to the problem.

If all deduced bound changes come with (global) inference information, depending on the conflict analyzing strategy, the resulting conflict set has the following property:

• 1-FirstUIP: In the depth level where the conflict was found, at most one variable assigned at that level is member of the conflict set. This conflict variable is the first unique implication point of its depth level (FUIP).
• All-FirstUIP: For each depth level, at most one variable assigned at that level is member of the conflict set. This conflict variable is the first unique implication point of its depth level (FUIP).

The user has to do the following to get the conflict analysis running in its current implementation:

• A constraint handler or propagator supporting the conflict analysis must implement the CONSRESPROP/PROPRESPROP call, that processes a bound change inference b and puts all the reason bounds leading to the application of b with calls to SCIPaddConflictBound() on the conflict queue (algorithm step 3.(a)).
• If the current bounds lead to a deduction of a bound change (e.g. in domain propagation), a constraint handler should call SCIPinferVarLbCons() or SCIPinferVarUbCons(), thus providing the constraint that inferred the bound change. A propagator should call SCIPinferVarLbProp() or SCIPinferVarUbProp() instead, thus providing a pointer to itself.
• If (in the current bounds) an infeasibility is detected, the constraint handler or propagator should
1. call SCIPinitConflictAnalysis() to initialize the conflict queue,
3. call SCIPanalyzeConflictCons() or SCIPanalyzeConflict() to analyze the conflict and add an appropriate conflict constraint.

Definition in file conflict_graphanalysis.c.

#include "lpi/lpi.h"
#include "scip/conflict_graphanalysis.h"
#include "scip/conflict_dualproofanalysis.h"
#include "scip/clock.h"
#include "scip/conflict.h"
#include "scip/cons.h"
#include "scip/cons_linear.h"
#include "scip/cuts.h"
#include "scip/history.h"
#include "scip/lp.h"
#include "scip/presolve.h"
#include "scip/prob.h"
#include "scip/prop.h"
#include "scip/pub_conflict.h"
#include "scip/pub_cons.h"
#include "scip/pub_lp.h"
#include "scip/pub_message.h"
#include "scip/pub_misc.h"
#include "scip/pub_misc_sort.h"
#include "scip/pub_paramset.h"
#include "scip/pub_prop.h"
#include "scip/pub_tree.h"
#include "scip/pub_var.h"
#include "scip/scip_conflict.h"
#include "scip/scip_cons.h"
#include "scip/scip_mem.h"
#include "scip/scip_sol.h"
#include "scip/scip_var.h"
#include "scip/set.h"
#include "scip/sol.h"
#include "scip/struct_conflict.h"
#include "scip/struct_lp.h"
#include "scip/struct_prob.h"
#include "scip/struct_set.h"
#include "scip/struct_stat.h"
#include "scip/struct_tree.h"
#include "scip/struct_var.h"
#include "scip/tree.h"
#include "scip/var.h"
#include "scip/visual.h"
#include <string.h>
#include <strings.h>

Go to the source code of this file.

Functions

static SCIP_RETCODE conflictsetEnsureBdchginfosMem (SCIP_CONFLICTSET *conflictset, BMS_BLKMEM *blkmem, SCIP_SET *set, int num)

static SCIP_RETCODE conflictsetAddBound (SCIP_CONFLICTSET *conflictset, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_BDCHGINFO *bdchginfo, SCIP_Real relaxedbd)

static void conflictsetCalcConflictDepth (SCIP_CONFLICTSET *conflictset)

static SCIP_RETCODE conflictsetCalcInsertDepth (SCIP_CONFLICTSET *conflictset, SCIP_SET *set, SCIP_TREE *tree)

static SCIP_Bool conflictsetIsRedundant (SCIP_CONFLICTSET *conflictset1, SCIP_CONFLICTSET *conflictset2)

static SCIP_Bool checkRedundancy (SCIP_SET *set, SCIP_CONFLICTSET *conflictset)

static SCIP_RETCODE detectImpliedBounds (SCIP_SET *set, SCIP_PROB *prob, SCIP_STAT *stat, SCIP_TREE *tree, BMS_BLKMEM *blkmem, SCIP_PROB *origprob, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_CONFLICTSET *conflictset, int *nbdchgs, int *nredvars, SCIP_Bool *redundant)

static void conflictsetClear (SCIP_CONFLICTSET *conflictset)

SCIP_RETCODE SCIPconflictsetCreate (SCIP_CONFLICTSET **conflictset, BMS_BLKMEM *blkmem)

static SCIP_RETCODE conflictsetCopy (SCIP_CONFLICTSET **targetconflictset, BMS_BLKMEM *blkmem, SCIP_CONFLICTSET *sourceconflictset, int nadditionalelems)

void SCIPconflictsetFree (SCIP_CONFLICTSET **conflictset, BMS_BLKMEM *blkmem)

static SCIP_Real conflictsetCalcScore (SCIP_CONFLICTSET *conflictset, SCIP_SET *set)

SCIP_DECL_SORTPTRCOMP (SCIPconflicthdlrComp)

SCIP_DECL_SORTPTRCOMP (SCIPconflicthdlrCompName)

static SCIP_DECL_PARAMCHGD (paramChgdConflicthdlrPriority)

SCIP_RETCODE SCIPconflicthdlrCopyInclude (SCIP_CONFLICTHDLR *conflicthdlr, SCIP_SET *set)

static SCIP_RETCODE doConflicthdlrCreate (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)

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)

SCIP_RETCODE SCIPconflicthdlrFree (SCIP_CONFLICTHDLR **conflicthdlr, SCIP_SET *set)

SCIP_RETCODE SCIPconflicthdlrInit (SCIP_CONFLICTHDLR *conflicthdlr, SCIP_SET *set)

SCIP_RETCODE SCIPconflicthdlrExit (SCIP_CONFLICTHDLR *conflicthdlr, SCIP_SET *set)

SCIP_RETCODE SCIPconflicthdlrInitsol (SCIP_CONFLICTHDLR *conflicthdlr, SCIP_SET *set)

SCIP_RETCODE SCIPconflicthdlrExitsol (SCIP_CONFLICTHDLR *conflicthdlr, SCIP_SET *set)

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)

SCIP_CONFLICTHDLRDATASCIPconflicthdlrGetData (SCIP_CONFLICTHDLR *conflicthdlr)

void SCIPconflicthdlrSetData (SCIP_CONFLICTHDLR *conflicthdlr, SCIP_CONFLICTHDLRDATA *conflicthdlrdata)

void SCIPconflicthdlrSetCopy (SCIP_CONFLICTHDLR *conflicthdlr, SCIP_DECL_CONFLICTCOPY((*conflictcopy)))

void SCIPconflicthdlrSetFree (SCIP_CONFLICTHDLR *conflicthdlr, SCIP_DECL_CONFLICTFREE((*conflictfree)))

void SCIPconflicthdlrSetInit (SCIP_CONFLICTHDLR *conflicthdlr, SCIP_DECL_CONFLICTINIT((*conflictinit)))

void SCIPconflicthdlrSetExit (SCIP_CONFLICTHDLR *conflicthdlr, SCIP_DECL_CONFLICTEXIT((*conflictexit)))

void SCIPconflicthdlrSetInitsol (SCIP_CONFLICTHDLR *conflicthdlr, SCIP_DECL_CONFLICTINITSOL((*conflictinitsol)))

void SCIPconflicthdlrSetExitsol (SCIP_CONFLICTHDLR *conflicthdlr, SCIP_DECL_CONFLICTEXITSOL((*conflictexitsol)))

const char * SCIPconflicthdlrGetName (SCIP_CONFLICTHDLR *conflicthdlr)

const char * SCIPconflicthdlrGetDesc (SCIP_CONFLICTHDLR *conflicthdlr)

int SCIPconflicthdlrGetPriority (SCIP_CONFLICTHDLR *conflicthdlr)

void SCIPconflicthdlrSetPriority (SCIP_CONFLICTHDLR *conflicthdlr, SCIP_SET *set, int priority)

SCIP_Bool SCIPconflicthdlrIsInitialized (SCIP_CONFLICTHDLR *conflicthdlr)

void SCIPconflicthdlrEnableOrDisableClocks (SCIP_CONFLICTHDLR *conflicthdlr, SCIP_Bool enable)

SCIP_Real SCIPconflicthdlrGetSetupTime (SCIP_CONFLICTHDLR *conflicthdlr)

SCIP_Real SCIPconflicthdlrGetTime (SCIP_CONFLICTHDLR *conflicthdlr)

SCIP_Bool SCIPconflictApplicable (SCIP_SET *set)

static SCIP_RETCODE conflictEnsureTmpbdchginfosMem (SCIP_CONFLICT *conflict, SCIP_SET *set, int num)

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)

static void conflictFreeTmpBdchginfos (SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem)

static SCIP_RETCODE incVSIDS (SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_BOUNDTYPE boundtype, SCIP_Real value, SCIP_Real weight)

static SCIP_RETCODE updateStatistics (SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_CONFLICTSET *conflictset, int insertdepth)

static SCIP_RETCODE conflictAddConflictCons (SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_CONFLICTSET *conflictset, int insertdepth, SCIP_Bool *success)

int conflictCalcMaxsize (SCIP_SET *set, SCIP_PROB *prob)

SCIP_RETCODE SCIPconflictFlushConss (SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable)

static SCIP_RETCODE conflictEnsureConflictsetsMem (SCIP_CONFLICT *conflict, SCIP_SET *set, int num)

static SCIP_RETCODE conflictInsertConflictset (SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_CONFLICTSET **conflictset)

static SCIP_Bool conflictMarkBoundCheckPresence (SCIP_CONFLICT *conflict, SCIP_SET *set, SCIP_BDCHGINFO *bdchginfo, SCIP_Real relaxedbd)

static SCIP_RETCODE conflictAddConflictBound (SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_BDCHGINFO *bdchginfo, SCIP_Real relaxedbd)

static SCIP_Bool isBoundchgUseless (SCIP_SET *set, SCIP_BDCHGINFO *bdchginfo)

static SCIP_RETCODE conflictQueueBound (SCIP_CONFLICT *conflict, SCIP_SET *set, SCIP_BDCHGINFO *bdchginfo, SCIP_Real relaxedbd)

static SCIP_RETCODE conflictAddBound (SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGINFO *bdchginfo, SCIP_Real relaxedbd)

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)

static SCIP_Bool bdchginfoIsInvalid (SCIP_CONFLICT *conflict, SCIP_BDCHGINFO *bdchginfo)

static SCIP_RETCODE conflictsetAddBounds (SCIP_CONFLICT *conflict, SCIP_CONFLICTSET *conflictset, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_BDCHGINFO **bdchginfos, int nbdchginfos)

static SCIP_BDCHGINFOconflictRemoveCand (SCIP_CONFLICT *conflict)

static SCIP_BDCHGINFOconflictFirstCand (SCIP_CONFLICT *conflict)

static SCIP_RETCODE conflictAddConflictset (SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, int validdepth, SCIP_Bool diving, SCIP_Bool repropagate, SCIP_Bool *success, int *nliterals)

static SCIP_RETCODE conflictResolveBound (SCIP_CONFLICT *conflict, SCIP_SET *set, SCIP_BDCHGINFO *bdchginfo, SCIP_Real relaxedbd, int validdepth, SCIP_Bool *resolved)

static void conflictClear (SCIP_CONFLICT *conflict)

SCIP_RETCODE SCIPconflictInit (SCIP_CONFLICT *conflict, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_CONFTYPE conftype, SCIP_Bool usescutoffbound)

static SCIP_RETCODE convertToActiveVar (SCIP_VAR **var, SCIP_SET *set, SCIP_BOUNDTYPE *boundtype, SCIP_Real *bound)

static SCIP_Bool bdchginfoIsResolvable (SCIP_BDCHGINFO *bdchginfo)

static SCIP_RETCODE conflictCreateReconvergenceConss (SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_TREE *tree, SCIP_Bool diving, int validdepth, SCIP_BDCHGINFO *firstuip, int *nreconvconss, int *nreconvliterals)

SCIP_RETCODE conflictAnalyze (SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_TREE *tree, SCIP_Bool diving, int validdepth, SCIP_Bool mustresolve, int *nconss, int *nliterals, int *nreconvconss, int *nreconvliterals)

static SCIP_Real calcBdchgScore (SCIP_Real prooflhs, SCIP_Real proofact, SCIP_Real proofactdelta, SCIP_Real proofcoef, int depth, int currentdepth, SCIP_VAR *var, SCIP_SET *set)

static SCIP_RETCODE ensureCandsSize (SCIP_SET *set, SCIP_VAR ***cands, SCIP_Real **candscores, SCIP_Real **newbounds, SCIP_Real **proofactdeltas, int *candssize, int num)

static void skipRedundantBdchginfos (SCIP_VAR *var, int *lbchginfopos, int *ubchginfopos)

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 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_RETCODE SCIPconflictIsVarUsed (SCIP_CONFLICT *conflict, SCIP_VAR *var, SCIP_SET *set, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool *used)

static SCIP_RETCODE addBdchg (SCIP_SET *set, SCIP_VAR *var, SCIP_Real newlb, SCIP_Real newub, SCIP_LPBDCHGS *oldlpbdchgs, SCIP_LPBDCHGS *relaxedlpbdchgs, SCIP_LPI *lpi)

static SCIP_RETCODE addCand (SCIP_SET *set, int currentdepth, SCIP_VAR *var, int lbchginfopos, int ubchginfopos, SCIP_Real proofcoef, SCIP_Real prooflhs, SCIP_Real proofact, SCIP_VAR ***cands, SCIP_Real **candscores, SCIP_Real **newbounds, SCIP_Real **proofactdeltas, int *candssize, int *ncands, int firstcand)

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)

static SCIP_RETCODE undoBdchgsDualfarkas (SCIP_SET *set, SCIP_PROB *prob, SCIP_LP *lp, int currentdepth, SCIP_Real *curvarlbs, SCIP_Real *curvarubs, int *lbchginfoposs, int *ubchginfoposs, SCIP_LPBDCHGS *oldlpbdchgs, SCIP_LPBDCHGS *relaxedlpbdchgs, SCIP_Bool *valid, SCIP_Bool *resolve, SCIP_Real *farkascoefs, SCIP_Real farkaslhs, SCIP_Real *farkasactivity)

static SCIP_RETCODE lpbdchgsCreate (SCIP_LPBDCHGS **lpbdchgs, SCIP_SET *set, int ncols)

static SCIP_RETCODE ensureSidechgsSize (SCIP_SET *set, int **sidechginds, SCIP_Real **sidechgoldlhss, SCIP_Real **sidechgoldrhss, SCIP_Real **sidechgnewlhss, SCIP_Real **sidechgnewrhss, int *sidechgssize, int num)

static SCIP_RETCODE addSideRemoval (SCIP_SET *set, SCIP_ROW *row, SCIP_Real lpiinfinity, int **sidechginds, SCIP_Real **sidechgoldlhss, SCIP_Real **sidechgoldrhss, SCIP_Real **sidechgnewlhss, SCIP_Real **sidechgnewrhss, int *sidechgssize, int *nsidechgs)

static void lpbdchgsReset (SCIP_LPBDCHGS *lpbdchgs, int ncols)

static void lpbdchgsFree (SCIP_LPBDCHGS **lpbdchgs, SCIP_SET *set)

static SCIP_RETCODE undoBdchgsDualsol (SCIP_SET *set, SCIP_PROB *prob, SCIP_LP *lp, int currentdepth, SCIP_Real *curvarlbs, SCIP_Real *curvarubs, int *lbchginfoposs, int *ubchginfoposs, SCIP_LPBDCHGS *oldlpbdchgs, SCIP_LPBDCHGS *relaxedlpbdchgs, SCIP_Bool *valid, SCIP_Bool *resolve, SCIP_Real *dualcoefs, SCIP_Real duallhs, SCIP_Real *dualactivity)

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 SCIPconflictAnalyze (SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_TREE *tree, int validdepth, SCIP_Bool *success)

◆ conflictsetEnsureBdchginfosMem()

 static SCIP_RETCODE conflictsetEnsureBdchginfosMem ( SCIP_CONFLICTSET * conflictset, BMS_BLKMEM * blkmem, SCIP_SET * set, int num )
static

Conflict sets resizes the arrays of the conflict set to be able to store at least num bound change entries

Parameters
 conflictset conflict set blkmem block memory of transformed problem set global SCIP settings num minimal number of slots in arrays

Definition at line 378 of file conflict_graphanalysis.c.

 static SCIP_RETCODE conflictsetAddBound ( SCIP_CONFLICTSET * conflictset, BMS_BLKMEM * blkmem, SCIP_SET * set, SCIP_BDCHGINFO * bdchginfo, SCIP_Real relaxedbd )
static

adds a bound change to a conflict set

Parameters
 conflictset conflict set blkmem block memory of transformed problem set global SCIP settings bdchginfo bound change to add to the conflict set relaxedbd relaxed bound

Definition at line 405 of file conflict_graphanalysis.c.

◆ conflictsetCalcConflictDepth()

 static void conflictsetCalcConflictDepth ( SCIP_CONFLICTSET * conflictset )
static

calculates the conflict and the repropagation depths of the conflict set

Parameters
 conflictset conflict set

Definition at line 478 of file conflict_graphanalysis.c.

Referenced by conflictInsertConflictset().

◆ conflictsetCalcInsertDepth()

 static SCIP_RETCODE conflictsetCalcInsertDepth ( SCIP_CONFLICTSET * conflictset, SCIP_SET * set, SCIP_TREE * tree )
static

identifies the depth, at which the conflict set should be added:

• if the branching rule operates on variables only, and if all branching variables up to a certain depth level are member of the conflict, the conflict constraint can only be violated in the subtree of the node at that depth, because in all other nodes, at least one of these branching variables violates its conflicting bound, such that the conflict constraint is feasible
• if there is at least one branching variable in a node, we assume, that this branching was performed on variables, and that the siblings of this node are disjunct w.r.t. the branching variables' fixings
• we have to add the conflict set at least in the valid depth of the initial conflict set, so we start searching at the first branching after this depth level, i.e. validdepth+1
Parameters
 conflictset conflict set set global SCIP settings tree branch and bound tree

Definition at line 522 of file conflict_graphanalysis.c.

◆ conflictsetIsRedundant()

 static SCIP_Bool conflictsetIsRedundant ( SCIP_CONFLICTSET * conflictset1, SCIP_CONFLICTSET * conflictset2 )
static

checks whether the first conflict set is redundant to the second one

Parameters
 conflictset1 first conflict conflict set conflictset2 second conflict conflict set

Definition at line 569 of file conflict_graphanalysis.c.

Referenced by conflictInsertConflictset().

◆ checkRedundancy()

 static SCIP_Bool checkRedundancy ( SCIP_SET * set, SCIP_CONFLICTSET * conflictset )
static

check conflict set for redundancy, other conflicts in the same conflict analysis could have led to global reductions an made this conflict set redundant

Parameters
 set global SCIP settings conflictset conflict set

Definition at line 633 of file conflict_graphanalysis.c.

Referenced by detectImpliedBounds().

◆ detectImpliedBounds()

 static SCIP_RETCODE detectImpliedBounds ( SCIP_SET * set, SCIP_PROB * prob, SCIP_STAT * stat, SCIP_TREE * tree, BMS_BLKMEM * blkmem, SCIP_PROB * origprob, SCIP_REOPT * reopt, SCIP_LP * lp, SCIP_CONFLICTSET * conflictset, int * nbdchgs, int * nredvars, SCIP_Bool * redundant )
static

find global fixings which can be derived from the new conflict set

Parameters
 set global SCIP settings prob transformed problem after presolve stat dynamic SCIP statistics tree tree data blkmem block memory origprob original problem reopt reoptimization data lp LP data conflictset conflict set to add to the tree nbdchgs number of global deducted bound changes due to the conflict set nredvars number of redundant and removed variables from conflict set redundant did we found a global reduction on a conflict set variable, which makes this conflict redundant

Definition at line 698 of file conflict_graphanalysis.c.

◆ conflictsetClear()

 static void conflictsetClear ( SCIP_CONFLICTSET * conflictset )
static

clears the given conflict set

Parameters
 conflictset conflict set

Definition at line 971 of file conflict_graphanalysis.c.

Referenced by conflictClear(), and SCIPconflictsetCreate().

◆ SCIPconflictsetCreate()

 SCIP_RETCODE SCIPconflictsetCreate ( SCIP_CONFLICTSET ** conflictset, BMS_BLKMEM * blkmem )

creates an empty conflict set

Parameters
 conflictset pointer to store the conflict set blkmem block memory of transformed problem

Definition at line 989 of file conflict_graphanalysis.c.

References BMSallocBlockMemory, conflictsetClear(), NULL, SCIP_ALLOC, and SCIP_OKAY.

Referenced by SCIPconflictCreate().

◆ conflictsetCopy()

 static SCIP_RETCODE conflictsetCopy ( SCIP_CONFLICTSET ** targetconflictset, BMS_BLKMEM * blkmem, SCIP_CONFLICTSET * sourceconflictset, int nadditionalelems )
static

creates a copy of the given conflict set, allocating an additional amount of memory

Parameters
 targetconflictset pointer to store the conflict set blkmem block memory of transformed problem sourceconflictset source conflict set nadditionalelems number of additional elements to allocate memory for

Definition at line 1009 of file conflict_graphanalysis.c.

◆ SCIPconflictsetFree()

 void SCIPconflictsetFree ( SCIP_CONFLICTSET ** conflictset, BMS_BLKMEM * blkmem )

frees a conflict set

Parameters
 conflictset pointer to the conflict set blkmem block memory of transformed problem

Definition at line 1045 of file conflict_graphanalysis.c.

References BMSfreeBlockMemory, BMSfreeBlockMemoryArrayNull, and NULL.

◆ conflictsetCalcScore()

 static SCIP_Real conflictsetCalcScore ( SCIP_CONFLICTSET * conflictset, SCIP_SET * set )
static

calculates the score of the conflict set

the score is weighted sum of number of bound changes, repropagation depth, and valid depth

Parameters
 conflictset conflict set set global SCIP settings

Definition at line 1064 of file conflict_graphanalysis.c.

Referenced by conflictInsertConflictset().

◆ SCIP_DECL_PARAMCHGD()

 static SCIP_DECL_PARAMCHGD ( paramChgdConflicthdlrPriority )
static

method to call, when the priority of a conflict handler was changed

Definition at line 1095 of file conflict_graphanalysis.c.

◆ SCIPconflicthdlrCopyInclude()

 SCIP_RETCODE SCIPconflicthdlrCopyInclude ( SCIP_CONFLICTHDLR * conflicthdlr, SCIP_SET * set )

copies the given conflict handler to a new scip

Parameters
 conflicthdlr conflict handler set SCIP_SET of SCIP to copy to

Definition at line 1109 of file conflict_graphanalysis.c.

References NULL, SCIP_CALL, SCIP_OKAY, SCIPconflicthdlrGetName(), and SCIPsetDebugMsg.

Referenced by SCIPsetCopyPlugins().

◆ doConflicthdlrCreate()

 static SCIP_RETCODE doConflicthdlrCreate ( 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 )
static

internal method for creating a conflict handler

Parameters
 conflicthdlr pointer to conflict handler data structure set global SCIP settings messagehdlr message handler blkmem block memory for parameter settings name name of conflict handler desc description of conflict handler priority priority of the conflict handler conflicthdlrdata conflict handler data

Definition at line 1129 of file conflict_graphanalysis.c.

Referenced by SCIPconflicthdlrCreate().

◆ SCIPconflicthdlrCreate()

 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 )

creates a conflict handler

Parameters
 conflicthdlr pointer to conflict handler data structure set global SCIP settings messagehdlr message handler blkmem block memory for parameter settings name name of conflict handler desc description of conflict handler priority priority of the conflict handler conflicthdlrdata conflict handler data

Definition at line 1183 of file conflict_graphanalysis.c.

References doConflicthdlrCreate(), NULL, SCIP_CALL_FINALLY, SCIP_OKAY, and SCIPconflicthdlrFree().

Referenced by SCIPincludeConflicthdlr(), and SCIPincludeConflicthdlrBasic().

◆ SCIPconflicthdlrFree()

 SCIP_RETCODE SCIPconflicthdlrFree ( SCIP_CONFLICTHDLR ** conflicthdlr, SCIP_SET * set )

calls destructor and frees memory of conflict handler

Parameters
 conflicthdlr pointer to conflict handler data structure set global SCIP settings

Definition at line 1214 of file conflict_graphanalysis.c.

References BMSfreeMemory, BMSfreeMemoryArrayNull, NULL, SCIP_CALL, SCIP_OKAY, and SCIPclockFree().

Referenced by SCIPconflicthdlrCreate().

◆ SCIPconflicthdlrInit()

 SCIP_RETCODE SCIPconflicthdlrInit ( SCIP_CONFLICTHDLR * conflicthdlr, SCIP_SET * set )

calls initialization method of conflict handler

Parameters
 conflicthdlr conflict handler set global SCIP settings

Definition at line 1242 of file conflict_graphanalysis.c.

◆ SCIPconflicthdlrExit()

 SCIP_RETCODE SCIPconflicthdlrExit ( SCIP_CONFLICTHDLR * conflicthdlr, SCIP_SET * set )

calls exit method of conflict handler

Parameters
 conflicthdlr conflict handler set global SCIP settings

Definition at line 1279 of file conflict_graphanalysis.c.

Referenced by SCIPsetInitPlugins().

◆ SCIPconflicthdlrInitsol()

 SCIP_RETCODE SCIPconflicthdlrInitsol ( SCIP_CONFLICTHDLR * conflicthdlr, SCIP_SET * set )

informs conflict handler that the branch and bound process is being started

Parameters
 conflicthdlr conflict handler set global SCIP settings

Definition at line 1310 of file conflict_graphanalysis.c.

Referenced by SCIPsetExitprePlugins().

◆ SCIPconflicthdlrExitsol()

 SCIP_RETCODE SCIPconflicthdlrExitsol ( SCIP_CONFLICTHDLR * conflicthdlr, SCIP_SET * set )

informs conflict handler that the branch and bound process data is being freed

Parameters
 conflicthdlr conflict handler set global SCIP settings

Definition at line 1334 of file conflict_graphanalysis.c.

Referenced by SCIPsetInitsolPlugins().

◆ SCIPconflicthdlrExec()

 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 )

calls execution method of conflict handler

Parameters
 conflicthdlr conflict handler set global SCIP settings node node to add conflict constraint to validnode node at which the constraint is valid bdchginfos bound change resembling the conflict set relaxedbds array with relaxed bounds which are efficient to create a valid conflict nbdchginfos number of bound changes in the conflict set conftype type of the conflict usescutoffbound depends the conflict on the cutoff bound? resolved was the conflict set already used to create a constraint? result pointer to store the result of the callback method

Definition at line 1358 of file conflict_graphanalysis.c.

◆ SCIPconflicthdlrSetCopy()

 void SCIPconflicthdlrSetCopy ( SCIP_CONFLICTHDLR * conflicthdlr, SCIP_DECL_CONFLICTCOPY((*conflictcopy)) )

set copy method of conflict handler

Parameters
 conflicthdlr conflict handler

Definition at line 1426 of file conflict_graphanalysis.c.

References NULL.

Referenced by SCIPsetConflicthdlrCopy().

◆ SCIPconflicthdlrSetFree()

 void SCIPconflicthdlrSetFree ( SCIP_CONFLICTHDLR * conflicthdlr, SCIP_DECL_CONFLICTFREE((*conflictfree)) )

set destructor of conflict handler

Parameters
 conflicthdlr conflict handler

Definition at line 1437 of file conflict_graphanalysis.c.

References NULL.

Referenced by SCIPsetConflicthdlrFree().

◆ SCIPconflicthdlrSetInit()

 void SCIPconflicthdlrSetInit ( SCIP_CONFLICTHDLR * conflicthdlr, SCIP_DECL_CONFLICTINIT((*conflictinit)) )

set initialization method of conflict handler

Parameters
 conflicthdlr conflict handler

Definition at line 1449 of file conflict_graphanalysis.c.

References NULL.

Referenced by SCIPsetConflicthdlrInit().

◆ SCIPconflicthdlrSetExit()

 void SCIPconflicthdlrSetExit ( SCIP_CONFLICTHDLR * conflicthdlr, SCIP_DECL_CONFLICTEXIT((*conflictexit)) )

set deinitialization method of conflict handler

Parameters
 conflicthdlr conflict handler

Definition at line 1460 of file conflict_graphanalysis.c.

References NULL.

Referenced by SCIPsetConflicthdlrExit().

◆ SCIPconflicthdlrSetInitsol()

 void SCIPconflicthdlrSetInitsol ( SCIP_CONFLICTHDLR * conflicthdlr, SCIP_DECL_CONFLICTINITSOL((*conflictinitsol)) )

set solving process initialization method of conflict handler

Parameters
 conflicthdlr conflict handler

Definition at line 1471 of file conflict_graphanalysis.c.

References NULL.

Referenced by SCIPsetConflicthdlrInitsol().

◆ SCIPconflicthdlrSetExitsol()

 void SCIPconflicthdlrSetExitsol ( SCIP_CONFLICTHDLR * conflicthdlr, SCIP_DECL_CONFLICTEXITSOL((*conflictexitsol)) )

set solving process deinitialization method of conflict handler

Parameters
 conflicthdlr conflict handler

Definition at line 1482 of file conflict_graphanalysis.c.

References NULL.

Referenced by SCIPsetConflicthdlrExitsol().

◆ SCIPconflicthdlrSetPriority()

 void SCIPconflicthdlrSetPriority ( SCIP_CONFLICTHDLR * conflicthdlr, SCIP_SET * set, int priority )

sets priority of conflict handler

Parameters
 conflicthdlr conflict handler set global SCIP settings priority new priority of the conflict handler

Definition at line 1523 of file conflict_graphanalysis.c.

References FALSE, NULL, and SCIP_Conflicthdlr::priority.

Referenced by SCIPsetConflicthdlrPriority().

◆ SCIPconflicthdlrEnableOrDisableClocks()

 void SCIPconflicthdlrEnableOrDisableClocks ( SCIP_CONFLICTHDLR * conflicthdlr, SCIP_Bool enable )

enables or disables all clocks of conflicthdlr, depending on the value of the flag

Parameters
 conflicthdlr the conflict handler for which all clocks should be enabled or disabled enable should the clocks of the conflict handler be enabled?

Definition at line 1547 of file conflict_graphanalysis.c.

Referenced by SCIP_DECL_PARAMCHGD().

◆ SCIPconflictApplicable()

 SCIP_Bool SCIPconflictApplicable ( SCIP_SET * set )

return TRUE if conflict analysis is applicable; In case the function return FALSE there is no need to initialize the conflict analysis since it will not be applied

Parameters
 set global SCIP settings

Definition at line 1581 of file conflict_graphanalysis.c.

References FALSE, and TRUE.

Referenced by SCIPconflictAnalyze(), and SCIPisConflictAnalysisApplicable().

◆ conflictEnsureTmpbdchginfosMem()

 static SCIP_RETCODE conflictEnsureTmpbdchginfosMem ( SCIP_CONFLICT * conflict, SCIP_SET * set, int num )
static

resizes the array of the temporary bound change informations to be able to store at least num bound change entries

Parameters
 conflict conflict analysis data set global SCIP settings num minimal number of slots in arrays

Definition at line 1598 of file conflict_graphanalysis.c.

Referenced by conflictCreateTmpBdchginfo().

◆ conflictCreateTmpBdchginfo()

 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 )

creates a temporary bound change information object that is destroyed after the conflict sets are flushed

Parameters
 conflict conflict analysis data blkmem block memory set global SCIP settings var active variable that changed the bounds boundtype type of bound for var: lower or upper bound oldbound old value for bound newbound new value for bound bdchginfo pointer to store bound change information

Definition at line 1621 of file conflict_graphanalysis.c.

Referenced by conflictCreateReconvergenceConss(), and SCIPconflictAnalyzeRemainingBdchgs().

◆ conflictFreeTmpBdchginfos()

 static void conflictFreeTmpBdchginfos ( SCIP_CONFLICT * conflict, BMS_BLKMEM * blkmem )
static

frees all temporarily created bound change information data

Parameters
 conflict conflict analysis data blkmem block memory

Definition at line 1645 of file conflict_graphanalysis.c.

Referenced by SCIPconflictFlushConss().

◆ incVSIDS()

 static SCIP_RETCODE incVSIDS ( SCIP_VAR * var, BMS_BLKMEM * blkmem, SCIP_SET * set, SCIP_STAT * stat, SCIP_BOUNDTYPE boundtype, SCIP_Real value, SCIP_Real weight )
static

increases the conflict score of the variable in the given direction

Parameters
 var problem variable blkmem block memory set global SCIP settings stat dynamic problem statistics boundtype type of bound for which the score should be increased value value of the bound weight weight of this VSIDS updates

Definition at line 1661 of file conflict_graphanalysis.c.

 static SCIP_RETCODE updateStatistics ( SCIP_CONFLICT * conflict, BMS_BLKMEM * blkmem, SCIP_SET * set, SCIP_STAT * stat, SCIP_CONFLICTSET * conflictset, int insertdepth )
static

update conflict statistics

Parameters
 conflict conflict analysis data blkmem block memory set global SCIP settings stat dynamic problem statistics conflictset conflict set to add to the tree insertdepth depth level at which the conflict set should be added

Definition at line 1692 of file conflict_graphanalysis.c.

 static SCIP_RETCODE conflictAddConflictCons ( SCIP_CONFLICT * conflict, BMS_BLKMEM * blkmem, SCIP_SET * set, SCIP_STAT * stat, SCIP_PROB * transprob, SCIP_PROB * origprob, SCIP_TREE * tree, SCIP_REOPT * reopt, SCIP_LP * lp, SCIP_BRANCHCAND * branchcand, SCIP_EVENTQUEUE * eventqueue, SCIP_CLIQUETABLE * cliquetable, SCIP_CONFLICTSET * conflictset, int insertdepth, SCIP_Bool * success )
static

adds the given conflict set as conflict constraint to the problem

Parameters
 conflict conflict analysis data blkmem block memory set global SCIP settings stat dynamic problem statistics transprob transformed problem after presolve origprob original problem tree branch and bound tree reopt reoptimization data structure lp current LP data branchcand branching candidate storage eventqueue event queue cliquetable clique table data structure conflictset conflict set to add to the tree insertdepth depth level at which the conflict set should be added success pointer to store whether the addition was successful

Definition at line 1743 of file conflict_graphanalysis.c.

Referenced by SCIPconflictFlushConss().

◆ conflictCalcMaxsize()

 int conflictCalcMaxsize ( SCIP_SET * set, SCIP_PROB * prob )

calculates the maximal size of conflict sets to be used

Parameters
 set global SCIP settings prob problem data

Definition at line 1896 of file conflict_graphanalysis.c.

References MAX, SCIP_Prob::ncontvars, NULL, and SCIP_Prob::nvars.

◆ SCIPconflictFlushConss()

 SCIP_RETCODE SCIPconflictFlushConss ( SCIP_CONFLICT * conflict, BMS_BLKMEM * blkmem, SCIP_SET * set, SCIP_STAT * stat, SCIP_PROB * transprob, SCIP_PROB * origprob, SCIP_TREE * tree, SCIP_REOPT * reopt, SCIP_LP * lp, SCIP_BRANCHCAND * branchcand, SCIP_EVENTQUEUE * eventqueue, SCIP_CLIQUETABLE * cliquetable )

adds the collected conflict constraints to the corresponding nodes; the best set->conf_maxconss conflict constraints are added to the node of their validdepth; additionally (if not yet added, and if repropagation is activated), the conflict constraint that triggers the earliest repropagation is added to the node of its validdepth

Parameters
 conflict conflict analysis data blkmem block memory of transformed problem set global SCIP settings stat dynamic problem statistics transprob transformed problem origprob original problem tree branch and bound tree reopt reoptimization data structure lp current LP data branchcand branching candidate storage eventqueue event queue cliquetable clique table data structure

Definition at line 1916 of file conflict_graphanalysis.c.

Referenced by conflictAnalyzeLP(), SCIPconflictAnalyzePseudo(), SCIPpropagateDomains(), and solveNode().

◆ conflictEnsureConflictsetsMem()

 static SCIP_RETCODE conflictEnsureConflictsetsMem ( SCIP_CONFLICT * conflict, SCIP_SET * set, int num )
static

resizes conflictsets array to be able to store at least num entries

Parameters
 conflict conflict analysis data set global SCIP settings num minimal number of slots in array

Definition at line 2126 of file conflict_graphanalysis.c.

Referenced by conflictInsertConflictset().

◆ conflictInsertConflictset()

 static SCIP_RETCODE conflictInsertConflictset ( SCIP_CONFLICT * conflict, BMS_BLKMEM * blkmem, SCIP_SET * set, SCIP_CONFLICTSET ** conflictset )
static

inserts conflict set into sorted conflictsets array and deletes the conflict set pointer

Parameters
 conflict conflict analysis data blkmem block memory of transformed problem set global SCIP settings conflictset pointer to conflict set to insert

Definition at line 2151 of file conflict_graphanalysis.c.

◆ conflictMarkBoundCheckPresence()

 static SCIP_Bool conflictMarkBoundCheckPresence ( SCIP_CONFLICT * conflict, SCIP_SET * set, SCIP_BDCHGINFO * bdchginfo, SCIP_Real relaxedbd )
static

marks bound to be present in the current conflict and returns whether a bound which is at least as tight was already member of the current conflict (i.e., the given bound change does not need to be added)

Parameters
 conflict conflict analysis data set global SCIP settings bdchginfo bound change to add to the conflict set relaxedbd relaxed bound

Definition at line 2247 of file conflict_graphanalysis.c.

 static SCIP_RETCODE conflictAddConflictBound ( SCIP_CONFLICT * conflict, BMS_BLKMEM * blkmem, SCIP_SET * set, SCIP_BDCHGINFO * bdchginfo, SCIP_Real relaxedbd )
static

puts bound change into the current conflict set

Parameters
 conflict conflict analysis data blkmem block memory of transformed problem set global SCIP settings bdchginfo bound change to add to the conflict set relaxedbd relaxed bound

Definition at line 2336 of file conflict_graphanalysis.c.

◆ isBoundchgUseless()

 static SCIP_Bool isBoundchgUseless ( SCIP_SET * set, SCIP_BDCHGINFO * bdchginfo )
static

returns whether the negation of the given bound change would lead to a globally valid literal

Parameters
 set global SCIP settings bdchginfo bound change information

Definition at line 2379 of file conflict_graphanalysis.c.

Referenced by conflictQueueBound().

◆ conflictQueueBound()

 static SCIP_RETCODE conflictQueueBound ( SCIP_CONFLICT * conflict, SCIP_SET * set, SCIP_BDCHGINFO * bdchginfo, SCIP_Real relaxedbd )
static

adds given bound change information to the conflict candidate queue

Parameters
 conflict conflict analysis data set global SCIP settings bdchginfo bound change information relaxedbd relaxed bound

Definition at line 2399 of file conflict_graphanalysis.c.

 static SCIP_RETCODE conflictAddBound ( SCIP_CONFLICT * conflict, BMS_BLKMEM * blkmem, SCIP_SET * set, SCIP_STAT * stat, SCIP_VAR * var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGINFO * bdchginfo, SCIP_Real relaxedbd )
static

adds variable's bound to conflict candidate queue

Parameters
 conflict conflict analysis data blkmem block memory set global SCIP settings stat dynamic problem statistics var problem variable boundtype type of bound that was changed: lower or upper bound bdchginfo bound change info, or NULL relaxedbd relaxed bound

Definition at line 2445 of file conflict_graphanalysis.c.

◆ SCIPconflictAnalyzeRemainingBdchgs()

 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 )

applies conflict analysis starting with given bound changes, that could not be undone during previous infeasibility analysis

Parameters
 conflict conflict analysis data blkmem block memory of transformed problem set global SCIP settings stat problem statistics prob problem data tree branch and bound tree diving are we in strong branching or diving mode? lbchginfoposs positions of currently active lower bound change information in variables' arrays ubchginfoposs positions of currently active upper bound change information in variables' arrays nconss pointer to store the number of generated conflict constraints nliterals pointer to store the number of literals in generated conflict constraints nreconvconss pointer to store the number of generated reconvergence constraints nreconvliterals pointer to store the number of literals generated reconvergence constraints

Definition at line 2503 of file conflict_graphanalysis.c.

Referenced by conflictAnalyzeLP(), and SCIPconflictAnalyzePseudo().

◆ bdchginfoIsInvalid()

 static SCIP_Bool bdchginfoIsInvalid ( SCIP_CONFLICT * conflict, SCIP_BDCHGINFO * bdchginfo )
static

check if the bound change info (which is the potential next candidate which is queued) is valid for the current conflict analysis; a bound change info can get invalid if after this one was added to the queue, a weaker bound change was added to the queue (due the bound widening idea) which immediately makes this bound change redundant; due to the priority we did not removed that bound change info since that cost O(log(n)); hence we have to skip/ignore it now

The following situations can occur before for example the bound change info (x >= 3) is potentially popped from the queue.

Postcondition: the reason why (x >= 3) was queued is that at this time point no lower bound of x was involved yet in the current conflict or the lower bound which was involved until then was stronger, e.g., (x >= 2).

1) during the time until (x >= 3) gets potentially popped no weaker lower bound was added to the queue, in that case the conflictlbcount is valid and conflictlb is 3; that is (var->conflictlbcount == conflict->count && var->conflictlb == 3)

2) a weaker bound change info gets queued (e.g., x >= 4); this bound change is popped before (x >= 3) since it has higher priority (which is the time stamp of the bound change info and (x >= 4) has to be done after (x >= 3) during propagation or branching)

a) if (x >= 4) is popped and added to the conflict set the conflictlbcount is still valid and conflictlb is at most 4; that is (var->conflictlbcount == conflict->count && var->conflictlb >= 4); it follows that any bound change info which is stronger than (x >= 4) gets ignored (for example x >= 2)

b) if (x >= 4) is popped and resolved without introducing a new lower bound on x until (x >= 3) is a potentially candidate the conflictlbcount indicates that bound change is currently not present; that is (var->conflictlbcount != conflict->count)

c) if (x >= 4) is popped and resolved and a new lower bound on x (e.g., x >= 2) is introduced until (x >= 3) is pooped, the conflictlbcount indicates that bound change is currently present; that is (var->conflictlbcount == conflict->count); however the (x >= 3) only has be explained if conflictlb matches that one; that is (var->conflictlb == bdchginfo->newbound); otherwise it redundant/invalid.

Parameters
 conflict conflict analysis data bdchginfo bound change information

Definition at line 2674 of file conflict_graphanalysis.c.

Referenced by conflictFirstCand(), conflictRemoveCand(), conflictResolveBound(), and conflictsetAddBounds().

 static SCIP_RETCODE conflictsetAddBounds ( SCIP_CONFLICT * conflict, SCIP_CONFLICTSET * conflictset, BMS_BLKMEM * blkmem, SCIP_SET * set, SCIP_BDCHGINFO ** bdchginfos, int nbdchginfos )
static

adds given bound changes to a conflict set

Parameters
 conflict conflict analysis data conflictset conflict set blkmem block memory of transformed problem set global SCIP settings bdchginfos bound changes to add to the conflict set nbdchginfos number of bound changes to add

Definition at line 2717 of file conflict_graphanalysis.c.

◆ conflictRemoveCand()

 static SCIP_BDCHGINFO* conflictRemoveCand ( SCIP_CONFLICT * conflict )
static

removes and returns next conflict analysis candidate from the candidate queue

Parameters
 conflict conflict analysis data

Definition at line 2886 of file conflict_graphanalysis.c.

Referenced by conflictAnalyze(), and conflictCreateReconvergenceConss().

◆ conflictFirstCand()

 static SCIP_BDCHGINFO* conflictFirstCand ( SCIP_CONFLICT * conflict )
static

returns next conflict analysis candidate from the candidate queue without removing it

Parameters
 conflict conflict analysis data

Definition at line 2930 of file conflict_graphanalysis.c.

Referenced by conflictAnalyze(), and conflictCreateReconvergenceConss().

 static SCIP_RETCODE conflictAddConflictset ( SCIP_CONFLICT * conflict, BMS_BLKMEM * blkmem, SCIP_SET * set, SCIP_STAT * stat, SCIP_TREE * tree, int validdepth, SCIP_Bool diving, SCIP_Bool repropagate, SCIP_Bool * success, int * nliterals )
static

adds the current conflict set (extended by all remaining bound changes in the queue) to the pool of conflict sets

Parameters
 conflict conflict analysis data blkmem block memory of transformed problem set global SCIP settings stat dynamic problem statistics tree branch and bound tree validdepth minimal depth level at which the conflict set is valid diving are we in strong branching or diving mode? repropagate should the constraint trigger a repropagation? success pointer to store whether the conflict set is valid nliterals pointer to store the number of literals in the generated conflictset

Definition at line 2984 of file conflict_graphanalysis.c.

Referenced by conflictAnalyze(), and conflictCreateReconvergenceConss().

◆ conflictResolveBound()

 static SCIP_RETCODE conflictResolveBound ( SCIP_CONFLICT * conflict, SCIP_SET * set, SCIP_BDCHGINFO * bdchginfo, SCIP_Real relaxedbd, int validdepth, SCIP_Bool * resolved )
static

tries to resolve given bound change

• resolutions on local constraints are only applied, if the constraint is valid at the current minimal valid depth level, because this depth level is the topmost level to add the conflict constraint to anyways
Note
it is sufficient to explain the relaxed bound change
Parameters
 conflict conflict analysis data set global SCIP settings bdchginfo bound change to resolve relaxedbd the relaxed bound validdepth minimal depth level at which the conflict is valid resolved pointer to store whether the bound change was resolved

Definition at line 3083 of file conflict_graphanalysis.c.

Referenced by conflictAnalyze(), and conflictCreateReconvergenceConss().

◆ conflictClear()

 static void conflictClear ( SCIP_CONFLICT * conflict )
static

clears the conflict queue and the current conflict set

Parameters
 conflict conflict analysis data

Definition at line 3293 of file conflict_graphanalysis.c.

Referenced by conflictAnalyze(), conflictCreateReconvergenceConss(), and SCIPconflictInit().

◆ SCIPconflictInit()

 SCIP_RETCODE SCIPconflictInit ( SCIP_CONFLICT * conflict, SCIP_SET * set, SCIP_STAT * stat, SCIP_PROB * prob, SCIP_CONFTYPE conftype, SCIP_Bool usescutoffbound )

initializes the propagation conflict analysis by clearing the conflict candidate queue

Parameters
 conflict conflict analysis data set global SCIP settings stat problem statistics prob problem data conftype type of the conflict usescutoffbound depends the conflict on a cutoff bound?

Definition at line 3305 of file conflict_graphanalysis.c.

◆ convertToActiveVar()

 static SCIP_RETCODE convertToActiveVar ( SCIP_VAR ** var, SCIP_SET * set, SCIP_BOUNDTYPE * boundtype, SCIP_Real * bound )
static

convert variable and bound change to active variable

Parameters
 var pointer to variable set global SCIP settings boundtype pointer to type of bound that was changed: lower or upper bound bound pointer to bound to convert, or NULL

Definition at line 3372 of file conflict_graphanalysis.c.

◆ bdchginfoIsResolvable()

 static SCIP_Bool bdchginfoIsResolvable ( SCIP_BDCHGINFO * bdchginfo )
static

returns whether bound change has a valid reason that can be resolved in conflict analysis

Parameters
 bdchginfo bound change information

Definition at line 3407 of file conflict_graphanalysis.c.

◆ conflictCreateReconvergenceConss()

 static SCIP_RETCODE conflictCreateReconvergenceConss ( SCIP_CONFLICT * conflict, BMS_BLKMEM * blkmem, SCIP_SET * set, SCIP_STAT * stat, SCIP_PROB * prob, SCIP_TREE * tree, SCIP_Bool diving, int validdepth, SCIP_BDCHGINFO * firstuip, int * nreconvconss, int * nreconvliterals )
static

if only one conflicting bound change of the last depth level was used, and if this can be resolved, creates GRASP-like reconvergence conflict constraints in the conflict graph up to the branching variable of this depth level

Parameters
 conflict conflict analysis data blkmem block memory of transformed problem set global SCIP settings stat problem statistics prob problem data tree branch and bound tree diving are we in strong branching or diving mode? validdepth minimal depth level at which the initial conflict set is valid firstuip first UIP of conflict graph nreconvconss pointer to store the number of generated reconvergence constraints nreconvliterals pointer to store the number of literals generated reconvergence constraints

Definition at line 3425 of file conflict_graphanalysis.c.

Referenced by conflictAnalyze().

◆ conflictAnalyze()

 SCIP_RETCODE conflictAnalyze ( SCIP_CONFLICT * conflict, BMS_BLKMEM * blkmem, SCIP_SET * set, SCIP_STAT * stat, SCIP_PROB * prob, SCIP_TREE * tree, SCIP_Bool diving, int validdepth, SCIP_Bool mustresolve, int * nconss, int * nliterals, int * nreconvconss, int * nreconvliterals )

analyzes conflicting bound changes that were added with calls to SCIPconflictAddBound() and SCIPconflictAddRelaxedBound(), and on success, calls the conflict handlers to create a conflict constraint out of the resulting conflict set; afterwards the conflict queue and the conflict set is cleared

Parameters
 conflict conflict analysis data blkmem block memory of transformed problem set global SCIP settings stat problem statistics prob problem data tree branch and bound tree diving are we in strong branching or diving mode? validdepth minimal depth level at which the initial conflict set is valid mustresolve should the conflict set only be used, if a resolution was applied? nconss pointer to store the number of generated conflict constraints nliterals pointer to store the number of literals in generated conflict constraints nreconvconss pointer to store the number of generated reconvergence constraints nreconvliterals pointer to store the number of literals generated reconvergence constraints

Definition at line 3661 of file conflict_graphanalysis.c.

Referenced by SCIPconflictAnalyze(), and SCIPconflictAnalyzeRemainingBdchgs().

◆ calcBdchgScore()

 static SCIP_Real calcBdchgScore ( SCIP_Real prooflhs, SCIP_Real proofact, SCIP_Real proofactdelta, SCIP_Real proofcoef, int depth, int currentdepth, SCIP_VAR * var, SCIP_SET * set )
static

calculates the score of a bound change within a conflict

Parameters
 prooflhs lhs of proof constraint proofact activity of the proof constraint proofactdelta activity change proofcoef coefficient in proof constraint depth bound change depth currentdepth current depth var variable corresponding to bound change set global SCIP settings

Definition at line 3946 of file conflict_graphanalysis.c.

◆ ensureCandsSize()

 static SCIP_RETCODE ensureCandsSize ( SCIP_SET * set, SCIP_VAR *** cands, SCIP_Real ** candscores, SCIP_Real ** newbounds, SCIP_Real ** proofactdeltas, int * candssize, int num )
static

ensures, that candidate array can store at least num entries

Parameters
 set global SCIP settings cands pointer to candidate array candscores pointer to candidate score array newbounds pointer to candidate new bounds array proofactdeltas pointer to candidate proof delta array candssize pointer to size of array num minimal number of candidates to store in array

Definition at line 3991 of file conflict_graphanalysis.c.

References NULL, SCIP_CALL, SCIP_OKAY, SCIPsetCalcMemGrowSize(), and SCIPsetReallocBufferArray.

◆ skipRedundantBdchginfos()

 static void skipRedundantBdchginfos ( SCIP_VAR * var, int * lbchginfopos, int * ubchginfopos )
static

after changing the global bound of a variable, the bdchginfos that are now redundant are replaced with oldbound = newbound = global bound; if the current bdchginfo is of such kind, the bound is equal to the global bound and we can ignore it by installing a -1 as the corresponding bound change info position

Parameters
 var problem variable lbchginfopos pointer to lower bound change information position ubchginfopos pointer to upper bound change information position

Definition at line 4025 of file conflict_graphanalysis.c.

Referenced by SCIPundoBdchgsProof().

 SCIP_RETCODE SCIPconflictAddBound ( SCIP_CONFLICT * conflict, BMS_BLKMEM * blkmem, SCIP_SET * set, SCIP_STAT * stat, SCIP_VAR * var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX * bdchgidx )

adds variable's bound to conflict candidate queue

Parameters
 conflict conflict analysis data blkmem block memory set global SCIP settings stat dynamic problem statistics var problem variable boundtype type of bound that was changed: lower or upper bound bdchgidx bound change index (time stamp of bound change), or NULL for current time

Definition at line 4056 of file conflict_graphanalysis.c.

 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 )

adds variable's bound to conflict candidate queue

Parameters
 conflict conflict analysis data blkmem block memory set global SCIP settings stat dynamic problem statistics var problem variable boundtype type of bound that was changed: lower or upper bound bdchgidx bound change index (time stamp of bound change), or NULL for current time relaxedbd the relaxed bound

Definition at line 4117 of file conflict_graphanalysis.c.

◆ SCIPconflictIsVarUsed()

 SCIP_RETCODE SCIPconflictIsVarUsed ( SCIP_CONFLICT * conflict, SCIP_VAR * var, SCIP_SET * set, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX * bdchgidx, SCIP_Bool * used )

checks if the given variable is already part of the current conflict set or queued for resolving with the same or even stronger bound

Parameters
 conflict conflict analysis data var problem variable set global SCIP settings boundtype type of bound for which the score should be increased bdchgidx bound change index (time stamp of bound change), or NULL for current time used pointer to store if the variable is already used

Definition at line 4281 of file conflict_graphanalysis.c.

Referenced by SCIPisConflictVarUsed().

 static SCIP_RETCODE addBdchg ( SCIP_SET * set, SCIP_VAR * var, SCIP_Real newlb, SCIP_Real newub, SCIP_LPBDCHGS * oldlpbdchgs, SCIP_LPBDCHGS * relaxedlpbdchgs, SCIP_LPI * lpi )
static

inserts variable's new bounds into bound change arrays

Parameters
 set global SCIP settings var variable to change the LP bounds for newlb new lower bound newub new upper bound oldlpbdchgs old LP bound changes used for reset the LP bound change relaxedlpbdchgs relaxed LP bound changes used for reset the LP bound change lpi pointer to LPi to access infinity of LP solver; necessary to set correct value

Definition at line 4340 of file conflict_graphanalysis.c.

Referenced by SCIPundoBdchgsProof().

 static SCIP_RETCODE addCand ( SCIP_SET * set, int currentdepth, SCIP_VAR * var, int lbchginfopos, int ubchginfopos, SCIP_Real proofcoef, SCIP_Real prooflhs, SCIP_Real proofact, SCIP_VAR *** cands, SCIP_Real ** candscores, SCIP_Real ** newbounds, SCIP_Real ** proofactdeltas, int * candssize, int * ncands, int firstcand )
static

adds variable to candidate list, if the current best bound corresponding to the proof coefficient is local; returns the array position in the candidate list, where the new candidate was inserted, or -1 if the variable can relaxed to global bounds immediately without increasing the proof's activity; the candidates are sorted with respect to the following two criteria:

• prefer bound changes that have been applied deeper in the tree, to get a more global conflict
• prefer variables with small Farkas coefficient to get rid of as many bound changes as possible
Parameters
 set global SCIP settings currentdepth current depth in the tree var variable to add to candidate array lbchginfopos positions of currently active lower bound change information in variable's array ubchginfopos positions of currently active upper bound change information in variable's array proofcoef coefficient of variable in infeasibility/bound proof prooflhs left hand side of infeasibility/bound proof proofact activity of infeasibility/bound proof row cands pointer to candidate array for undoing bound changes candscores pointer to candidate score array for undoing bound changes newbounds pointer to candidate new bounds array for undoing bound changes proofactdeltas pointer to proof activity increase array for undoing bound changes candssize pointer to size of cands arrays ncands pointer to count number of candidates in bound change list firstcand position of first unprocessed bound change candidate

Definition at line 4427 of file conflict_graphanalysis.c.

Referenced by SCIPundoBdchgsProof().

◆ SCIPundoBdchgsProof()

 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 )

undoes bound changes on variables, still leaving the given infeasibility proof valid

Parameters
 set global SCIP settings prob problem data currentdepth current depth in the tree proofcoefs coefficients in infeasibility proof prooflhs left hand side of proof proofact current activity of proof curvarlbs current lower bounds of active problem variables curvarubs current upper bounds of active problem variables lbchginfoposs positions of currently active lower bound change information in variables' arrays ubchginfoposs positions of currently active upper bound change information in variables' arrays oldlpbdchgs old LP bound changes used for reset the LP bound change, or NULL relaxedlpbdchgs relaxed LP bound changes used for reset the LP bound change, or NULL resolve pointer to store whether the changed LP should be resolved again, or NULL lpi pointer to LPi to access infinity of LP solver; necessary to set correct values

Definition at line 4559 of file conflict_graphanalysis.c.

Referenced by SCIPconflictAnalyzePseudo(), undoBdchgsDualfarkas(), and undoBdchgsDualsol().

◆ undoBdchgsDualfarkas()

 static SCIP_RETCODE undoBdchgsDualfarkas ( SCIP_SET * set, SCIP_PROB * prob, SCIP_LP * lp, int currentdepth, SCIP_Real * curvarlbs, SCIP_Real * curvarubs, int * lbchginfoposs, int * ubchginfoposs, SCIP_LPBDCHGS * oldlpbdchgs, SCIP_LPBDCHGS * relaxedlpbdchgs, SCIP_Bool * valid, SCIP_Bool * resolve, SCIP_Real * farkascoefs, SCIP_Real farkaslhs, SCIP_Real * farkasactivity )
static

analyzes an infeasible LP and undoes additional bound changes while staying infeasible

Parameters
 set global SCIP settings prob problem data lp LP data currentdepth current depth in the tree curvarlbs current lower bounds of active problem variables curvarubs current upper bounds of active problem variables lbchginfoposs positions of currently active lower bound change information in variables' arrays ubchginfoposs positions of currently active upper bound change information in variables' arrays oldlpbdchgs old LP bound changes used for reset the LP bound change, or NULL relaxedlpbdchgs relaxed LP bound changes used for reset the LP bound change, or NULL valid pointer to store whether the unfixings are valid resolve pointer to store whether the changed LP should be resolved again farkascoefs coefficients in the proof constraint farkaslhs lhs of the proof constraint farkasactivity maximal activity of the proof constraint

Definition at line 4771 of file conflict_graphanalysis.c.

Referenced by SCIPrunBoundHeuristic().

◆ lpbdchgsCreate()

 static SCIP_RETCODE lpbdchgsCreate ( SCIP_LPBDCHGS ** lpbdchgs, SCIP_SET * set, int ncols )
static

create conflict LP bound change data structure

Parameters
 lpbdchgs pointer to store the conflict LP bound change data structure set global SCIP settings ncols number of columns

Definition at line 4832 of file conflict_graphanalysis.c.

Referenced by SCIPrunBoundHeuristic().

◆ ensureSidechgsSize()

 static SCIP_RETCODE ensureSidechgsSize ( SCIP_SET * set, int ** sidechginds, SCIP_Real ** sidechgoldlhss, SCIP_Real ** sidechgoldrhss, SCIP_Real ** sidechgnewlhss, SCIP_Real ** sidechgnewrhss, int * sidechgssize, int num )
static

ensures, that side change arrays can store at least num entries

Parameters
 set global SCIP settings sidechginds pointer to side change index array sidechgoldlhss pointer to side change old left hand sides array sidechgoldrhss pointer to side change old right hand sides array sidechgnewlhss pointer to side change new left hand sides array sidechgnewrhss pointer to side change new right hand sides array sidechgssize pointer to size of side change arrays num minimal number of entries to be able to store in side change arrays

Definition at line 4859 of file conflict_graphanalysis.c.

References NULL, SCIP_CALL, SCIP_OKAY, SCIPsetCalcMemGrowSize(), and SCIPsetReallocBufferArray.

 static SCIP_RETCODE addSideRemoval ( SCIP_SET * set, SCIP_ROW * row, SCIP_Real lpiinfinity, int ** sidechginds, SCIP_Real ** sidechgoldlhss, SCIP_Real ** sidechgoldrhss, SCIP_Real ** sidechgnewlhss, SCIP_Real ** sidechgnewrhss, int * sidechgssize, int * nsidechgs )
static

adds removal of row's side to side change arrays; finite sides are only replaced by near infinite sides, such that the row's sense in the LP solver is not changed

Parameters
 set global SCIP settings row LP row to change the sides for lpiinfinity value treated as infinity in LP solver sidechginds pointer to side change index array sidechgoldlhss pointer to side change old left hand sides array sidechgoldrhss pointer to side change old right hand sides array sidechgnewlhss pointer to side change new left hand sides array sidechgnewrhss pointer to side change new right hand sides array sidechgssize pointer to size of side change arrays nsidechgs pointer to number of used slots in side change arrays

Definition at line 4898 of file conflict_graphanalysis.c.

Referenced by SCIPrunBoundHeuristic().

◆ lpbdchgsReset()

 static void lpbdchgsReset ( SCIP_LPBDCHGS * lpbdchgs, int ncols )
static

reset conflict LP bound change data structure

Parameters
 lpbdchgs conflict LP bound change data structure ncols number of columns

Definition at line 4972 of file conflict_graphanalysis.c.

References BMSclearMemoryArray, SCIP_LPBdChgs::nbdchgs, NULL, and SCIP_LPBdChgs::usedcols.

Referenced by SCIPrunBoundHeuristic().

◆ lpbdchgsFree()

 static void lpbdchgsFree ( SCIP_LPBDCHGS ** lpbdchgs, SCIP_SET * set )
static

free conflict LP bound change data structure

Parameters
 lpbdchgs pointer to store the conflict LP bound change data structure set global SCIP settings

Definition at line 4985 of file conflict_graphanalysis.c.

References SCIPsetFreeBuffer, and SCIPsetFreeBufferArray.

Referenced by SCIPrunBoundHeuristic().

◆ undoBdchgsDualsol()

 static SCIP_RETCODE undoBdchgsDualsol ( SCIP_SET * set, SCIP_PROB * prob, SCIP_LP * lp, int currentdepth, SCIP_Real * curvarlbs, SCIP_Real * curvarubs, int * lbchginfoposs, int * ubchginfoposs, SCIP_LPBDCHGS * oldlpbdchgs, SCIP_LPBDCHGS * relaxedlpbdchgs, SCIP_Bool * valid, SCIP_Bool * resolve, SCIP_Real * dualcoefs, SCIP_Real duallhs, SCIP_Real * dualactivity )
static

analyzes an LP exceeding the objective limit and undoes additional bound changes while staying beyond the objective limit

Parameters
 set global SCIP settings prob problem data lp LP data currentdepth current depth in the tree curvarlbs current lower bounds of active problem variables curvarubs current upper bounds of active problem variables lbchginfoposs positions of currently active lower bound change information in variables' arrays ubchginfoposs positions of currently active upper bound change information in variables' arrays oldlpbdchgs old LP bound changes used for reset the LP bound change, or NULL relaxedlpbdchgs relaxed LP bound changes used for reset the LP bound change, or NULL valid pointer to store whether the unfixings are valid resolve pointer to store whether the changed LP should be resolved again dualcoefs coefficients in the proof constraint duallhs lhs of the proof constraint dualactivity maximal activity of the proof constraint

Definition at line 5003 of file conflict_graphanalysis.c.

Referenced by SCIPrunBoundHeuristic().

◆ SCIPrunBoundHeuristic()

 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 )

try to find a subset of changed bounds leading to an infeasible LP

1. call undoBdchgsDualfarkas() or undoBdchgsDualsol() -> update lb/ubchginfoposs arrays -> store additional changes in bdchg and curvarlbs/ubs arrays -> apply additional changes to the LPI
2. (optional) if additional bound changes were undone: -> resolve LP -> goto 1.
3. redo all bound changes in the LPI to restore the LPI to its original state
4. analyze conflict -> put remaining changed bounds (see lb/ubchginfoposs arrays) into starting conflict set
Parameters
 conflict conflict data set global SCIP settings stat problem statistics origprob original problem transprob transformed problem tree branch and bound tree reopt reoptimization data lp LP data lpi LPI data blkmem block memory proofcoefs coefficients in the proof constraint prooflhs lhs of the proof constraint proofactivity maximal activity of the proof constraint curvarlbs current lower bounds of active problem variables curvarubs current upper bounds of active problem variables lbchginfoposs positions of currently active lower bound change information in variables' arrays ubchginfoposs positions of currently active upper bound change information in variables' arrays iterations pointer to store the total number of LP iterations used marklpunsolved whether LP should be marked unsolved after analysis (needed for strong branching) dualproofsuccess pointer to store success result of dual proof analysis valid pointer to store whether the result is still a valid proof

Definition at line 5069 of file conflict_graphanalysis.c.

Referenced by conflictAnalyzeLP().

◆ SCIPconflictAnalyze()

 SCIP_RETCODE SCIPconflictAnalyze ( SCIP_CONFLICT * conflict, BMS_BLKMEM * blkmem, SCIP_SET * set, SCIP_STAT * stat, SCIP_PROB * prob, SCIP_TREE * tree, int validdepth, SCIP_Bool * success )

analyzes conflicting bound changes that were added with calls to SCIPconflictAddBound(), and on success, calls the conflict handlers to create a conflict constraint out of the resulting conflict set; updates statistics for propagation conflict analysis

Parameters
 conflict conflict analysis data blkmem block memory of transformed problem set global SCIP settings stat problem statistics prob problem data tree branch and bound tree validdepth minimal depth level at which the initial conflict set is valid success pointer to store whether a conflict constraint was created, or NULL

Definition at line 5448 of file conflict_graphanalysis.c.

Referenced by SCIPanalyzeConflict(), and SCIPanalyzeConflictCons().