249#define CONSHDLR_NAME "indicator"
250#define CONSHDLR_DESC "indicator constraint handler"
251#define CONSHDLR_SEPAPRIORITY 10
252#define CONSHDLR_ENFOPRIORITY -100
253#define CONSHDLR_CHECKPRIORITY -6000000
254#define CONSHDLR_SEPAFREQ 10
255#define CONSHDLR_PROPFREQ 1
256#define CONSHDLR_EAGERFREQ 100
258#define CONSHDLR_MAXPREROUNDS -1
259#define CONSHDLR_DELAYSEPA FALSE
260#define CONSHDLR_DELAYPROP FALSE
261#define CONSHDLR_NEEDSCONS TRUE
263#define CONSHDLR_PRESOLTIMING SCIP_PRESOLTIMING_FAST
264#define CONSHDLR_PROP_TIMING SCIP_PROPTIMING_BEFORELP
268#define EVENTHDLR_BOUND_NAME "indicatorbound"
269#define EVENTHDLR_BOUND_DESC "bound change event handler for indicator constraints"
271#define EVENTHDLR_RESTART_NAME "indicatorrestart"
272#define EVENTHDLR_RESTART_DESC "force restart if absolute gap is 1 or enough binary variables have been fixed"
276#define CONFLICTHDLR_NAME "indicatorconflict"
277#define CONFLICTHDLR_DESC "replace slack variables and generate logicor constraints"
278#define CONFLICTHDLR_PRIORITY 200000
281#define LINCONSUPGD_PRIORITY +100000
284#define DEFAULT_BRANCHINDICATORS FALSE
285#define DEFAULT_GENLOGICOR FALSE
286#define DEFAULT_ADDCOUPLING TRUE
287#define DEFAULT_MAXCOUPLINGVALUE 1e4
288#define DEFAULT_ADDCOUPLINGCONS FALSE
289#define DEFAULT_SEPACOUPLINGCUTS TRUE
290#define DEFAULT_SEPACOUPLINGLOCAL FALSE
291#define DEFAULT_SEPACOUPLINGVALUE 1e4
292#define DEFAULT_SEPAALTERNATIVELP FALSE
293#define DEFAULT_SEPAPERSPECTIVE FALSE
294#define DEFAULT_SEPAPERSPLOCAL TRUE
295#define DEFAULT_MAXSEPANONVIOLATED 3
296#define DEFAULT_TRYSOLFROMCOVER FALSE
297#define DEFAULT_UPGRADELINEAR FALSE
298#define DEFAULT_USEOTHERCONSS FALSE
299#define DEFAULT_USEOBJECTIVECUT FALSE
300#define DEFAULT_UPDATEBOUNDS FALSE
301#define DEFAULT_MAXCONDITIONALTLP 0.0
302#define DEFAULT_MAXSEPACUTS 100
303#define DEFAULT_MAXSEPACUTSROOT 2000
304#define DEFAULT_REMOVEINDICATORS FALSE
305#define DEFAULT_GENERATEBILINEAR FALSE
306#define DEFAULT_SCALESLACKVAR FALSE
307#define DEFAULT_NOLINCONSCONT FALSE
308#define DEFAULT_TRYSOLUTIONS TRUE
309#define DEFAULT_ENFORCECUTS FALSE
310#define DEFAULT_DUALREDUCTIONS TRUE
311#define DEFAULT_ADDOPPOSITE FALSE
312#define DEFAULT_CONFLICTSUPGRADE FALSE
313#define DEFAULT_FORCERESTART FALSE
314#define DEFAULT_RESTARTFRAC 0.9
318#define OBJEPSILON 0.001
319#define SEPAALTTHRESHOLD 10
320#define MAXROUNDINGROUNDS 1
330 SCIP_Bool lessthanineq;
333 unsigned int linconsactive:1;
334 unsigned int implicationadded:1;
335 unsigned int slacktypechecked:1;
340struct SCIP_ConshdlrData
346 SCIP_Bool objindicatoronly;
347 SCIP_Bool objothervarsonly;
362 SCIP_Real objupperbound;
363 SCIP_Real objaltlpbound;
364 int maxroundingrounds;
365 SCIP_Real roundingminthres;
366 SCIP_Real roundingmaxthres;
367 SCIP_Real roundingoffset;
368 SCIP_Bool branchindicators;
369 SCIP_Bool genlogicor;
370 SCIP_Bool addcoupling;
371 SCIP_Bool addcouplingcons;
372 SCIP_Bool sepacouplingcuts;
373 SCIP_Bool sepacouplinglocal;
374 SCIP_Bool sepaperspective;
375 SCIP_Bool sepapersplocal;
376 SCIP_Bool removeindicators;
377 SCIP_Bool updatebounds;
378 SCIP_Bool trysolutions;
379 SCIP_Bool enforcecuts;
380 SCIP_Bool dualreductions;
381 SCIP_Bool addopposite;
382 SCIP_Bool generatebilinear;
383 SCIP_Bool scaleslackvar;
384 SCIP_Bool conflictsupgrade;
385 SCIP_Bool performedrestart;
388 int maxsepanonviolated;
391 SCIP_Real maxcouplingvalue;
392 SCIP_Real sepacouplingvalue;
393 SCIP_Real maxconditionaltlp;
394 SCIP_Real restartfrac;
396 SCIP_Bool addedcouplingcons;
400 SCIP_Bool useotherconss;
401 SCIP_Bool useobjectivecut;
402 SCIP_Bool trysolfromcover;
403 SCIP_Bool upgradelinear;
406 SCIP_Bool sepaalternativelp;
407 SCIP_Bool sepaalternativelp_;
408 SCIP_Bool nolinconscont;
409 SCIP_Bool nolinconscont_;
410 SCIP_Bool forcerestart;
411 SCIP_Bool forcerestart_;
416struct SCIP_ConflicthdlrData
437#define SCIP_CALL_PARAM(x) do \
439 SCIP_RETCODE _restat_; \
440 if ( (_restat_ = (x)) != SCIP_OKAY && (_restat_ != SCIP_PARAMETERUNKNOWN) ) \
442 SCIPerrorMessage("[%s:%d] Error <%d> in function call\n", __FILE__, __LINE__, _restat_); \
471 assert( 0 <= consdata->nfixednonzero && consdata->nfixednonzero <= 2 );
472 assert( consdata->linconsactive );
483 ++(consdata->nfixednonzero);
484#ifdef SCIP_MORE_DEBUG
485 SCIPdebugMsg(
scip,
"Changed lower bound of variable <%s> from %g to %g (nfixednonzero: %d).\n",
493 ++(consdata->nfixednonzero);
494#ifdef SCIP_MORE_DEBUG
495 SCIPdebugMsg(
scip,
"Changed upper bound of variable <%s> from %g to %g (nfixednonzero: %d).\n",
503 --(consdata->nfixednonzero);
504#ifdef SCIP_MORE_DEBUG
505 SCIPdebugMsg(
scip,
"Changed lower bound of variable <%s> from %g to %g (nfixednonzero: %d).\n",
513 --(consdata->nfixednonzero);
514#ifdef SCIP_MORE_DEBUG
515 SCIPdebugMsg(
scip,
"Changed upper bound of variable <%s> from %g to %g (nfixednonzero: %d).\n",
525 assert( 0 <= consdata->nfixednonzero && consdata->nfixednonzero <= 2 );
554 assert( conshdlrdata->forcerestart );
577 if ( conshdlrdata->performedrestart )
581 ++(conshdlrdata->nbinvarszero);
589 if ( conshdlrdata->nbinvarszero > (
int) ((SCIP_Real) conshdlrdata->ninitconss * conshdlrdata->restartfrac) )
592 "Forcing restart, since %d binary variables among %d have been fixed.\n", conshdlrdata->nbinvarszero, conshdlrdata->ninitconss);
596 if ( conshdlrdata->objindicatoronly )
600 conshdlrdata->performedrestart =
TRUE;
612 if ( ! conshdlrdata->objindicatoronly )
629 conshdlrdata->performedrestart =
TRUE;
679 assert( bdchginfos !=
NULL || nbdchginfos == 0 );
702 for (
i = 0;
i < nbdchginfos; ++
i)
741 SCIPdebugMsg(
scip,
"Found conflict involving slack variables that can be remodelled.\n");
751 for (
i = 0;
i < nbdchginfos; ++
i)
767 for (
j = 0;
j < nconss; ++
j)
774 if ( slackvar ==
var )
802 if (
i == nbdchginfos )
913#ifdef SCIP_ENABLE_IISCHECK
956 for (
c = 0;
c < nconss; ++
c)
972 SCIP_Real
sign = 1.0;
983 lincons = consdata->lincons;
988 slackvar = consdata->slackvar;
996 SCIP_Real scalar = 1.0;
997 SCIP_Real constant = 0.0;
1040 for (v = 0; v < nlinvars; ++v)
1047 if (
var == slackvar )
1060 newvars[nnewvars++] =
var;
1078 for (v = 0; v < nnewvars; ++v)
1092 for (v = nnewvars - 1; v >= 0; --v)
1104 for (v = 0; v < nlinvars; ++v)
1111 if (
var == slackvar )
1141 if ( conshdlrdata->useotherconss )
1148 for (
c = 0;
c < nconss; ++
c)
1192 for (v = 0; v < nlinvars; ++v)
1208 newvars[nnewvars++] =
var;
1226 for (v = 0; v < nnewvars; ++v)
1240 for (v = nnewvars - 1; v >= 0; --v)
1251 for (v = 0; v < nlinvars; ++v)
1337 assert( conshdlrdata->naddlincons <= conshdlrdata->maxaddlincons );
1339 if ( num > conshdlrdata->maxaddlincons )
1345 conshdlrdata->maxaddlincons =
newsize;
1369 SCIP_Real lhs = -1.0;
1370 SCIP_Real rhs = -1.0;
1393 conshdlrdata->nrows = 1;
1440 for (
j = 0;
j < nconss; ++
j)
1448 ind = consdata->colindex;
1501 int* indices =
NULL;
1511 for (
j = 0;
j < nconss; ++
j)
1519 if ( consdata->colindex >= 0 )
1525 obj[cnt] = 1.0 - val;
1526 indices[cnt++] = consdata->colindex;
1553 int* indices =
NULL;
1563 for (
j = 0;
j < nconss; ++
j)
1571 if ( consdata->colindex >= 0 )
1574 indices[cnt++] = consdata->colindex;
1600 SCIP_Real* lb =
NULL;
1601 SCIP_Real* ub =
NULL;
1602 int* indices =
NULL;
1615 for (
j = 0;
j < nconss; ++
j)
1623 if ( consdata->colindex >= 0 )
1627 indices[cnt] = consdata->colindex;
1692 SCIP_Real* lb =
NULL;
1693 SCIP_Real* ub =
NULL;
1694 int* indices =
NULL;
1707 for (
j = 0;
j < nconss; ++
j)
1717 if ( consdata->colindex >= 0 )
1719 indices[cnt] = consdata->colindex;
1759 altlp = conshdlrdata->altlp;
1760 lbhash = conshdlrdata->lbhash;
1761 ubhash = conshdlrdata->ubhash;
1769 for (v = 0; v <
nvars; ++v)
1795 conshdlrdata->scaled =
FALSE;
1823 altlp = conshdlrdata->altlp;
1824 lbhash = conshdlrdata->lbhash;
1825 ubhash = conshdlrdata->ubhash;
1833 for (v = 0; v <
nvars; ++v)
1895 lbhash = conshdlrdata->lbhash;
1896 ubhash = conshdlrdata->ubhash;
1904 for (v = 0; v <
nvars; ++v)
1965 if ( ! conshdlrdata->scaled )
1970 SCIP_Real sum = 0.0;
1976 altlp = conshdlrdata->altlp;
1986 for (
j = 0;
j < cnt; ++
j)
1990 sum = -
REALABS(sum) / ((double) cnt);
1998 conshdlrdata->scaled =
TRUE;
2051 if ( conshdlrdata->altlp ==
NULL )
2065 assert( nrows == conshdlrdata->nrows );
2092 for (v = 0; v <
nvars; ++v)
2103 if (
var != slackvar )
2117 matind[cnt] = (conshdlrdata->nrows)++;
2137 matind[cnt] = (conshdlrdata->nrows)++;
2141 newvars[nnewvars++] =
var;
2189 for (v = 0; v < nnewvars; ++v)
2208 obj[nnewcols] = 0.0;
2211 ++conshdlrdata->nlbbounds;
2215 SCIPdebugMsg(
scip,
"Added column for lower bound (%f) of variable <%s> to alternative polyhedron (col: %d).\n",
2234 obj[nnewcols] = 0.0;
2237 ++conshdlrdata->nubbounds;
2241 SCIPdebugMsg(
scip,
"Added column for upper bound (%f) of variable <%s> to alternative polyhedron (col: %d).\n",
2255 assert( cnt == ncols + nnewcols + 1 );
2267 conshdlrdata->scaled =
FALSE;
2314 SCIP_Real scalar = 1.0;
2315 SCIP_Real constant = 0.0;
2321 SCIPdebugMsg(
scip,
"Slack variable is aggregated (scalar: %f, constant: %f).\n", scalar, constant);
2354 SCIP_CALL(
addAltLPColumn(
scip, conshdlr, conshdlrdata, slackvar, nlinvars, linvars,
linvals,
linrhs,
objcoef, 1.0,
TRUE, colindex) );
2359 SCIP_CALL(
addAltLPColumn(
scip, conshdlr, conshdlrdata, slackvar, nlinvars, linvars,
linvals,
linrhs,
objcoef, 1.0,
FALSE, colindex) );
2365 SCIP_CALL(
addAltLPColumn(
scip, conshdlr, conshdlrdata, slackvar, nlinvars, linvars,
linvals,
linlhs,
objcoef, -1.0,
FALSE, colindex) );
2434 SCIP_CALL(
addAltLPColumn(
scip, conshdlr, conshdlrdata,
NULL,
nrowcols,
rowvars,
rowvals,
rowrhs,
objcoef, 1.0,
TRUE, colindex) );
2439 SCIP_CALL(
addAltLPColumn(
scip, conshdlr, conshdlrdata,
NULL,
nrowcols,
rowvars,
rowvals,
rowrhs,
objcoef, 1.0,
FALSE, colindex) );
2445 SCIP_CALL(
addAltLPColumn(
scip, conshdlr, conshdlrdata,
NULL,
nrowcols,
rowvars,
rowvals,
rowlhs,
objcoef, -1.0,
FALSE, colindex) );
2477 if ( conshdlrdata->objcutindex >= 0 )
2481 if ( ! conshdlrdata->objothervarsonly )
2485 SCIPdebugMsg(
scip,
"Add objective cut to alternative LP (obj. bound: %g).\n", conshdlrdata->objupperbound);
2492 for (v = 0; v <
nvars; ++v)
2504 objvars[nobjvars] =
var;
2510 SCIP_CALL(
addAltLPColumn(
scip, conshdlr, conshdlrdata,
NULL, nobjvars, objvars,
objvals, conshdlrdata->objupperbound, 0.0, 1.0,
FALSE, &conshdlrdata->objcutindex) );
2511 assert( conshdlrdata->objcutindex >= 0 );
2512 conshdlrdata->objaltlpbound = conshdlrdata->objupperbound;
2542 if ( conshdlrdata->altlp !=
NULL )
2549 if ( consdata->colindex >= 0 )
2553 consdata->colindex = -1;
2557 conshdlrdata->scaled =
FALSE;
2576 if ( ! conshdlrdata->useobjectivecut )
2579 if ( conshdlrdata->altlp ==
NULL )
2592 conshdlrdata->objupperbound =
objbnd;
2599 if (
SCIPisLT(
scip, conshdlrdata->objupperbound, conshdlrdata->objaltlpbound) )
2601 SCIPdebugMsg(
scip,
"Update objective bound to %g.\n", conshdlrdata->objupperbound);
2604 if ( conshdlrdata->objcutindex < 0 )
2618 conshdlrdata->objaltlpbound = conshdlrdata->objupperbound;
2646 SCIP_Bool* infeasible,
2716 SCIPdebugMsg(
scip,
"Estimated condition number of basis matrix not available.\n");
2774 *infeasible =
FALSE;
2795 SCIP_Bool removable,
2796 SCIP_Bool genlogicor,
2835 SCIP_Bool infeasible;
2836 SCIP_Real sum = 0.0;
2839 SCIP_Real norm = 1.0;
2862 SCIPdebugMsg(
scip,
" size: %4d produced possible cover with indicator variable objective value %f.\n", *size, *value);
2865 if ( conshdlrdata->trysolfromcover )
2892 for (
j = 0;
j < nconss; ++
j)
2899 ind = consdata->colindex;
2939 switch ( conshdlrdata->normtype )
2954 SCIPerrorMessage(
"Invalid efficacy norm parameter '%c'.\n", conshdlrdata->normtype);
2959 SCIPdebugMsg(
scip,
" size: %4d, add var. %4d (obj: %-6g, alt-LP sol: %-8.4f); IIS size: %4d, eff.: %g.\n",
2975#ifdef SCIP_ENABLE_IISCHECK
2981 if ( conshdlrdata->updatebounds )
2996 for (
j = 0;
j < nconss; ++
j)
3002 ind = consdata->colindex;
3022 SCIP_CALL(
SCIPcreateConsLogicor(
scip, &cons, name, cnt,
vars,
FALSE,
TRUE,
TRUE,
TRUE,
TRUE,
isLocal,
FALSE,
TRUE, removable,
FALSE) );
3024 SCIP_CALL(
SCIPcreateConsLogicor(
scip, &cons,
"", cnt,
vars,
FALSE,
TRUE,
TRUE,
TRUE,
TRUE,
isLocal,
FALSE,
TRUE, removable,
FALSE) );
3076 for (
j = 0;
j < nconss; ++
j)
3082 ind = consdata->colindex;
3129 while (
step < nconss);
3145 const char* consname,
3150 SCIP_Bool activeone,
3151 SCIP_Bool lessthanineq,
3154 SCIP_Bool linconsactive
3179 (*consdata)->nfixednonzero = 0;
3180 (*consdata)->colindex = -1;
3181 (*consdata)->linconsactive = linconsactive;
3183 (*consdata)->slackvar = slackvar;
3184 (*consdata)->activeone = activeone;
3185 (*consdata)->lessthanineq = lessthanineq;
3186 (*consdata)->lincons = lincons;
3187 (*consdata)->implicationadded =
FALSE;
3188 (*consdata)->slacktypechecked =
FALSE;
3200 (*consdata)->binvar =
var;
3215 if ( linconsactive )
3221 if ( conshdlrdata->forcerestart )
3229 ++((*consdata)->nfixednonzero);
3235 (*consdata)->slackvar =
var;
3238 if ( linconsactive )
3244 ++((*consdata)->nfixednonzero);
3255 SCIPdebugMsg(
scip,
"Added column for <%s> to alternative LP with column index %d.\n", consname, (*consdata)->colindex);
3263 if ( (*consdata)->nfixednonzero > 0 )
3265 SCIPdebugMsg(
scip,
"Constraint <%s> has %d variables fixed to be nonzero.\n", consname, (*consdata)->nfixednonzero);
3294 for (
c = 0;
c < nconss; ++
c)
3325 !conshdlrdata->removeindicators, !conshdlrdata->removeindicators,
FALSE) );
3331 if ( conshdlrdata->removeindicators )
3361 SCIP_Bool dualreductions,
3368 SCIP_Bool infeasible;
3392 SCIPdebugMsg(
scip,
"The problem is infeasible: binary and slack variable are fixed to be nonzero.\n");
3447 SCIPdebugMsg(
scip,
"The problem is infeasible: binary and slack variable are fixed to be nonzero.\n");
3453 SCIPdebugMsg(
scip,
"Fix binary variable to 0 and delete indicator constraint.\n");
3478 if ( dualreductions )
3484 binvar = consdata->binvar;
3550 var = consdata->binvar;
3560 assert( conshdlrdata->eventhdlrbound !=
NULL );
3567 if ( conshdlrdata->forcerestart )
3569 assert( conshdlrdata->eventhdlrrestart !=
NULL );
3571 conshdlrdata->eventhdlrrestart, (
SCIP_EVENTDATA*) conshdlrdata, -1) );
3580 consdata->binvar =
var;
3591 if (
var == consdata->slackvar )
3610 var = consdata->slackvar;
3623 assert( conshdlrdata->eventhdlrbound !=
NULL );
3634 consdata->slackvar =
var;
3636 else if (
var == consdata->binvar )
3644 SCIPdebugMsg(
scip,
"Slack variable <%s> is aggregated to negated indicator variable <%s> -> constraint redundant.\n",
3658 SCIPdebugMsg(
scip,
"Slack variable <%s> is aggregated to the indicator variable <%s> -> fix indicator variable to 0.\n",
3693 SCIP_Bool dualreductions,
3694 SCIP_Bool addopposite,
3699 SCIP_Bool infeasible;
3700 SCIP_Bool tightened;
3712 if ( ! consdata->linconsactive )
3720 if ( consdata->nfixednonzero > 1 )
3722 SCIPdebugMsg(
scip,
"The node is infeasible, both the slack variable and the binary variable are fixed to be nonzero.\n");
3747 if ( consdata->nfixednonzero == 1 )
3761 SCIPdebugMsg(
scip,
"Binary variable <%s> is fixed to be nonzero, fixing slack variable <%s> to 0.\n",
3778 SCIPdebugMsg(
scip,
"Slack variable <%s> is fixed to be nonzero, fixing binary variable <%s> to 0.\n",
3813 if ( addopposite && consdata->linconsactive )
3850 slackvar = consdata->slackvar;
3857 for (
j = 0;
j < nlinvars; ++
j)
3859 if ( linvars[
j] != slackvar )
3904 if ( dualreductions )
3910 binvar = consdata->binvar;
3995 SCIP_Bool genlogicor,
4003 SCIP_Real value = 0.0;
4021 lp = conshdlrdata->altlp;
4029 if ( conshdlrdata->updatebounds )
4044 for (
j = 0;
j < nconss; ++
j)
4068 SCIP_CALL(
extendToCover(
scip, conshdlr, conshdlrdata, lp,
sol,
enfosepatype, conshdlrdata->removable, genlogicor, nconss, conss,
S, &size, &value, &
error,
cutoff, &
nCuts) );
4106 SCIP_Bool genlogicor,
4139 for (
c = 0;
c < nconss; ++
c)
4151 if ( ! consdata->linconsactive )
4175 binvar = consdata->binvar;
4208 conshdlrdata->niiscutsgen +=
ngen;
4215 conshdlrdata->niiscutsgen +=
ngen;
4241 if ( ! conshdlrdata->branchindicators )
4251 binvar = consdata->binvar;
4252 slackvar = consdata->slackvar;
4316 if ( *
nGen >= maxsepacuts )
4324 lp = conshdlrdata->altlp;
4334 if ( conshdlrdata->updatebounds )
4352 for (
threshold = conshdlrdata->roundingmaxthres;
4353 rounds < conshdlrdata->maxroundingrounds &&
threshold >= conshdlrdata->roundingminthres && *
nGen < maxsepacuts && ! (*cutoff);
4354 threshold -= conshdlrdata->roundingoffset )
4356 SCIP_Real value = 0.0;
4369 for (
j = 0;
j < nconss; ++
j)
4419 if ( size == nconss )
4428 SCIPdebugMsg(
scip,
"Skipping computation: size support has not changed.\n");
4522 if ( *
nGen >= maxsepacuts )
4533 for (
c = 0;
c < nconss; ++
c)
4544 slackvar = consdata->slackvar;
4546 lincons = consdata->lincons;
4549 binvar = consdata->binvar;
4586 for (
j = 0;
j < nlinvars; ++
j)
4591 SCIP_Real
din = 0.0;
4592 SCIP_Real
dout = 0.0;
4596 if ( linvars[
j] == slackvar )
4599 if ( conshdlrdata->sepapersplocal )
4663 SCIP_Bool infeasible;
4685 if ( *
nGen >= maxsepacuts )
4733 maxsepacuts = conshdlrdata->maxsepacutsroot;
4735 maxsepacuts = conshdlrdata->maxsepacuts;
4738 if ( conshdlrdata->sepacouplingcuts )
4760 if ( conshdlrdata->sepacouplinglocal )
4779 SCIP_Bool infeasible;
4809 SCIPdebugMsg(
scip,
"Number of separated coupling inequalities: %d.\n", ncuts);
4818 SCIPdebugMsg(
scip,
"Separating inequalities for indicator constraints.\n");
4832 conshdlrdata->niiscutsgen += ncuts;
4835 if ( conshdlrdata->genlogicor )
4847 SCIPdebugMsg(
scip,
"Separating inequalities based on perspective formulation.\n");
4859 conshdlrdata->nperspcutsgen += ncuts;
4879 conshdlrdata->removable =
TRUE;
4880 conshdlrdata->scaled =
FALSE;
4881 conshdlrdata->altlp =
NULL;
4882 conshdlrdata->nrows = 0;
4883 conshdlrdata->varhash =
NULL;
4884 conshdlrdata->slackhash =
NULL;
4885 conshdlrdata->lbhash =
NULL;
4886 conshdlrdata->ubhash =
NULL;
4887 conshdlrdata->nlbbounds = 0;
4888 conshdlrdata->nubbounds = 0;
4889 conshdlrdata->nslackvars = 0;
4890 conshdlrdata->objcutindex = -1;
4893 conshdlrdata->roundingminthres = 0.1;
4894 conshdlrdata->roundingmaxthres = 0.6;
4896 conshdlrdata->roundingoffset = 0.1;
4897 conshdlrdata->addedcouplingcons =
FALSE;
4898 conshdlrdata->ninitconss = 0;
4899 conshdlrdata->nbinvarszero = 0;
4900 conshdlrdata->performedrestart =
FALSE;
4901 conshdlrdata->objindicatoronly =
FALSE;
4902 conshdlrdata->objothervarsonly =
FALSE;
4903 conshdlrdata->minabsobj = 0.0;
4904 conshdlrdata->normtype =
'e';
4905 conshdlrdata->niiscutsgen = 0;
4906 conshdlrdata->nperspcutsgen = 0;
4927 SCIP_Real minactivity = 0.0;
4928 SCIP_Real maxactivity = 0.0;
4929 SCIP_Real maxabsval = -1.0;
4953 if ( ! conshdlrdata->upgradelinear )
4997 minactivity += val * lb;
5006 maxactivity += val * ub;
5010 assert( maxabsval >= 0.0 );
5091 if (
vars[
l] == indvar )
5184 if ( conshdlrdata->trysolutions && conshdlrdata->heurtrysol ==
NULL )
5205 if ( conshdlrdata->binvarhash !=
NULL )
5209 conshdlrdata->maxaddlincons = 0;
5210 conshdlrdata->naddlincons = 0;
5211 conshdlrdata->nrows = 0;
5235 if ( conshdlrdata->maxaddlincons > 0 )
5241 conshdlrdata->naddlincons = 0;
5242 conshdlrdata->maxaddlincons = 0;
5273 if ( conshdlrdata->sepaalternativelp )
5280 for (
c = 0;
c < nconss; ++
c)
5296 ++conshdlrdata->nslackvars;
5299 if ( conshdlrdata->genlogicor )
5309 SCIPerrorMessage(
"Logicor constraint handler not included, cannot generate constraints.\n");
5314 if ( (sepafreq != -1 || conshdlrdata->enforcecuts) &&
logicorsepafreq != 1 )
5316 SCIPwarningMessage(
scip,
"For better performance set parameter 'constraints/logicor/sepafreq' to 1 if 'constraints/included/genlogicor' is true.\n");
5322 conshdlrdata->objothervarsonly =
TRUE;
5323 for (
c = 0;
c < nconss; ++
c)
5339 conshdlrdata->objothervarsonly =
FALSE;
5342 if ( ! consdata->linconsactive )
5349 if ( conshdlrdata->sepaalternativelp && consdata->colindex < 0 )
5376 SCIP_CALL(
SCIPcreateNlRow(
scip, &nlrow,
SCIPconsGetName(conss[
c]), 0.0, 0,
NULL,
NULL,
quadexpr, 0.0, 0.0,
SCIP_EXPRCURV_UNKNOWN) );
5391 if ( conshdlrdata->sepaalternativelp )
5398 if ( conshdlrdata->naddlincons > 0 )
5400 for (
c = 0;
c < conshdlrdata->naddlincons; ++
c)
5402 cons = conshdlrdata->addlincons[
c];
5421 SCIPdebugMsg(
scip,
"Added %d additional columns to alternative LP.\n", cnt);
5428 if ( conshdlrdata->useotherconss )
5460 SCIPdebugMsg(
scip,
"Added %d additional columns from linear constraints to alternative LP.\n", cnt);
5466 if ( conshdlrdata->forcerestart )
5473 assert( conshdlrdata->eventhdlrrestart !=
NULL );
5479 conshdlrdata->nbinvarszero = 0;
5485 conshdlrdata->objindicatoronly =
FALSE;
5494 for (
c = 0;
c < nconss; ++
c)
5519 if ( probindex < 0 )
5538 if (
REALABS(
obj) < conshdlrdata->minabsobj )
5552 conshdlrdata->objindicatoronly =
TRUE;
5554 assert( conshdlrdata->eventhdlrrestart !=
NULL );
5580 if ( conshdlrdata->sepaalternativelp )
5582 if ( conshdlrdata->slackhash !=
NULL )
5591 if ( conshdlrdata->altlp !=
NULL )
5613 for (
c = 0;
c < nconss; ++
c)
5622 consdata->colindex = -1;
5648#ifdef SCIP_MORE_DEBUG
5661 if ( conshdlrdata->sepaalternativelp )
5672 if ( (*consdata)->linconsactive )
5674 assert( conshdlrdata->eventhdlrbound !=
NULL );
5680 if ( conshdlrdata->forcerestart )
5682 assert( conshdlrdata->eventhdlrrestart !=
NULL );
5720 assert( conshdlrdata->eventhdlrbound !=
NULL );
5722#ifdef SCIP_MORE_DEBUG
5769 if ( conshdlrdata->sepaalternativelp )
5771 if ( conshdlrdata->binvarhash ==
NULL )
5805 for (
c = 0;
c < nconss; ++
c)
5838 conshdlrdata->addedcouplingcons =
FALSE;
5882 for (
c = 0;
c < nconss; ++
c)
5897#ifdef SCIP_MORE_DEBUG
5902 if ( ! consdata->linconsactive )
5911 if ( ! consdata->implicationadded )
5920 consdata->implicationadded =
TRUE;
5929 if ( ! consdata->slacktypechecked )
5931 consdata->slacktypechecked =
TRUE;
5946 slackvar = consdata->slackvar;
5951 if (
vars[
j] == slackvar )
5962 SCIP_Bool infeasible;
5978 SCIPdebugMsg(
scip,
"Cannot change type of slack variable (<%s>) to IMPLINT, since global bound is non-integral: (%g, %g).\n",
6014 *nupgdconss +=
ngen;
6015 if ( conshdlrdata->removeindicators )
6018 conshdlrdata->addedcouplingcons =
TRUE;
6021 SCIPdebug(
SCIPdebugMsg(
scip,
"Presolved %d constraints (fixed %d variables, removed 0 variables, and deleted %d constraints).\n",
6047 *infeasible =
FALSE;
6050 if ( ! conshdlrdata->addcoupling )
6054 if ( conshdlrdata->addcouplingcons && conshdlrdata->addedcouplingcons )
6057 SCIPdebugMsg(
scip,
"Handle initial rows for %d indicator constraints.\n", nconss);
6060 for (
c = 0;
c < nconss && !(*infeasible); ++
c)
6071 if ( ! consdata->linconsactive )
6090 if ( conshdlrdata->addcouplingcons )
6094 assert( ! conshdlrdata->addedcouplingcons );
6279 for (
c = 0;
c < nconss; ++
c)
6289 if ( ! consdata->linconsactive )
6320 if ( trysol !=
NULL )
6336 if ( trysol !=
NULL )
6349 SCIP_Bool infeasible;
6353 lp = conshdlrdata->altlp;
6354 assert( conshdlrdata->sepaalternativelp );
6364 if ( conshdlrdata->updatebounds )
6378 for (
c = 0;
c < nconss; ++
c)
6430 if ( trysol !=
NULL )
6471 for (
c = 0;
c < nconss; ++
c)
6484#ifdef SCIP_MORE_DEBUG
6491 conshdlrdata->addopposite, &
cutoff, &cnt) );
6531 assert( inferinfo == 0 || inferinfo == 1 || inferinfo == 2 );
6532 assert( consdata->linconsactive );
6535 if ( inferinfo == 0 )
6542 else if ( inferinfo == 1 )
6553 assert( inferinfo == 2 );
6583#ifdef SCIP_MORE_DEBUG
6589 if ( consdata->linconsactive )
6613 for (
j = 0;
j < nlinvars; ++
j)
6662 binvar = consdata->binvar;
6690 const char* consname;
6704#ifdef SCIP_MORE_DEBUG
6790 initial, separate, enforce, check,
propagate, local, dynamic, removable, stickingatnode) );
6843 if ( binvar ==
NULL )
6855 if ( slackvar ==
NULL )
6866 if ( lincons ==
NULL )
6899 if ( lincons ==
NULL )
6905 if ( lincons ==
NULL )
6911 if( lincons ==
NULL )
6933 initial, separate, enforce, check,
propagate, local, dynamic, removable, stickingatnode) );
6951#ifdef SCIP_MORE_DEBUG
6961 if ( conshdlrdata->altlp !=
NULL )
6963 assert( conshdlrdata->sepaalternativelp );
6965 if ( consdata->colindex >= 0 )
6986#ifdef SCIP_MORE_DEBUG
6993 if ( conshdlrdata->altlp !=
NULL )
6999 assert( conshdlrdata->sepaalternativelp );
7001 if ( consdata->colindex >= 0 )
7037 if ( consdata->binvar !=
NULL )
7042 if ( consdata->slackvar !=
NULL )
7081 if ( consdata->binvar !=
NULL )
7083 if ( consdata->slackvar !=
NULL )
7121 *infeasible =
FALSE;
7127 for (
c = 0;
c < nindconss; ++
c)
7187 conshdlrdata->eventhdlrbound =
NULL;
7190 assert(conshdlrdata->eventhdlrbound !=
NULL);
7193 conshdlrdata->eventhdlrrestart =
NULL;
7196 assert( conshdlrdata->eventhdlrrestart !=
NULL );
7198 conshdlrdata->heurtrysol =
NULL;
7202 conshdlrdata->binvarhash =
NULL;
7210 conshdlrdata->addlincons =
NULL;
7211 conshdlrdata->naddlincons = 0;
7212 conshdlrdata->maxaddlincons = 0;
7257 conflicthdlrdata->conshdlrdata = conshdlrdata;
7258 conflicthdlrdata->conshdlr = conshdlr;
7259 assert( conflicthdlrdata->conshdlr !=
NULL );
7269 "constraints/indicator/branchindicators",
7270 "Branch on indicator constraints in enforcing?",
7274 "constraints/indicator/genlogicor",
7275 "Generate logicor constraints instead of cuts?",
7279 "constraints/indicator/addcoupling",
7280 "Add coupling constraints or rows if big-M is small enough?",
7284 "constraints/indicator/maxcouplingvalue",
7285 "maximum coefficient for binary variable in coupling constraint",
7289 "constraints/indicator/addcouplingcons",
7290 "Add initial variable upper bound constraints, if 'addcoupling' is true?",
7294 "constraints/indicator/sepacouplingcuts",
7295 "Should the coupling inequalities be separated dynamically?",
7299 "constraints/indicator/sepacouplinglocal",
7300 "Allow to use local bounds in order to separate coupling inequalities?",
7304 "constraints/indicator/sepacouplingvalue",
7305 "maximum coefficient for binary variable in separated coupling constraint",
7309 "constraints/indicator/sepaperspective",
7310 "Separate cuts based on perspective formulation?",
7314 "constraints/indicator/sepapersplocal",
7315 "Allow to use local bounds in order to separate perspective cuts?",
7319 "constraints/indicator/maxsepanonviolated",
7320 "maximal number of separated non violated IISs, before separation is stopped",
7324 "constraints/indicator/updatebounds",
7325 "Update bounds of original variables for separation?",
7329 "constraints/indicator/maxconditionaltlp",
7330 "maximum estimated condition of the solution basis matrix of the alternative LP to be trustworthy (0.0 to disable check)",
7334 "constraints/indicator/maxsepacuts",
7335 "maximal number of cuts separated per separation round",
7339 "constraints/indicator/maxsepacutsroot",
7340 "maximal number of cuts separated per separation round in the root node",
7344 "constraints/indicator/removeindicators",
7345 "Remove indicator constraint if corresponding variable bound constraint has been added?",
7349 "constraints/indicator/generatebilinear",
7350 "Do not generate indicator constraint, but a bilinear constraint instead?",
7354 "constraints/indicator/scaleslackvar",
7355 "Scale slack variable coefficient at construction time?",
7359 "constraints/indicator/trysolutions",
7360 "Try to make solutions feasible by setting indicator variables?",
7364 "constraints/indicator/enforcecuts",
7365 "In enforcing try to generate cuts (only if sepaalternativelp is true)?",
7369 "constraints/indicator/dualreductions",
7370 "Should dual reduction steps be performed?",
7374 "constraints/indicator/addopposite",
7375 "Add opposite inequality in nodes in which the binary variable has been fixed to 0?",
7379 "constraints/indicator/conflictsupgrade",
7380 "Try to upgrade bounddisjunction conflicts by replacing slack variables?",
7384 "constraints/indicator/restartfrac",
7385 "fraction of binary variables that need to be fixed before restart occurs (in forcerestart)",
7389 "constraints/indicator/useotherconss",
7390 "Collect other constraints to alternative LP?",
7394 "constraints/indicator/useobjectivecut",
7395 "Use objective cut with current best solution to alternative LP?",
7399 "constraints/indicator/trysolfromcover",
7400 "Try to construct a feasible solution from a cover?",
7404 "constraints/indicator/upgradelinear",
7405 "Try to upgrade linear constraints to indicator constraints?",
7410 "constraints/indicator/sepaalternativelp",
7411 "Separate using the alternative LP?",
7415 "constraints/indicator/forcerestart",
7416 "Force restart if absolute gap is 1 or enough binary variables have been fixed?",
7420 "constraints/indicator/nolinconscont",
7421 "Decompose problem (do not generate linear constraint if all variables are continuous)?",
7457 SCIP_Bool removable,
7459 SCIP_Bool stickingatnode
7464 return SCIPcreateConsIndicatorGeneric(
scip, cons, name, binvar,
nvars,
vars, vals, rhs,
TRUE,
TRUE, initial,
7465 separate, enforce, check,
propagate, local, dynamic, removable, stickingatnode);
7484 SCIP_Bool activeone,
7485 SCIP_Bool lessthanineq,
7500 SCIP_Bool removable,
7502 SCIP_Bool stickingatnode
7512 SCIP_Bool modifiable =
FALSE;
7513 SCIP_Bool linconsactive;
7522 SCIPerrorMessage(
"Indicator constraint <%s> needs nonnegative number of variables in linear constraint.\n", name);
7528 if ( conshdlr ==
NULL )
7537 if ( conshdlrdata->nolinconscont && ! conshdlrdata->sepaalternativelp )
7539 SCIPerrorMessage(
"constraint handler <%s>: need parameter <sepaalternativelp> to be true if parameter <nolinconscont> is true.\n",
CONSHDLR_NAME);
7543 if ( conshdlrdata->nolinconscont && conshdlrdata->generatebilinear )
7566 if ( conshdlrdata->scaleslackvar )
7571 if ( ! conshdlrdata->scaleslackvar )
7587 linconsactive =
TRUE;
7588 if ( conshdlrdata->nolinconscont )
7592 assert( ! conshdlrdata->generatebilinear );
7608 linconsactive =
FALSE;
7615 if ( linconsactive )
7628 if ( ! lessthanineq )
7636 if ( conshdlrdata->scaleslackvar &&
nvars > 0 )
7652 if ( conshdlrdata->generatebilinear )
7654 SCIP_Real val = 1.0;
7666 SCIP_CALL(
SCIPcreateConsQuadraticNonlinear(
scip, cons, name, 0,
NULL,
NULL, 1, &
binvarinternal, &slackvar, &val, 0.0, 0.0,
7673 SCIP_CALL(
consdataCreate(
scip, conshdlr, conshdlrdata, name, &consdata, conshdlrdata->eventhdlrbound, conshdlrdata->eventhdlrrestart,
7674 binvar, activeone, lessthanineq, slackvar, lincons, linconsactive) );
7679 SCIP_CALL(
SCIPcreateCons(
scip, cons, name, conshdlr, consdata, initial, separate, enforce, check,
propagate,
7680 local, modifiable, dynamic, removable, stickingatnode) );
7685 if ( conshdlrdata->sepaalternativelp )
7689 if ( conshdlrdata->binvarhash ==
NULL )
7763 SCIP_Bool activeone,
7778 SCIP_Bool removable,
7780 SCIP_Bool stickingatnode
7788 SCIP_Bool modifiable =
FALSE;
7789 SCIP_Bool linconsactive =
TRUE;
7805 if ( conshdlr ==
NULL )
7814 if ( conshdlrdata->nolinconscont && ! conshdlrdata->sepaalternativelp )
7816 SCIPerrorMessage(
"constraint handler <%s>: need parameter <sepaalternativelp> to be true if parameter <nolinconscont> is true.\n",
CONSHDLR_NAME);
7824 if ( conshdlrdata->nolinconscont )
7835 for (v = 0; v <
nvars; ++v)
7848 linconsactive =
FALSE;
7856 if ( conshdlrdata->generatebilinear )
7858 SCIP_Real val = 1.0;
7872 SCIP_CALL(
SCIPcreateConsQuadraticNonlinear(
scip, cons, name, 0,
NULL,
NULL, 1, &
binvarinternal, &slackvar, &val, 0.0, 0.0,
7878 SCIP_CALL(
consdataCreate(
scip, conshdlr, conshdlrdata, name, &consdata, conshdlrdata->eventhdlrbound, conshdlrdata->eventhdlrrestart,
7879 binvar, activeone,
TRUE, slackvar, lincons, linconsactive) );
7883 SCIP_CALL(
SCIPcreateCons(
scip, cons, name, conshdlr, consdata, initial, separate, enforce, check,
propagate,
7884 local, modifiable, dynamic, removable, stickingatnode) );
7925 SCIP_Bool removable,
7927 SCIP_Bool stickingatnode
7933 enforce, check,
propagate, local, dynamic, removable, stickingatnode);
7988 if ( !consdata->lessthanineq )
7996 SCIP_Bool infeasible;
8019 return consdata->lincons;
8056 consdata->lincons = lincons;
8057 consdata->linconsactive =
TRUE;
8061 if ( conshdlrdata->nolinconscont )
8074 for (v = 0; v <
nvars; ++v)
8087 consdata->linconsactive =
FALSE;
8106 return consdata->activeone;
8123 return consdata->binvar;
8139 binvar = consdata->binvar;
8141 if ( ! consdata->activeone )
8172 if ( consdata->binvar !=
NULL )
8190 if ( ! consdata->activeone )
8193 consdata->binvar =
var;
8200 assert( conshdlrdata->eventhdlrbound !=
NULL );
8201 assert( conshdlrdata->eventhdlrrestart !=
NULL );
8204 if ( consdata->linconsactive )
8210 if ( conshdlrdata->forcerestart )
8217 ++(consdata->nfixednonzero);
8221 if ( ! consdata->activeone )
8223 consdata->binvar = binvar;
8242 return consdata->slackvar;
8298 if ( consdata->linconsactive )
8372 if ( ! consdata->linconsactive )
8375 lincons = consdata->lincons;
8381 slackvar = consdata->slackvar;
8382 binvar = consdata->binvar;
8393 for (v = 0; v < nlinvars; ++v)
8397 if (
var != slackvar )
8536 for (
c = 0;
c < nconss; ++
c)
8546 if ( ! consdata->linconsactive )
8550 *changed = *changed ||
chg;
8577 assert( conshdlrdata->naddlincons+1 <= conshdlrdata->maxaddlincons );
8579 conshdlrdata->addlincons[conshdlrdata->naddlincons++] = lincons;
8610 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
static SCIP_RETCODE consdataCreate(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_CONSHDLRDATA *conshdlrdata, const char *consname, SCIP_CONSDATA **consdata, SCIP_EVENTHDLR *eventhdlrbound, SCIP_EVENTHDLR *eventhdlrrestart, SCIP_VAR *binvar, SCIP_Bool activeone, SCIP_Bool lessthanineq, SCIP_VAR *slackvar, SCIP_CONS *lincons, SCIP_Bool linconsactive)
#define DEFAULT_ADDOPPOSITE
static SCIP_RETCODE checkLPBoundsClean(SCIP *scip, SCIP_LPI *lp, int nconss, SCIP_CONS **conss)
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
#define DEFAULT_REMOVEINDICATORS
#define DEFAULT_UPGRADELINEAR
#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
static SCIP_RETCODE propIndicator(SCIP *scip, SCIP_CONS *cons, SCIP_CONSDATA *consdata, SCIP_Bool dualreductions, SCIP_Bool addopposite, SCIP_Bool *cutoff, int *nGen)
#define DEFAULT_SEPACOUPLINGLOCAL
#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
#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 .
product expression handler
variable expression handler
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_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)
SCIP_RETCODE SCIPwriteTransProblem(SCIP *scip, const char *filename, const char *extension, SCIP_Bool genericnames)
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)
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,)
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 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)
int SCIPcalcMemGrowSize(SCIP *scip, int num)
#define SCIPallocBufferArray(scip, ptr, num)
#define SCIPfreeBufferArray(scip, ptr)
#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_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
#define SCIP_DECL_CONFLICTEXEC(x)
#define SCIP_DECL_CONFLICTFREE(x)
@ SCIP_CONFTYPE_PROPAGATION
struct SCIP_ConflicthdlrData SCIP_CONFLICTHDLRDATA
#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
@ SCIP_VARTYPE_CONTINUOUS
@ SCIP_VARSTATUS_MULTAGGR
@ SCIP_VARSTATUS_AGGREGATED
enum SCIP_Vartype SCIP_VARTYPE