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;
519 for(
i = 0;
i < nvarslincons; ++
i )
522 vals[
i] = linvals[
i];
524 nlocvars = nvarslincons;
546 vars[0] = consdata->binvar;
554 actweight = consdata->activeone ? 1.0 : -1.0;
565 else if( nlocvars == 1 )
586 vars[0] = consdata->slackvar;
602 else if( nlocvars == 1 )
643 assert( 0 <= consdata->nfixednonzero && consdata->nfixednonzero <= 2 );
644 assert( consdata->linconsactive );
661 ++(consdata->nfixednonzero);
662#ifdef SCIP_MORE_DEBUG
663 SCIPdebugMsg(
scip,
"Changed lower bound of variable <%s> from %g to %g (nfixednonzero: %d).\n",
673 ++(consdata->nfixednonzero);
674#ifdef SCIP_MORE_DEBUG
675 SCIPdebugMsg(
scip,
"Changed upper bound of variable <%s> from %g to %g (nfixednonzero: %d).\n",
685 --(consdata->nfixednonzero);
686#ifdef SCIP_MORE_DEBUG
687 SCIPdebugMsg(
scip,
"Changed lower bound of variable <%s> from %g to %g (nfixednonzero: %d).\n",
697 --(consdata->nfixednonzero);
698#ifdef SCIP_MORE_DEBUG
699 SCIPdebugMsg(
scip,
"Changed upper bound of variable <%s> from %g to %g (nfixednonzero: %d).\n",
710 assert( 0 <= consdata->nfixednonzero && consdata->nfixednonzero <= 2 );
713 conshdlrdata->boundhaschanged =
TRUE;
733#ifdef SCIP_MORE_DEBUG
741 conshdlrdata->linconsboundschanged =
TRUE;
769 assert( conshdlrdata->forcerestart );
792 if ( conshdlrdata->performedrestart )
796 ++(conshdlrdata->nbinvarszero);
804 if ( conshdlrdata->nbinvarszero > (
int) ((SCIP_Real) conshdlrdata->ninitconss * conshdlrdata->restartfrac) )
807 "Forcing restart, since %d binary variables among %d have been fixed.\n", conshdlrdata->nbinvarszero, conshdlrdata->ninitconss);
811 if ( conshdlrdata->objindicatoronly )
815 conshdlrdata->performedrestart =
TRUE;
827 if ( ! conshdlrdata->objindicatoronly )
844 conshdlrdata->performedrestart =
TRUE;
894 assert( bdchginfos !=
NULL || nbdchginfos == 0 );
917 for (
i = 0;
i < nbdchginfos; ++
i)
949 if ( haveslack &&
i == nbdchginfos )
956 SCIPdebugMsg(
scip,
"Found conflict involving slack variables that can be remodelled.\n");
966 for (
i = 0;
i < nbdchginfos; ++
i)
982 for (j = 0; j < nconss; ++j)
989 if ( slackvar ==
var )
1017 if (
i == nbdchginfos )
1073 if ( *value == newvalue )
1128#ifdef SCIP_ENABLE_IISCHECK
1171 for (
c = 0;
c < nconss; ++
c)
1187 SCIP_Real sign = 1.0;
1198 lincons = consdata->lincons;
1203 slackvar = consdata->slackvar;
1211 SCIP_Real scalar = 1.0;
1212 SCIP_Real constant = 0.0;
1225 linvals[0] = scalar;
1255 for (v = 0; v < nlinvars; ++v)
1262 if (
var == slackvar )
1275 newvars[nnewvars++] =
var;
1293 for (v = 0; v < nnewvars; ++v)
1307 for (v = nnewvars - 1; v >= 0; --v)
1319 for (v = 0; v < nlinvars; ++v)
1326 if (
var == slackvar )
1331 matval[cnt] = sign * linvals[v];
1356 if ( conshdlrdata->useotherconss )
1363 for (
c = 0;
c < nconss; ++
c)
1407 for (v = 0; v < nlinvars; ++v)
1423 newvars[nnewvars++] =
var;
1441 for (v = 0; v < nnewvars; ++v)
1455 for (v = nnewvars - 1; v >= 0; --v)
1466 for (v = 0; v < nlinvars; ++v)
1474 matval[cnt] = linvals[v];
1552 assert( conshdlrdata->naddlincons <= conshdlrdata->maxaddlincons );
1554 if ( num > conshdlrdata->maxaddlincons )
1560 conshdlrdata->maxaddlincons = newsize;
1562 assert( num <= conshdlrdata->maxaddlincons );
1584 SCIP_Real lhs = -1.0;
1585 SCIP_Real rhs = -1.0;
1608 conshdlrdata->nrows = 1;
1650 for (j = 0; j < nCols; ++j)
1655 for (j = 0; j < nconss; ++j)
1663 ind = consdata->colindex;
1668 covered[ind] =
TRUE;
1677 for (j = 0; j < nCols; ++j)
1716 int* indices =
NULL;
1726 for (j = 0; j < nconss; ++j)
1734 if ( consdata->colindex >= 0 )
1740 obj[cnt] = 1.0 - val;
1741 indices[cnt++] = consdata->colindex;
1768 int* indices =
NULL;
1778 for (j = 0; j < nconss; ++j)
1786 if ( consdata->colindex >= 0 )
1789 indices[cnt++] = consdata->colindex;
1815 SCIP_Real* lb =
NULL;
1816 SCIP_Real* ub =
NULL;
1817 int* indices =
NULL;
1830 for (j = 0; j < nconss; ++j)
1838 if ( consdata->colindex >= 0 )
1842 indices[cnt] = consdata->colindex;
1907 SCIP_Real* lb =
NULL;
1908 SCIP_Real* ub =
NULL;
1909 int* indices =
NULL;
1922 for (j = 0; j < nconss; ++j)
1932 if ( consdata->colindex >= 0 )
1934 indices[cnt] = consdata->colindex;
1974 altlp = conshdlrdata->altlp;
1975 lbhash = conshdlrdata->lbhash;
1976 ubhash = conshdlrdata->ubhash;
1984 for (v = 0; v <
nvars; ++v)
2010 conshdlrdata->scaled =
FALSE;
2038 altlp = conshdlrdata->altlp;
2039 lbhash = conshdlrdata->lbhash;
2040 ubhash = conshdlrdata->ubhash;
2048 for (v = 0; v <
nvars; ++v)
2110 lbhash = conshdlrdata->lbhash;
2111 ubhash = conshdlrdata->ubhash;
2119 for (v = 0; v <
nvars; ++v)
2133 assert( 0 <= col && col < nCols );
2151 assert( 0 <= col && col < nCols );
2180 if ( ! conshdlrdata->scaled )
2185 SCIP_Real sum = 0.0;
2191 altlp = conshdlrdata->altlp;
2201 for (j = 0; j < cnt; ++j)
2205 sum = -
REALABS(sum) / ((double) cnt);
2213 conshdlrdata->scaled =
TRUE;
2243 SCIP_Bool* newrowsslack;
2266 if ( conshdlrdata->altlp ==
NULL )
2280 assert( nrows == conshdlrdata->nrows );
2303 matval[cnt++] = sign * rhscoef;
2307 for (v = 0; v <
nvars; ++v)
2318 if (
var != slackvar )
2324 if ( ind < INT_MAX )
2332 matind[cnt] = (conshdlrdata->nrows)++;
2335 newrowsslack[nnewrows++] =
TRUE;
2338 matval[cnt++] = sign * vals[v];
2352 matind[cnt] = (conshdlrdata->nrows)++;
2355 newrowsslack[nnewrows++] =
FALSE;
2356 newvars[nnewvars++] =
var;
2359 matval[cnt++] = sign * vals[v];
2372 for (
i = 0;
i < nnewrows; ++
i)
2374 if ( newrowsslack[
i] )
2404 for (v = 0; v < nnewvars; ++v)
2413 matbeg[nnewcols] = cnt;
2417 matval[cnt++] = -val;
2422 matval[cnt++] = -1.0;
2423 obj[nnewcols] = 0.0;
2426 ++conshdlrdata->nlbbounds;
2430 SCIPdebugMsg(
scip,
"Added column for lower bound (%f) of variable <%s> to alternative polyhedron (col: %d).\n",
2439 matbeg[nnewcols] = cnt;
2443 matval[cnt++] = val;
2448 matval[cnt++] = 1.0;
2449 obj[nnewcols] = 0.0;
2452 ++conshdlrdata->nubbounds;
2456 SCIPdebugMsg(
scip,
"Added column for upper bound (%f) of variable <%s> to alternative polyhedron (col: %d).\n",
2470 assert( cnt == ncols + nnewcols + 1 );
2482 conshdlrdata->scaled =
FALSE;
2529 SCIP_Real scalar = 1.0;
2530 SCIP_Real constant = 0.0;
2536 SCIPdebugMsg(
scip,
"Slack variable is aggregated (scalar: %f, constant: %f).\n", scalar, constant);
2546 linvals[0] = scalar;
2569 SCIP_CALL(
addAltLPColumn(
scip, conshdlr, conshdlrdata, slackvar, nlinvars, linvars, linvals, linrhs, objcoef, 1.0,
TRUE, colindex) );
2574 SCIP_CALL(
addAltLPColumn(
scip, conshdlr, conshdlrdata, slackvar, nlinvars, linvars, linvals, linrhs, objcoef, 1.0,
FALSE, colindex) );
2580 SCIP_CALL(
addAltLPColumn(
scip, conshdlr, conshdlrdata, slackvar, nlinvars, linvars, linvals, linlhs, objcoef, -1.0,
FALSE, colindex) );
2639 for (j = 0; j < nrowcols; ++j)
2649 SCIP_CALL(
addAltLPColumn(
scip, conshdlr, conshdlrdata,
NULL, nrowcols, rowvars, rowvals, rowrhs, objcoef, 1.0,
TRUE, colindex) );
2654 SCIP_CALL(
addAltLPColumn(
scip, conshdlr, conshdlrdata,
NULL, nrowcols, rowvars, rowvals, rowrhs, objcoef, 1.0,
FALSE, colindex) );
2660 SCIP_CALL(
addAltLPColumn(
scip, conshdlr, conshdlrdata,
NULL, nrowcols, rowvars, rowvals, rowlhs, objcoef, -1.0,
FALSE, colindex) );
2692 if ( conshdlrdata->objcutindex >= 0 )
2696 if ( ! conshdlrdata->objothervarsonly )
2700 SCIPdebugMsg(
scip,
"Add objective cut to alternative LP (obj. bound: %g).\n", conshdlrdata->objupperbound);
2707 for (v = 0; v <
nvars; ++v)
2719 objvars[nobjvars] =
var;
2720 objvals[nobjvars++] =
objval;
2725 SCIP_CALL(
addAltLPColumn(
scip, conshdlr, conshdlrdata,
NULL, nobjvars, objvars, objvals, conshdlrdata->objupperbound, 0.0, 1.0,
FALSE, &conshdlrdata->objcutindex) );
2726 assert( conshdlrdata->objcutindex >= 0 );
2727 conshdlrdata->objaltlpbound = conshdlrdata->objupperbound;
2757 if ( conshdlrdata->altlp !=
NULL )
2764 if ( consdata->colindex >= 0 )
2768 consdata->colindex = -1;
2772 conshdlrdata->scaled =
FALSE;
2791 if ( ! conshdlrdata->useobjectivecut )
2794 if ( conshdlrdata->altlp ==
NULL )
2806 if (
SCIPisLT(
scip, objbnd, conshdlrdata->objupperbound) )
2807 conshdlrdata->objupperbound = objbnd;
2814 if (
SCIPisLT(
scip, conshdlrdata->objupperbound, conshdlrdata->objaltlpbound) )
2816 SCIPdebugMsg(
scip,
"Update objective bound to %g.\n", conshdlrdata->objupperbound);
2819 if ( conshdlrdata->objcutindex < 0 )
2833 conshdlrdata->objaltlpbound = conshdlrdata->objupperbound;
2859 SCIP_Real maxcondition,
2861 SCIP_Bool* infeasible,
2866 SCIP_Real condition;
2913 if ( maxcondition > 0.0 )
2917 if ( condition !=
SCIP_INVALID && condition > maxcondition )
2919 SCIPdebugMsg(
scip,
"Estimated condition number of basis matrix (%e) exceeds maximal allowance (%e).\n", condition, maxcondition);
2927 SCIPdebugMsg(
scip,
"Estimated condition number of basis matrix (%e) is below maximal allowance (%e).\n", condition, maxcondition);
2931 SCIPdebugMsg(
scip,
"Estimated condition number of basis matrix not available.\n");
2989 *infeasible =
FALSE;
3010 SCIP_Bool removable,
3011 SCIP_Bool genlogicor,
3026 int nnonviolated = 0;
3046 assert( nconss <= nCols );
3050 SCIP_Bool infeasible;
3051 SCIP_Real sum = 0.0;
3052 SCIP_Real candobj = -1.0;
3053 SCIP_Real candval = 2.0;
3054 SCIP_Real norm = 1.0;
3077 SCIPdebugMsg(
scip,
" size: %4d produced possible cover with indicator variable objective value %f.\n", *size, *value);
3080 if ( conshdlrdata->trysolfromcover )
3090 if ( heurindicator ==
NULL )
3107 for (j = 0; j < nconss; ++j)
3114 ind = consdata->colindex;
3131 if ( val < candval )
3143 if ( candidate < 0 )
3149 assert( candidate >= 0 );
3150 assert( ! S[candidate] );
3154 switch ( conshdlrdata->normtype )
3157 norm = sqrt((SCIP_Real) sizeIIS);
3169 SCIPerrorMessage(
"Invalid efficacy norm parameter '%c'.\n", conshdlrdata->normtype);
3174 SCIPdebugMsg(
scip,
" size: %4d, add var. %4d (obj: %-6g, alt-LP sol: %-8.4f); IIS size: %4d, eff.: %g.\n",
3175 *size, candidate, candobj,
primsol[
SCIPconsGetData(conss[candidate])->colindex], sizeIIS, (sum - (SCIP_Real) (sizeIIS - 1))/norm);
3178 S[candidate] =
TRUE;
3188 SCIP_Bool isLocal =
FALSE;
3190#ifdef SCIP_ENABLE_IISCHECK
3196 if ( conshdlrdata->updatebounds )
3211 for (j = 0; j < nconss; ++j)
3217 ind = consdata->colindex;
3233 assert( cnt == sizeIIS );
3237 SCIP_CALL(
SCIPcreateConsLogicor(
scip, &cons, name, cnt,
vars,
FALSE,
TRUE,
TRUE,
TRUE,
TRUE, isLocal,
FALSE,
TRUE, removable,
FALSE) );
3239 SCIP_CALL(
SCIPcreateConsLogicor(
scip, &cons,
"", cnt,
vars,
FALSE,
TRUE,
TRUE,
TRUE,
TRUE, isLocal,
FALSE,
TRUE, removable,
FALSE) );
3248 switch ( enfosepatype )
3291 for (j = 0; j < nconss; ++j)
3297 ind = consdata->colindex;
3338 if ( nnonviolated > conshdlrdata->maxsepanonviolated )
3340 SCIPdebugMsg(
scip,
"Stop separation after %d non violated IISs.\n", nnonviolated);
3344 while (step < nconss);
3360 const char* consname,
3364 SCIP_Bool activeone,
3365 SCIP_Bool lessthanineq,
3368 SCIP_Bool linconsactive
3383 binvarinternal = binvar;
3392 (*consdata)->nfixednonzero = 0;
3393 (*consdata)->colindex = -1;
3394 (*consdata)->linconsactive = linconsactive;
3395 (*consdata)->binvar = binvarinternal;
3396 (*consdata)->slackvar = slackvar;
3397 (*consdata)->activeone = activeone;
3398 (*consdata)->lessthanineq = lessthanineq;
3399 (*consdata)->lincons = lincons;
3400 (*consdata)->implicationadded =
FALSE;
3401 (*consdata)->slacktypechecked =
FALSE;
3402 (*consdata)->varswithevents =
NULL;
3403 (*consdata)->eventtypes =
NULL;
3404 (*consdata)->nevents = 0;
3412 if ( binvarinternal !=
NULL )
3416 (*consdata)->binvar =
var;
3431 if ( conshdlrdata->forcerestart )
3439 ++((*consdata)->nfixednonzero);
3445 (*consdata)->slackvar =
var;
3448 if ( linconsactive )
3452 ++((*consdata)->nfixednonzero);
3463 SCIPdebugMsg(
scip,
"Added column for <%s> to alternative LP with column index %d.\n", consname, (*consdata)->colindex);
3471 if ( (*consdata)->nfixednonzero > 0 )
3473 SCIPdebugMsg(
scip,
"Constraint <%s> has %d variables fixed to be nonzero.\n", consname, (*consdata)->nfixednonzero);
3502 for (
c = 0;
c < nconss; ++
c)
3514 if ( ub <= conshdlrdata->maxcouplingvalue )
3531 !conshdlrdata->removeindicators, !conshdlrdata->removeindicators,
FALSE) );
3537 if ( conshdlrdata->removeindicators )
3559 SCIP_Bool dualreductions,
3566 SCIP_Bool infeasible;
3590 SCIPdebugMsg(
scip,
"The problem is infeasible: binary and slack variable are fixed to be nonzero.\n");
3631 SCIPdebugMsg(
scip,
"The problem is infeasible: binary and slack variable are fixed to be nonzero.\n");
3637 SCIPdebugMsg(
scip,
"Fix binary variable to 0 and delete indicator constraint.\n");
3655 if ( dualreductions )
3661 binvar = consdata->binvar;
3717 SCIP_Bool negated =
FALSE;
3721 var = consdata->binvar;
3726 if (
var != consdata->binvar && ! negated )
3731 assert( conshdlrdata->eventhdlrbound !=
NULL );
3738 if ( conshdlrdata->forcerestart )
3740 assert( conshdlrdata->eventhdlrrestart !=
NULL );
3742 conshdlrdata->eventhdlrrestart, (
SCIP_EVENTDATA*) conshdlrdata, -1) );
3751 consdata->binvar =
var;
3762 if (
var == consdata->slackvar )
3781 var = consdata->slackvar;
3794 assert( conshdlrdata->eventhdlrbound !=
NULL );
3805 consdata->slackvar =
var;
3807 else if (
var == consdata->binvar )
3815 SCIPdebugMsg(
scip,
"Slack variable <%s> is aggregated to negated indicator variable <%s> -> constraint redundant.\n",
3829 SCIPdebugMsg(
scip,
"Slack variable <%s> is aggregated to the indicator variable <%s> -> fix indicator variable to 0.\n",
3865 SCIP_Bool dualreductions,
3866 SCIP_Bool addopposite,
3871 SCIP_Bool infeasible;
3872 SCIP_Bool tightened;
3884 if ( ! consdata->linconsactive )
3898 if ( consdata->nfixednonzero > 1 )
3900 SCIPdebugMsg(
scip,
"The node is infeasible, both the slack variable and the binary variable are fixed to be nonzero.\n");
3925 if ( consdata->nfixednonzero == 1 )
3935 SCIPdebugMsg(
scip,
"Binary variable <%s> is fixed to be nonzero, fixing slack variable <%s> to 0.\n",
3952 SCIPdebugMsg(
scip,
"Slack variable <%s> is fixed to be nonzero, fixing binary variable <%s> to 0.\n",
3976 if ( addopposite && consdata->linconsactive )
3982 SCIP_Bool allintegral =
TRUE;
4013 slackvar = consdata->slackvar;
4020 for (j = 0; j < nlinvars; ++j)
4022 if ( linvars[j] != slackvar )
4025 allintegral =
FALSE;
4028 vals[
nvars++] = linvals[j];
4072 if ( dualreductions )
4078 binvar = consdata->binvar;
4153 SCIP_Real* consvals;
4154 SCIP_Real maxactivity;
4157 SCIP_Real coeffslack;
4169 for (j = 0; j < nlinconsvars; ++j)
4182 if (
var == consdata->slackvar )
4199 maxactivity += val * ub;
4211 newub = maxactivity - rhs;
4215 newub = newub / (-1.0 * coeffslack);
4260 SCIP_Bool genlogicor,
4268 SCIP_Real value = 0.0;
4286 lp = conshdlrdata->altlp;
4294 if ( conshdlrdata->updatebounds )
4309 for (j = 0; j < nconss; ++j)
4333 SCIP_CALL(
extendToCover(
scip, conshdlr, conshdlrdata, lp,
sol, enfosepatype, conshdlrdata->removable, genlogicor, nconss, conss, S, &size, &value, &error,
cutoff, &nCuts) );
4337 if ( nCuts == 0 && error )
4371 SCIP_Bool genlogicor,
4382 SCIP_Real maxSlack = -1.0;
4383 SCIP_Bool someLinconsNotActive =
FALSE;
4384 SCIP_Bool dualreductions;
4403 for (
c = 0;
c < nconss; ++
c)
4415 if ( ! consdata->linconsactive )
4417 someLinconsNotActive =
TRUE;
4437 binvar = consdata->binvar;
4445 if ( valSlack > maxSlack )
4447 maxSlack = valSlack;
4462 if ( (someLinconsNotActive || conshdlrdata->enforcecuts) && conshdlrdata->sepaalternativelp )
4470 conshdlrdata->niiscutsgen += ngen;
4477 conshdlrdata->niiscutsgen += ngen;
4503 if ( ! conshdlrdata->branchindicators )
4513 binvar = consdata->binvar;
4514 slackvar = consdata->slackvar;
4566 SCIP_Real threshold;
4578 if ( *nGen >= maxsepacuts )
4586 lp = conshdlrdata->altlp;
4596 if ( conshdlrdata->updatebounds )
4614 for (threshold = conshdlrdata->roundingmaxthres;
4615 rounds < conshdlrdata->maxroundingrounds && threshold >= conshdlrdata->roundingminthres && *nGen < maxsepacuts && ! (*
cutoff);
4616 threshold -= conshdlrdata->roundingoffset )
4618 SCIP_Real value = 0.0;
4631 for (j = 0; j < nconss; ++j)
4634 SCIP_Real binvarval;
4663 if ( binvarval > binvarnegval )
4681 if ( size == nconss )
4688 if ( size == oldsize )
4690 SCIPdebugMsg(
scip,
"Skipping computation: size support has not changed.\n");
4696 SCIPdebugMsg(
scip,
" Vars with value 1: %d 0: %d and fractional: %d.\n", nvarsone, nvarszero, nvarsfrac);
4704 nconss, conss, S, &size, &value, &error,
cutoff, &nCuts) );
4784 if ( *nGen >= maxsepacuts )
4795 for (
c = 0;
c < nconss; ++
c)
4806 slackvar = consdata->slackvar;
4808 lincons = consdata->lincons;
4811 binvar = consdata->binvar;
4820 SCIP_Bool finitebound =
TRUE;
4821 SCIP_Real cutrhs = 0.0;
4823 SCIP_Real signfactor = 1.0;
4825 SCIP_Bool islocal =
FALSE;
4846 cutval = binval * ypart;
4848 for (j = 0; j < nlinvars; ++j)
4853 SCIP_Real din = 0.0;
4854 SCIP_Real dout = 0.0;
4858 if ( linvars[j] == slackvar )
4861 if ( conshdlrdata->sepapersplocal )
4880 finitebound =
FALSE;
4885 linval = signfactor * linvals[j];
4889 dout += linval * lb;
4894 dout += linval * ub;
4898 xpart = linval * xval;
4901 if (
SCIPisGT(
scip, binval * din, binval * dout + xpart) )
4904 cutval += binval * din;
4912 cutval += binval * dout + xpart;
4914 cutvars[cnt] = linvars[j];
4915 cutvals[cnt++] = linval;
4919 if ( ! finitebound )
4925 SCIP_Bool infeasible;
4929 cutvars[cnt] = binvar;
4930 cutvals[cnt] = ypart;
4934 (void)
SCIPsnprintf(name, 50,
"persp%d", conshdlrdata->nperspcutsgen + *nGen);
4947 if ( *nGen >= maxsepacuts )
4995 maxsepacuts = conshdlrdata->maxsepacutsroot;
4997 maxsepacuts = conshdlrdata->maxsepacuts;
5000 if ( conshdlrdata->sepacouplingcuts )
5007 for (
c = 0;
c < nusefulconss && ncuts < maxsepacuts; ++
c)
5022 if ( conshdlrdata->sepacouplinglocal )
5033 if ( ub <= conshdlrdata->sepacouplingvalue )
5041 SCIP_Bool infeasible;
5071 SCIPdebugMsg(
scip,
"Number of separated coupling inequalities: %d.\n", ncuts);
5080 SCIPdebugMsg(
scip,
"Separating inequalities for indicator constraints.\n");
5088 SCIPdebugMsg(
scip,
"Separated %d cuts from indicator constraints.\n", ncuts - noldcuts);
5092 else if ( ncuts > noldcuts )
5094 conshdlrdata->niiscutsgen += ncuts;
5097 if ( conshdlrdata->genlogicor )
5109 SCIPdebugMsg(
scip,
"Separating inequalities based on perspective formulation.\n");
5117 SCIPdebugMsg(
scip,
"Separated %d cuts from perspective formulation.\n", ncuts - noldcuts);
5119 if ( ncuts > noldcuts )
5121 conshdlrdata->nperspcutsgen += ncuts;
5141 conshdlrdata->linconsevents =
FALSE;
5142 conshdlrdata->linconsboundschanged =
TRUE;
5143 conshdlrdata->boundhaschanged =
TRUE;
5144 conshdlrdata->removable =
TRUE;
5145 conshdlrdata->scaled =
FALSE;
5146 conshdlrdata->altlp =
NULL;
5147 conshdlrdata->nrows = 0;
5148 conshdlrdata->varhash =
NULL;
5149 conshdlrdata->slackhash =
NULL;
5150 conshdlrdata->lbhash =
NULL;
5151 conshdlrdata->ubhash =
NULL;
5152 conshdlrdata->nlbbounds = 0;
5153 conshdlrdata->nubbounds = 0;
5154 conshdlrdata->nslackvars = 0;
5155 conshdlrdata->objcutindex = -1;
5158 conshdlrdata->roundingminthres = 0.1;
5159 conshdlrdata->roundingmaxthres = 0.6;
5161 conshdlrdata->roundingoffset = 0.1;
5162 conshdlrdata->addedcouplingcons =
FALSE;
5163 conshdlrdata->ninitconss = 0;
5164 conshdlrdata->nbinvarszero = 0;
5165 conshdlrdata->performedrestart =
FALSE;
5166 conshdlrdata->objindicatoronly =
FALSE;
5167 conshdlrdata->objothervarsonly =
FALSE;
5168 conshdlrdata->minabsobj = 0.0;
5169 conshdlrdata->normtype =
'e';
5170 conshdlrdata->niiscutsgen = 0;
5171 conshdlrdata->nperspcutsgen = 0;
5192 SCIP_Real minactivity = 0.0;
5193 SCIP_Real maxactivity = 0.0;
5194 SCIP_Real maxabsval = -1.0;
5195 SCIP_Real secabsval = -1.0;
5196 int maxabsvalidx = -1;
5218 if ( ! conshdlrdata->upgradelinear )
5222 for (j = 0; j <
nvars; ++j)
5238 secabsval = maxabsval;
5262 minactivity += val * lb;
5271 maxactivity += val * ub;
5275 assert( maxabsval >= 0.0 );
5276 assert( 0 <= maxabsvalidx && maxabsvalidx <
nvars );
5291 for (j = 0; j <
nvars; ++j)
5294 SCIP_Real* indconsvals;
5295 SCIP_Bool upgdlhs =
FALSE;
5296 SCIP_Bool upgdrhs =
FALSE;
5297 SCIP_Bool indneglhs =
FALSE;
5298 SCIP_Bool indnegrhs =
FALSE;
5341 if ( upgdlhs || upgdrhs )
5347 assert( ! upgdlhs || ! upgdrhs );
5354 for (l = 0; l <
nvars; ++l)
5356 if (
vars[l] == indvar )
5358 indconsvars[cnt] =
vars[l];
5360 indconsvals[cnt] = -vals[l];
5362 indconsvals[cnt] = vals[l];
5366 if ( indneglhs || indnegrhs )
5449 if ( conshdlrdata->trysolutions && conshdlrdata->heurtrysol ==
NULL )
5473 if ( conshdlrdata->binvarhash !=
NULL )
5476 if ( conshdlrdata->binslackvarhash !=
NULL )
5480 for (
i = 0;
i < nconss;
i++)
5485 if ( consdata->varswithevents !=
NULL )
5490 for (j = 0; j < consdata->nevents; ++j)
5497 consdata->nevents = 0;
5504 conshdlrdata->maxaddlincons = 0;
5505 conshdlrdata->naddlincons = 0;
5506 conshdlrdata->nrows = 0;
5530 if ( conshdlrdata->maxaddlincons > 0 )
5536 conshdlrdata->naddlincons = 0;
5537 conshdlrdata->maxaddlincons = 0;
5566 conshdlrdata->boundhaschanged =
TRUE;
5570 if ( conshdlrdata->sepaalternativelp )
5577 for (
c = 0;
c < nconss; ++
c)
5593 ++conshdlrdata->nslackvars;
5596 if ( conshdlrdata->genlogicor )
5599 int logicorsepafreq;
5604 if ( logicorconshdlr ==
NULL )
5606 SCIPerrorMessage(
"Logicor constraint handler not included, cannot generate constraints.\n");
5611 if ( (sepafreq != -1 || conshdlrdata->enforcecuts) && logicorsepafreq != 1 )
5613 SCIPwarningMessage(
scip,
"For better performance set parameter 'constraints/logicor/sepafreq' to 1 if 'constraints/included/genlogicor' is true.\n");
5619 conshdlrdata->objothervarsonly =
TRUE;
5620 for (
c = 0;
c < nconss; ++
c)
5636 conshdlrdata->objothervarsonly =
FALSE;
5639 if ( ! consdata->linconsactive )
5646 if ( conshdlrdata->sepaalternativelp && consdata->colindex < 0 )
5673 SCIP_CALL(
SCIPcreateNlRow(
scip, &nlrow,
SCIPconsGetName(conss[
c]), 0.0, 0,
NULL,
NULL, quadexpr, 0.0, 0.0,
SCIP_EXPRCURV_UNKNOWN) );
5688 if ( conshdlrdata->sepaalternativelp )
5695 if ( conshdlrdata->naddlincons > 0 )
5697 for (
c = 0;
c < conshdlrdata->naddlincons; ++
c)
5699 cons = conshdlrdata->addlincons[
c];
5718 SCIPdebugMsg(
scip,
"Added %d additional columns to alternative LP.\n", cnt);
5725 if ( conshdlrdata->useotherconss )
5727 const char* conshdlrname;
5735 for (
c = 0;
c < nallconss; ++
c)
5757 SCIPdebugMsg(
scip,
"Added %d additional columns from linear constraints to alternative LP.\n", cnt);
5763 if ( conshdlrdata->forcerestart )
5770 assert( conshdlrdata->eventhdlrrestart !=
NULL );
5776 conshdlrdata->nbinvarszero = 0;
5782 conshdlrdata->objindicatoronly =
FALSE;
5787 for (j = 0; j <
nvars; ++j)
5791 for (
c = 0;
c < nconss; ++
c)
5816 if ( probindex < 0 )
5820 covered[probindex] =
TRUE;
5824 for (j = 0; j <
nvars; ++j)
5835 if (
REALABS(
obj) < conshdlrdata->minabsobj )
5849 conshdlrdata->objindicatoronly =
TRUE;
5851 assert( conshdlrdata->eventhdlrrestart !=
NULL );
5877 if ( conshdlrdata->sepaalternativelp )
5879 if ( conshdlrdata->slackhash !=
NULL )
5888 if ( conshdlrdata->altlp !=
NULL )
5910 for (
c = 0;
c < nconss; ++
c)
5919 consdata->colindex = -1;
5945#ifdef SCIP_MORE_DEBUG
5960 if ( conshdlrdata->binslackvarhash !=
NULL )
5973 if ( conshdlrdata->sepaalternativelp )
5984 if ( (*consdata)->linconsactive )
5986 assert( conshdlrdata->eventhdlrbound !=
NULL );
5992 if ( conshdlrdata->forcerestart )
5994 assert( conshdlrdata->eventhdlrrestart !=
NULL );
6000 if ( conshdlrdata->linconsevents && (*consdata)->linconsactive && (*consdata)->varswithevents !=
NULL )
6007 for (j = 0; j < (*consdata)->nevents; ++j)
6015 (*consdata)->nevents = 0;
6016 assert( (*consdata)->varswithevents ==
NULL );
6060 assert( conshdlrdata->eventhdlrbound !=
NULL );
6062#ifdef SCIP_MORE_DEBUG
6072 if ( sourcedata->slackvar ==
NULL )
6079 if ( sourcedata->lincons ==
NULL )
6091 sourcedata->binvar,
TRUE, sourcedata->lessthanineq, sourcedata->slackvar, sourcedata->lincons, sourcedata->linconsactive) );
6092 consdata->activeone = sourcedata->activeone;
6109 if ( sourcedata->linconsactive )
6117 if ( conshdlrdata->sepaalternativelp )
6119 if ( conshdlrdata->binvarhash ==
NULL )
6153 for (
c = 0;
c < nconss; ++
c)
6178 consdata->lincons = translincons;
6186 conshdlrdata->addedcouplingcons =
FALSE;
6207 SCIP_Bool noReductions;
6208 SCIPdebug(
int oldnfixedvars = *nfixedvars; )
6209 SCIPdebug(
int oldndelconss = *ndelconss; )
6226 if ( nrounds == 0 || nnewfixedvars > 0 || nnewchgbds > 0 || nnewaggrvars > 0 )
6231 for (
c = 0;
c < nconss; ++
c)
6246#ifdef SCIP_MORE_DEBUG
6251 if ( ! consdata->linconsactive )
6260 if ( ! consdata->implicationadded )
6269 consdata->implicationadded =
TRUE;
6278 if ( ! consdata->slacktypechecked )
6280 consdata->slacktypechecked =
TRUE;
6287 SCIP_Bool foundslackvar =
FALSE;
6295 slackvar = consdata->slackvar;
6298 for (j = 0; j <
nvars; ++j)
6300 if (
vars[j] == slackvar )
6301 foundslackvar =
TRUE;
6309 if ( j ==
nvars && foundslackvar )
6311 SCIP_Bool infeasible;
6327 SCIPdebugMsg(
scip,
"Cannot change type of slack variable (<%s>) to IMPLINT, since global bound is non-integral: (%g, %g).\n",
6349 noReductions = nnewfixedvars == 0 && nnewaggrvars == 0 && nnewchgvartypes == 0 && nnewchgbds == 0
6350 && nnewdelconss == 0 && nnewchgcoefs == 0 && nnewchgsides == 0;
6353 if ( noReductions && *
result !=
SCIP_SUCCESS && conshdlrdata->addcouplingcons && ! conshdlrdata->addedcouplingcons )
6363 *nupgdconss += ngen;
6364 if ( conshdlrdata->removeindicators )
6367 conshdlrdata->addedcouplingcons =
TRUE;
6370 SCIPdebug(
SCIPdebugMsg(
scip,
"Presolved %d constraints (fixed %d variables, removed 0 variables, and deleted %d constraints).\n",
6371 nconss, *nfixedvars - oldnfixedvars, *ndelconss - oldndelconss); )
6396 *infeasible =
FALSE;
6399 if ( ! conshdlrdata->addcoupling )
6403 if ( conshdlrdata->addcouplingcons && conshdlrdata->addedcouplingcons )
6406 SCIPdebugMsg(
scip,
"Handle initial rows for %d indicator constraints.\n", nconss);
6409 for (
c = 0;
c < nconss && !(*infeasible); ++
c)
6420 if ( ! consdata->linconsactive )
6428 if ( ub <= conshdlrdata->maxcouplingvalue )
6439 if ( conshdlrdata->addcouplingcons )
6443 assert( ! conshdlrdata->addedcouplingcons );
6524 if ( solinfeasible )
6552 if ( solinfeasible )
6578 if ( solinfeasible )
6584 if ( objinfeasible )
6602 SCIP_Bool someLinconsNotActive;
6603 SCIP_Bool changedSol;
6627 someLinconsNotActive =
FALSE;
6628 for (
c = 0;
c < nconss; ++
c)
6638 if ( ! consdata->linconsactive )
6640 someLinconsNotActive =
TRUE;
6670 if ( trysol !=
NULL )
6674 changedSol = changedSol || changed;
6686 if ( trysol !=
NULL )
6690 changedSol = changedSol || changed;
6696 if ( someLinconsNotActive )
6699 SCIP_Bool infeasible;
6703 lp = conshdlrdata->altlp;
6704 assert( conshdlrdata->sepaalternativelp );
6714 if ( conshdlrdata->updatebounds )
6728 for (
c = 0;
c < nconss; ++
c)
6773 if ( trysol !=
NULL && changedSol )
6780 if ( trysol !=
NULL )
6801 SCIP_Bool dualreductions;
6829 if ( !conshdlrdata->linconsevents )
6831 for (
c = 0;
c < nconss; ++
c)
6844 if ( ! consdata->linconsactive )
6866 for (j = 0; j <
nvars; ++j)
6868 if (
vars[j] == consdata->slackvar )
6872 if ( vals[j] > 0.0 )
6875 consdata->varswithevents[consdata->nevents] =
vars[j];
6877 consdata->nevents++;
6882 consdata->varswithevents[consdata->nevents] =
vars[j];
6884 consdata->nevents++;
6889 conshdlrdata->linconsevents =
TRUE;
6893 conshdlrdata->boundhaschanged =
FALSE;
6894 conshdlrdata->linconsboundschanged =
FALSE;
6899 for (
c = 0;
c < nconss; ++
c)
6913#ifdef SCIP_MORE_DEBUG
6958 assert( inferinfo == 0 || inferinfo == 1 || inferinfo == 2 || inferinfo == 3 );
6959 assert( consdata->linconsactive );
6962 if ( inferinfo == 0 )
6965 assert( infervar != consdata->binvar );
6969 else if ( inferinfo == 1 )
6972 assert( infervar != consdata->slackvar );
6978 else if ( inferinfo == 2 )
6986 assert( inferinfo == 3 );
7015#ifdef SCIP_MORE_DEBUG
7021 if ( consdata->linconsactive )
7045 for (j = 0; j < nlinvars; ++j)
7094 binvar = consdata->binvar;
7122 const char* consname;
7136#ifdef SCIP_MORE_DEBUG
7151 sourcelincons = sourceconsdata->lincons;
7180 sourceconsdata->lincons = translincons;
7181 sourcelincons = translincons;
7195 sourcebinvar = sourceconsdata->binvar;
7206 sourceslackvar = sourceconsdata->slackvar;
7222 initial, separate, enforce, check,
propagate, local, dynamic, removable, stickingatnode) );
7230 if ( targetlincons !=
NULL )
7243 char binvarname[1024];
7244 char slackvarname[1024];
7245 char linconsname[1024];
7256 nargs = sscanf(str,
" <%1023[^>]> = %d -> <%1023[^>]> = 0 (<%1023[^>]>)", binvarname, &zeroone, slackvarname, linconsname);
7259 if ( nargs != 3 && nargs != 4 )
7266 if ( zeroone != 0 && zeroone != 1 )
7275 if ( binvar ==
NULL )
7287 if ( slackvar ==
NULL )
7298 if ( lincons ==
NULL )
7319 posstr = strstr(slackvarname,
"indslack");
7320 if ( posstr ==
NULL )
7328 (void)
SCIPsnprintf(binvarname, 1023,
"indlin%s", posstr+8);
7331 if ( lincons ==
NULL )
7337 if ( lincons ==
NULL )
7340 (void)
SCIPsnprintf(binvarname, 1023,
"%s", posstr+16);
7343 if( lincons ==
NULL )
7346 name, posstr+8, posstr+9, posstr+16);
7365 initial, separate, enforce, check,
propagate, local, dynamic, removable, stickingatnode) );
7383#ifdef SCIP_MORE_DEBUG
7393 if ( conshdlrdata->altlp !=
NULL )
7395 assert( conshdlrdata->sepaalternativelp );
7397 if ( consdata->colindex >= 0 )
7418#ifdef SCIP_MORE_DEBUG
7425 if ( conshdlrdata->altlp !=
NULL )
7431 assert( conshdlrdata->sepaalternativelp );
7433 if ( consdata->colindex >= 0 )
7469 if ( consdata->binvar !=
NULL )
7474 if ( consdata->slackvar !=
NULL )
7513 if ( consdata->binvar !=
NULL )
7515 if ( consdata->slackvar !=
NULL )
7542 SCIP_Bool bestvarroundup =
FALSE;
7553 *infeasible =
FALSE;
7559 for (
c = 0;
c < nindconss; ++
c)
7580 if ( score > bestscore )
7637 conshdlrdata->eventhdlrbound =
NULL;
7639 eventExecIndicatorBound,
NULL) );
7640 assert(conshdlrdata->eventhdlrbound !=
NULL);
7643 conshdlrdata->eventhdlrlinconsbound =
NULL;
7645 eventExecIndicatorLinconsBound,
NULL) );
7646 assert(conshdlrdata->eventhdlrlinconsbound !=
NULL);
7649 conshdlrdata->eventhdlrrestart =
NULL;
7651 eventExecIndicatorRestart,
NULL) );
7652 assert( conshdlrdata->eventhdlrrestart !=
NULL );
7654 conshdlrdata->heurtrysol =
NULL;
7658 conshdlrdata->binvarhash =
NULL;
7659 conshdlrdata->binslackvarhash =
NULL;
7667 conshdlrdata->addlincons =
NULL;
7668 conshdlrdata->naddlincons = 0;
7669 conshdlrdata->maxaddlincons = 0;
7674 consEnfolpIndicator, consEnfopsIndicator, consCheckIndicator, consLockIndicator,
7716 conflicthdlrdata->conshdlrdata = conshdlrdata;
7717 conflicthdlrdata->conshdlr = conshdlr;
7718 assert( conflicthdlrdata->conshdlr !=
NULL );
7722 conflictExecIndicator, conflicthdlrdata) );
7728 "constraints/indicator/branchindicators",
7729 "Branch on indicator constraints in enforcing?",
7733 "constraints/indicator/genlogicor",
7734 "Generate logicor constraints instead of cuts?",
7738 "constraints/indicator/addcoupling",
7739 "Add coupling constraints or rows if big-M is small enough?",
7743 "constraints/indicator/maxcouplingvalue",
7744 "maximum coefficient for binary variable in coupling constraint",
7748 "constraints/indicator/addcouplingcons",
7749 "Add initial variable upper bound constraints, if 'addcoupling' is true?",
7753 "constraints/indicator/sepacouplingcuts",
7754 "Should the coupling inequalities be separated dynamically?",
7758 "constraints/indicator/sepacouplinglocal",
7759 "Allow to use local bounds in order to separate coupling inequalities?",
7763 "constraints/indicator/sepacouplingvalue",
7764 "maximum coefficient for binary variable in separated coupling constraint",
7768 "constraints/indicator/sepaperspective",
7769 "Separate cuts based on perspective formulation?",
7773 "constraints/indicator/sepapersplocal",
7774 "Allow to use local bounds in order to separate perspective cuts?",
7778 "constraints/indicator/maxsepanonviolated",
7779 "maximal number of separated non violated IISs, before separation is stopped",
7783 "constraints/indicator/updatebounds",
7784 "Update bounds of original variables for separation?",
7788 "constraints/indicator/maxconditionaltlp",
7789 "maximum estimated condition of the solution basis matrix of the alternative LP to be trustworthy (0.0 to disable check)",
7793 "constraints/indicator/maxsepacuts",
7794 "maximal number of cuts separated per separation round",
7798 "constraints/indicator/maxsepacutsroot",
7799 "maximal number of cuts separated per separation round in the root node",
7803 "constraints/indicator/removeindicators",
7804 "Remove indicator constraint if corresponding variable bound constraint has been added?",
7808 "constraints/indicator/generatebilinear",
7809 "Do not generate indicator constraint, but a bilinear constraint instead?",
7813 "constraints/indicator/scaleslackvar",
7814 "Scale slack variable coefficient at construction time?",
7818 "constraints/indicator/trysolutions",
7819 "Try to make solutions feasible by setting indicator variables?",
7823 "constraints/indicator/enforcecuts",
7824 "In enforcing try to generate cuts (only if sepaalternativelp is true)?",
7828 "constraints/indicator/dualreductions",
7829 "Should dual reduction steps be performed?",
7833 "constraints/indicator/addopposite",
7834 "Add opposite inequality in nodes in which the binary variable has been fixed to 0?",
7838 "constraints/indicator/conflictsupgrade",
7839 "Try to upgrade bounddisjunction conflicts by replacing slack variables?",
7843 "constraints/indicator/restartfrac",
7844 "fraction of binary variables that need to be fixed before restart occurs (in forcerestart)",
7848 "constraints/indicator/useotherconss",
7849 "Collect other constraints to alternative LP?",
7853 "constraints/indicator/useobjectivecut",
7854 "Use objective cut with current best solution to alternative LP?",
7858 "constraints/indicator/trysolfromcover",
7859 "Try to construct a feasible solution from a cover?",
7863 "constraints/indicator/upgradelinear",
7864 "Try to upgrade linear constraints to indicator constraints?",
7869 "constraints/indicator/sepaalternativelp",
7870 "Separate using the alternative LP?",
7874 "constraints/indicator/forcerestart",
7875 "Force restart if absolute gap is 1 or enough binary variables have been fixed?",
7879 "constraints/indicator/nolinconscont",
7880 "Decompose problem (do not generate linear constraint if all variables are continuous)?",
7916 SCIP_Bool removable,
7918 SCIP_Bool stickingatnode
7923 return SCIPcreateConsIndicatorGeneric(
scip, cons, name, binvar,
nvars,
vars, vals, rhs,
TRUE,
TRUE, initial,
7924 separate, enforce, check,
propagate, local, dynamic, removable, stickingatnode);
7943 SCIP_Bool activeone,
7944 SCIP_Bool lessthanineq,
7959 SCIP_Bool removable,
7961 SCIP_Bool stickingatnode
7971 SCIP_Bool modifiable =
FALSE;
7972 SCIP_Bool linconsactive =
TRUE;
7974 SCIP_Real absvalsum = 0.0;
7976 SCIP_Real* valscopy;
7981 SCIPerrorMessage(
"Indicator constraint <%s> needs nonnegative number of variables in linear constraint.\n", name);
7987 if ( conshdlr ==
NULL )
7996 if ( conshdlrdata->nolinconscont && ! conshdlrdata->sepaalternativelp )
7998 SCIPerrorMessage(
"constraint handler <%s>: need parameter <sepaalternativelp> to be true if parameter <nolinconscont> is true.\n",
CONSHDLR_NAME);
8002 if ( conshdlrdata->nolinconscont && conshdlrdata->generatebilinear )
8015 for (j = 0; j <
nvars; ++j)
8016 valscopy[j] = -vals[j];
8023 for (j = 0; j <
nvars; ++j)
8025 if ( conshdlrdata->scaleslackvar )
8026 absvalsum +=
REALABS(valscopy[j]);
8030 if ( ! conshdlrdata->scaleslackvar )
8036 if ( binvar !=
NULL )
8042 binvarinternal = binvar;
8049 if ( conshdlrdata->binslackvarhash ==
NULL )
8054 assert( conshdlrdata->binslackvarhash !=
NULL );
8057 SCIP_Bool infeasible;
8100 if ( conshdlrdata->nolinconscont )
8102 SCIP_Bool onlyCont =
TRUE;
8104 assert( ! conshdlrdata->generatebilinear );
8107 for (j = 0; j <
nvars; ++j)
8120 linconsactive =
FALSE;
8127 if ( linconsactive )
8140 if ( ! lessthanineq )
8148 if ( conshdlrdata->scaleslackvar &&
nvars > 0 )
8164 if ( conshdlrdata->generatebilinear )
8166 SCIP_Real val = 1.0;
8171 binvarinternal = binvar;
8178 SCIP_CALL(
SCIPcreateConsQuadraticNonlinear(
scip, cons, name, 0,
NULL,
NULL, 1, &binvarinternal, &slackvar, &val, 0.0, 0.0,
8185 binvar, activeone, lessthanineq, slackvar, lincons, linconsactive) );
8190 SCIP_CALL(
SCIPcreateCons(
scip, cons, name, conshdlr, consdata, initial, separate, enforce, check,
propagate,
8191 local, modifiable, dynamic, removable, stickingatnode) );
8196 if ( linconsactive )
8203 if ( conshdlrdata->sepaalternativelp )
8207 if ( conshdlrdata->binvarhash ==
NULL )
8214 binvarinternal = binvar;
8281 SCIP_Bool activeone,
8296 SCIP_Bool removable,
8298 SCIP_Bool stickingatnode
8306 SCIP_Bool modifiable =
FALSE;
8307 SCIP_Bool linconsactive =
TRUE;
8324 if ( conshdlr ==
NULL )
8333 if ( conshdlrdata->nolinconscont && ! conshdlrdata->sepaalternativelp )
8335 SCIPerrorMessage(
"constraint handler <%s>: need parameter <sepaalternativelp> to be true if parameter <nolinconscont> is true.\n",
CONSHDLR_NAME);
8343 if ( conshdlrdata->nolinconscont )
8345 SCIP_Bool onlyCont =
TRUE;
8354 for (v = 0; v <
nvars; ++v)
8367 linconsactive =
FALSE;
8375 if ( conshdlrdata->generatebilinear )
8377 SCIP_Real val = 1.0;
8383 binvarinternal = binvar;
8391 SCIP_CALL(
SCIPcreateConsQuadraticNonlinear(
scip, cons, name, 0,
NULL,
NULL, 1, &binvarinternal, &slackvar, &val, 0.0, 0.0,
8398 binvar, activeone,
TRUE, slackvar, lincons, linconsactive) );
8402 SCIP_CALL(
SCIPcreateCons(
scip, cons, name, conshdlr, consdata, initial, separate, enforce, check,
propagate,
8403 local, modifiable, dynamic, removable, stickingatnode) );
8451 SCIP_Bool removable,
8453 SCIP_Bool stickingatnode
8459 enforce, check,
propagate, local, dynamic, removable, stickingatnode);
8516 SCIP_Bool activeone,
8531 SCIP_Bool removable,
8533 SCIP_Bool stickingatnode
8542 SCIP_Bool modifiable =
FALSE;
8543 SCIP_Bool linconsactive =
TRUE;
8569 if ( conshdlr ==
NULL )
8578 if ( conshdlrdata->nolinconscont && ! conshdlrdata->sepaalternativelp )
8580 SCIPerrorMessage(
"constraint handler <%s>: need parameter <sepaalternativelp> to be true if parameter <nolinconscont> is true.\n",
CONSHDLR_NAME);
8597 for (j = 0; j <
nvars; ++j)
8608 binvarinternal = binvar;
8615 if ( conshdlrdata->binslackvarhash ==
NULL )
8620 assert( conshdlrdata->binslackvarhash !=
NULL );
8630 SCIP_Bool infeasible;
8654 if ( conshdlrdata->nolinconscont )
8656 SCIP_Bool onlyCont =
TRUE;
8662 for (j = 0; j <
nvars; ++j)
8675 linconsactive =
FALSE;
8691 if ( conshdlrdata->generatebilinear )
8693 SCIP_Real val = 1.0;
8696 SCIP_CALL(
SCIPcreateConsQuadraticNonlinear(
scip, cons, name, 0,
NULL,
NULL, 1, &binvarinternal, &slackvar, &val, 0.0, 0.0,
8703 binvar, activeone,
TRUE, slackvar, lincons, linconsactive) );
8707 SCIP_CALL(
SCIPcreateCons(
scip, cons, name, conshdlr, consdata, initial, separate, enforce, check,
propagate,
8708 local, modifiable, dynamic, removable, stickingatnode) );
8754 SCIP_Bool removable,
8756 SCIP_Bool stickingatnode
8762 enforce, check,
propagate, local, dynamic, removable, stickingatnode);
8783 if ( !consdata->lessthanineq )
8791 SCIP_Bool infeasible;
8814 return consdata->lincons;
8851 consdata->lincons = lincons;
8852 consdata->linconsactive =
TRUE;
8856 if ( conshdlrdata->nolinconscont )
8869 for (v = 0; v <
nvars; ++v)
8882 consdata->linconsactive =
FALSE;
8901 return consdata->activeone;
8918 return consdata->binvar;
8934 binvar = consdata->binvar;
8936 if ( ! consdata->activeone )
8967 if ( consdata->binvar !=
NULL )
8985 if ( ! consdata->activeone )
8988 consdata->binvar =
var;
8995 assert( conshdlrdata->eventhdlrbound !=
NULL );
8996 assert( conshdlrdata->eventhdlrrestart !=
NULL );
8999 if ( consdata->linconsactive )
9005 if ( conshdlrdata->forcerestart )
9012 ++(consdata->nfixednonzero);
9016 if ( ! consdata->activeone )
9018 consdata->binvar = binvar;
9037 return consdata->slackvar;
9093 if ( consdata->linconsactive )
9144 SCIP_Real slackcoef;
9167 if ( ! consdata->linconsactive )
9170 lincons = consdata->lincons;
9176 slackvar = consdata->slackvar;
9177 binvar = consdata->binvar;
9188 for (v = 0; v < nlinvars; ++v)
9192 if (
var != slackvar )
9195 slackcoef = linvals[v];
9203 assert( slackcoef != 0.0 );
9216 val = (val - sum)/slackcoef;
9219 if ( slackcoef < 0 )
9331 for (
c = 0;
c < nconss; ++
c)
9334 SCIP_Bool chg =
FALSE;
9341 if ( ! consdata->linconsactive )
9345 *changed = *changed || chg;
9372 assert( conshdlrdata->naddlincons+1 <= conshdlrdata->maxaddlincons );
9374 conshdlrdata->addlincons[conshdlrdata->naddlincons++] = lincons;
9405 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