251#define CONSHDLR_NAME "indicator"
252#define CONSHDLR_DESC "indicator constraint handler"
253#define CONSHDLR_SEPAPRIORITY 10
254#define CONSHDLR_ENFOPRIORITY -100
255#define CONSHDLR_CHECKPRIORITY -6000000
256#define CONSHDLR_SEPAFREQ 10
257#define CONSHDLR_PROPFREQ 1
258#define CONSHDLR_EAGERFREQ 100
260#define CONSHDLR_MAXPREROUNDS -1
261#define CONSHDLR_DELAYSEPA FALSE
262#define CONSHDLR_DELAYPROP FALSE
263#define CONSHDLR_NEEDSCONS TRUE
265#define CONSHDLR_PRESOLTIMING SCIP_PRESOLTIMING_FAST
266#define CONSHDLR_PROP_TIMING SCIP_PROPTIMING_BEFORELP
270#define EVENTHDLR_BOUND_NAME "indicatorbound"
271#define EVENTHDLR_BOUND_DESC "bound change event handler for indicator constraints"
273#define EVENTHDLR_LINCONSBOUND_NAME "indicatorlinconsbound"
274#define EVENTHDLR_LINCONSBOUND_DESC "bound change event handler for lincons of indicator constraints"
276#define EVENTHDLR_RESTART_NAME "indicatorrestart"
277#define EVENTHDLR_RESTART_DESC "force restart if absolute gap is 1 or enough binary variables have been fixed"
281#define CONFLICTHDLR_NAME "indicatorconflict"
282#define CONFLICTHDLR_DESC "replace slack variables and generate logicor constraints"
283#define CONFLICTHDLR_PRIORITY 200000
286#define LINCONSUPGD_PRIORITY +100000
289#define DEFAULT_BRANCHINDICATORS FALSE
290#define DEFAULT_GENLOGICOR FALSE
291#define DEFAULT_ADDCOUPLING TRUE
292#define DEFAULT_MAXCOUPLINGVALUE 1e4
293#define DEFAULT_ADDCOUPLINGCONS FALSE
294#define DEFAULT_SEPACOUPLINGCUTS TRUE
295#define DEFAULT_SEPACOUPLINGLOCAL FALSE
296#define DEFAULT_SEPACOUPLINGVALUE 1e4
297#define DEFAULT_SEPAALTERNATIVELP FALSE
298#define DEFAULT_SEPAPERSPECTIVE FALSE
299#define DEFAULT_SEPAPERSPLOCAL TRUE
300#define DEFAULT_MAXSEPANONVIOLATED 3
301#define DEFAULT_TRYSOLFROMCOVER FALSE
302#define DEFAULT_UPGRADELINEAR FALSE
303#define DEFAULT_USEOTHERCONSS FALSE
304#define DEFAULT_USEOBJECTIVECUT FALSE
305#define DEFAULT_UPDATEBOUNDS FALSE
306#define DEFAULT_MAXCONDITIONALTLP 0.0
307#define DEFAULT_MAXSEPACUTS 100
308#define DEFAULT_MAXSEPACUTSROOT 2000
309#define DEFAULT_REMOVEINDICATORS FALSE
310#define DEFAULT_GENERATEBILINEAR FALSE
311#define DEFAULT_SCALESLACKVAR FALSE
312#define DEFAULT_NOLINCONSCONT FALSE
313#define DEFAULT_TRYSOLUTIONS TRUE
314#define DEFAULT_ENFORCECUTS FALSE
315#define DEFAULT_DUALREDUCTIONS TRUE
316#define DEFAULT_ADDOPPOSITE FALSE
317#define DEFAULT_CONFLICTSUPGRADE FALSE
318#define DEFAULT_FORCERESTART FALSE
319#define DEFAULT_RESTARTFRAC 0.9
323#define OBJEPSILON 0.001
324#define SEPAALTTHRESHOLD 10
325#define MAXROUNDINGROUNDS 1
338 SCIP_Bool lessthanineq;
341 unsigned int linconsactive:1;
342 unsigned int implicationadded:1;
343 unsigned int slacktypechecked:1;
348struct SCIP_ConshdlrData
353 SCIP_Bool boundhaschanged;
354 SCIP_Bool linconsevents;
355 SCIP_Bool linconsboundschanged;
358 SCIP_Bool objindicatoronly;
359 SCIP_Bool objothervarsonly;
375 SCIP_Real objupperbound;
376 SCIP_Real objaltlpbound;
377 int maxroundingrounds;
378 SCIP_Real roundingminthres;
379 SCIP_Real roundingmaxthres;
380 SCIP_Real roundingoffset;
381 SCIP_Bool branchindicators;
382 SCIP_Bool genlogicor;
383 SCIP_Bool addcoupling;
384 SCIP_Bool addcouplingcons;
385 SCIP_Bool sepacouplingcuts;
386 SCIP_Bool sepacouplinglocal;
387 SCIP_Bool sepaperspective;
388 SCIP_Bool sepapersplocal;
389 SCIP_Bool removeindicators;
390 SCIP_Bool updatebounds;
391 SCIP_Bool trysolutions;
392 SCIP_Bool enforcecuts;
393 SCIP_Bool dualreductions;
394 SCIP_Bool addopposite;
395 SCIP_Bool generatebilinear;
396 SCIP_Bool scaleslackvar;
397 SCIP_Bool conflictsupgrade;
398 SCIP_Bool performedrestart;
401 int maxsepanonviolated;
404 SCIP_Real maxcouplingvalue;
405 SCIP_Real sepacouplingvalue;
406 SCIP_Real maxconditionaltlp;
407 SCIP_Real restartfrac;
409 SCIP_Bool addedcouplingcons;
413 SCIP_Bool useotherconss;
414 SCIP_Bool useobjectivecut;
415 SCIP_Bool trysolfromcover;
416 SCIP_Bool upgradelinear;
419 SCIP_Bool sepaalternativelp;
420 SCIP_Bool sepaalternativelp_;
421 SCIP_Bool nolinconscont;
422 SCIP_Bool nolinconscont_;
423 SCIP_Bool forcerestart;
424 SCIP_Bool forcerestart_;
429struct SCIP_ConflicthdlrData
450#define SCIP_CALL_PARAM(x) do \
452 SCIP_RETCODE _restat_; \
453 if ( (_restat_ = (x)) != SCIP_OKAY && (_restat_ != SCIP_PARAMETERUNKNOWN) ) \
455 SCIPerrorMessage("[%s:%d] Error <%d> in function call\n", __FILE__, __LINE__, _restat_); \
502 lincons = consdata->lincons;
546 vars[0] = consdata->binvar;
554 actweight = consdata->activeone ? 1.0 : -1.0;
586 vars[0] = consdata->slackvar;
641 assert( 0 <= consdata->nfixednonzero && consdata->nfixednonzero <= 2 );
642 assert( consdata->linconsactive );
659 ++(consdata->nfixednonzero);
660#ifdef SCIP_MORE_DEBUG
661 SCIPdebugMsg(
scip,
"Changed lower bound of variable <%s> from %g to %g (nfixednonzero: %d).\n",
671 ++(consdata->nfixednonzero);
672#ifdef SCIP_MORE_DEBUG
673 SCIPdebugMsg(
scip,
"Changed upper bound of variable <%s> from %g to %g (nfixednonzero: %d).\n",
683 --(consdata->nfixednonzero);
684#ifdef SCIP_MORE_DEBUG
685 SCIPdebugMsg(
scip,
"Changed lower bound of variable <%s> from %g to %g (nfixednonzero: %d).\n",
695 --(consdata->nfixednonzero);
696#ifdef SCIP_MORE_DEBUG
697 SCIPdebugMsg(
scip,
"Changed upper bound of variable <%s> from %g to %g (nfixednonzero: %d).\n",
708 assert( 0 <= consdata->nfixednonzero && consdata->nfixednonzero <= 2 );
711 conshdlrdata->boundhaschanged =
TRUE;
731#ifdef SCIP_MORE_DEBUG
739 conshdlrdata->linconsboundschanged =
TRUE;
767 assert( conshdlrdata->forcerestart );
790 if ( conshdlrdata->performedrestart )
794 ++(conshdlrdata->nbinvarszero);
802 if ( conshdlrdata->nbinvarszero > (
int) ((SCIP_Real) conshdlrdata->ninitconss * conshdlrdata->restartfrac) )
805 "Forcing restart, since %d binary variables among %d have been fixed.\n", conshdlrdata->nbinvarszero, conshdlrdata->ninitconss);
809 if ( conshdlrdata->objindicatoronly )
813 conshdlrdata->performedrestart =
TRUE;
825 if ( ! conshdlrdata->objindicatoronly )
842 conshdlrdata->performedrestart =
TRUE;
892 assert( bdchginfos !=
NULL || nbdchginfos == 0 );
915 for (
i = 0;
i < nbdchginfos; ++
i)
954 SCIPdebugMsg(
scip,
"Found conflict involving slack variables that can be remodelled.\n");
964 for (
i = 0;
i < nbdchginfos; ++
i)
980 for (
j = 0;
j < nconss; ++
j)
987 if ( slackvar ==
var )
1015 if (
i == nbdchginfos )
1126#ifdef SCIP_ENABLE_IISCHECK
1169 for (
c = 0;
c < nconss; ++
c)
1185 SCIP_Real
sign = 1.0;
1196 lincons = consdata->lincons;
1201 slackvar = consdata->slackvar;
1209 SCIP_Real scalar = 1.0;
1210 SCIP_Real constant = 0.0;
1253 for (v = 0; v < nlinvars; ++v)
1260 if (
var == slackvar )
1273 newvars[nnewvars++] =
var;
1291 for (v = 0; v < nnewvars; ++v)
1305 for (v = nnewvars - 1; v >= 0; --v)
1317 for (v = 0; v < nlinvars; ++v)
1324 if (
var == slackvar )
1354 if ( conshdlrdata->useotherconss )
1361 for (
c = 0;
c < nconss; ++
c)
1405 for (v = 0; v < nlinvars; ++v)
1421 newvars[nnewvars++] =
var;
1439 for (v = 0; v < nnewvars; ++v)
1453 for (v = nnewvars - 1; v >= 0; --v)
1464 for (v = 0; v < nlinvars; ++v)
1550 assert( conshdlrdata->naddlincons <= conshdlrdata->maxaddlincons );
1552 if ( num > conshdlrdata->maxaddlincons )
1558 conshdlrdata->maxaddlincons =
newsize;
1582 SCIP_Real lhs = -1.0;
1583 SCIP_Real rhs = -1.0;
1606 conshdlrdata->nrows = 1;
1653 for (
j = 0;
j < nconss; ++
j)
1661 ind = consdata->colindex;
1714 int* indices =
NULL;
1724 for (
j = 0;
j < nconss; ++
j)
1732 if ( consdata->colindex >= 0 )
1738 obj[cnt] = 1.0 - val;
1739 indices[cnt++] = consdata->colindex;
1766 int* indices =
NULL;
1776 for (
j = 0;
j < nconss; ++
j)
1784 if ( consdata->colindex >= 0 )
1787 indices[cnt++] = consdata->colindex;
1813 SCIP_Real* lb =
NULL;
1814 SCIP_Real* ub =
NULL;
1815 int* indices =
NULL;
1828 for (
j = 0;
j < nconss; ++
j)
1836 if ( consdata->colindex >= 0 )
1840 indices[cnt] = consdata->colindex;
1905 SCIP_Real* lb =
NULL;
1906 SCIP_Real* ub =
NULL;
1907 int* indices =
NULL;
1920 for (
j = 0;
j < nconss; ++
j)
1930 if ( consdata->colindex >= 0 )
1932 indices[cnt] = consdata->colindex;
1972 altlp = conshdlrdata->altlp;
1973 lbhash = conshdlrdata->lbhash;
1974 ubhash = conshdlrdata->ubhash;
1982 for (v = 0; v <
nvars; ++v)
2008 conshdlrdata->scaled =
FALSE;
2036 altlp = conshdlrdata->altlp;
2037 lbhash = conshdlrdata->lbhash;
2038 ubhash = conshdlrdata->ubhash;
2046 for (v = 0; v <
nvars; ++v)
2108 lbhash = conshdlrdata->lbhash;
2109 ubhash = conshdlrdata->ubhash;
2117 for (v = 0; v <
nvars; ++v)
2178 if ( ! conshdlrdata->scaled )
2183 SCIP_Real sum = 0.0;
2189 altlp = conshdlrdata->altlp;
2199 for (
j = 0;
j < cnt; ++
j)
2203 sum = -
REALABS(sum) / ((double) cnt);
2211 conshdlrdata->scaled =
TRUE;
2264 if ( conshdlrdata->altlp ==
NULL )
2278 assert( nrows == conshdlrdata->nrows );
2305 for (v = 0; v <
nvars; ++v)
2316 if (
var != slackvar )
2330 matind[cnt] = (conshdlrdata->nrows)++;
2350 matind[cnt] = (conshdlrdata->nrows)++;
2354 newvars[nnewvars++] =
var;
2402 for (v = 0; v < nnewvars; ++v)
2421 obj[nnewcols] = 0.0;
2424 ++conshdlrdata->nlbbounds;
2428 SCIPdebugMsg(
scip,
"Added column for lower bound (%f) of variable <%s> to alternative polyhedron (col: %d).\n",
2447 obj[nnewcols] = 0.0;
2450 ++conshdlrdata->nubbounds;
2454 SCIPdebugMsg(
scip,
"Added column for upper bound (%f) of variable <%s> to alternative polyhedron (col: %d).\n",
2468 assert( cnt == ncols + nnewcols + 1 );
2480 conshdlrdata->scaled =
FALSE;
2527 SCIP_Real scalar = 1.0;
2528 SCIP_Real constant = 0.0;
2534 SCIPdebugMsg(
scip,
"Slack variable is aggregated (scalar: %f, constant: %f).\n", scalar, constant);
2567 SCIP_CALL(
addAltLPColumn(
scip, conshdlr, conshdlrdata, slackvar, nlinvars, linvars,
linvals,
linrhs,
objcoef, 1.0,
TRUE, colindex) );
2572 SCIP_CALL(
addAltLPColumn(
scip, conshdlr, conshdlrdata, slackvar, nlinvars, linvars,
linvals,
linrhs,
objcoef, 1.0,
FALSE, colindex) );
2578 SCIP_CALL(
addAltLPColumn(
scip, conshdlr, conshdlrdata, slackvar, nlinvars, linvars,
linvals,
linlhs,
objcoef, -1.0,
FALSE, colindex) );
2647 SCIP_CALL(
addAltLPColumn(
scip, conshdlr, conshdlrdata,
NULL,
nrowcols,
rowvars,
rowvals,
rowrhs,
objcoef, 1.0,
TRUE, colindex) );
2652 SCIP_CALL(
addAltLPColumn(
scip, conshdlr, conshdlrdata,
NULL,
nrowcols,
rowvars,
rowvals,
rowrhs,
objcoef, 1.0,
FALSE, colindex) );
2658 SCIP_CALL(
addAltLPColumn(
scip, conshdlr, conshdlrdata,
NULL,
nrowcols,
rowvars,
rowvals,
rowlhs,
objcoef, -1.0,
FALSE, colindex) );
2690 if ( conshdlrdata->objcutindex >= 0 )
2694 if ( ! conshdlrdata->objothervarsonly )
2698 SCIPdebugMsg(
scip,
"Add objective cut to alternative LP (obj. bound: %g).\n", conshdlrdata->objupperbound);
2705 for (v = 0; v <
nvars; ++v)
2717 objvars[nobjvars] =
var;
2723 SCIP_CALL(
addAltLPColumn(
scip, conshdlr, conshdlrdata,
NULL, nobjvars, objvars,
objvals, conshdlrdata->objupperbound, 0.0, 1.0,
FALSE, &conshdlrdata->objcutindex) );
2724 assert( conshdlrdata->objcutindex >= 0 );
2725 conshdlrdata->objaltlpbound = conshdlrdata->objupperbound;
2755 if ( conshdlrdata->altlp !=
NULL )
2762 if ( consdata->colindex >= 0 )
2766 consdata->colindex = -1;
2770 conshdlrdata->scaled =
FALSE;
2789 if ( ! conshdlrdata->useobjectivecut )
2792 if ( conshdlrdata->altlp ==
NULL )
2805 conshdlrdata->objupperbound =
objbnd;
2812 if (
SCIPisLT(
scip, conshdlrdata->objupperbound, conshdlrdata->objaltlpbound) )
2814 SCIPdebugMsg(
scip,
"Update objective bound to %g.\n", conshdlrdata->objupperbound);
2817 if ( conshdlrdata->objcutindex < 0 )
2831 conshdlrdata->objaltlpbound = conshdlrdata->objupperbound;
2859 SCIP_Bool* infeasible,
2864 SCIP_Real condition;
2929 SCIPdebugMsg(
scip,
"Estimated condition number of basis matrix not available.\n");
2987 *infeasible =
FALSE;
3008 SCIP_Bool removable,
3009 SCIP_Bool genlogicor,
3048 SCIP_Bool infeasible;
3049 SCIP_Real sum = 0.0;
3052 SCIP_Real norm = 1.0;
3075 SCIPdebugMsg(
scip,
" size: %4d produced possible cover with indicator variable objective value %f.\n", *size, *value);
3078 if ( conshdlrdata->trysolfromcover )
3105 for (
j = 0;
j < nconss; ++
j)
3112 ind = consdata->colindex;
3152 switch ( conshdlrdata->normtype )
3167 SCIPerrorMessage(
"Invalid efficacy norm parameter '%c'.\n", conshdlrdata->normtype);
3172 SCIPdebugMsg(
scip,
" size: %4d, add var. %4d (obj: %-6g, alt-LP sol: %-8.4f); IIS size: %4d, eff.: %g.\n",
3188#ifdef SCIP_ENABLE_IISCHECK
3194 if ( conshdlrdata->updatebounds )
3209 for (
j = 0;
j < nconss; ++
j)
3215 ind = consdata->colindex;
3235 SCIP_CALL(
SCIPcreateConsLogicor(
scip, &cons, name, cnt,
vars,
FALSE,
TRUE,
TRUE,
TRUE,
TRUE,
isLocal,
FALSE,
TRUE, removable,
FALSE) );
3237 SCIP_CALL(
SCIPcreateConsLogicor(
scip, &cons,
"", cnt,
vars,
FALSE,
TRUE,
TRUE,
TRUE,
TRUE,
isLocal,
FALSE,
TRUE, removable,
FALSE) );
3289 for (
j = 0;
j < nconss; ++
j)
3295 ind = consdata->colindex;
3342 while (
step < nconss);
3358 const char* consname,
3362 SCIP_Bool activeone,
3363 SCIP_Bool lessthanineq,
3366 SCIP_Bool linconsactive
3390 (*consdata)->nfixednonzero = 0;
3391 (*consdata)->colindex = -1;
3392 (*consdata)->linconsactive = linconsactive;
3394 (*consdata)->slackvar = slackvar;
3395 (*consdata)->activeone = activeone;
3396 (*consdata)->lessthanineq = lessthanineq;
3397 (*consdata)->lincons = lincons;
3398 (*consdata)->implicationadded =
FALSE;
3399 (*consdata)->slacktypechecked =
FALSE;
3400 (*consdata)->varswithevents =
NULL;
3401 (*consdata)->eventtypes =
NULL;
3402 (*consdata)->nevents = 0;
3414 (*consdata)->binvar =
var;
3429 if ( conshdlrdata->forcerestart )
3437 ++((*consdata)->nfixednonzero);
3443 (*consdata)->slackvar =
var;
3446 if ( linconsactive )
3450 ++((*consdata)->nfixednonzero);
3461 SCIPdebugMsg(
scip,
"Added column for <%s> to alternative LP with column index %d.\n", consname, (*consdata)->colindex);
3469 if ( (*consdata)->nfixednonzero > 0 )
3471 SCIPdebugMsg(
scip,
"Constraint <%s> has %d variables fixed to be nonzero.\n", consname, (*consdata)->nfixednonzero);
3500 for (
c = 0;
c < nconss; ++
c)
3529 !conshdlrdata->removeindicators, !conshdlrdata->removeindicators,
FALSE) );
3535 if ( conshdlrdata->removeindicators )
3557 SCIP_Bool dualreductions,
3564 SCIP_Bool infeasible;
3588 SCIPdebugMsg(
scip,
"The problem is infeasible: binary and slack variable are fixed to be nonzero.\n");
3629 SCIPdebugMsg(
scip,
"The problem is infeasible: binary and slack variable are fixed to be nonzero.\n");
3635 SCIPdebugMsg(
scip,
"Fix binary variable to 0 and delete indicator constraint.\n");
3653 if ( dualreductions )
3659 binvar = consdata->binvar;
3719 var = consdata->binvar;
3729 assert( conshdlrdata->eventhdlrbound !=
NULL );
3736 if ( conshdlrdata->forcerestart )
3738 assert( conshdlrdata->eventhdlrrestart !=
NULL );
3740 conshdlrdata->eventhdlrrestart, (
SCIP_EVENTDATA*) conshdlrdata, -1) );
3749 consdata->binvar =
var;
3760 if (
var == consdata->slackvar )
3779 var = consdata->slackvar;
3792 assert( conshdlrdata->eventhdlrbound !=
NULL );
3803 consdata->slackvar =
var;
3805 else if (
var == consdata->binvar )
3813 SCIPdebugMsg(
scip,
"Slack variable <%s> is aggregated to negated indicator variable <%s> -> constraint redundant.\n",
3827 SCIPdebugMsg(
scip,
"Slack variable <%s> is aggregated to the indicator variable <%s> -> fix indicator variable to 0.\n",
3863 SCIP_Bool dualreductions,
3864 SCIP_Bool addopposite,
3869 SCIP_Bool infeasible;
3870 SCIP_Bool tightened;
3882 if ( ! consdata->linconsactive )
3896 if ( consdata->nfixednonzero > 1 )
3898 SCIPdebugMsg(
scip,
"The node is infeasible, both the slack variable and the binary variable are fixed to be nonzero.\n");
3923 if ( consdata->nfixednonzero == 1 )
3933 SCIPdebugMsg(
scip,
"Binary variable <%s> is fixed to be nonzero, fixing slack variable <%s> to 0.\n",
3950 SCIPdebugMsg(
scip,
"Slack variable <%s> is fixed to be nonzero, fixing binary variable <%s> to 0.\n",
3974 if ( addopposite && consdata->linconsactive )
4011 slackvar = consdata->slackvar;
4018 for (
j = 0;
j < nlinvars; ++
j)
4020 if ( linvars[
j] != slackvar )
4070 if ( dualreductions )
4076 binvar = consdata->binvar;
4152 SCIP_Real maxactivity;
4180 if (
var == consdata->slackvar )
4197 maxactivity += val * ub;
4209 newub = maxactivity - rhs;
4258 SCIP_Bool genlogicor,
4266 SCIP_Real value = 0.0;
4284 lp = conshdlrdata->altlp;
4292 if ( conshdlrdata->updatebounds )
4307 for (
j = 0;
j < nconss; ++
j)
4331 SCIP_CALL(
extendToCover(
scip, conshdlr, conshdlrdata, lp,
sol,
enfosepatype, conshdlrdata->removable, genlogicor, nconss, conss,
S, &size, &value, &
error,
cutoff, &
nCuts) );
4369 SCIP_Bool genlogicor,
4382 SCIP_Bool dualreductions;
4401 for (
c = 0;
c < nconss; ++
c)
4413 if ( ! consdata->linconsactive )
4435 binvar = consdata->binvar;
4468 conshdlrdata->niiscutsgen +=
ngen;
4475 conshdlrdata->niiscutsgen +=
ngen;
4501 if ( ! conshdlrdata->branchindicators )
4511 binvar = consdata->binvar;
4512 slackvar = consdata->slackvar;
4576 if ( *
nGen >= maxsepacuts )
4584 lp = conshdlrdata->altlp;
4594 if ( conshdlrdata->updatebounds )
4612 for (
threshold = conshdlrdata->roundingmaxthres;
4613 rounds < conshdlrdata->maxroundingrounds &&
threshold >= conshdlrdata->roundingminthres && *
nGen < maxsepacuts && ! (*cutoff);
4614 threshold -= conshdlrdata->roundingoffset )
4616 SCIP_Real value = 0.0;
4629 for (
j = 0;
j < nconss; ++
j)
4679 if ( size == nconss )
4688 SCIPdebugMsg(
scip,
"Skipping computation: size support has not changed.\n");
4782 if ( *
nGen >= maxsepacuts )
4793 for (
c = 0;
c < nconss; ++
c)
4804 slackvar = consdata->slackvar;
4806 lincons = consdata->lincons;
4809 binvar = consdata->binvar;
4846 for (
j = 0;
j < nlinvars; ++
j)
4851 SCIP_Real
din = 0.0;
4852 SCIP_Real
dout = 0.0;
4856 if ( linvars[
j] == slackvar )
4859 if ( conshdlrdata->sepapersplocal )
4923 SCIP_Bool infeasible;
4945 if ( *
nGen >= maxsepacuts )
4993 maxsepacuts = conshdlrdata->maxsepacutsroot;
4995 maxsepacuts = conshdlrdata->maxsepacuts;
4998 if ( conshdlrdata->sepacouplingcuts )
5020 if ( conshdlrdata->sepacouplinglocal )
5039 SCIP_Bool infeasible;
5069 SCIPdebugMsg(
scip,
"Number of separated coupling inequalities: %d.\n", ncuts);
5078 SCIPdebugMsg(
scip,
"Separating inequalities for indicator constraints.\n");
5092 conshdlrdata->niiscutsgen += ncuts;
5095 if ( conshdlrdata->genlogicor )
5107 SCIPdebugMsg(
scip,
"Separating inequalities based on perspective formulation.\n");
5119 conshdlrdata->nperspcutsgen += ncuts;
5139 conshdlrdata->linconsevents =
FALSE;
5140 conshdlrdata->linconsboundschanged =
TRUE;
5141 conshdlrdata->boundhaschanged =
TRUE;
5142 conshdlrdata->removable =
TRUE;
5143 conshdlrdata->scaled =
FALSE;
5144 conshdlrdata->altlp =
NULL;
5145 conshdlrdata->nrows = 0;
5146 conshdlrdata->varhash =
NULL;
5147 conshdlrdata->slackhash =
NULL;
5148 conshdlrdata->lbhash =
NULL;
5149 conshdlrdata->ubhash =
NULL;
5150 conshdlrdata->nlbbounds = 0;
5151 conshdlrdata->nubbounds = 0;
5152 conshdlrdata->nslackvars = 0;
5153 conshdlrdata->objcutindex = -1;
5156 conshdlrdata->roundingminthres = 0.1;
5157 conshdlrdata->roundingmaxthres = 0.6;
5159 conshdlrdata->roundingoffset = 0.1;
5160 conshdlrdata->addedcouplingcons =
FALSE;
5161 conshdlrdata->ninitconss = 0;
5162 conshdlrdata->nbinvarszero = 0;
5163 conshdlrdata->performedrestart =
FALSE;
5164 conshdlrdata->objindicatoronly =
FALSE;
5165 conshdlrdata->objothervarsonly =
FALSE;
5166 conshdlrdata->minabsobj = 0.0;
5167 conshdlrdata->normtype =
'e';
5168 conshdlrdata->niiscutsgen = 0;
5169 conshdlrdata->nperspcutsgen = 0;
5190 SCIP_Real minactivity = 0.0;
5191 SCIP_Real maxactivity = 0.0;
5192 SCIP_Real maxabsval = -1.0;
5216 if ( ! conshdlrdata->upgradelinear )
5260 minactivity += val * lb;
5269 maxactivity += val * ub;
5273 assert( maxabsval >= 0.0 );
5354 if (
vars[
l] == indvar )
5447 if ( conshdlrdata->trysolutions && conshdlrdata->heurtrysol ==
NULL )
5471 if ( conshdlrdata->binvarhash !=
NULL )
5474 if ( conshdlrdata->binslackvarhash !=
NULL )
5478 for (
i = 0;
i < nconss;
i++)
5483 if ( consdata->varswithevents !=
NULL )
5488 for (
j = 0;
j < consdata->nevents; ++
j)
5495 consdata->nevents = 0;
5502 conshdlrdata->maxaddlincons = 0;
5503 conshdlrdata->naddlincons = 0;
5504 conshdlrdata->nrows = 0;
5528 if ( conshdlrdata->maxaddlincons > 0 )
5534 conshdlrdata->naddlincons = 0;
5535 conshdlrdata->maxaddlincons = 0;
5564 conshdlrdata->boundhaschanged =
TRUE;
5568 if ( conshdlrdata->sepaalternativelp )
5575 for (
c = 0;
c < nconss; ++
c)
5591 ++conshdlrdata->nslackvars;
5594 if ( conshdlrdata->genlogicor )
5604 SCIPerrorMessage(
"Logicor constraint handler not included, cannot generate constraints.\n");
5609 if ( (sepafreq != -1 || conshdlrdata->enforcecuts) &&
logicorsepafreq != 1 )
5611 SCIPwarningMessage(
scip,
"For better performance set parameter 'constraints/logicor/sepafreq' to 1 if 'constraints/included/genlogicor' is true.\n");
5617 conshdlrdata->objothervarsonly =
TRUE;
5618 for (
c = 0;
c < nconss; ++
c)
5634 conshdlrdata->objothervarsonly =
FALSE;
5637 if ( ! consdata->linconsactive )
5644 if ( conshdlrdata->sepaalternativelp && consdata->colindex < 0 )
5671 SCIP_CALL(
SCIPcreateNlRow(
scip, &nlrow,
SCIPconsGetName(conss[
c]), 0.0, 0,
NULL,
NULL,
quadexpr, 0.0, 0.0,
SCIP_EXPRCURV_UNKNOWN) );
5686 if ( conshdlrdata->sepaalternativelp )
5693 if ( conshdlrdata->naddlincons > 0 )
5695 for (
c = 0;
c < conshdlrdata->naddlincons; ++
c)
5697 cons = conshdlrdata->addlincons[
c];
5716 SCIPdebugMsg(
scip,
"Added %d additional columns to alternative LP.\n", cnt);
5723 if ( conshdlrdata->useotherconss )
5755 SCIPdebugMsg(
scip,
"Added %d additional columns from linear constraints to alternative LP.\n", cnt);
5761 if ( conshdlrdata->forcerestart )
5768 assert( conshdlrdata->eventhdlrrestart !=
NULL );
5774 conshdlrdata->nbinvarszero = 0;
5780 conshdlrdata->objindicatoronly =
FALSE;
5789 for (
c = 0;
c < nconss; ++
c)
5814 if ( probindex < 0 )
5833 if (
REALABS(
obj) < conshdlrdata->minabsobj )
5847 conshdlrdata->objindicatoronly =
TRUE;
5849 assert( conshdlrdata->eventhdlrrestart !=
NULL );
5875 if ( conshdlrdata->sepaalternativelp )
5877 if ( conshdlrdata->slackhash !=
NULL )
5886 if ( conshdlrdata->altlp !=
NULL )
5908 for (
c = 0;
c < nconss; ++
c)
5917 consdata->colindex = -1;
5943#ifdef SCIP_MORE_DEBUG
5958 if ( conshdlrdata->binslackvarhash !=
NULL )
5971 if ( conshdlrdata->sepaalternativelp )
5982 if ( (*consdata)->linconsactive )
5984 assert( conshdlrdata->eventhdlrbound !=
NULL );
5990 if ( conshdlrdata->forcerestart )
5992 assert( conshdlrdata->eventhdlrrestart !=
NULL );
5998 if ( conshdlrdata->linconsevents && (*consdata)->linconsactive && (*consdata)->varswithevents !=
NULL )
6005 for (
j = 0;
j < (*consdata)->nevents; ++
j)
6013 (*consdata)->nevents = 0;
6014 assert( (*consdata)->varswithevents ==
NULL );
6058 assert( conshdlrdata->eventhdlrbound !=
NULL );
6060#ifdef SCIP_MORE_DEBUG
6115 if ( conshdlrdata->sepaalternativelp )
6117 if ( conshdlrdata->binvarhash ==
NULL )
6151 for (
c = 0;
c < nconss; ++
c)
6184 conshdlrdata->addedcouplingcons =
FALSE;
6229 for (
c = 0;
c < nconss; ++
c)
6244#ifdef SCIP_MORE_DEBUG
6249 if ( ! consdata->linconsactive )
6258 if ( ! consdata->implicationadded )
6267 consdata->implicationadded =
TRUE;
6276 if ( ! consdata->slacktypechecked )
6278 consdata->slacktypechecked =
TRUE;
6293 slackvar = consdata->slackvar;
6298 if (
vars[
j] == slackvar )
6309 SCIP_Bool infeasible;
6325 SCIPdebugMsg(
scip,
"Cannot change type of slack variable (<%s>) to IMPLINT, since global bound is non-integral: (%g, %g).\n",
6361 *nupgdconss +=
ngen;
6362 if ( conshdlrdata->removeindicators )
6365 conshdlrdata->addedcouplingcons =
TRUE;
6368 SCIPdebug(
SCIPdebugMsg(
scip,
"Presolved %d constraints (fixed %d variables, removed 0 variables, and deleted %d constraints).\n",
6394 *infeasible =
FALSE;
6397 if ( ! conshdlrdata->addcoupling )
6401 if ( conshdlrdata->addcouplingcons && conshdlrdata->addedcouplingcons )
6404 SCIPdebugMsg(
scip,
"Handle initial rows for %d indicator constraints.\n", nconss);
6407 for (
c = 0;
c < nconss && !(*infeasible); ++
c)
6418 if ( ! consdata->linconsactive )
6437 if ( conshdlrdata->addcouplingcons )
6441 assert( ! conshdlrdata->addedcouplingcons );
6626 for (
c = 0;
c < nconss; ++
c)
6636 if ( ! consdata->linconsactive )
6668 if ( trysol !=
NULL )
6684 if ( trysol !=
NULL )
6697 SCIP_Bool infeasible;
6701 lp = conshdlrdata->altlp;
6702 assert( conshdlrdata->sepaalternativelp );
6712 if ( conshdlrdata->updatebounds )
6726 for (
c = 0;
c < nconss; ++
c)
6778 if ( trysol !=
NULL )
6799 SCIP_Bool dualreductions;
6827 if ( !conshdlrdata->linconsevents )
6829 for (
c = 0;
c < nconss; ++
c)
6842 if ( ! consdata->linconsactive )
6866 if (
vars[
j] == consdata->slackvar )
6870 if ( vals[
j] > 0.0 )
6873 consdata->varswithevents[consdata->nevents] =
vars[
j];
6875 consdata->nevents++;
6880 consdata->varswithevents[consdata->nevents] =
vars[
j];
6882 consdata->nevents++;
6887 conshdlrdata->linconsevents =
TRUE;
6891 conshdlrdata->boundhaschanged =
FALSE;
6892 conshdlrdata->linconsboundschanged =
FALSE;
6897 for (
c = 0;
c < nconss; ++
c)
6911#ifdef SCIP_MORE_DEBUG
6956 assert( inferinfo == 0 || inferinfo == 1 || inferinfo == 2 || inferinfo == 3 );
6957 assert( consdata->linconsactive );
6960 if ( inferinfo == 0 )
6967 else if ( inferinfo == 1 )
6976 else if ( inferinfo == 2 )
6984 assert( inferinfo == 3 );
7013#ifdef SCIP_MORE_DEBUG
7019 if ( consdata->linconsactive )
7043 for (
j = 0;
j < nlinvars; ++
j)
7092 binvar = consdata->binvar;
7120 const char* consname;
7134#ifdef SCIP_MORE_DEBUG
7220 initial, separate, enforce, check,
propagate, local, dynamic, removable, stickingatnode) );
7273 if ( binvar ==
NULL )
7285 if ( slackvar ==
NULL )
7296 if ( lincons ==
NULL )
7329 if ( lincons ==
NULL )
7335 if ( lincons ==
NULL )
7341 if( lincons ==
NULL )
7363 initial, separate, enforce, check,
propagate, local, dynamic, removable, stickingatnode) );
7381#ifdef SCIP_MORE_DEBUG
7391 if ( conshdlrdata->altlp !=
NULL )
7393 assert( conshdlrdata->sepaalternativelp );
7395 if ( consdata->colindex >= 0 )
7416#ifdef SCIP_MORE_DEBUG
7423 if ( conshdlrdata->altlp !=
NULL )
7429 assert( conshdlrdata->sepaalternativelp );
7431 if ( consdata->colindex >= 0 )
7467 if ( consdata->binvar !=
NULL )
7472 if ( consdata->slackvar !=
NULL )
7511 if ( consdata->binvar !=
NULL )
7513 if ( consdata->slackvar !=
NULL )
7551 *infeasible =
FALSE;
7557 for (
c = 0;
c < nindconss; ++
c)
7635 conshdlrdata->eventhdlrbound =
NULL;
7638 assert(conshdlrdata->eventhdlrbound !=
NULL);
7641 conshdlrdata->eventhdlrlinconsbound =
NULL;
7644 assert(conshdlrdata->eventhdlrlinconsbound !=
NULL);
7647 conshdlrdata->eventhdlrrestart =
NULL;
7650 assert( conshdlrdata->eventhdlrrestart !=
NULL );
7652 conshdlrdata->heurtrysol =
NULL;
7656 conshdlrdata->binvarhash =
NULL;
7657 conshdlrdata->binslackvarhash =
NULL;
7665 conshdlrdata->addlincons =
NULL;
7666 conshdlrdata->naddlincons = 0;
7667 conshdlrdata->maxaddlincons = 0;
7714 conflicthdlrdata->conshdlrdata = conshdlrdata;
7715 conflicthdlrdata->conshdlr = conshdlr;
7716 assert( conflicthdlrdata->conshdlr !=
NULL );
7726 "constraints/indicator/branchindicators",
7727 "Branch on indicator constraints in enforcing?",
7731 "constraints/indicator/genlogicor",
7732 "Generate logicor constraints instead of cuts?",
7736 "constraints/indicator/addcoupling",
7737 "Add coupling constraints or rows if big-M is small enough?",
7741 "constraints/indicator/maxcouplingvalue",
7742 "maximum coefficient for binary variable in coupling constraint",
7746 "constraints/indicator/addcouplingcons",
7747 "Add initial variable upper bound constraints, if 'addcoupling' is true?",
7751 "constraints/indicator/sepacouplingcuts",
7752 "Should the coupling inequalities be separated dynamically?",
7756 "constraints/indicator/sepacouplinglocal",
7757 "Allow to use local bounds in order to separate coupling inequalities?",
7761 "constraints/indicator/sepacouplingvalue",
7762 "maximum coefficient for binary variable in separated coupling constraint",
7766 "constraints/indicator/sepaperspective",
7767 "Separate cuts based on perspective formulation?",
7771 "constraints/indicator/sepapersplocal",
7772 "Allow to use local bounds in order to separate perspective cuts?",
7776 "constraints/indicator/maxsepanonviolated",
7777 "maximal number of separated non violated IISs, before separation is stopped",
7781 "constraints/indicator/updatebounds",
7782 "Update bounds of original variables for separation?",
7786 "constraints/indicator/maxconditionaltlp",
7787 "maximum estimated condition of the solution basis matrix of the alternative LP to be trustworthy (0.0 to disable check)",
7791 "constraints/indicator/maxsepacuts",
7792 "maximal number of cuts separated per separation round",
7796 "constraints/indicator/maxsepacutsroot",
7797 "maximal number of cuts separated per separation round in the root node",
7801 "constraints/indicator/removeindicators",
7802 "Remove indicator constraint if corresponding variable bound constraint has been added?",
7806 "constraints/indicator/generatebilinear",
7807 "Do not generate indicator constraint, but a bilinear constraint instead?",
7811 "constraints/indicator/scaleslackvar",
7812 "Scale slack variable coefficient at construction time?",
7816 "constraints/indicator/trysolutions",
7817 "Try to make solutions feasible by setting indicator variables?",
7821 "constraints/indicator/enforcecuts",
7822 "In enforcing try to generate cuts (only if sepaalternativelp is true)?",
7826 "constraints/indicator/dualreductions",
7827 "Should dual reduction steps be performed?",
7831 "constraints/indicator/addopposite",
7832 "Add opposite inequality in nodes in which the binary variable has been fixed to 0?",
7836 "constraints/indicator/conflictsupgrade",
7837 "Try to upgrade bounddisjunction conflicts by replacing slack variables?",
7841 "constraints/indicator/restartfrac",
7842 "fraction of binary variables that need to be fixed before restart occurs (in forcerestart)",
7846 "constraints/indicator/useotherconss",
7847 "Collect other constraints to alternative LP?",
7851 "constraints/indicator/useobjectivecut",
7852 "Use objective cut with current best solution to alternative LP?",
7856 "constraints/indicator/trysolfromcover",
7857 "Try to construct a feasible solution from a cover?",
7861 "constraints/indicator/upgradelinear",
7862 "Try to upgrade linear constraints to indicator constraints?",
7867 "constraints/indicator/sepaalternativelp",
7868 "Separate using the alternative LP?",
7872 "constraints/indicator/forcerestart",
7873 "Force restart if absolute gap is 1 or enough binary variables have been fixed?",
7877 "constraints/indicator/nolinconscont",
7878 "Decompose problem (do not generate linear constraint if all variables are continuous)?",
7914 SCIP_Bool removable,
7916 SCIP_Bool stickingatnode
7921 return SCIPcreateConsIndicatorGeneric(
scip, cons, name, binvar,
nvars,
vars, vals, rhs,
TRUE,
TRUE, initial,
7922 separate, enforce, check,
propagate, local, dynamic, removable, stickingatnode);
7941 SCIP_Bool activeone,
7942 SCIP_Bool lessthanineq,
7957 SCIP_Bool removable,
7959 SCIP_Bool stickingatnode
7969 SCIP_Bool modifiable =
FALSE;
7970 SCIP_Bool linconsactive =
TRUE;
7979 SCIPerrorMessage(
"Indicator constraint <%s> needs nonnegative number of variables in linear constraint.\n", name);
7985 if ( conshdlr ==
NULL )
7994 if ( conshdlrdata->nolinconscont && ! conshdlrdata->sepaalternativelp )
7996 SCIPerrorMessage(
"constraint handler <%s>: need parameter <sepaalternativelp> to be true if parameter <nolinconscont> is true.\n",
CONSHDLR_NAME);
8000 if ( conshdlrdata->nolinconscont && conshdlrdata->generatebilinear )
8023 if ( conshdlrdata->scaleslackvar )
8028 if ( ! conshdlrdata->scaleslackvar )
8034 if ( binvar !=
NULL )
8047 if ( conshdlrdata->binslackvarhash ==
NULL )
8052 assert( conshdlrdata->binslackvarhash !=
NULL );
8055 SCIP_Bool infeasible;
8098 if ( conshdlrdata->nolinconscont )
8102 assert( ! conshdlrdata->generatebilinear );
8118 linconsactive =
FALSE;
8125 if ( linconsactive )
8138 if ( ! lessthanineq )
8146 if ( conshdlrdata->scaleslackvar &&
nvars > 0 )
8162 if ( conshdlrdata->generatebilinear )
8164 SCIP_Real val = 1.0;
8176 SCIP_CALL(
SCIPcreateConsQuadraticNonlinear(
scip, cons, name, 0,
NULL,
NULL, 1, &
binvarinternal, &slackvar, &val, 0.0, 0.0,
8183 binvar, activeone, lessthanineq, slackvar, lincons, linconsactive) );
8188 SCIP_CALL(
SCIPcreateCons(
scip, cons, name, conshdlr, consdata, initial, separate, enforce, check,
propagate,
8189 local, modifiable, dynamic, removable, stickingatnode) );
8194 if ( linconsactive )
8201 if ( conshdlrdata->sepaalternativelp )
8205 if ( conshdlrdata->binvarhash ==
NULL )
8279 SCIP_Bool activeone,
8294 SCIP_Bool removable,
8296 SCIP_Bool stickingatnode
8304 SCIP_Bool modifiable =
FALSE;
8305 SCIP_Bool linconsactive =
TRUE;
8322 if ( conshdlr ==
NULL )
8331 if ( conshdlrdata->nolinconscont && ! conshdlrdata->sepaalternativelp )
8333 SCIPerrorMessage(
"constraint handler <%s>: need parameter <sepaalternativelp> to be true if parameter <nolinconscont> is true.\n",
CONSHDLR_NAME);
8341 if ( conshdlrdata->nolinconscont )
8352 for (v = 0; v <
nvars; ++v)
8365 linconsactive =
FALSE;
8373 if ( conshdlrdata->generatebilinear )
8375 SCIP_Real val = 1.0;
8389 SCIP_CALL(
SCIPcreateConsQuadraticNonlinear(
scip, cons, name, 0,
NULL,
NULL, 1, &
binvarinternal, &slackvar, &val, 0.0, 0.0,
8396 binvar, activeone,
TRUE, slackvar, lincons, linconsactive) );
8400 SCIP_CALL(
SCIPcreateCons(
scip, cons, name, conshdlr, consdata, initial, separate, enforce, check,
propagate,
8401 local, modifiable, dynamic, removable, stickingatnode) );
8449 SCIP_Bool removable,
8451 SCIP_Bool stickingatnode
8457 enforce, check,
propagate, local, dynamic, removable, stickingatnode);
8514 SCIP_Bool activeone,
8529 SCIP_Bool removable,
8531 SCIP_Bool stickingatnode
8540 SCIP_Bool modifiable =
FALSE;
8541 SCIP_Bool linconsactive =
TRUE;
8567 if ( conshdlr ==
NULL )
8576 if ( conshdlrdata->nolinconscont && ! conshdlrdata->sepaalternativelp )
8578 SCIPerrorMessage(
"constraint handler <%s>: need parameter <sepaalternativelp> to be true if parameter <nolinconscont> is true.\n",
CONSHDLR_NAME);
8613 if ( conshdlrdata->binslackvarhash ==
NULL )
8618 assert( conshdlrdata->binslackvarhash !=
NULL );
8628 SCIP_Bool infeasible;
8652 if ( conshdlrdata->nolinconscont )
8673 linconsactive =
FALSE;
8689 if ( conshdlrdata->generatebilinear )
8691 SCIP_Real val = 1.0;
8694 SCIP_CALL(
SCIPcreateConsQuadraticNonlinear(
scip, cons, name, 0,
NULL,
NULL, 1, &
binvarinternal, &slackvar, &val, 0.0, 0.0,
8701 binvar, activeone,
TRUE, slackvar, lincons, linconsactive) );
8705 SCIP_CALL(
SCIPcreateCons(
scip, cons, name, conshdlr, consdata, initial, separate, enforce, check,
propagate,
8706 local, modifiable, dynamic, removable, stickingatnode) );
8752 SCIP_Bool removable,
8754 SCIP_Bool stickingatnode
8760 enforce, check,
propagate, local, dynamic, removable, stickingatnode);
8781 if ( !consdata->lessthanineq )
8789 SCIP_Bool infeasible;
8812 return consdata->lincons;
8849 consdata->lincons = lincons;
8850 consdata->linconsactive =
TRUE;
8854 if ( conshdlrdata->nolinconscont )
8867 for (v = 0; v <
nvars; ++v)
8880 consdata->linconsactive =
FALSE;
8899 return consdata->activeone;
8916 return consdata->binvar;
8932 binvar = consdata->binvar;
8934 if ( ! consdata->activeone )
8965 if ( consdata->binvar !=
NULL )
8983 if ( ! consdata->activeone )
8986 consdata->binvar =
var;
8993 assert( conshdlrdata->eventhdlrbound !=
NULL );
8994 assert( conshdlrdata->eventhdlrrestart !=
NULL );
8997 if ( consdata->linconsactive )
9003 if ( conshdlrdata->forcerestart )
9010 ++(consdata->nfixednonzero);
9014 if ( ! consdata->activeone )
9016 consdata->binvar = binvar;
9035 return consdata->slackvar;
9091 if ( consdata->linconsactive )
9165 if ( ! consdata->linconsactive )
9168 lincons = consdata->lincons;
9174 slackvar = consdata->slackvar;
9175 binvar = consdata->binvar;
9186 for (v = 0; v < nlinvars; ++v)
9190 if (
var != slackvar )
9329 for (
c = 0;
c < nconss; ++
c)
9339 if ( ! consdata->linconsactive )
9343 *changed = *changed ||
chg;
9370 assert( conshdlrdata->naddlincons+1 <= conshdlrdata->maxaddlincons );
9372 conshdlrdata->addlincons[conshdlrdata->naddlincons++] = lincons;
9403 if ( ! conshdlrdata->sepaalternativelp )
static SCIP_RETCODE branchCons(SCIP *scip, SCIP_CONS *cons, SCIP_RESULT *result)
#define DEFAULT_FORCERESTART
#define DEFAULT_TRYSOLUTIONS
#define EVENTHDLR_RESTART_NAME
static SCIP_RETCODE addAltLPRow(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_ROW *row, SCIP_Real objcoef, int *colindex)
#define CONSHDLR_NEEDSCONS
#define CONSHDLR_SEPAFREQ
#define CONFLICTHDLR_PRIORITY
#define SCIP_CALL_PARAM(x)
#define CONFLICTHDLR_NAME
#define CONSHDLR_CHECKPRIORITY
#define DEFAULT_ADDCOUPLINGCONS
#define MAXROUNDINGROUNDS
#define DEFAULT_ADDOPPOSITE
static SCIP_RETCODE checkLPBoundsClean(SCIP *scip, SCIP_LPI *lp, int nconss, SCIP_CONS **conss)
static SCIP_RETCODE propIndicator(SCIP *scip, SCIP_CONS *cons, SCIP_CONSDATA *consdata, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_Bool dualreductions, SCIP_Bool addopposite, SCIP_Bool *cutoff, int *nGen)
static SCIP_RETCODE updateFirstRowGlobal(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata)
static SCIP_RETCODE fixAltLPVariables(SCIP *scip, SCIP_LPI *lp, int nconss, SCIP_CONS **conss, SCIP_Bool *S)
static SCIP_RETCODE createVarUbs(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_CONS **conss, int nconss, int *ngen)
#define CONSHDLR_PROP_TIMING
#define DEFAULT_USEOBJECTIVECUT
static SCIP_RETCODE addAltLPConstraint(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *lincons, SCIP_VAR *slackvar, SCIP_Real objcoef, int *colindex)
static SCIP_RETCODE extendToCover(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_LPI *lp, SCIP_SOL *sol, SCIP_ENFOSEPATYPE enfosepatype, SCIP_Bool removable, SCIP_Bool genlogicor, int nconss, SCIP_CONS **conss, SCIP_Bool *S, int *size, SCIP_Real *value, SCIP_Bool *error, SCIP_Bool *cutoff, int *nGen)
#define CONFLICTHDLR_DESC
static SCIP_RETCODE scaleFirstRow(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata)
static SCIP_RETCODE separateIISRounding(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_SOL *sol, SCIP_ENFOSEPATYPE enfosepatype, int nconss, SCIP_CONS **conss, int maxsepacuts, SCIP_Bool *cutoff, int *nGen)
static SCIP_Real varGetObjDelta(SCIP_VAR *var)
#define CONSHDLR_MAXPREROUNDS
static SCIP_RETCODE addAltLPColumn(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_VAR *slackvar, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Real rhscoef, SCIP_Real objcoef, SCIP_Real sign, SCIP_Bool colfree, int *colindex)
#define DEFAULT_MAXCONDITIONALTLP
static SCIP_RETCODE presolRoundIndicator(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_CONS *cons, SCIP_CONSDATA *consdata, SCIP_Bool dualreductions, SCIP_Bool *cutoff, SCIP_Bool *success, int *ndelconss, int *nfixedvars)
#define DEFAULT_SCALESLACKVAR
static SCIP_RETCODE checkAltLPInfeasible(SCIP *scip, SCIP_LPI *lp, SCIP_Real maxcondition, SCIP_Bool primal, SCIP_Bool *infeasible, SCIP_Bool *error)
#define CONSHDLR_SEPAPRIORITY
static SCIP_RETCODE setAltLPObj(SCIP *scip, SCIP_LPI *lp, SCIP_SOL *sol, int nconss, SCIP_CONS **conss)
static SCIP_RETCODE checkIISlocal(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_Real *vector, SCIP_Bool *isLocal)
#define DEFAULT_SEPAPERSPLOCAL
static SCIP_RETCODE unfixAltLPVariables(SCIP *scip, SCIP_LPI *lp, int nconss, SCIP_CONS **conss, SCIP_Bool *S)
static SCIP_RETCODE separatePerspective(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_SOL *sol, int nconss, SCIP_CONS **conss, int maxsepacuts, int *nGen)
#define DEFAULT_SEPAPERSPECTIVE
static SCIP_RETCODE enforceCuts(SCIP *scip, SCIP_CONSHDLR *conshdlr, int nconss, SCIP_CONS **conss, SCIP_SOL *sol, SCIP_ENFOSEPATYPE enfosepatype, SCIP_Bool genlogicor, SCIP_Bool *cutoff, int *nGen)
#define DEFAULT_CONFLICTSUPGRADE
static SCIP_RETCODE initAlternativeLP(SCIP *scip, SCIP_CONSHDLR *conshdlr)
#define DEFAULT_MAXCOUPLINGVALUE
#define DEFAULT_SEPACOUPLINGVALUE
static SCIP_RETCODE addSymmetryInformation(SCIP *scip, SYM_SYMTYPE symtype, SCIP_CONS *cons, SYM_GRAPH *graph, SCIP_Bool *success)
#define DEFAULT_REMOVEINDICATORS
#define DEFAULT_UPGRADELINEAR
#define EVENTHDLR_LINCONSBOUND_DESC
#define DEFAULT_MAXSEPACUTSROOT
static SCIP_RETCODE updateObjUpperbound(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONSHDLRDATA *conshdlrdata)
static SCIP_RETCODE checkTransferBoolParam(SCIP *scip, SCIP_PARAM *param, const char *name, SCIP_Bool newvalue, SCIP_Bool *value)
#define EVENTHDLR_BOUND_DESC
static SCIP_RETCODE separateIndicators(SCIP *scip, SCIP_CONSHDLR *conshdlr, int nconss, int nusefulconss, SCIP_CONS **conss, SCIP_SOL *sol, SCIP_ENFOSEPATYPE enfosepatype, SCIP_RESULT *result)
static SCIP_RETCODE fixAltLPVariable(SCIP_LPI *lp, int ind)
enum SCIP_enfosepatype SCIP_ENFOSEPATYPE
#define DEFAULT_SEPACOUPLINGLOCAL
#define EVENTHDLR_LINCONSBOUND_NAME
#define DEFAULT_UPDATEBOUNDS
#define DEFAULT_RESTARTFRAC
static SCIP_RETCODE enforceIndicators(SCIP *scip, SCIP_CONSHDLR *conshdlr, int nconss, SCIP_CONS **conss, SCIP_SOL *sol, SCIP_ENFOSEPATYPE enfosepatype, SCIP_Bool genlogicor, SCIP_RESULT *result)
#define CONSHDLR_PROPFREQ
#define DEFAULT_SEPAALTERNATIVELP
static void initConshdlrData(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata)
#define DEFAULT_ENFORCECUTS
#define CONSHDLR_PRESOLTIMING
static SCIP_RETCODE unfixAltLPVariable(SCIP_LPI *lp, int ind)
static SCIP_RETCODE consdataEnsureAddLinConsSize(SCIP *scip, SCIP_CONSHDLR *conshdlr, int num)
#define DEFAULT_MAXSEPACUTS
static SCIP_RETCODE setAltLPObjZero(SCIP *scip, SCIP_LPI *lp, int nconss, SCIP_CONS **conss)
#define EVENTHDLR_BOUND_NAME
#define DEFAULT_BRANCHINDICATORS
#define CONSHDLR_EAGERFREQ
static SCIP_RETCODE consdataCreate(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONSHDLRDATA *conshdlrdata, const char *consname, SCIP_CONSDATA **consdata, SCIP_EVENTHDLR *eventhdlrrestart, SCIP_VAR *binvar, SCIP_Bool activeone, SCIP_Bool lessthanineq, SCIP_VAR *slackvar, SCIP_CONS *lincons, SCIP_Bool linconsactive)
#define DEFAULT_USEOTHERCONSS
#define CONSHDLR_ENFOPRIORITY
#define DEFAULT_DUALREDUCTIONS
static SCIP_RETCODE deleteAltLPConstraint(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons)
#define LINCONSUPGD_PRIORITY
#define DEFAULT_GENERATEBILINEAR
#define CONSHDLR_DELAYSEPA
static SCIP_RETCODE addObjcut(SCIP *scip, SCIP_CONSHDLR *conshdlr)
#define DEFAULT_GENLOGICOR
#define DEFAULT_TRYSOLFROMCOVER
#define EVENTHDLR_RESTART_DESC
#define DEFAULT_MAXSEPANONVIOLATED
#define DEFAULT_ADDCOUPLING
#define DEFAULT_SEPACOUPLINGCUTS
static SCIP_RETCODE updateFirstRow(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata)
#define CONSHDLR_DELAYPROP
#define DEFAULT_NOLINCONSCONT
constraint handler for indicator constraints
Constraint handler for linear constraints in their most general form, .
Constraint handler for logicor constraints (equivalent to set covering, but algorithms are suited fo...
constraint handler for nonlinear constraints specified by algebraic expressions
Constraint handler for variable bound constraints .
#define SCIP_LONGINT_FORMAT
product expression handler
variable expression handler
SCIP_RETCODE SCIPcreateConsIndicatorGenericLinConsPure(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *binvar, SCIP_CONS *lincons, SCIP_Bool activeone, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)
SCIP_RETCODE SCIPcreateConsIndicatorLinCons(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *binvar, SCIP_CONS *lincons, SCIP_VAR *slackvar, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)
SCIP_RETCODE SCIPincludeLinconsUpgrade(SCIP *scip, SCIP_DECL_LINCONSUPGD((*linconsupgd)), int priority, const char *conshdlrname)
SCIP_RETCODE SCIPcreateConsBasicIndicator(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *binvar, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Real rhs)
SCIP_VAR * SCIPgetBinaryVarIndicatorGeneric(SCIP_CONS *cons)
SCIP_RETCODE SCIPsetSlackVarUb(SCIP *scip, SCIP_CONS *cons, SCIP_Real ub)
SCIP_Real SCIPgetRhsLinear(SCIP *scip, SCIP_CONS *cons)
SCIP_VAR ** SCIPgetVarsLinear(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPaddCoefLinear(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real val)
SCIP_RETCODE SCIPaddRowIndicator(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_ROW *row)
SCIP_Real SCIPgetLhsLinear(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPcreateConsIndicatorGeneric(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *binvar, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Real rhs, SCIP_Bool activeone, SCIP_Bool lessthanineq, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)
int SCIPgetNVarsLinear(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPaddLinearConsIndicator(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *lincons)
SCIP_RETCODE SCIPsetLinearConsIndicator(SCIP *scip, SCIP_CONS *cons, SCIP_CONS *lincons)
SCIP_RETCODE SCIPcreateConsIndicator(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *binvar, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Real rhs, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)
SCIP_Real * SCIPgetValsLinear(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPcreateConsIndicatorGenericLinCons(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *binvar, SCIP_CONS *lincons, SCIP_VAR *slackvar, SCIP_Bool activeone, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)
SCIP_RETCODE SCIPcreateConsBasicIndicatorLinCons(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *binvar, SCIP_CONS *lincons, SCIP_VAR *slackvar)
SCIP_RETCODE SCIPmakeIndicatorsFeasible(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_SOL *sol, SCIP_Bool *changed)
SCIP_VAR * SCIPgetBinaryVarIndicator(SCIP_CONS *cons)
#define SCIP_DECL_LINCONSUPGD(x)
SCIP_VAR * SCIPgetSlackVarIndicator(SCIP_CONS *cons)
SCIP_CONS * SCIPgetLinearConsIndicator(SCIP_CONS *cons)
SCIP_RETCODE SCIPcreateConsLinear(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)
SCIP_RETCODE SCIPcreateConsLogicor(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)
SCIP_RETCODE SCIPsetBinaryVarIndicator(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *binvar)
SCIP_RETCODE SCIPmakeIndicatorFeasible(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Bool *changed)
SCIP_RETCODE SCIPcreateConsVarbound(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *var, SCIP_VAR *vbdvar, SCIP_Real vbdcoef, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)
SCIP_RETCODE SCIPcreateConsQuadraticNonlinear(SCIP *scip, SCIP_CONS **cons, const char *name, int nlinvars, SCIP_VAR **linvars, SCIP_Real *lincoefs, int nquadterms, SCIP_VAR **quadvars1, SCIP_VAR **quadvars2, SCIP_Real *quadcoefs, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable)
SCIP_RETCODE SCIPcreateConsIndicatorLinConsPure(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *binvar, SCIP_CONS *lincons, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)
SCIP_Bool SCIPisViolatedIndicator(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol)
SCIP_RETCODE SCIPaddVarIndicator(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real val)
SCIP_Bool SCIPgetActiveOnIndicator(SCIP_CONS *cons)
SCIP_RETCODE SCIPincludeConshdlrIndicator(SCIP *scip)
SCIP_RETCODE SCIPgetConsCopy(SCIP *sourcescip, SCIP *targetscip, SCIP_CONS *sourcecons, SCIP_CONS **targetcons, SCIP_CONSHDLR *sourceconshdlr, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, const char *name, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode, SCIP_Bool global, SCIP_Bool *valid)
SCIP_RETCODE SCIPgetVarCopy(SCIP *sourcescip, SCIP *targetscip, SCIP_VAR *sourcevar, SCIP_VAR **targetvar, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, SCIP_Bool *success)
SCIP_RETCODE SCIPcreateExprVar(SCIP *scip, SCIP_EXPR **expr, SCIP_VAR *var, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)
SCIP_RETCODE SCIPcreateExprProduct(SCIP *scip, SCIP_EXPR **expr, int nchildren, SCIP_EXPR **children, SCIP_Real coefficient, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)
SCIP_Bool SCIPisTransformed(SCIP *scip)
SCIP_STATUS SCIPgetStatus(SCIP *scip)
SCIP_STAGE SCIPgetStage(SCIP *scip)
SCIP_RETCODE SCIPaddVar(SCIP *scip, SCIP_VAR *var)
int SCIPgetNIntVars(SCIP *scip)
SCIP_RETCODE SCIPgetVarsData(SCIP *scip, SCIP_VAR ***vars, int *nvars, int *nbinvars, int *nintvars, int *nimplvars, int *ncontvars)
SCIP_CONS ** SCIPgetConss(SCIP *scip)
int SCIPgetNVars(SCIP *scip)
SCIP_RETCODE SCIPaddCons(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPdelCons(SCIP *scip, SCIP_CONS *cons)
int SCIPgetNConss(SCIP *scip)
SCIP_VAR ** SCIPgetVars(SCIP *scip)
int SCIPgetNOrigVars(SCIP *scip)
int SCIPgetNBinVars(SCIP *scip)
SCIP_Bool SCIPisObjIntegral(SCIP *scip)
SCIP_VAR * SCIPfindVar(SCIP *scip, const char *name)
SCIP_CONS * SCIPfindCons(SCIP *scip, const char *name)
void SCIPhashmapFree(SCIP_HASHMAP **hashmap)
void SCIPhashmapPrintStatistics(SCIP_HASHMAP *hashmap, SCIP_MESSAGEHDLR *messagehdlr)
int SCIPhashmapGetImageInt(SCIP_HASHMAP *hashmap, void *origin)
void * SCIPhashmapGetImage(SCIP_HASHMAP *hashmap, void *origin)
SCIP_RETCODE SCIPhashmapInsert(SCIP_HASHMAP *hashmap, void *origin, void *image)
SCIP_RETCODE SCIPhashmapCreate(SCIP_HASHMAP **hashmap, BMS_BLKMEM *blkmem, int mapsize)
SCIP_Bool SCIPhashmapExists(SCIP_HASHMAP *hashmap, void *origin)
SCIP_RETCODE SCIPhashmapInsertInt(SCIP_HASHMAP *hashmap, void *origin, int image)
SCIP_RETCODE SCIPhashmapSetImageInt(SCIP_HASHMAP *hashmap, void *origin, int image)
SCIP_RETCODE SCIPlpiChgSides(SCIP_LPI *lpi, int nrows, const int *ind, const SCIP_Real *lhs, const SCIP_Real *rhs)
SCIP_Real SCIPlpiInfinity(SCIP_LPI *lpi)
SCIP_Bool SCIPlpiIsInfinity(SCIP_LPI *lpi, SCIP_Real val)
SCIP_Bool SCIPlpiExistsPrimalRay(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiAddRows(SCIP_LPI *lpi, int nrows, const SCIP_Real *lhs, const SCIP_Real *rhs, char **rownames, int nnonz, const int *beg, const int *ind, const SCIP_Real *val)
SCIP_RETCODE SCIPlpiWriteLP(SCIP_LPI *lpi, const char *fname)
SCIP_RETCODE SCIPlpiGetBounds(SCIP_LPI *lpi, int firstcol, int lastcol, SCIP_Real *lbs, SCIP_Real *ubs)
int SCIPlpiGetInternalStatus(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiChgBounds(SCIP_LPI *lpi, int ncols, const int *ind, const SCIP_Real *lb, const SCIP_Real *ub)
SCIP_Bool SCIPlpiIsPrimalUnbounded(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiFree(SCIP_LPI **lpi)
SCIP_RETCODE SCIPlpiGetCoef(SCIP_LPI *lpi, int row, int col, SCIP_Real *val)
SCIP_RETCODE SCIPlpiGetRealSolQuality(SCIP_LPI *lpi, SCIP_LPSOLQUALITY qualityindicator, SCIP_Real *quality)
SCIP_RETCODE SCIPlpiSetIntpar(SCIP_LPI *lpi, SCIP_LPPARAM type, int ival)
SCIP_RETCODE SCIPlpiGetRows(SCIP_LPI *lpi, int firstrow, int lastrow, SCIP_Real *lhs, SCIP_Real *rhs, int *nnonz, int *beg, int *ind, SCIP_Real *val)
SCIP_Bool SCIPlpiIsOptimal(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 SCIPlpiIsPrimalInfeasible(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiSolveDual(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiAddCols(SCIP_LPI *lpi, int ncols, const SCIP_Real *obj, const SCIP_Real *lb, const SCIP_Real *ub, char **colnames, int nnonz, const int *beg, const int *ind, const SCIP_Real *val)
SCIP_RETCODE SCIPlpiSolvePrimal(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiCreate(SCIP_LPI **lpi, SCIP_MESSAGEHDLR *messagehdlr, const char *name, SCIP_OBJSEN objsen)
SCIP_RETCODE SCIPlpiChgObj(SCIP_LPI *lpi, int ncols, const int *ind, const SCIP_Real *obj)
SCIP_Bool SCIPlpiIsStable(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiGetNCols(SCIP_LPI *lpi, int *ncols)
SCIP_RETCODE SCIPlpiGetNRows(SCIP_LPI *lpi, int *nrows)
SCIP_RETCODE SCIPlpiChgCoef(SCIP_LPI *lpi, int row, int col, SCIP_Real newval)
SCIP_RETCODE SCIPdelConsLocal(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPaddConflict(SCIP *scip, SCIP_NODE *node, SCIP_CONS *cons, SCIP_NODE *validnode, SCIP_CONFTYPE conftype, SCIP_Bool iscutoffinvolved)
void SCIPinfoMessage(SCIP *scip, FILE *file, const char *formatstr,...)
void SCIPverbMessage(SCIP *scip, SCIP_VERBLEVEL msgverblevel, FILE *file, const char *formatstr,...)
SCIP_MESSAGEHDLR * SCIPgetMessagehdlr(SCIP *scip)
void SCIPwarningMessage(SCIP *scip, const char *formatstr,...)
SCIP_Real SCIPrelDiff(SCIP_Real val1, SCIP_Real val2)
SCIP_RETCODE SCIPheurPassSolTrySol(SCIP *scip, SCIP_HEUR *heur, SCIP_SOL *sol)
SCIP_RETCODE SCIPheurPassIndicator(SCIP *scip, SCIP_HEUR *heur, int nindconss, SCIP_CONS **indconss, SCIP_Bool *solcand, SCIP_Real obj)
SCIP_Bool SCIPisParamFixed(SCIP *scip, const char *name)
SCIP_RETCODE SCIPaddIntParam(SCIP *scip, const char *name, const char *desc, int *valueptr, SCIP_Bool isadvanced, int defaultvalue, int minvalue, int maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
SCIP_RETCODE SCIPaddRealParam(SCIP *scip, const char *name, const char *desc, SCIP_Real *valueptr, SCIP_Bool isadvanced, SCIP_Real defaultvalue, SCIP_Real minvalue, SCIP_Real maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
SCIP_RETCODE SCIPsetIntParam(SCIP *scip, const char *name, int value)
SCIP_RETCODE SCIPchgBoolParam(SCIP *scip, SCIP_PARAM *param, SCIP_Bool value)
SCIP_RETCODE SCIPaddBoolParam(SCIP *scip, const char *name, const char *desc, SCIP_Bool *valueptr, SCIP_Bool isadvanced, SCIP_Bool defaultvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
SCIP_RETCODE SCIPgetCharParam(SCIP *scip, const char *name, char *value)
SCIP_BRANCHRULE * SCIPfindBranchrule(SCIP *scip, const char *name)
SCIP_Real SCIPcalcChildEstimate(SCIP *scip, SCIP_VAR *var, SCIP_Real targetvalue)
SCIP_RETCODE SCIPcreateChild(SCIP *scip, SCIP_NODE **node, SCIP_Real nodeselprio, SCIP_Real estimate)
SCIP_VAR * SCIPcolGetVar(SCIP_COL *col)
SCIP_BOUNDTYPE SCIPboundtypeOpposite(SCIP_BOUNDTYPE boundtype)
SCIP_RETCODE SCIPaddConflictLb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx)
SCIP_RETCODE SCIPinitConflictAnalysis(SCIP *scip, SCIP_CONFTYPE conftype, SCIP_Bool iscutoffinvolved)
SCIP_CONFLICTHDLRDATA * SCIPconflicthdlrGetData(SCIP_CONFLICTHDLR *conflicthdlr)
SCIP_RETCODE SCIPaddConflictUb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx)
const char * SCIPconflicthdlrGetName(SCIP_CONFLICTHDLR *conflicthdlr)
SCIP_Bool SCIPisConflictAnalysisApplicable(SCIP *scip)
SCIP_RETCODE SCIPaddConflictBinvar(SCIP *scip, SCIP_VAR *var)
SCIP_RETCODE SCIPanalyzeConflictCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *success)
SCIP_RETCODE SCIPsetConflicthdlrFree(SCIP *scip, SCIP_CONFLICTHDLR *conflicthdlr,)
SCIP_RETCODE SCIPincludeConflicthdlrBasic(SCIP *scip, SCIP_CONFLICTHDLR **conflicthdlrptr, const char *name, const char *desc, int priority, SCIP_DECL_CONFLICTEXEC((*conflictexec)), SCIP_CONFLICTHDLRDATA *conflicthdlrdata)
SCIP_RETCODE SCIPsetConshdlrFree(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrPresol(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPRESOL((*conspresol)), int maxprerounds, SCIP_PRESOLTIMING presoltiming)
SCIP_RETCODE SCIPsetConshdlrEnable(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrInitpre(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrSepa(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSSEPALP((*conssepalp)), SCIP_DECL_CONSSEPASOL((*conssepasol)), int sepafreq, int sepapriority, SCIP_Bool delaysepa)
SCIP_RETCODE SCIPsetConshdlrProp(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPROP((*consprop)), int propfreq, SCIP_Bool delayprop, SCIP_PROPTIMING proptiming)
SCIP_RETCODE SCIPsetConshdlrEnforelax(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPincludeConshdlrBasic(SCIP *scip, SCIP_CONSHDLR **conshdlrptr, const char *name, const char *desc, int enfopriority, int chckpriority, int eagerfreq, SCIP_Bool needscons, SCIP_DECL_CONSENFOLP((*consenfolp)), SCIP_DECL_CONSENFOPS((*consenfops)), SCIP_DECL_CONSCHECK((*conscheck)), SCIP_DECL_CONSLOCK((*conslock)), SCIP_CONSHDLRDATA *conshdlrdata)
SCIP_RETCODE SCIPsetConshdlrGetDiveBdChgs(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrDisable(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrParse(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrGetVars(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrPrint(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrGetSignedPermsymGraph(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
int SCIPconshdlrGetNConss(SCIP_CONSHDLR *conshdlr)
const char * SCIPconshdlrGetName(SCIP_CONSHDLR *conshdlr)
SCIP_RETCODE SCIPsetConshdlrCopy(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)),)
SCIP_CONSHDLR * SCIPfindConshdlr(SCIP *scip, const char *name)
SCIP_RETCODE SCIPsetConshdlrInit(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrGetPermsymGraph(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrDelete(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrInitsol(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_CONSHDLRDATA * SCIPconshdlrGetData(SCIP_CONSHDLR *conshdlr)
int SCIPconshdlrGetNActiveConss(SCIP_CONSHDLR *conshdlr)
int SCIPconshdlrGetSepaFreq(SCIP_CONSHDLR *conshdlr)
SCIP_RETCODE SCIPsetConshdlrTrans(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrResprop(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrExitsol(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_CONS ** SCIPconshdlrGetConss(SCIP_CONSHDLR *conshdlr)
SCIP_RETCODE SCIPsetConshdlrExit(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrInitlp(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrGetNVars(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPgetConsNVars(SCIP *scip, SCIP_CONS *cons, int *nvars, SCIP_Bool *success)
SCIP_CONSDATA * SCIPconsGetData(SCIP_CONS *cons)
SCIP_RETCODE SCIPenfopsCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool solinfeasible, SCIP_Bool objinfeasible, SCIP_RESULT *result)
void SCIPconsAddUpgradeLocks(SCIP_CONS *cons, int nlocks)
SCIP_Bool SCIPconsIsDynamic(SCIP_CONS *cons)
SCIP_CONSHDLR * SCIPconsGetHdlr(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsInitial(SCIP_CONS *cons)
SCIP_RETCODE SCIPenfolpCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool solinfeasible, SCIP_RESULT *result)
SCIP_RETCODE SCIPprintCons(SCIP *scip, SCIP_CONS *cons, FILE *file)
int SCIPconsGetNUpgradeLocks(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsChecked(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsDeleted(SCIP_CONS *cons)
SCIP_RETCODE SCIPsepalpCons(SCIP *scip, SCIP_CONS *cons, SCIP_RESULT *result)
SCIP_Bool SCIPconsIsTransformed(SCIP_CONS *cons)
SCIP_RETCODE SCIPgetConsVars(SCIP *scip, SCIP_CONS *cons, SCIP_VAR **vars, int varssize, SCIP_Bool *success)
SCIP_Bool SCIPconsIsEnforced(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsActive(SCIP_CONS *cons)
SCIP_RETCODE SCIPcreateCons(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_CONSHDLR *conshdlr, SCIP_CONSDATA *consdata, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)
SCIP_Bool SCIPconsIsPropagated(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsLocal(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsEnabled(SCIP_CONS *cons)
SCIP_RETCODE SCIPdisableCons(SCIP *scip, SCIP_CONS *cons)
const char * SCIPconsGetName(SCIP_CONS *cons)
SCIP_RETCODE SCIPresetConsAge(SCIP *scip, SCIP_CONS *cons)
SCIP_Bool SCIPconsIsModifiable(SCIP_CONS *cons)
SCIP_RETCODE SCIPgetTransformedCons(SCIP *scip, SCIP_CONS *cons, SCIP_CONS **transcons)
SCIP_RETCODE SCIPenforelaxCons(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Bool solinfeasible, SCIP_RESULT *result)
SCIP_Bool SCIPconsIsStickingAtNode(SCIP_CONS *cons)
SCIP_RETCODE SCIPsepasolCons(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_RESULT *result)
SCIP_RETCODE SCIPreleaseCons(SCIP *scip, SCIP_CONS **cons)
SCIP_Bool SCIPconsIsSeparated(SCIP_CONS *cons)
SCIP_RETCODE SCIPcaptureCons(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPincConsAge(SCIP *scip, SCIP_CONS *cons)
SCIP_Bool SCIPconsIsRemovable(SCIP_CONS *cons)
SCIP_RETCODE SCIPaddPoolCut(SCIP *scip, SCIP_ROW *row)
SCIP_Bool SCIPisEfficacious(SCIP *scip, SCIP_Real efficacy)
SCIP_RETCODE SCIPaddRow(SCIP *scip, SCIP_ROW *row, SCIP_Bool forcecut, SCIP_Bool *infeasible)
SCIP_RETCODE SCIPincludeEventhdlrBasic(SCIP *scip, SCIP_EVENTHDLR **eventhdlrptr, const char *name, const char *desc, SCIP_DECL_EVENTEXEC((*eventexec)), SCIP_EVENTHDLRDATA *eventhdlrdata)
const char * SCIPeventhdlrGetName(SCIP_EVENTHDLR *eventhdlr)
SCIP_EVENTTYPE SCIPeventGetType(SCIP_EVENT *event)
SCIP_RETCODE SCIPcatchVarEvent(SCIP *scip, SCIP_VAR *var, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)
SCIP_RETCODE SCIPdropVarEvent(SCIP *scip, SCIP_VAR *var, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)
SCIP_Real SCIPeventGetOldbound(SCIP_EVENT *event)
SCIP_VAR * SCIPeventGetVar(SCIP_EVENT *event)
SCIP_Real SCIPeventGetNewbound(SCIP_EVENT *event)
SCIP_RETCODE SCIPcatchEvent(SCIP *scip, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)
SCIP_RETCODE SCIPdropEvent(SCIP *scip, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)
SCIP_RETCODE SCIPreleaseExpr(SCIP *scip, SCIP_EXPR **expr)
SCIP_HEUR * SCIPfindHeur(SCIP *scip, const char *name)
#define SCIPfreeBlockMemoryArray(scip, ptr, num)
int SCIPcalcMemGrowSize(SCIP *scip, int num)
#define SCIPallocBufferArray(scip, ptr, num)
#define SCIPfreeBufferArray(scip, ptr)
#define SCIPallocBlockMemoryArray(scip, ptr, num)
#define SCIPreallocBlockMemoryArray(scip, ptr, oldnum, newnum)
#define SCIPfreeBlockMemory(scip, ptr)
#define SCIPfreeBlockMemoryArrayNull(scip, ptr, num)
#define SCIPallocBlockMemory(scip, ptr)
SCIP_RETCODE SCIPaddNlRow(SCIP *scip, SCIP_NLROW *nlrow)
SCIP_Bool SCIPisNLPConstructed(SCIP *scip)
SCIP_RETCODE SCIPreleaseNlRow(SCIP *scip, SCIP_NLROW **nlrow)
SCIP_RETCODE SCIPcreateNlRow(SCIP *scip, SCIP_NLROW **nlrow, const char *name, SCIP_Real constant, int nlinvars, SCIP_VAR **linvars, SCIP_Real *lincoefs, SCIP_EXPR *expr, SCIP_Real lhs, SCIP_Real rhs, SCIP_EXPRCURV curvature)
SCIP_RETCODE SCIPgetDivesetScore(SCIP *scip, SCIP_DIVESET *diveset, SCIP_DIVETYPE divetype, SCIP_VAR *divecand, SCIP_Real divecandsol, SCIP_Real divecandfrac, SCIP_Real *candscore, SCIP_Bool *roundup)
SCIP_Bool SCIPinProbing(SCIP *scip)
SCIP_RETCODE SCIPaddDiveBoundChange(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir, SCIP_Real value, SCIP_Bool preferred)
SCIP_Real SCIProwGetLhs(SCIP_ROW *row)
SCIP_RETCODE SCIPcacheRowExtensions(SCIP *scip, SCIP_ROW *row)
int SCIProwGetNNonz(SCIP_ROW *row)
SCIP_COL ** SCIProwGetCols(SCIP_ROW *row)
SCIP_Real SCIProwGetRhs(SCIP_ROW *row)
SCIP_RETCODE SCIPcreateEmptyRowCons(SCIP *scip, SCIP_ROW **row, SCIP_CONS *cons, const char *name, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)
SCIP_RETCODE SCIPflushRowExtensions(SCIP *scip, SCIP_ROW *row)
SCIP_Bool SCIProwIsLocal(SCIP_ROW *row)
SCIP_RETCODE SCIPcreateEmptyRowConshdlr(SCIP *scip, SCIP_ROW **row, SCIP_CONSHDLR *conshdlr, const char *name, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)
SCIP_RETCODE SCIPaddVarToRow(SCIP *scip, SCIP_ROW *row, SCIP_VAR *var, SCIP_Real val)
SCIP_RETCODE SCIPprintRow(SCIP *scip, SCIP_ROW *row, FILE *file)
const char * SCIProwGetName(SCIP_ROW *row)
SCIP_Real SCIPgetRowSolFeasibility(SCIP *scip, SCIP_ROW *row, SCIP_SOL *sol)
SCIP_RETCODE SCIPreleaseRow(SCIP *scip, SCIP_ROW **row)
SCIP_Real SCIProwGetConstant(SCIP_ROW *row)
SCIP_RETCODE SCIPaddVarsToRow(SCIP *scip, SCIP_ROW *row, int nvars, SCIP_VAR **vars, SCIP_Real *vals)
SCIP_Real * SCIProwGetVals(SCIP_ROW *row)
SCIP_RETCODE SCIPcreateSolCopy(SCIP *scip, SCIP_SOL **sol, SCIP_SOL *sourcesol)
void SCIPupdateSolConsViolation(SCIP *scip, SCIP_SOL *sol, SCIP_Real absviol, SCIP_Real relviol)
SCIP_RETCODE SCIPsetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var, SCIP_Real val)
SCIP_Real SCIPgetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var)
SCIP_RETCODE SCIPrestartSolve(SCIP *scip)
SCIP_Real SCIPgetPrimalbound(SCIP *scip)
SCIP_Real SCIPgetUpperbound(SCIP *scip)
SCIP_Real SCIPgetDualbound(SCIP *scip)
int SCIPgetNRuns(SCIP *scip)
SCIP_Longint SCIPgetNConflictConssApplied(SCIP *scip)
SCIP_RETCODE SCIPaddSymgraphEdge(SCIP *scip, SYM_GRAPH *graph, int first, int second, SCIP_Bool hasval, SCIP_Real val)
SCIP_RETCODE SCIPaddSymgraphOpnode(SCIP *scip, SYM_GRAPH *graph, int op, int *nodeidx)
SCIP_RETCODE SCIPgetSymActiveVariables(SCIP *scip, SYM_SYMTYPE symtype, SCIP_VAR ***vars, SCIP_Real **scalars, int *nvars, SCIP_Real *constant, SCIP_Bool transformed)
int SCIPgetSymgraphVarnodeidx(SCIP *scip, SYM_GRAPH *graph, SCIP_VAR *var)
SCIP_RETCODE SCIPaddSymgraphConsnode(SCIP *scip, SYM_GRAPH *graph, SCIP_CONS *cons, SCIP_Real lhs, SCIP_Real rhs, int *nodeidx)
SCIP_RETCODE SCIPaddSymgraphVarAggregation(SCIP *scip, SYM_GRAPH *graph, int rootidx, SCIP_VAR **vars, SCIP_Real *vals, int nvars, SCIP_Real constant)
int SCIPgetSymgraphNegatedVarnodeidx(SCIP *scip, SYM_GRAPH *graph, SCIP_VAR *var)
SCIP_Bool SCIPisFeasGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Real SCIPinfinity(SCIP *scip)
SCIP_Bool SCIPisGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisIntegral(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisFeasEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisPositive(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPfeasCeil(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisFeasZero(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisFeasLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisFeasNegative(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisFeasIntegral(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisNegative(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPceil(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Real SCIPcutoffbounddelta(SCIP *scip)
SCIP_Bool SCIPisZero(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisFeasPositive(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPinRepropagation(SCIP *scip)
int SCIPgetDepth(SCIP *scip)
SCIP_RETCODE SCIPvarGetProbvarBound(SCIP_VAR **var, SCIP_Real *bound, SCIP_BOUNDTYPE *boundtype)
SCIP_Bool SCIPvarIsDeleted(SCIP_VAR *var)
SCIP_RETCODE SCIPlockVarCons(SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, SCIP_Bool lockdown, SCIP_Bool lockup)
SCIP_VAR * SCIPvarGetNegatedVar(SCIP_VAR *var)
SCIP_Bool SCIPvarIsActive(SCIP_VAR *var)
SCIP_Bool SCIPvarIsBinary(SCIP_VAR *var)
SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)
int SCIPvarGetNLocksUpType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)
SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
SCIP_RETCODE SCIPinferVarUbCons(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_CONS *infercons, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
SCIP_RETCODE SCIPchgVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
SCIP_RETCODE SCIPchgVarUbNode(SCIP *scip, SCIP_NODE *node, SCIP_VAR *var, SCIP_Real newbound)
SCIP_Real SCIPvarGetObj(SCIP_VAR *var)
SCIP_Real SCIPvarGetAggrScalar(SCIP_VAR *var)
SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)
SCIP_RETCODE SCIPgetProbvarSum(SCIP *scip, SCIP_VAR **var, SCIP_Real *scalar, SCIP_Real *constant)
SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)
SCIP_RETCODE SCIPaddVarLocksType(SCIP *scip, SCIP_VAR *var, SCIP_LOCKTYPE locktype, int nlocksdown, int nlocksup)
SCIP_RETCODE SCIPunlockVarCons(SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, SCIP_Bool lockdown, SCIP_Bool lockup)
SCIP_Real SCIPgetVarUbAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
int SCIPvarGetProbindex(SCIP_VAR *var)
const char * SCIPvarGetName(SCIP_VAR *var)
SCIP_VAR * SCIPbdchginfoGetVar(SCIP_BDCHGINFO *bdchginfo)
SCIP_RETCODE SCIPreleaseVar(SCIP *scip, SCIP_VAR **var)
SCIP_Bool SCIPvarIsIntegral(SCIP_VAR *var)
SCIP_RETCODE SCIPchgVarType(SCIP *scip, SCIP_VAR *var, SCIP_VARTYPE vartype, SCIP_Bool *infeasible)
SCIP_Real SCIPgetVarSol(SCIP *scip, SCIP_VAR *var)
SCIP_RETCODE SCIPgetNegatedVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **negvar)
SCIP_RETCODE SCIPaddVarImplication(SCIP *scip, SCIP_VAR *var, SCIP_Bool varfixing, SCIP_VAR *implvar, SCIP_BOUNDTYPE impltype, SCIP_Real implbound, SCIP_Bool *infeasible, int *nbdchgs)
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
SCIP_Bool SCIPvarIsNegated(SCIP_VAR *var)
SCIP_VAR * SCIPvarGetNegationVar(SCIP_VAR *var)
SCIP_RETCODE SCIPcreateVar(SCIP *scip, SCIP_VAR **var, const char *name, SCIP_Real lb, SCIP_Real ub, SCIP_Real obj, SCIP_VARTYPE vartype, SCIP_Bool initial, SCIP_Bool removable, SCIP_DECL_VARDELORIG((*vardelorig)), SCIP_DECL_VARTRANS((*vartrans)), SCIP_DECL_VARDELTRANS((*vardeltrans)), SCIP_DECL_VARCOPY((*varcopy)), SCIP_VARDATA *vardata)
SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)
SCIP_RETCODE SCIPmarkDoNotMultaggrVar(SCIP *scip, SCIP_VAR *var)
SCIP_RETCODE SCIPfixVar(SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval, SCIP_Bool *infeasible, SCIP_Bool *fixed)
SCIP_RETCODE SCIPinferVarLbCons(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_CONS *infercons, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
SCIP_Real SCIPgetVarLbAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
SCIP_RETCODE SCIPchgVarLbNode(SCIP *scip, SCIP_NODE *node, SCIP_VAR *var, SCIP_Real newbound)
SCIP_RETCODE SCIPvarGetProbvarBinary(SCIP_VAR **var, SCIP_Bool *negated)
SCIP_BOUNDTYPE SCIPbdchginfoGetBoundtype(SCIP_BDCHGINFO *bdchginfo)
SCIP_Real SCIPbdchginfoGetNewbound(SCIP_BDCHGINFO *bdchginfo)
int SCIPvarGetNLocksDownType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)
SCIP_Bool SCIPallowWeakDualReds(SCIP *scip)
SCIP_RETCODE SCIPgetTransformedVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **transvar)
SCIP_RETCODE SCIPcaptureVar(SCIP *scip, SCIP_VAR *var)
SCIP_Bool SCIPallowStrongDualReds(SCIP *scip)
SCIP_VAR * SCIPvarGetAggrVar(SCIP_VAR *var)
int SCIPsnprintf(char *t, int len, const char *s,...)
SCIPfreeSol(scip, &heurdata->sol))
static SCIP_DIVESET * diveset
handle partial solutions for linear problems with indicators and otherwise continuous variables
assert(minobj< SCIPgetCutoffbound(scip))
static SCIP_Bool propagate
primal heuristic that tries a given solution
interface methods for specific LP solvers
static const char * paramname[]
memory allocation routines
BMS_BLKMEM * SCIPblkmem(SCIP *scip)
const char * SCIPparamGetName(SCIP_PARAM *param)
SCIP_PARAMTYPE SCIPparamGetType(SCIP_PARAM *param)
public methods for conflict analysis handlers
public methods for managing constraints
public methods for managing events
public methods for LP management
public methods for message output
#define SCIPdebugPrintCons(x, y, z)
public data structures and miscellaneous methods
public methods for handling parameter settings
public methods for problem variables
public methods for branching rule plugins and branching
public methods for conflict handler plugins and conflict analysis
public methods for constraint handler plugins and constraints
public methods for problem copies
public methods for cuts and aggregation rows
public methods for event handler plugins and event handlers
public methods for primal heuristic plugins and divesets
public methods for the LP relaxation, rows and columns
public methods for memory management
public methods for message handling
public methods for nonlinear relaxation
public methods for numerical tolerances
public methods for SCIP parameter handling
public methods for global and local (sub)problems
public methods for the probing mode
public methods for solutions
public methods for querying solving statistics
public methods for the branch-and-bound tree
public methods for SCIP variables
structs for symmetry computations
methods for dealing with symmetry detection graphs
#define SCIP_DECL_CONFLICTEXEC(x)
#define SCIP_DECL_CONFLICTFREE(x)
@ SCIP_CONFTYPE_PROPAGATION
struct SCIP_ConflicthdlrData SCIP_CONFLICTHDLRDATA
#define SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH(x)
#define SCIP_DECL_CONSGETPERMSYMGRAPH(x)
#define SCIP_DECL_CONSENFOLP(x)
#define SCIP_DECL_CONSINITPRE(x)
#define SCIP_DECL_CONSDELETE(x)
#define SCIP_DECL_CONSEXIT(x)
#define SCIP_DECL_CONSGETVARS(x)
#define SCIP_DECL_CONSINITSOL(x)
#define SCIP_DECL_CONSPRINT(x)
struct SCIP_ConshdlrData SCIP_CONSHDLRDATA
#define SCIP_DECL_CONSSEPALP(x)
#define SCIP_DECL_CONSDISABLE(x)
#define SCIP_DECL_CONSENFORELAX(x)
#define SCIP_DECL_CONSGETDIVEBDCHGS(x)
#define SCIP_DECL_CONSPROP(x)
#define SCIP_DECL_CONSGETNVARS(x)
#define SCIP_DECL_CONSRESPROP(x)
#define SCIP_DECL_CONSENFOPS(x)
#define SCIP_DECL_CONSPARSE(x)
#define SCIP_DECL_CONSTRANS(x)
#define SCIP_DECL_CONSPRESOL(x)
#define SCIP_DECL_CONSENABLE(x)
#define SCIP_DECL_CONSINITLP(x)
#define SCIP_DECL_CONSLOCK(x)
#define SCIP_DECL_CONSCOPY(x)
#define SCIP_DECL_CONSINIT(x)
struct SCIP_ConsData SCIP_CONSDATA
#define SCIP_DECL_CONSCHECK(x)
#define SCIP_DECL_CONSHDLRCOPY(x)
#define SCIP_DECL_CONSEXITSOL(x)
#define SCIP_DECL_CONSFREE(x)
#define SCIP_DECL_CONSSEPASOL(x)
#define SCIP_EVENTTYPE_BOUNDCHANGED
#define SCIP_EVENTTYPE_GUBCHANGED
#define SCIP_EVENTTYPE_GBDCHANGED
struct SCIP_EventData SCIP_EVENTDATA
#define SCIP_EVENTTYPE_UBTIGHTENED
#define SCIP_DECL_EVENTEXEC(x)
#define SCIP_EVENTTYPE_LBRELAXED
#define SCIP_EVENTTYPE_BESTSOLFOUND
#define SCIP_EVENTTYPE_GLBCHANGED
#define SCIP_EVENTTYPE_LBTIGHTENED
#define SCIP_EVENTTYPE_UBRELAXED
#define SCIP_DIVETYPE_INTEGRALITY
@ SCIP_BRANCHDIR_DOWNWARDS
enum SCIP_BoundType SCIP_BOUNDTYPE
type definitions for specific LP solvers interface
@ SCIP_LPSOLQUALITY_ESTIMCONDITION
#define SCIP_DECL_PARAMCHGD(x)
enum SCIP_Result SCIP_RESULT
enum SCIP_Retcode SCIP_RETCODE
@ SCIP_STAGE_INITPRESOLVE
@ SCIP_STAGE_TRANSFORMING
enum SYM_Symtype SYM_SYMTYPE
@ SCIP_VARTYPE_CONTINUOUS
@ SCIP_VARSTATUS_MULTAGGR
@ SCIP_VARSTATUS_AGGREGATED
enum SCIP_Vartype SCIP_VARTYPE