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
320#define DEFAULT_USESAMESLACKVAR FALSE
324#define OBJEPSILON 0.001
325#define SEPAALTTHRESHOLD 10
326#define MAXROUNDINGROUNDS 1
342 unsigned int linconsactive:1;
343 unsigned int implicationadded:1;
344 unsigned int slacktypechecked:1;
349struct SCIP_ConshdlrData
378 int maxroundingrounds;
402 int maxsepanonviolated;
431struct SCIP_ConflicthdlrData
452#define SCIP_CALL_PARAM(x) do \
454 SCIP_RETCODE _restat_; \
455 if ( (_restat_ = (x)) != SCIP_OKAY && (_restat_ != SCIP_PARAMETERUNKNOWN) ) \
457 SCIPerrorMessage("[%s:%d] Error <%d> in function call\n", __FILE__, __LINE__, _restat_); \
503 lincons = consdata->lincons;
520 for(
i = 0;
i < nvarslincons; ++
i )
523 vals[
i] = linvals[
i];
525 nlocvars = nvarslincons;
547 vars[0] = consdata->binvar;
563 else if( nlocvars == 1 )
584 vars[0] = consdata->slackvar;
600 else if( nlocvars == 1 )
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)
947 if ( haveslack &&
i == nbdchginfos )
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 )
1071 if ( *value == newvalue )
1126#ifdef SCIP_ENABLE_IISCHECK
1169 for (
c = 0;
c < nconss; ++
c)
1196 lincons = consdata->lincons;
1201 slackvar = consdata->slackvar;
1223 linvals[0] = scalar;
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 )
1329 matval[cnt] = sign * linvals[v];
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)
1472 matval[cnt] = linvals[v];
1550 assert( conshdlrdata->naddlincons <= conshdlrdata->maxaddlincons );
1552 if ( num > conshdlrdata->maxaddlincons )
1558 conshdlrdata->maxaddlincons = newsize;
1560 assert( num <= conshdlrdata->maxaddlincons );
1606 conshdlrdata->nrows = 1;
1648 for (j = 0; j < nCols; ++j)
1653 for (j = 0; j < nconss; ++j)
1661 ind = consdata->colindex;
1666 covered[ind] =
TRUE;
1675 for (j = 0; j < nCols; ++j)
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;
1815 int* indices =
NULL;
1828 for (j = 0; j < nconss; ++j)
1836 if ( consdata->colindex >= 0 )
1840 indices[cnt] = consdata->colindex;
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)
2131 assert( 0 <= col && col < nCols );
2149 assert( 0 <= col && col < nCols );
2178 if ( ! conshdlrdata->scaled )
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 );
2301 matval[cnt++] = sign * rhscoef;
2305 for (v = 0; v <
nvars; ++v)
2316 if (
var != slackvar )
2322 if ( ind < INT_MAX )
2330 matind[cnt] = (conshdlrdata->nrows)++;
2333 newrowsslack[nnewrows++] =
TRUE;
2336 matval[cnt++] = sign * vals[v];
2350 matind[cnt] = (conshdlrdata->nrows)++;
2353 newrowsslack[nnewrows++] =
FALSE;
2354 newvars[nnewvars++] =
var;
2357 matval[cnt++] = sign * vals[v];
2370 for (
i = 0;
i < nnewrows; ++
i)
2372 if ( newrowsslack[
i] )
2402 for (v = 0; v < nnewvars; ++v)
2411 matbeg[nnewcols] = cnt;
2415 matval[cnt++] = -val;
2420 matval[cnt++] = -1.0;
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",
2437 matbeg[nnewcols] = cnt;
2441 matval[cnt++] = val;
2446 matval[cnt++] = 1.0;
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;
2534 SCIPdebugMsg(
scip,
"Slack variable is aggregated (scalar: %f, constant: %f).\n", scalar, constant);
2544 linvals[0] = scalar;
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) );
2637 for (j = 0; j < nrowcols; ++j)
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;
2718 objvals[nobjvars++] =
objval;
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 )
2804 if (
SCIPisLT(
scip, objbnd, conshdlrdata->objupperbound) )
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;
2911 if ( maxcondition > 0.0 )
2915 if ( condition !=
SCIP_INVALID && condition > maxcondition )
2917 SCIPdebugMsg(
scip,
"Estimated condition number of basis matrix (%e) exceeds maximal allowance (%e).\n", condition, maxcondition);
2925 SCIPdebugMsg(
scip,
"Estimated condition number of basis matrix (%e) is below maximal allowance (%e).\n", condition, maxcondition);
2929 SCIPdebugMsg(
scip,
"Estimated condition number of basis matrix not available.\n");
2987 *infeasible =
FALSE;
3024 int nnonviolated = 0;
3044 assert( nconss <= nCols );
3075 SCIPdebugMsg(
scip,
" size: %4d produced possible cover with indicator variable objective value %f.\n", *size, *value);
3078 if ( conshdlrdata->trysolfromcover )
3088 if ( heurindicator ==
NULL )
3105 for (j = 0; j < nconss; ++j)
3112 ind = consdata->colindex;
3129 if ( val < candval )
3141 if ( candidate < 0 )
3147 assert( candidate >= 0 );
3148 assert( ! S[candidate] );
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",
3176 S[candidate] =
TRUE;
3188#ifdef SCIP_ENABLE_IISCHECK
3194 if ( conshdlrdata->updatebounds )
3209 for (j = 0; j < nconss; ++j)
3215 ind = consdata->colindex;
3231 assert( cnt == sizeIIS );
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) );
3246 switch ( enfosepatype )
3289 for (j = 0; j < nconss; ++j)
3295 ind = consdata->colindex;
3336 if ( nnonviolated > conshdlrdata->maxsepanonviolated )
3338 SCIPdebugMsg(
scip,
"Stop separation after %d non violated IISs.\n", nnonviolated);
3342 while (step < nconss);
3358 const char* consname,
3379 if ( activeone || binvar ==
NULL )
3381 binvarinternal = binvar;
3390 (*consdata)->nfixednonzero = 0;
3391 (*consdata)->colindex = -1;
3392 (*consdata)->linconsactive = linconsactive;
3393 (*consdata)->binvar = binvarinternal;
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;
3410 if ( binvarinternal !=
NULL )
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)
3512 if ( ub <= conshdlrdata->maxcouplingvalue )
3529 !conshdlrdata->removeindicators, !conshdlrdata->removeindicators,
FALSE) );
3535 if ( conshdlrdata->removeindicators )
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;
3724 if (
var != consdata->binvar && ! negated )
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",
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 )
4023 allintegral =
FALSE;
4026 vals[
nvars++] = linvals[j];
4070 if ( dualreductions )
4076 binvar = consdata->binvar;
4164 for (j = 0; j < nlinconsvars; ++j)
4170 val = linconsvals[j];
4173 var = linconsvars[j];
4177 if (
var == consdata->slackvar )
4194 maxactivity += val *
bound;
4206 newub = (maxactivity - rhs) / (-1.0 * coeffslack);
4215 SCIPdebugMsg(
scip,
"Adjusting upper bound of slack variable <%s> to %g for indicator constraint <%s>.\n",
4277 lp = conshdlrdata->altlp;
4285 if ( conshdlrdata->updatebounds )
4300 for (j = 0; j < nconss; ++j)
4324 SCIP_CALL(
extendToCover(
scip, conshdlr, conshdlrdata, lp,
sol, enfosepatype, conshdlrdata->removable, genlogicor, nconss, conss, S, &size, &value, &error,
cutoff, &nCuts) );
4328 if ( nCuts == 0 && error )
4394 for (
c = 0;
c < nconss; ++
c)
4406 if ( ! consdata->linconsactive )
4408 someLinconsNotActive =
TRUE;
4428 binvar = consdata->binvar;
4436 if ( valSlack > maxSlack )
4438 maxSlack = valSlack;
4453 if ( (someLinconsNotActive || conshdlrdata->enforcecuts) && conshdlrdata->sepaalternativelp )
4461 conshdlrdata->niiscutsgen += ngen;
4468 conshdlrdata->niiscutsgen += ngen;
4494 if ( ! conshdlrdata->branchindicators )
4504 binvar = consdata->binvar;
4505 slackvar = consdata->slackvar;
4569 if ( *nGen >= maxsepacuts )
4577 lp = conshdlrdata->altlp;
4587 if ( conshdlrdata->updatebounds )
4605 for (threshold = conshdlrdata->roundingmaxthres;
4606 rounds < conshdlrdata->maxroundingrounds && threshold >= conshdlrdata->roundingminthres && *nGen < maxsepacuts && ! (*
cutoff);
4607 threshold -= conshdlrdata->roundingoffset )
4622 for (j = 0; j < nconss; ++j)
4654 if ( binvarval > binvarnegval )
4672 if ( size == nconss )
4679 if ( size == oldsize )
4681 SCIPdebugMsg(
scip,
"Skipping computation: size support has not changed.\n");
4687 SCIPdebugMsg(
scip,
" Vars with value 1: %d 0: %d and fractional: %d.\n", nvarsone, nvarszero, nvarsfrac);
4695 nconss, conss, S, &size, &value, &error,
cutoff, &nCuts) );
4775 if ( *nGen >= maxsepacuts )
4786 for (
c = 0;
c < nconss; ++
c)
4797 slackvar = consdata->slackvar;
4799 lincons = consdata->lincons;
4802 binvar = consdata->binvar;
4837 cutval = binval * ypart;
4839 for (j = 0; j < nlinvars; ++j)
4849 if ( linvars[j] == slackvar )
4852 if ( conshdlrdata->sepapersplocal )
4871 finitebound =
FALSE;
4876 linval = signfactor * linvals[j];
4880 dout += linval * lb;
4885 dout += linval * ub;
4889 xpart = linval * xval;
4892 if (
SCIPisGT(
scip, binval * din, binval * dout + xpart) )
4895 cutval += binval * din;
4903 cutval += binval * dout + xpart;
4905 cutvars[cnt] = linvars[j];
4906 cutvals[cnt++] = linval;
4910 if ( ! finitebound )
4920 cutvars[cnt] = binvar;
4921 cutvals[cnt] = ypart;
4925 (void)
SCIPsnprintf(name, 50,
"persp%d", conshdlrdata->nperspcutsgen + *nGen);
4938 if ( *nGen >= maxsepacuts )
4986 maxsepacuts = conshdlrdata->maxsepacutsroot;
4988 maxsepacuts = conshdlrdata->maxsepacuts;
4991 if ( conshdlrdata->sepacouplingcuts )
4998 for (
c = 0;
c < nusefulconss && ncuts < maxsepacuts; ++
c)
5013 if ( conshdlrdata->sepacouplinglocal )
5024 if ( ub <= conshdlrdata->sepacouplingvalue )
5062 SCIPdebugMsg(
scip,
"Number of separated coupling inequalities: %d.\n", ncuts);
5071 SCIPdebugMsg(
scip,
"Separating inequalities for indicator constraints.\n");
5079 SCIPdebugMsg(
scip,
"Separated %d cuts from indicator constraints.\n", ncuts - noldcuts);
5083 else if ( ncuts > noldcuts )
5085 conshdlrdata->niiscutsgen += ncuts;
5088 if ( conshdlrdata->genlogicor )
5100 SCIPdebugMsg(
scip,
"Separating inequalities based on perspective formulation.\n");
5108 SCIPdebugMsg(
scip,
"Separated %d cuts from perspective formulation.\n", ncuts - noldcuts);
5110 if ( ncuts > noldcuts )
5112 conshdlrdata->nperspcutsgen += ncuts;
5132 conshdlrdata->linconsevents =
FALSE;
5133 conshdlrdata->linconsboundschanged =
TRUE;
5134 conshdlrdata->boundhaschanged =
TRUE;
5135 conshdlrdata->removable =
TRUE;
5136 conshdlrdata->scaled =
FALSE;
5137 conshdlrdata->altlp =
NULL;
5138 conshdlrdata->nrows = 0;
5139 conshdlrdata->varhash =
NULL;
5140 conshdlrdata->slackhash =
NULL;
5141 conshdlrdata->lbhash =
NULL;
5142 conshdlrdata->ubhash =
NULL;
5143 conshdlrdata->nlbbounds = 0;
5144 conshdlrdata->nubbounds = 0;
5145 conshdlrdata->nslackvars = 0;
5146 conshdlrdata->objcutindex = -1;
5149 conshdlrdata->roundingminthres = 0.1;
5150 conshdlrdata->roundingmaxthres = 0.6;
5152 conshdlrdata->roundingoffset = 0.1;
5153 conshdlrdata->addedcouplingcons =
FALSE;
5154 conshdlrdata->ninitconss = 0;
5155 conshdlrdata->nbinvarszero = 0;
5156 conshdlrdata->performedrestart =
FALSE;
5157 conshdlrdata->objindicatoronly =
FALSE;
5158 conshdlrdata->objothervarsonly =
FALSE;
5159 conshdlrdata->minabsobj = 0.0;
5160 conshdlrdata->normtype =
'e';
5161 conshdlrdata->niiscutsgen = 0;
5162 conshdlrdata->nperspcutsgen = 0;
5187 int maxabsvalidx = -1;
5209 if ( ! conshdlrdata->upgradelinear )
5213 for (j = 0; j <
nvars; ++j)
5229 secabsval = maxabsval;
5253 minactivity += val * lb;
5262 maxactivity += val * ub;
5266 assert( maxabsval >= 0.0 );
5267 assert( 0 <= maxabsvalidx && maxabsvalidx <
nvars );
5282 for (j = 0; j <
nvars; ++j)
5332 if ( upgdlhs || upgdrhs )
5338 assert( ! upgdlhs || ! upgdrhs );
5345 for (l = 0; l <
nvars; ++l)
5347 if (
vars[l] == indvar )
5349 indconsvars[cnt] =
vars[l];
5351 indconsvals[cnt] = -vals[l];
5353 indconsvals[cnt] = vals[l];
5357 if ( indneglhs || indnegrhs )
5440 if ( conshdlrdata->trysolutions && conshdlrdata->heurtrysol ==
NULL )
5464 if ( conshdlrdata->binvarhash !=
NULL )
5467 if ( conshdlrdata->binslackvarhash !=
NULL )
5471 for (
i = 0;
i < nconss;
i++)
5476 if ( consdata->varswithevents !=
NULL )
5481 for (j = 0; j < consdata->nevents; ++j)
5488 consdata->nevents = 0;
5495 conshdlrdata->maxaddlincons = 0;
5496 conshdlrdata->naddlincons = 0;
5497 conshdlrdata->nrows = 0;
5521 if ( conshdlrdata->maxaddlincons > 0 )
5527 conshdlrdata->naddlincons = 0;
5528 conshdlrdata->maxaddlincons = 0;
5557 conshdlrdata->boundhaschanged =
TRUE;
5561 if ( conshdlrdata->sepaalternativelp )
5568 for (
c = 0;
c < nconss; ++
c)
5584 ++conshdlrdata->nslackvars;
5587 if ( conshdlrdata->genlogicor )
5590 int logicorsepafreq;
5595 if ( logicorconshdlr ==
NULL )
5597 SCIPerrorMessage(
"Logicor constraint handler not included, cannot generate constraints.\n");
5602 if ( (sepafreq != -1 || conshdlrdata->enforcecuts) && logicorsepafreq != 1 )
5604 SCIPwarningMessage(
scip,
"For better performance set parameter 'constraints/logicor/sepafreq' to 1 if 'constraints/included/genlogicor' is true.\n");
5610 conshdlrdata->objothervarsonly =
TRUE;
5611 for (
c = 0;
c < nconss; ++
c)
5627 conshdlrdata->objothervarsonly =
FALSE;
5630 if ( ! consdata->linconsactive )
5637 if ( conshdlrdata->sepaalternativelp && consdata->colindex < 0 )
5664 SCIP_CALL(
SCIPcreateNlRow(
scip, &nlrow,
SCIPconsGetName(conss[
c]), 0.0, 0,
NULL,
NULL, quadexpr, 0.0, 0.0,
SCIP_EXPRCURV_UNKNOWN) );
5679 if ( conshdlrdata->sepaalternativelp )
5686 if ( conshdlrdata->naddlincons > 0 )
5688 for (
c = 0;
c < conshdlrdata->naddlincons; ++
c)
5690 cons = conshdlrdata->addlincons[
c];
5709 SCIPdebugMsg(
scip,
"Added %d additional columns to alternative LP.\n", cnt);
5716 if ( conshdlrdata->useotherconss )
5718 const char* conshdlrname;
5726 for (
c = 0;
c < nallconss; ++
c)
5748 SCIPdebugMsg(
scip,
"Added %d additional columns from linear constraints to alternative LP.\n", cnt);
5754 if ( conshdlrdata->forcerestart )
5761 assert( conshdlrdata->eventhdlrrestart !=
NULL );
5767 conshdlrdata->nbinvarszero = 0;
5773 conshdlrdata->objindicatoronly =
FALSE;
5778 for (j = 0; j <
nvars; ++j)
5782 for (
c = 0;
c < nconss; ++
c)
5807 if ( probindex < 0 )
5811 covered[probindex] =
TRUE;
5815 for (j = 0; j <
nvars; ++j)
5826 if (
REALABS(
obj) < conshdlrdata->minabsobj )
5840 conshdlrdata->objindicatoronly =
TRUE;
5842 assert( conshdlrdata->eventhdlrrestart !=
NULL );
5868 if ( conshdlrdata->sepaalternativelp )
5870 if ( conshdlrdata->slackhash !=
NULL )
5879 if ( conshdlrdata->altlp !=
NULL )
5901 for (
c = 0;
c < nconss; ++
c)
5910 consdata->colindex = -1;
5936#ifdef SCIP_MORE_DEBUG
5951 if ( conshdlrdata->binslackvarhash !=
NULL )
5964 if ( conshdlrdata->sepaalternativelp )
5975 if ( (*consdata)->linconsactive )
5977 assert( conshdlrdata->eventhdlrbound !=
NULL );
5983 if ( conshdlrdata->forcerestart )
5985 assert( conshdlrdata->eventhdlrrestart !=
NULL );
5991 if ( conshdlrdata->linconsevents && (*consdata)->linconsactive && (*consdata)->varswithevents !=
NULL )
5998 for (j = 0; j < (*consdata)->nevents; ++j)
6006 (*consdata)->nevents = 0;
6007 assert( (*consdata)->varswithevents ==
NULL );
6051 assert( conshdlrdata->eventhdlrbound !=
NULL );
6053#ifdef SCIP_MORE_DEBUG
6063 if ( sourcedata->slackvar ==
NULL )
6070 if ( sourcedata->lincons ==
NULL )
6082 sourcedata->binvar,
TRUE, sourcedata->lessthanineq, sourcedata->slackvar, sourcedata->lincons, sourcedata->linconsactive) );
6083 consdata->activeone = sourcedata->activeone;
6100 if ( sourcedata->linconsactive )
6108 if ( conshdlrdata->sepaalternativelp )
6110 if ( conshdlrdata->binvarhash ==
NULL )
6144 for (
c = 0;
c < nconss; ++
c)
6169 consdata->lincons = translincons;
6177 conshdlrdata->addedcouplingcons =
FALSE;
6199 SCIPdebug(
int oldnfixedvars = *nfixedvars; )
6200 SCIPdebug(
int oldndelconss = *ndelconss; )
6217 if ( nrounds == 0 || nnewfixedvars > 0 || nnewchgbds > 0 || nnewaggrvars > 0 )
6222 for (
c = 0;
c < nconss; ++
c)
6237#ifdef SCIP_MORE_DEBUG
6242 if ( ! consdata->linconsactive )
6251 if ( ! consdata->implicationadded )
6260 consdata->implicationadded =
TRUE;
6269 if ( ! consdata->slacktypechecked )
6271 consdata->slacktypechecked =
TRUE;
6286 slackvar = consdata->slackvar;
6289 for (j = 0; j <
nvars; ++j)
6291 if (
vars[j] == slackvar )
6292 foundslackvar =
TRUE;
6300 if ( j ==
nvars && foundslackvar )
6318 SCIPdebugMsg(
scip,
"Cannot change type of slack variable (<%s>) to IMPLINT, since global bound is non-integral: (%g, %g).\n",
6340 noReductions = nnewfixedvars == 0 && nnewaggrvars == 0 && nnewchgvartypes == 0 && nnewchgbds == 0
6341 && nnewdelconss == 0 && nnewchgcoefs == 0 && nnewchgsides == 0;
6344 if ( noReductions && *
result !=
SCIP_SUCCESS && conshdlrdata->addcouplingcons && ! conshdlrdata->addedcouplingcons )
6354 *nupgdconss += ngen;
6355 if ( conshdlrdata->removeindicators )
6358 conshdlrdata->addedcouplingcons =
TRUE;
6361 SCIPdebug(
SCIPdebugMsg(
scip,
"Presolved %d constraints (fixed %d variables, removed 0 variables, and deleted %d constraints).\n",
6362 nconss, *nfixedvars - oldnfixedvars, *ndelconss - oldndelconss); )
6387 *infeasible =
FALSE;
6390 if ( ! conshdlrdata->addcoupling )
6394 if ( conshdlrdata->addcouplingcons && conshdlrdata->addedcouplingcons )
6397 SCIPdebugMsg(
scip,
"Handle initial rows for %d indicator constraints.\n", nconss);
6400 for (
c = 0;
c < nconss && !(*infeasible); ++
c)
6411 if ( ! consdata->linconsactive )
6419 if ( ub <= conshdlrdata->maxcouplingvalue )
6430 if ( conshdlrdata->addcouplingcons )
6434 assert( ! conshdlrdata->addedcouplingcons );
6515 if ( solinfeasible )
6543 if ( solinfeasible )
6569 if ( solinfeasible )
6575 if ( objinfeasible )
6618 someLinconsNotActive =
FALSE;
6619 for (
c = 0;
c < nconss; ++
c)
6629 if ( ! consdata->linconsactive )
6631 someLinconsNotActive =
TRUE;
6661 if ( trysol !=
NULL )
6665 changedSol = changedSol || changed;
6677 if ( trysol !=
NULL )
6681 changedSol = changedSol || changed;
6687 if ( someLinconsNotActive )
6694 lp = conshdlrdata->altlp;
6695 assert( conshdlrdata->sepaalternativelp );
6705 if ( conshdlrdata->updatebounds )
6719 for (
c = 0;
c < nconss; ++
c)
6764 if ( trysol !=
NULL && changedSol )
6771 if ( trysol !=
NULL )
6820 if ( !conshdlrdata->linconsevents )
6822 for (
c = 0;
c < nconss; ++
c)
6835 if ( ! consdata->linconsactive )
6857 for (j = 0; j <
nvars; ++j)
6859 if (
vars[j] == consdata->slackvar )
6863 if ( vals[j] > 0.0 )
6866 consdata->varswithevents[consdata->nevents] =
vars[j];
6868 consdata->nevents++;
6873 consdata->varswithevents[consdata->nevents] =
vars[j];
6875 consdata->nevents++;
6880 conshdlrdata->linconsevents =
TRUE;
6884 conshdlrdata->boundhaschanged =
FALSE;
6885 conshdlrdata->linconsboundschanged =
FALSE;
6890 for (
c = 0;
c < nconss; ++
c)
6904#ifdef SCIP_MORE_DEBUG
6949 assert( inferinfo == 0 || inferinfo == 1 || inferinfo == 2 || inferinfo == 3 );
6950 assert( consdata->linconsactive );
6953 if ( inferinfo == 0 )
6956 assert( infervar != consdata->binvar );
6960 else if ( inferinfo == 1 )
6963 assert( infervar != consdata->slackvar );
6969 else if ( inferinfo == 2 )
6982 assert( inferinfo == 3 );
6989 for (j = 0; j < nlinconsvars; ++j)
6991 if ( linconsvals[j] > 0.0 )
7029#ifdef SCIP_MORE_DEBUG
7035 if ( consdata->linconsactive )
7059 for (j = 0; j < nlinvars; ++j)
7108 binvar = consdata->binvar;
7136 const char* consname;
7150#ifdef SCIP_MORE_DEBUG
7165 sourcelincons = sourceconsdata->lincons;
7194 sourceconsdata->lincons = translincons;
7195 sourcelincons = translincons;
7209 sourcebinvar = sourceconsdata->binvar;
7220 sourceslackvar = sourceconsdata->slackvar;
7236 initial, separate, enforce, check,
propagate, local, dynamic, removable, stickingatnode) );
7244 if ( targetlincons !=
NULL )
7257 char binvarname[1024];
7258 char slackvarname[1024];
7259 char linconsname[1024];
7270 nargs = sscanf(str,
" <%1023[^>]> = %d -> <%1023[^>]> = 0 (<%1023[^>]>)", binvarname, &zeroone, slackvarname, linconsname);
7273 if ( nargs != 3 && nargs != 4 )
7280 if ( zeroone != 0 && zeroone != 1 )
7289 if ( binvar ==
NULL )
7301 if ( slackvar ==
NULL )
7312 if ( lincons ==
NULL )
7333 posstr = strstr(slackvarname,
"indslack");
7334 if ( posstr ==
NULL )
7342 (void)
SCIPsnprintf(binvarname, 1023,
"indlin%s", posstr+8);
7345 if ( lincons ==
NULL )
7351 if ( lincons ==
NULL )
7354 (void)
SCIPsnprintf(binvarname, 1023,
"%s", posstr+16);
7357 if( lincons ==
NULL )
7360 name, posstr+8, posstr+9, posstr+16);
7379 initial, separate, enforce, check,
propagate, local, dynamic, removable, stickingatnode) );
7397#ifdef SCIP_MORE_DEBUG
7407 if ( conshdlrdata->altlp !=
NULL )
7409 assert( conshdlrdata->sepaalternativelp );
7411 if ( consdata->colindex >= 0 )
7432#ifdef SCIP_MORE_DEBUG
7439 if ( conshdlrdata->altlp !=
NULL )
7445 assert( conshdlrdata->sepaalternativelp );
7447 if ( consdata->colindex >= 0 )
7483 if ( consdata->binvar !=
NULL )
7488 if ( consdata->slackvar !=
NULL )
7527 if ( consdata->binvar !=
NULL )
7529 if ( consdata->slackvar !=
NULL )
7567 *infeasible =
FALSE;
7573 for (
c = 0;
c < nindconss; ++
c)
7594 if ( score > bestscore )
7651 conshdlrdata->eventhdlrbound =
NULL;
7653 eventExecIndicatorBound,
NULL) );
7654 assert(conshdlrdata->eventhdlrbound !=
NULL);
7657 conshdlrdata->eventhdlrlinconsbound =
NULL;
7659 eventExecIndicatorLinconsBound,
NULL) );
7660 assert(conshdlrdata->eventhdlrlinconsbound !=
NULL);
7663 conshdlrdata->eventhdlrrestart =
NULL;
7665 eventExecIndicatorRestart,
NULL) );
7666 assert( conshdlrdata->eventhdlrrestart !=
NULL );
7668 conshdlrdata->heurtrysol =
NULL;
7672 conshdlrdata->binvarhash =
NULL;
7673 conshdlrdata->binslackvarhash =
NULL;
7681 conshdlrdata->addlincons =
NULL;
7682 conshdlrdata->naddlincons = 0;
7683 conshdlrdata->maxaddlincons = 0;
7688 consEnfolpIndicator, consEnfopsIndicator, consCheckIndicator, consLockIndicator,
7730 conflicthdlrdata->conshdlrdata = conshdlrdata;
7731 conflicthdlrdata->conshdlr = conshdlr;
7732 assert( conflicthdlrdata->conshdlr !=
NULL );
7736 conflictExecIndicator, conflicthdlrdata) );
7742 "constraints/indicator/branchindicators",
7743 "Branch on indicator constraints in enforcing?",
7747 "constraints/indicator/genlogicor",
7748 "Generate logicor constraints instead of cuts?",
7752 "constraints/indicator/addcoupling",
7753 "Add coupling constraints or rows if big-M is small enough?",
7757 "constraints/indicator/maxcouplingvalue",
7758 "maximum coefficient for binary variable in coupling constraint",
7762 "constraints/indicator/addcouplingcons",
7763 "Add initial variable upper bound constraints, if 'addcoupling' is true?",
7767 "constraints/indicator/sepacouplingcuts",
7768 "Should the coupling inequalities be separated dynamically?",
7772 "constraints/indicator/sepacouplinglocal",
7773 "Allow to use local bounds in order to separate coupling inequalities?",
7777 "constraints/indicator/sepacouplingvalue",
7778 "maximum coefficient for binary variable in separated coupling constraint",
7782 "constraints/indicator/sepaperspective",
7783 "Separate cuts based on perspective formulation?",
7787 "constraints/indicator/sepapersplocal",
7788 "Allow to use local bounds in order to separate perspective cuts?",
7792 "constraints/indicator/maxsepanonviolated",
7793 "maximal number of separated non violated IISs, before separation is stopped",
7797 "constraints/indicator/updatebounds",
7798 "Update bounds of original variables for separation?",
7802 "constraints/indicator/maxconditionaltlp",
7803 "maximum estimated condition of the solution basis matrix of the alternative LP to be trustworthy (0.0 to disable check)",
7807 "constraints/indicator/maxsepacuts",
7808 "maximal number of cuts separated per separation round",
7812 "constraints/indicator/maxsepacutsroot",
7813 "maximal number of cuts separated per separation round in the root node",
7817 "constraints/indicator/removeindicators",
7818 "Remove indicator constraint if corresponding variable bound constraint has been added?",
7822 "constraints/indicator/generatebilinear",
7823 "Do not generate indicator constraint, but a bilinear constraint instead?",
7827 "constraints/indicator/scaleslackvar",
7828 "Scale slack variable coefficient at construction time?",
7832 "constraints/indicator/trysolutions",
7833 "Try to make solutions feasible by setting indicator variables?",
7837 "constraints/indicator/enforcecuts",
7838 "In enforcing try to generate cuts (only if sepaalternativelp is true)?",
7842 "constraints/indicator/dualreductions",
7843 "Should dual reduction steps be performed?",
7847 "constraints/indicator/addopposite",
7848 "Add opposite inequality in nodes in which the binary variable has been fixed to 0?",
7852 "constraints/indicator/conflictsupgrade",
7853 "Try to upgrade bounddisjunction conflicts by replacing slack variables?",
7857 "constraints/indicator/restartfrac",
7858 "fraction of binary variables that need to be fixed before restart occurs (in forcerestart)",
7862 "constraints/indicator/useotherconss",
7863 "Collect other constraints to alternative LP?",
7867 "constraints/indicator/useobjectivecut",
7868 "Use objective cut with current best solution to alternative LP?",
7872 "constraints/indicator/trysolfromcover",
7873 "Try to construct a feasible solution from a cover?",
7877 "constraints/indicator/upgradelinear",
7878 "Try to upgrade linear constraints to indicator constraints?",
7882 "constraints/indicator/usesameslackvar",
7883 "Use same slack variable for indicator constraints with common binary variable?",
7888 "constraints/indicator/sepaalternativelp",
7889 "Separate using the alternative LP?",
7893 "constraints/indicator/forcerestart",
7894 "Force restart if absolute gap is 1 or enough binary variables have been fixed?",
7898 "constraints/indicator/nolinconscont",
7899 "Decompose problem (do not generate linear constraint if all variables are continuous)?",
7942 return SCIPcreateConsIndicatorGeneric(
scip, cons, name, binvar,
nvars,
vars, vals, rhs,
TRUE,
TRUE, initial,
7943 separate, enforce, check,
propagate, local, dynamic, removable, stickingatnode);
8001 SCIPerrorMessage(
"Indicator constraint <%s> needs nonnegative number of variables in linear constraint.\n", name);
8007 if ( conshdlr ==
NULL )
8016 if ( conshdlrdata->nolinconscont && ! conshdlrdata->sepaalternativelp )
8018 SCIPerrorMessage(
"constraint handler <%s>: need parameter <sepaalternativelp> to be true if parameter <nolinconscont> is true.\n",
CONSHDLR_NAME);
8022 if ( conshdlrdata->nolinconscont && conshdlrdata->generatebilinear )
8035 for (j = 0; j <
nvars; ++j)
8036 valscopy[j] = -vals[j];
8043 for (j = 0; j <
nvars; ++j)
8045 if ( conshdlrdata->scaleslackvar )
8046 absvalsum +=
REALABS(valscopy[j]);
8050 if ( ! conshdlrdata->scaleslackvar )
8056 if ( activeone || binvar ==
NULL )
8057 binvarinternal = binvar;
8065 if ( binvarinternal !=
NULL )
8068 if ( conshdlrdata->usesameslackvar && conshdlrdata->binslackvarhash ==
NULL )
8073 if ( conshdlrdata->binslackvarhash !=
NULL &&
SCIPhashmapExists(conshdlrdata->binslackvarhash, (
void*) binvarinternal) )
8100 if ( conshdlrdata->binslackvarhash !=
NULL )
8121 if ( conshdlrdata->nolinconscont )
8125 assert( ! conshdlrdata->generatebilinear );
8128 for (j = 0; j <
nvars; ++j)
8141 linconsactive =
FALSE;
8148 if ( linconsactive )
8161 if ( ! lessthanineq )
8169 if ( conshdlrdata->scaleslackvar &&
nvars > 0 )
8185 if ( conshdlrdata->generatebilinear )
8190 SCIP_CALL(
SCIPcreateConsQuadraticNonlinear(
scip, cons, name, 0,
NULL,
NULL, 1, &binvarinternal, &slackvar, &val, 0.0, 0.0,
8197 binvar, activeone, lessthanineq, slackvar, lincons, linconsactive) );
8202 SCIP_CALL(
SCIPcreateCons(
scip, cons, name, conshdlr, consdata, initial, separate, enforce, check,
propagate,
8203 local, modifiable, dynamic, removable, stickingatnode) );
8208 if ( linconsactive )
8215 if ( conshdlrdata->sepaalternativelp )
8217 if ( conshdlrdata->binvarhash ==
NULL )
8326 if ( conshdlr ==
NULL )
8335 if ( conshdlrdata->nolinconscont && ! conshdlrdata->sepaalternativelp )
8337 SCIPerrorMessage(
"constraint handler <%s>: need parameter <sepaalternativelp> to be true if parameter <nolinconscont> is true.\n",
CONSHDLR_NAME);
8345 if ( conshdlrdata->nolinconscont )
8356 for (v = 0; v <
nvars; ++v)
8369 linconsactive =
FALSE;
8377 if ( conshdlrdata->generatebilinear )
8385 binvarinternal = binvar;
8393 SCIP_CALL(
SCIPcreateConsQuadraticNonlinear(
scip, cons, name, 0,
NULL,
NULL, 1, &binvarinternal, &slackvar, &val, 0.0, 0.0,
8400 binvar, activeone,
TRUE, slackvar, lincons, linconsactive) );
8404 SCIP_CALL(
SCIPcreateCons(
scip, cons, name, conshdlr, consdata, initial, separate, enforce, check,
propagate,
8405 local, modifiable, dynamic, removable, stickingatnode) );
8461 enforce, check,
propagate, local, dynamic, removable, stickingatnode);
8571 if ( conshdlr ==
NULL )
8580 if ( conshdlrdata->nolinconscont && ! conshdlrdata->sepaalternativelp )
8582 SCIPerrorMessage(
"constraint handler <%s>: need parameter <sepaalternativelp> to be true if parameter <nolinconscont> is true.\n",
CONSHDLR_NAME);
8599 for (j = 0; j <
nvars; ++j)
8619 binvarinternal = binvar;
8627 if ( conshdlrdata->usesameslackvar && conshdlrdata->binslackvarhash ==
NULL )
8632 if ( conshdlrdata->binslackvarhash !=
NULL &&
SCIPhashmapExists(conshdlrdata->binslackvarhash, (
void*) binvarinternal) )
8659 if ( conshdlrdata->binslackvarhash !=
NULL )
8667 if ( conshdlrdata->nolinconscont )
8675 for (j = 0; j <
nvars; ++j)
8688 linconsactive =
FALSE;
8704 if ( conshdlrdata->generatebilinear )
8709 SCIP_CALL(
SCIPcreateConsQuadraticNonlinear(
scip, cons, name, 0,
NULL,
NULL, 1, &binvarinternal, &slackvar, &val, 0.0, 0.0,
8716 binvar, activeone,
TRUE, slackvar, lincons, linconsactive) );
8720 SCIP_CALL(
SCIPcreateCons(
scip, cons, name, conshdlr, consdata, initial, separate, enforce, check,
propagate,
8721 local, modifiable, dynamic, removable, stickingatnode) );
8775 enforce, check,
propagate, local, dynamic, removable, stickingatnode);
8796 if ( !consdata->lessthanineq )
8827 return consdata->lincons;
8864 consdata->lincons = lincons;
8865 consdata->linconsactive =
TRUE;
8869 if ( conshdlrdata->nolinconscont )
8882 for (v = 0; v <
nvars; ++v)
8895 consdata->linconsactive =
FALSE;
8914 return consdata->activeone;
8931 return consdata->binvar;
8947 binvar = consdata->binvar;
8949 if ( ! consdata->activeone )
8980 if ( consdata->binvar !=
NULL )
8998 if ( ! consdata->activeone )
9001 consdata->binvar =
var;
9008 assert( conshdlrdata->eventhdlrbound !=
NULL );
9009 assert( conshdlrdata->eventhdlrrestart !=
NULL );
9012 if ( consdata->linconsactive )
9018 if ( conshdlrdata->forcerestart )
9025 ++(consdata->nfixednonzero);
9029 if ( ! consdata->activeone )
9031 consdata->binvar = binvar;
9050 return consdata->slackvar;
9106 if ( consdata->linconsactive )
9180 if ( ! consdata->linconsactive )
9183 lincons = consdata->lincons;
9189 slackvar = consdata->slackvar;
9190 binvar = consdata->binvar;
9201 for (v = 0; v < nlinvars; ++v)
9205 if (
var != slackvar )
9208 slackcoef = linvals[v];
9216 assert( slackcoef != 0.0 );
9229 val = (val - sum)/slackcoef;
9232 if ( slackcoef < 0 )
9344 for (
c = 0;
c < nconss; ++
c)
9354 if ( ! consdata->linconsactive )
9358 *changed = *changed || chg;
9385 assert( conshdlrdata->naddlincons+1 <= conshdlrdata->maxaddlincons );
9387 conshdlrdata->addlincons[conshdlrdata->naddlincons++] = lincons;
9418 if ( ! conshdlrdata->sepaalternativelp )
#define CONSHDLR_NEEDSCONS
#define CONSHDLR_SEPAFREQ
#define CONSHDLR_CHECKPRIORITY
#define CONSHDLR_PROP_TIMING
#define CONSHDLR_MAXPREROUNDS
#define CONSHDLR_SEPAPRIORITY
#define CONSHDLR_PROPFREQ
#define DEFAULT_ENFORCECUTS
#define CONSHDLR_PRESOLTIMING
#define CONSHDLR_EAGERFREQ
#define CONSHDLR_ENFOPRIORITY
#define CONSHDLR_DELAYSEPA
#define CONSHDLR_DELAYPROP
#define CONFLICTHDLR_PRIORITY
#define CONFLICTHDLR_NAME
#define CONFLICTHDLR_DESC
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 SCIP_CALL_PARAM(x)
#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 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)
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)
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)
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_USESAMESLACKVAR
#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 DEFAULT_SEPAALTERNATIVELP
static void initConshdlrData(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata)
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
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 DEFAULT_DUALREDUCTIONS
static SCIP_RETCODE deleteAltLPConstraint(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONS *cons)
#define LINCONSUPGD_PRIORITY
#define DEFAULT_GENERATEBILINEAR
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 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_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_Bool SCIPdoNotMultaggrVar(SCIP *scip, 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_Real SCIPadjustedVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real ub)
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,...)
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)
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
struct SCIP_Conflicthdlr SCIP_CONFLICTHDLR
#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)
struct SCIP_Cons SCIP_CONS
#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)
struct SYM_Graph SYM_GRAPH
#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)
struct SCIP_Conshdlr SCIP_CONSHDLR
#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)
struct SCIP_Eventhdlr SCIP_EVENTHDLR
#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
struct SCIP_Expr SCIP_EXPR
struct SCIP_Heur SCIP_HEUR
#define SCIP_DIVETYPE_INTEGRALITY
@ SCIP_BRANCHDIR_DOWNWARDS
enum SCIP_BoundType SCIP_BOUNDTYPE
type definitions for specific LP solvers interface
@ SCIP_LPSOLQUALITY_ESTIMCONDITION
struct SCIP_HashMap SCIP_HASHMAP
struct SCIP_NlRow SCIP_NLROW
struct SCIP_Param SCIP_PARAM
#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
struct SCIP_Node SCIP_NODE
@ SCIP_VARTYPE_CONTINUOUS
@ SCIP_VARSTATUS_MULTAGGR
@ SCIP_VARSTATUS_AGGREGATED
enum SCIP_Vartype SCIP_VARTYPE