88#if defined(_WIN32) || defined(_WIN64)
96#define NUMSTOP 9007199254740992.0
100#define SOLSTOP 10000000.0
208 if( bdchginfo1 == bdchginfo2 )
255 conflictBdchginfoComp,
NULL) );
257 conflictBdchginfoComp,
NULL) );
259 (*conflict)->conflictsets =
NULL;
260 (*conflict)->conflictsetscores =
NULL;
261 (*conflict)->tmpbdchginfos =
NULL;
262 (*conflict)->conflictsetssize = 0;
263 (*conflict)->nconflictsets = 0;
264 (*conflict)->proofsets =
NULL;
265 (*conflict)->proofsetssize = 0;
266 (*conflict)->nproofsets = 0;
267 (*conflict)->tmpbdchginfossize = 0;
268 (*conflict)->ntmpbdchginfos = 0;
269 (*conflict)->count = 0;
270 (*conflict)->nglbchgbds = 0;
271 (*conflict)->nappliedglbconss = 0;
272 (*conflict)->nappliedglbliterals = 0;
273 (*conflict)->nlocchgbds = 0;
274 (*conflict)->nappliedlocconss = 0;
275 (*conflict)->nappliedlocliterals = 0;
276 (*conflict)->npropcalls = 0;
277 (*conflict)->npropsuccess = 0;
278 (*conflict)->npropconfconss = 0;
279 (*conflict)->npropconfliterals = 0;
280 (*conflict)->npropreconvconss = 0;
281 (*conflict)->npropreconvliterals = 0;
282 (*conflict)->ninflpcalls = 0;
283 (*conflict)->ninflpsuccess = 0;
284 (*conflict)->ninflpconfconss = 0;
285 (*conflict)->ninflpconfliterals = 0;
286 (*conflict)->ninflpreconvconss = 0;
287 (*conflict)->ninflpreconvliterals = 0;
288 (*conflict)->ninflpiterations = 0;
289 (*conflict)->nboundlpcalls = 0;
290 (*conflict)->nboundlpsuccess = 0;
291 (*conflict)->nboundlpconfconss = 0;
292 (*conflict)->nboundlpconfliterals = 0;
293 (*conflict)->nboundlpreconvconss = 0;
294 (*conflict)->nboundlpreconvliterals = 0;
295 (*conflict)->nboundlpiterations = 0;
296 (*conflict)->nsbcalls = 0;
297 (*conflict)->nsbsuccess = 0;
298 (*conflict)->nsbconfconss = 0;
299 (*conflict)->nsbconfliterals = 0;
300 (*conflict)->nsbreconvconss = 0;
301 (*conflict)->nsbreconvliterals = 0;
302 (*conflict)->nsbiterations = 0;
303 (*conflict)->npseudocalls = 0;
304 (*conflict)->npseudosuccess = 0;
305 (*conflict)->npseudoconfconss = 0;
306 (*conflict)->npseudoconfliterals = 0;
307 (*conflict)->npseudoreconvconss = 0;
308 (*conflict)->npseudoreconvliterals = 0;
309 (*conflict)->ndualproofsinfglobal = 0;
310 (*conflict)->ndualproofsinflocal = 0;
311 (*conflict)->ndualproofsinfsuccess = 0;
312 (*conflict)->dualproofsinfnnonzeros = 0;
313 (*conflict)->ndualproofsbndglobal = 0;
314 (*conflict)->ndualproofsbndlocal = 0;
315 (*conflict)->ndualproofsbndsuccess = 0;
316 (*conflict)->dualproofsbndnnonzeros = 0;
331 assert((*conflict)->nconflictsets == 0);
332 assert((*conflict)->ntmpbdchginfos == 0);
334#if defined(SCIP_CONFGRAPH) || defined(SCIP_CONFGRAPH_DOT)
816 SCIPsetDebugMsg(
set,
" -> add %s row <%s>[%g,%g](lp depth: %d): dual=%g -> dualrhs=%g\n",
817 row->
local ?
"local" :
"global",
830 SCIP_Bool* zerocontribution
835 *zerocontribution =
TRUE;
840 *zerocontribution =
FALSE;
853 for(
i = 0;
i < row->
len && *zerocontribution;
i++ )
856 *zerocontribution =
FALSE;
859 if( !(*zerocontribution) )
861 SCIPsetDebugMsg(
set,
" -> invalid dual solution value %g for row <%s>: lhs=%g, rhs=%g\n",
877 SCIP_Real* curvarlbs,
878 SCIP_Real* curvarubs,
883 SCIP_Real
QUAD(minact);
896 if( infdelta !=
NULL )
899 for(
i = 0;
i < nnz;
i++ )
902 SCIP_Real
QUAD(delta);
915 if( infdelta !=
NULL )
929 if( infdelta !=
NULL )
973 assert(rowdepth[0] <= rowdepth[nrows-1]);
978 for(
i = 0;
i < nrows;
i++ )
983 rownnz[
i] = row->
len;
987 for(
i = 0;
i < nrows;
i++ )
993 while( j+1 < nrows && rowdepth[j+1] == d )
1004 assert(rownnz[
i] <= rownnz[j]);
1010 for(
i = 0;
i < nrows-1;
i++ )
1011 assert(rowdepth[
i] < rowdepth[
i+1] || (rowdepth[
i] == rowdepth[
i+1] && rownnz[
i] <= rownnz[
i+1]));
1027 SCIP_Real* dualsols,
1031 SCIP_Real* proofact,
1033 SCIP_Real* curvarlbs,
1034 SCIP_Real* curvarubs,
1046 if( !
set->conf_uselocalrows )
1075 for(
i = 0;
i < nlocalrows; ++
i )
1080 r = localrowinds[
i];
1094 SCIP_Bool zerocontribution;
1099 assert(!zerocontribution);
1109 if( *validdepth < localrowdepth[
i] )
1110 *validdepth = localrowdepth[
i];
1168 SCIP_Real* farkasact,
1170 SCIP_Real* curvarlbs,
1171 SCIP_Real* curvarubs,
1176 SCIP_Real* dualfarkas;
1217 localrowinds =
NULL;
1218 localrowdepth =
NULL;
1225 for(
r = 0;
r < nrows; ++
r )
1238 for(
r = 0;
r < nrows; ++
r )
1249 SCIP_Bool zerocontribution;
1257 if( zerocontribution )
1289 localrowinds[nlocalrows] =
r;
1290 localrowdepth[nlocalrows++] = lpdepth;
1319 if( nlocalrows > 0 &&
set->conf_uselocalrows > 0 )
1322 nlocalrows, farkasact, validdepth, curvarlbs, curvarubs,
valid) );
1348 SCIP_Real* farkasact,
1350 SCIP_Real* curvarlbs,
1351 SCIP_Real* curvarubs,
1358 SCIP_Real* primsols;
1359 SCIP_Real* dualsols;
1360 SCIP_Real* redcosts;
1381 localrowinds =
NULL;
1382 localrowdepth =
NULL;
1414 for(
r = 0;
r < nrows; ++
r )
1452 for(
r = 0;
r < nrows; ++
r )
1463 SCIP_Bool zerocontribution;
1471 if( zerocontribution )
1504 localrowinds[nlocalrows] =
r;
1505 localrowdepth[nlocalrows++] = lpdepth;
1534 if( nlocalrows > 0 &&
set->conf_uselocalrows > 0 )
1537 nlocalrows, farkasact, validdepth, curvarlbs, curvarubs,
valid) );
1586 SCIP_Real* curvarlbs;
1587 SCIP_Real* curvarubs;
1590 SCIP_Real* pseudocoefs;
1591 SCIP_Real pseudolhs;
1592 SCIP_Real pseudoact;
1605 if( success !=
NULL )
1609 if( !
set->conf_enable || !
set->conf_usepseudo )
1613 if(
set->nconflicthdlrs == 0 )
1616 SCIPsetDebugMsg(
set,
"analyzing pseudo solution (obj: %g) that exceeds objective limit (%g)\n",
1656 for( v = 0; v <
nvars; ++v )
1667 pseudocoefs[v] = 0.0;
1671 if( pseudocoefs[v] > 0.0 )
1672 pseudoact += pseudocoefs[v] * curvarubs[v];
1674 pseudoact += pseudocoefs[v] * curvarlbs[v];
1677 SCIPsetDebugMsg(
set,
" -> recalculated pseudo infeasibility proof: %g <= %g\n", pseudolhs, pseudoact);
1685 int nreconvliterals;
1689 curvarlbs, curvarubs, lbchginfoposs, ubchginfoposs,
NULL,
NULL,
NULL, lp->
lpi) );
1693 lbchginfoposs, ubchginfoposs, &nconss, &nliterals, &nreconvconss, &nreconvliterals) );
1699 if( success !=
NULL )
1700 *success = (nconss > 0);
1711 SCIP_CALL(
SCIPconflictFlushConss(conflict, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue, cliquetable) );
1806 SCIP_Bool* dualproofsuccess,
1811 int* nreconvliterals,
1812 SCIP_Bool marklpunsolved
1819 SCIP_Bool globalinfeasible;
1825 SCIP_Real* curvarlbs;
1826 SCIP_Real* curvarubs;
1827 SCIP_Real farkasactivity;
1848 *nreconvliterals = 0;
1901 (*iterations) += iter;
1944 farkasactivity = 0.0;
2001 curvarlbs, curvarubs, &
valid) );
2008 curvarlbs, curvarubs, &
valid) );
2014 globalinfeasible =
FALSE;
2021 SCIP_CALL(
SCIPconflictAnalyzeDualProof(conflict,
set, stat, blkmem, origprob, transprob, tree, reopt, lp, farkasrow, \
2022 validdepth, curvarlbs, curvarubs,
TRUE, &globalinfeasible, dualproofsuccess) );
2032 SCIP_Real* farkascoefs;
2033 SCIP_Real farkaslhs;
2040 SCIPsetDebugMsg(
set,
"analyzing conflict on infeasible LP (infeasible: %u, objlimexc: %u, optimal:%u) in depth %d (diving: %u)\n",
2052 farkasactivity = -farkasactivity;
2057 for( v = 0; v < nnz; v++ )
2066 SCIP_CALL(
SCIPrunBoundHeuristic(conflict,
set, stat, origprob, transprob, tree, reopt, lp, lpi, blkmem, farkascoefs,
2067 &farkaslhs, &farkasactivity, curvarlbs, curvarubs, lbchginfoposs, ubchginfoposs, iterations, marklpunsolved,
2068 dualproofsuccess, &
valid) );
2073 goto FLUSHPROOFSETS;
2077 lbchginfoposs, ubchginfoposs, nconss, nliterals, nreconvconss, nreconvliterals) );
2080 SCIP_CALL(
SCIPconflictFlushConss(conflict, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, \
2081 eventqueue, cliquetable) );
2088 SCIP_CALL(
SCIPconflictFlushProofset(conflict, conflictstore, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, \
2089 branchcand, eventqueue, cliquetable) );
2123 SCIP_Bool* downconflict,
2125 SCIP_Bool* upconflict
2137 SCIP_Bool dualraysuccess;
2142 int nreconvliterals;
2156 if( downconflict !=
NULL )
2157 *downconflict =
FALSE;
2158 if( upconflict !=
NULL )
2159 *upconflict =
FALSE;
2162 if( !
set->conf_enable || !
set->conf_usesb )
2166 if(
set->nconflicthdlrs == 0 )
2192 if( newub >= col->
lb - 0.5 )
2194 SCIPsetDebugMsg(
set,
"analyzing conflict on infeasible downwards strongbranch for variable <%s>[%g,%g] in depth %d\n",
2227 SCIPsetDebugMsg(
set,
" -> resolved downwards strong branching LP in %d iterations\n", iter);
2231 lp, branchcand, eventqueue, cliquetable,
TRUE, &dualraysuccess, &iter, &nconss, &nliterals, \
2232 &nreconvconss, &nreconvliterals,
FALSE) );
2233 conflict->
nsbsuccess += ((nconss > 0 || dualraysuccess) ? 1 : 0);
2239 if( downconflict !=
NULL )
2240 *downconflict = (nconss > 0);
2259 if( newlb <= col->ub + 0.5 )
2261 SCIPsetDebugMsg(
set,
"analyzing conflict on infeasible upwards strongbranch for variable <%s>[%g,%g] in depth %d\n",
2294 SCIPsetDebugMsg(
set,
" -> resolved upwards strong branching LP in %d iterations\n", iter);
2298 lp, branchcand, eventqueue, cliquetable,
TRUE, &dualraysuccess, &iter, &nconss, &nliterals, \
2299 &nreconvconss, &nreconvliterals,
FALSE) );
2300 conflict->
nsbsuccess += ((nconss > 0 || dualraysuccess) ? 1 : 0);
2306 if( upconflict !=
NULL )
2307 *upconflict = (nconss > 0);
2373 SCIP_Bool dualraysuccess =
FALSE;
2374 SCIP_Longint olddualproofsuccess;
2379 int nreconvliterals;
2389 if( !
set->conf_enable ||
set->conf_useinflp ==
'o' )
2393 if(
set->nconflicthdlrs == 0 )
2396 SCIPsetDebugMsg(
set,
"analyzing conflict on infeasible LP in depth %d (solstat: %d, objchanged: %u)\n",
2408 SCIP_CALL(
conflictAnalyzeLP(conflict, conflictstore, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue, \
2409 cliquetable,
SCIPlpDiving(lp), &dualraysuccess, &iterations, &nconss, &nliterals, &nreconvconss, &nreconvliterals,
TRUE) );
2416 if( success !=
NULL )
2449 SCIP_Bool dualraysuccess;
2450 SCIP_Longint oldnsuccess;
2455 int nreconvliterals;
2466 if( !
set->conf_enable ||
set->conf_useboundlp ==
'o')
2470 if(
set->nconflicthdlrs == 0 )
2473 SCIPsetDebugMsg(
set,
"analyzing conflict on bound exceeding LP in depth %d (solstat: %d)\n",
2487 SCIP_CALL(
conflictAnalyzeLP(conflict, conflictstore, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue, \
2488 cliquetable,
SCIPlpDiving(lp), &dualraysuccess, &iterations, &nconss, &nliterals, &nreconvconss, &nreconvliterals,
TRUE) );
2495 if( success !=
NULL )
2534 if( success !=
NULL )
2538 if( !
set->conf_enable || (
set->conf_useinflp ==
'o' &&
set->conf_useboundlp ==
'o') )
2602 reopt, lp, branchcand, eventqueue, cliquetable, success) );
2607 reopt, lp, branchcand, eventqueue, cliquetable, success) );
void SCIPclockStop(SCIP_CLOCK *clck, SCIP_SET *set)
void SCIPclockEnableOrDisable(SCIP_CLOCK *clck, SCIP_Bool enable)
void SCIPclockStart(SCIP_CLOCK *clck, SCIP_SET *set)
SCIP_Real SCIPclockGetTime(SCIP_CLOCK *clck)
void SCIPclockFree(SCIP_CLOCK **clck)
SCIP_RETCODE SCIPclockCreate(SCIP_CLOCK **clck, SCIP_CLOCKTYPE clocktype)
internal methods for clocks and timing issues
internal methods for conflict analysis
void SCIPproofsetFree(SCIP_PROOFSET **proofset, BMS_BLKMEM *blkmem)
SCIP_RETCODE SCIPconflictInitProofset(SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem)
SCIP_RETCODE SCIPconflictAnalyzeDualProof(SCIP_CONFLICT *conflict, SCIP_SET *set, SCIP_STAT *stat, BMS_BLKMEM *blkmem, SCIP_PROB *origprob, SCIP_PROB *transprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_AGGRROW *proofrow, int validdepth, SCIP_Real *curvarlbs, SCIP_Real *curvarubs, SCIP_Bool initialproof, SCIP_Bool *globalinfeasible, SCIP_Bool *success)
SCIP_RETCODE SCIPconflictFlushProofset(SCIP_CONFLICT *conflict, SCIP_CONFLICTSTORE *conflictstore, 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)
int SCIPproofsetGetNVars(SCIP_PROOFSET *proofset)
int SCIPconflictGetNConflicts(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNAppliedGlobalConss(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNDualproofsInfLocal(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNAppliedLocalLiterals(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNPropCalls(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNDualproofsInfNonzeros(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNStrongbranchIterations(SCIP_CONFLICT *conflict)
SCIP_Real SCIPconflictGetInfeasibleLPTime(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNInfeasibleLPCalls(SCIP_CONFLICT *conflict)
SCIP_RETCODE SCIPgetFarkasProof(SCIP_SET *set, SCIP_PROB *prob, SCIP_LP *lp, SCIP_LPI *lpi, SCIP_TREE *tree, SCIP_AGGRROW *farkasrow, SCIP_Real *farkasact, int *validdepth, SCIP_Real *curvarlbs, SCIP_Real *curvarubs, SCIP_Bool *valid)
SCIP_RETCODE SCIPconflictCreate(SCIP_CONFLICT **conflict, BMS_BLKMEM *blkmem, SCIP_SET *set)
SCIP_Real SCIPconflictGetGlobalApplTime(SCIP_CONFLICT *conflict)
SCIP_RETCODE SCIPgetDualProof(SCIP_SET *set, SCIP_PROB *transprob, SCIP_LP *lp, SCIP_LPI *lpi, SCIP_TREE *tree, SCIP_AGGRROW *farkasrow, SCIP_Real *farkasact, int *validdepth, SCIP_Real *curvarlbs, SCIP_Real *curvarubs, SCIP_Bool *valid)
SCIP_Longint SCIPconflictGetNInfeasibleLPSuccess(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNBoundexceedingLPReconvergenceConss(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNGlobalChgBds(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNAppliedLiterals(SCIP_CONFLICT *conflict)
static SCIP_Bool checkDualFeasibility(SCIP_SET *set, SCIP_ROW *row, SCIP_Real weight, SCIP_Bool *zerocontribution)
SCIP_RETCODE SCIPconflictAnalyzeStrongbranch(SCIP_CONFLICT *conflict, SCIP_CONFLICTSTORE *conflictstore, 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_COL *col, SCIP_Bool *downconflict, SCIP_Bool *upconflict)
SCIP_Longint SCIPconflictGetNPropConflictLiterals(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNAppliedConss(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNInfeasibleLPConflictConss(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNBoundexceedingLPConflictConss(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNBoundexceedingLPSuccess(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNStrongbranchCalls(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNInfeasibleLPReconvergenceLiterals(SCIP_CONFLICT *conflict)
static SCIP_RETCODE conflictAnalyzeLP(SCIP_CONFLICT *conflict, SCIP_CONFLICTSTORE *conflictstore, 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_Bool diving, SCIP_Bool *dualproofsuccess, int *iterations, int *nconss, int *nliterals, int *nreconvconss, int *nreconvliterals, SCIP_Bool marklpunsolved)
SCIP_Longint SCIPconflictGetNPropReconvergenceConss(SCIP_CONFLICT *conflict)
SCIP_RETCODE SCIPconflictAnalyzePseudo(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_Bool *success)
SCIP_Real SCIPconflictGetBoundexceedingLPTime(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNStrongbranchReconvergenceLiterals(SCIP_CONFLICT *conflict)
SCIP_Real SCIPconflictGetPseudoTime(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNPseudoReconvergenceLiterals(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNPropReconvergenceLiterals(SCIP_CONFLICT *conflict)
static SCIP_RETCODE addLocalRows(SCIP_SET *set, SCIP_PROB *transprob, SCIP_LP *lp, SCIP_AGGRROW *proofrow, SCIP_ROW **rows, SCIP_Real *dualsols, int *localrowinds, int *localrowdepth, int nlocalrows, SCIP_Real *proofact, int *validdepth, SCIP_Real *curvarlbs, SCIP_Real *curvarubs, SCIP_Bool *valid)
SCIP_Longint SCIPconflictGetNInfeasibleLPReconvergenceConss(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNAppliedLocalConss(SCIP_CONFLICT *conflict)
static SCIP_RETCODE sortLocalRows(SCIP_SET *set, SCIP_AGGRROW *aggrrow, SCIP_ROW **rows, int *rowinds, int *rowdepth, int nrows)
SCIP_Longint SCIPconflictGetNStrongbranchReconvergenceConss(SCIP_CONFLICT *conflict)
static SCIP_RETCODE conflictAnalyzeBoundexceedingLP(SCIP_CONFLICT *conflict, SCIP_CONFLICTSTORE *conflictstore, 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_Bool *success)
SCIP_Real SCIPconflictGetVarUb(SCIP_CONFLICT *conflict, SCIP_VAR *var)
SCIP_RETCODE SCIPconflictAnalyzeLP(SCIP_CONFLICT *conflict, SCIP_CONFLICTSTORE *conflictstore, 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_Bool *success)
SCIP_Longint SCIPconflictGetNBoundexceedingLPConflictLiterals(SCIP_CONFLICT *conflict)
SCIP_Real SCIPconflictGetStrongbranchTime(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNPseudoSuccess(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNInfeasibleLPConflictLiterals(SCIP_CONFLICT *conflict)
SCIP_Real SCIPaggrRowGetMinActivity(SCIP_SET *set, SCIP_PROB *transprob, SCIP_AGGRROW *aggrrow, SCIP_Real *curvarlbs, SCIP_Real *curvarubs, SCIP_Bool *infdelta)
SCIP_Longint SCIPconflictGetNPseudoConflictLiterals(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNLocalChgBds(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNDualproofsBndSuccess(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNPropSuccess(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNDualproofsInfSuccess(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNBoundexceedingLPCalls(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNPropConflictConss(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNStrongbranchSuccess(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNDualproofsBndGlobal(SCIP_CONFLICT *conflict)
static SCIP_RETCODE conflictAnalyzeInfeasibleLP(SCIP_CONFLICT *conflict, SCIP_CONFLICTSTORE *conflictstore, 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_Bool *success)
SCIP_Longint SCIPconflictGetNPseudoReconvergenceConss(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNAppliedGlobalLiterals(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNDualproofsBndLocal(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNPseudoCalls(SCIP_CONFLICT *conflict)
void SCIPconflictEnableOrDisableClocks(SCIP_CONFLICT *conflict, SCIP_Bool enable)
SCIP_Real SCIPconflictGetPropTime(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNBoundexceedingLPIterations(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNStrongbranchConflictLiterals(SCIP_CONFLICT *conflict)
static SCIP_RETCODE addRowToAggrRow(SCIP_SET *set, SCIP_ROW *row, SCIP_Real weight, SCIP_AGGRROW *aggrrow)
SCIP_Longint SCIPconflictGetNPseudoConflictConss(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNDualproofsBndNonzeros(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNDualproofsInfGlobal(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNBoundexceedingLPReconvergenceLiterals(SCIP_CONFLICT *conflict)
SCIP_RETCODE SCIPconflictFree(SCIP_CONFLICT **conflict, BMS_BLKMEM *blkmem)
SCIP_Real SCIPconflictGetVarLb(SCIP_CONFLICT *conflict, SCIP_VAR *var)
SCIP_Longint SCIPconflictGetNStrongbranchConflictConss(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNInfeasibleLPIterations(SCIP_CONFLICT *conflict)
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)
void SCIPconflictsetFree(SCIP_CONFLICTSET **conflictset, BMS_BLKMEM *blkmem)
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 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 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)
SCIP_RETCODE SCIPconflictsetCreate(SCIP_CONFLICTSET **conflictset, BMS_BLKMEM *blkmem)
internal methods for storing conflicts
internal methods for constraints and constraint handlers
Constraint handler for linear constraints in their most general form, .
methods for the aggregation rows
#define SCIPquadprecProdDD(r, a, b)
#define QUAD_ASSIGN(a, constant)
#define SCIPquadprecSumQQ(r, a, b)
#define SCIP_LONGINT_FORMAT
SCIP_RETCODE SCIPlpiGetRealpar(SCIP_LPI *lpi, SCIP_LPPARAM type, SCIP_Real *dval)
SCIP_Real SCIPlpiInfinity(SCIP_LPI *lpi)
SCIP_Bool SCIPlpiIsObjlimExc(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiGetBase(SCIP_LPI *lpi, int *cstat, int *rstat)
SCIP_RETCODE SCIPlpiSetRealpar(SCIP_LPI *lpi, SCIP_LPPARAM type, SCIP_Real dval)
SCIP_RETCODE SCIPlpiGetDualfarkas(SCIP_LPI *lpi, SCIP_Real *dualfarkas)
SCIP_RETCODE SCIPlpiGetObjval(SCIP_LPI *lpi, SCIP_Real *objval)
SCIP_RETCODE SCIPlpiStartStrongbranch(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiChgBounds(SCIP_LPI *lpi, int ncols, const int *ind, const SCIP_Real *lb, const SCIP_Real *ub)
SCIP_Bool SCIPlpiIsDualFeasible(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiSetIntpar(SCIP_LPI *lpi, SCIP_LPPARAM type, int ival)
SCIP_RETCODE SCIPlpiSetBase(SCIP_LPI *lpi, const int *cstat, const int *rstat)
SCIP_Bool SCIPlpiWasSolved(SCIP_LPI *lpi)
SCIP_Bool SCIPlpiIsOptimal(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiEndStrongbranch(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiGetSol(SCIP_LPI *lpi, SCIP_Real *objval, SCIP_Real *primsol, SCIP_Real *dualsol, SCIP_Real *activity, SCIP_Real *redcost)
SCIP_Bool SCIPlpiHasDualRay(SCIP_LPI *lpi)
SCIP_Bool SCIPlpiIsPrimalInfeasible(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiSolveDual(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiGetIterations(SCIP_LPI *lpi, int *iterations)
SCIP_Bool SCIPlpiIsStable(SCIP_LPI *lpi)
SCIP_RETCODE SCIPpqueueCreate(SCIP_PQUEUE **pqueue, int initsize, SCIP_Real sizefac, SCIP_DECL_SORTPTRCOMP((*ptrcomp)),)
void SCIPpqueueFree(SCIP_PQUEUE **pqueue)
SCIP_VAR * SCIPcolGetVar(SCIP_COL *col)
SCIP_RETCODE SCIPaggrRowCreate(SCIP *scip, SCIP_AGGRROW **aggrrow)
void SCIPaggrRowClear(SCIP_AGGRROW *aggrrow)
SCIP_Real SCIPaggrRowGetRhs(SCIP_AGGRROW *aggrrow)
void SCIPaggrRowFree(SCIP *scip, SCIP_AGGRROW **aggrrow)
int * SCIPaggrRowGetInds(SCIP_AGGRROW *aggrrow)
void SCIPaggrRowRemoveZeros(SCIP *scip, SCIP_AGGRROW *aggrrow, SCIP_Bool useglbbounds, SCIP_Bool *valid)
int SCIPaggrRowGetNNz(SCIP_AGGRROW *aggrrow)
SCIP_RETCODE SCIPaggrRowAddRow(SCIP *scip, SCIP_AGGRROW *aggrrow, SCIP_ROW *row, SCIP_Real weight, int sidetype)
static INLINE SCIP_Real SCIPaggrRowGetProbvarValue(SCIP_AGGRROW *aggrrow, int probindex)
SCIP_RETCODE SCIPaggrRowAddObjectiveFunction(SCIP *scip, SCIP_AGGRROW *aggrrow, SCIP_Real rhs, SCIP_Real scale)
#define SCIPfreeBufferArrayNull(scip, ptr)
int SCIProwGetLPDepth(SCIP_ROW *row)
const char * SCIProwGetName(SCIP_ROW *row)
SCIP_Bool SCIPbdchginfoIsRedundant(SCIP_BDCHGINFO *bdchginfo)
SCIP_BDCHGIDX * SCIPbdchginfoGetIdx(SCIP_BDCHGINFO *bdchginfo)
SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
SCIP_Real SCIPvarGetObj(SCIP_VAR *var)
SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)
int SCIPvarGetProbindex(SCIP_VAR *var)
const char * SCIPvarGetName(SCIP_VAR *var)
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)
SCIP_Bool SCIPbdchgidxIsEarlierNonNull(SCIP_BDCHGIDX *bdchgidx1, SCIP_BDCHGIDX *bdchgidx2)
void SCIPsortIntInt(int *intarray1, int *intarray2, int len)
void SCIPsortIntIntInt(int *intarray1, int *intarray2, int *intarray3, int len)
assert(minobj< SCIPgetCutoffbound(scip))
internal methods for branching and inference history
SCIP_Bool SCIPlpDivingObjChanged(SCIP_LP *lp)
SCIP_LPSOLSTAT SCIPlpGetSolstat(SCIP_LP *lp)
SCIP_LPI * SCIPlpGetLPI(SCIP_LP *lp)
SCIP_Bool SCIPlpDiving(SCIP_LP *lp)
int SCIPlpGetNCols(SCIP_LP *lp)
SCIP_ROW ** SCIPlpGetRows(SCIP_LP *lp)
int SCIPlpGetNRows(SCIP_LP *lp)
SCIP_Real SCIPlpGetPseudoObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
internal methods for LP management
interface methods for specific LP solvers
#define BMSfreeMemory(ptr)
#define BMSclearMemoryArray(ptr, num)
struct BMS_BlkMem BMS_BLKMEM
#define BMSfreeMemoryArrayNull(ptr)
#define BMSallocMemory(ptr)
methods commonly used for presolving
SCIP_Bool SCIPprobIsObjIntegral(SCIP_PROB *prob)
int SCIPprobGetNVars(SCIP_PROB *prob)
SCIP_VAR ** SCIPprobGetVars(SCIP_PROB *prob)
SCIP_Bool SCIPprobAllColsInLP(SCIP_PROB *prob, SCIP_SET *set, SCIP_LP *lp)
internal methods for storing and manipulating the main problem
internal methods for propagators
public methods for conflict analysis handlers
public methods for managing constraints
public methods for LP management
public methods for message output
public data structures and miscellaneous methods
methods for sorting joint arrays of various types
public methods for handling parameter settings
public methods for propagators
public methods for branch and bound tree
public methods for problem variables
public methods for conflict handler plugins and conflict analysis
public methods for constraint handler plugins and constraints
public methods for memory management
public methods for solutions
public methods for SCIP variables
SCIP_Bool SCIPsetIsDualfeasZero(SCIP_SET *set, SCIP_Real val)
SCIP_Bool SCIPsetIsGE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Real SCIPsetFeasCeil(SCIP_SET *set, SCIP_Real val)
SCIP_Bool SCIPsetIsFeasGT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsetIsFeasLE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsetIsFeasEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsetIsLE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Real SCIPsetFeasFloor(SCIP_SET *set, SCIP_Real val)
SCIP_Bool SCIPsetIsEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Real SCIPsetInfinity(SCIP_SET *set)
SCIP_Bool SCIPsetIsLT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsetIsInfinity(SCIP_SET *set, SCIP_Real val)
SCIP_Bool SCIPsetIsGT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsetIsZero(SCIP_SET *set, SCIP_Real val)
SCIP_Real SCIPsetCutoffbounddelta(SCIP_SET *set)
internal methods for global SCIP settings
#define SCIPsetFreeBufferArray(set, ptr)
#define SCIPsetAllocBufferArray(set, ptr, num)
internal methods for storing primal CIP solutions
SCIP_CONFTYPE conflicttype
unsigned int usescutoffbound
SCIP_Longint ninflpiterations
SCIP_Longint ndualproofsbndglobal
SCIP_Longint ndualproofsinfsuccess
SCIP_Longint nappliedglbconss
SCIP_Longint nsbiterations
SCIP_Longint npropconfconss
SCIP_Longint ninflpconfconss
SCIP_Longint npseudoreconvliterals
SCIP_Longint npseudosuccess
SCIP_Longint ninflpconfliterals
SCIP_CLOCK * propanalyzetime
SCIP_Longint nboundlpconfliterals
SCIP_Longint ndualproofsinflocal
SCIP_Longint npseudoconfconss
SCIP_Longint nboundlpcalls
SCIP_Longint nappliedglbliterals
SCIP_Longint nboundlpreconvliterals
SCIP_Longint npseudocalls
SCIP_Longint ninflpreconvconss
SCIP_Longint dualproofsbndnnonzeros
SCIP_CLOCK * pseudoanalyzetime
SCIP_Longint nsbconfliterals
SCIP_CLOCK * inflpanalyzetime
SCIP_Longint nboundlpiterations
SCIP_Longint npseudoreconvconss
SCIP_Longint npseudoconfliterals
SCIP_Longint nsbreconvconss
SCIP_Longint nsbreconvliterals
SCIP_Longint npropsuccess
SCIP_Longint ndualproofsinfglobal
SCIP_Longint nappliedlocconss
SCIP_Longint nsbconfconss
SCIP_Longint ninflpsuccess
SCIP_CLOCK * sbanalyzetime
SCIP_Longint nboundlpreconvconss
SCIP_Longint ndualproofsbndsuccess
SCIP_Longint dualproofsinfnnonzeros
SCIP_Longint nboundlpconfconss
SCIP_Longint npropreconvliterals
SCIP_CLOCK * boundlpanalyzetime
SCIP_Longint nboundlpsuccess
SCIP_Longint npropconfliterals
SCIP_Longint ninflpreconvliterals
SCIP_CONFLICTSET * conflictset
SCIP_Longint ndualproofsbndlocal
SCIP_Longint nappliedlocliterals
SCIP_Longint npropreconvconss
SCIP_Longint nconflictlps
SCIP_Longint nconflictlpiterations
SCIP_CLOCK * conflictlptime
SCIP_Real conflictrelaxedub
SCIP_Real conflictrelaxedlb
datastructures for conflict analysis
data structures for LP management
datastructures for storing and manipulating the main problem
datastructures for global SCIP settings
datastructures for problem statistics
data structures for branch and bound tree
datastructures for problem variables
int SCIPtreeGetFocusDepth(SCIP_TREE *tree)
int SCIPtreeGetEffectiveRootDepth(SCIP_TREE *tree)
int SCIPtreeGetCurrentDepth(SCIP_TREE *tree)
internal methods for branch and bound tree
@ SCIP_CONFTYPE_BNDEXCEEDING
@ SCIP_LPSOLSTAT_NOTSOLVED
@ SCIP_LPSOLSTAT_INFEASIBLE
@ SCIP_LPSOLSTAT_OBJLIMIT
#define SCIP_DECL_SORTPTRCOMP(x)
enum SCIP_Retcode SCIP_RETCODE
SCIP_Real SCIPvarGetLbLP(SCIP_VAR *var, SCIP_SET *set)
SCIP_Real SCIPvarGetUbLP(SCIP_VAR *var, SCIP_SET *set)
internal methods for problem variables
methods for creating output for visualization tools (VBC, BAK)