84#define CONSHDLR_NAME "varbound"
85#define CONSHDLR_DESC "variable bounds lhs <= x + c*y <= rhs, x non-binary, y non-continuous"
86#define CONSHDLR_SEPAPRIORITY +900000
87#define CONSHDLR_ENFOPRIORITY -500000
88#define CONSHDLR_CHECKPRIORITY -500000
89#define CONSHDLR_SEPAFREQ 0
90#define CONSHDLR_PROPFREQ 1
91#define CONSHDLR_EAGERFREQ 100
93#define CONSHDLR_MAXPREROUNDS -1
94#define CONSHDLR_DELAYSEPA FALSE
95#define CONSHDLR_DELAYPROP FALSE
96#define CONSHDLR_NEEDSCONS TRUE
98#define CONSHDLR_PRESOLTIMING (SCIP_PRESOLTIMING_FAST | SCIP_PRESOLTIMING_MEDIUM)
99#define CONSHDLR_PROP_TIMING SCIP_PROPTIMING_BEFORELP
101#define EVENTHDLR_NAME "varbound"
102#define EVENTHDLR_DESC "bound change event handler for variable bound constraints"
104#define LINCONSUPGD_PRIORITY +50000
113#define DEFAULT_PRESOLPAIRWISE TRUE
114#define DEFAULT_MAXLPCOEF 1e+09
115#define DEFAULT_USEBDWIDENING TRUE
118#define MAXSCALEDCOEF 1000LL
132 unsigned int presolved:1;
133 unsigned int varboundsadded:1;
134 unsigned int changed:1;
135 unsigned int tightened:1;
139struct SCIP_ConshdlrData
142 SCIP_Bool presolpairwise;
144 SCIP_Bool usebdwidening;
224 (*conshdlrdata)->eventhdlr = eventhdlr;
315 SCIPerrorMessage(
"left hand side of varbound constraint greater than right hand side\n");
331 (*consdata)->var =
var;
332 (*consdata)->vbdvar = vbdvar;
333 (*consdata)->vbdcoef = vbdcoef;
334 (*consdata)->lhs = lhs;
335 (*consdata)->rhs = rhs;
336 (*consdata)->row =
NULL;
337 (*consdata)->nlrow =
NULL;
338 (*consdata)->presolved =
FALSE;
339 (*consdata)->varboundsadded =
FALSE;
340 (*consdata)->changed =
TRUE;
341 (*consdata)->tightened =
FALSE;
373 if( (*consdata)->row !=
NULL )
379 if( (*consdata)->nlrow !=
NULL )
419 SCIP_Bool* infeasible
431 if( conshdlr ==
NULL )
446 if( consdata->row ==
NULL )
480 if( consdata->nlrow ==
NULL )
485 assert(consdata->lhs <= consdata->rhs);
487 vars[0] = consdata->var;
488 vars[1] = consdata->vbdvar;
491 coefs[1] = consdata->vbdcoef;
523 SCIPdebugMsg(
scip,
"checking variable bound constraint <%s> for feasibility of solution %p (lprows=%u)\n",
535 absviol =
MAX(consdata->lhs - sum, sum - consdata->rhs);
566 SCIP_Bool usebdwidening
581 vbdvar = consdata->vbdvar;
584 vbdcoef = consdata->vbdcoef;
984 SCIP_Bool usebdwidening
1148 SCIP_Bool usebdwidening,
1168 if( conshdlr ==
NULL )
1176 var = consdata->var;
1177 vbdvar = consdata->vbdvar;
1178 vbdcoef = consdata->vbdcoef;
1191 SCIP_Bool tightened;
1211 else if( tightened )
1222 SCIP_Bool tightened;
1242 else if( tightened )
1257 if( consdata->row ==
NULL )
1269 SCIP_Bool infeasible;
1314 consdata->rhs = lhs;
1323 if( consdata->vbdcoef > 0.0 )
1337 if( consdata->vbdcoef > 0.0 )
1350 consdata->varboundsadded =
FALSE;
1351 consdata->tightened =
FALSE;
1356 consdata->presolved =
FALSE;
1357 consdata->lhs = lhs;
1358 consdata->changed =
TRUE;
1394 consdata->lhs = rhs;
1404 if( consdata->vbdcoef > 0.0 )
1418 if( consdata->vbdcoef > 0.0 )
1431 consdata->varboundsadded =
FALSE;
1432 consdata->tightened =
FALSE;
1437 consdata->presolved =
FALSE;
1438 consdata->rhs = rhs;
1439 consdata->changed =
TRUE;
1449 SCIP_Bool usebdwidening,
1463 SCIP_Bool tightened;
1472 SCIPdebugMsg(
scip,
"propagating variable bound constraint <%s>: %.15g <= <%s>[%.9g, %.9g] + %.15g<%s>[%.9g, %.9g] <= %.15g\n",
1494 SCIP_Bool infeasible;
1522 if( consdata->vbdcoef > 0.0 )
1586 if( consdata->vbdcoef > 0.0 )
1665 if( consdata->vbdcoef > 0.0 )
1729 if( consdata->vbdcoef > 0.0 )
1808 ((consdata->vbdcoef > 0.0 &&
SCIPisGE(
scip,
xlb + consdata->vbdcoef *
ylb, consdata->lhs))
1809 || (consdata->vbdcoef < 0.0 &&
SCIPisGE(
scip,
xlb + consdata->vbdcoef *
yub, consdata->lhs))) )
1819 ((consdata->vbdcoef > 0.0 &&
SCIPisLE(
scip,
xub + consdata->vbdcoef *
yub, consdata->rhs))
1820 || (consdata->vbdcoef < 0.0 &&
SCIPisLE(
scip,
xub + consdata->vbdcoef *
ylb, consdata->rhs))) )
1830 || (consdata->vbdcoef > 0.0 &&
SCIPisGE(
scip,
xlb + consdata->vbdcoef *
ylb, consdata->lhs))
1831 || (consdata->vbdcoef < 0.0 &&
SCIPisGE(
scip,
xlb + consdata->vbdcoef *
yub, consdata->lhs)))
1833 || (consdata->vbdcoef > 0.0 &&
SCIPisLE(
scip,
xub + consdata->vbdcoef *
yub, consdata->rhs))
1834 || (consdata->vbdcoef < 0.0 &&
SCIPisLE(
scip,
xub + consdata->vbdcoef *
ylb, consdata->rhs))) )
1836 SCIPdebugMsg(
scip,
"variable bound constraint <%s> is redundant: <%s>[%.15g,%.15g], <%s>[%.15g,%.15g]\n",
1843#ifdef SCIP_DISABLED_CODE
1888 if( ndelconss !=
NULL )
2279 for(
c = nconss - 1;
c > 0 && !(*cutoff); --
c )
2303 for( s =
c - 1; s >= 0; --s )
2334 SCIP_Bool tightened =
FALSE;
2339 scalar = (1.0 - coef *
consdata1->vbdcoef);
2570 checkRedundancySide(
scip,
consdata0->var,
consdata0->vbdvar, coef,
consdata1->vbdcoef, lhs,
consdata1->lhs, &
lhsequal, &
cons0lhsred, &
cons1lhsred,
TRUE);
2573 checkRedundancySide(
scip,
consdata0->var,
consdata0->vbdvar, coef,
consdata1->vbdcoef, rhs,
consdata1->rhs, &
rhsequal, &
cons0rhsred, &
cons1rhsred,
FALSE);
2712 rhs = (lhs + rhs)/2;
2723 SCIP_Bool infeasible;
2724 SCIP_Bool tightened;
2873 for(
c = nconss - 1;
c >= 0; --
c )
2929 if( consdata->vbdcoef < 0 )
2956 tmp = consdata->lhs;
2959 consdata->tightened =
FALSE;
2992 consdata->var = consdata->vbdvar;
3000 consdata->varboundsadded =
FALSE;
3001 consdata->tightened =
FALSE;
3032 SCIP_Bool redundant;
3049 var = consdata->var;
3053 vbdvar = consdata->vbdvar;
3057 varschanged = (
var != consdata->var || vbdvar != consdata->vbdvar);
3065 SCIPdebugMsg(
scip,
"variable bound constraint <%s> has equal variable and vbd variable <%s>\n",
3079 else if( scalar > 0.0 )
3083 SCIP_Bool tightened;
3094 SCIP_Bool tightened;
3108 SCIP_Bool tightened;
3119 SCIP_Bool tightened;
3145 SCIPdebugMsg(
scip,
"variable bound constraint <%s>: variable <%s> is fixed to %.15g\n",
3157 assert( consdata->vbdcoef != 0.0 );
3163 if( consdata->vbdcoef > 0.0 )
3165 SCIP_Bool tightened;
3177 SCIP_Bool tightened;
3190 if( consdata->vbdcoef > 0.0 )
3192 SCIP_Bool tightened;
3204 SCIP_Bool tightened;
3218 else if(
var != consdata->var )
3226 if( consdata->vbdcoef > 0.0 )
3254 consdata->tightened =
FALSE;
3266 lhs = consdata->lhs;
3267 consdata->lhs = -consdata->rhs;
3268 consdata->rhs = -lhs;
3279 consdata->tightened =
FALSE;
3282 consdata->var =
var;
3290 if( consdata->vbdcoef > 0.0 )
3305 SCIPdebugMsg(
scip,
"variable bound constraint <%s>: vbd variable <%s> is fixed to %.15g\n",
3317 SCIP_Bool tightened;
3329 SCIP_Bool tightened;
3342 else if( vbdvar != consdata->vbdvar )
3345 if( consdata->vbdcoef > 0.0 )
3371 consdata->tightened =
FALSE;
3373 consdata->vbdvar = vbdvar;
3377 if( consdata->vbdcoef > 0.0 )
3401 consdata->changed =
TRUE;
3411 lhs = consdata->lhs;
3412 rhs = consdata->rhs;
3422 if(
var != consdata->var )
3448 if( vbdvar != consdata->vbdvar )
3468 assert(vbdvar == consdata->vbdvar);
3485 if( !(*
cutoff) && redundant )
3524 if( consdata->tightened )
3529 consdata->tightened =
TRUE;
3540 consdata->changed =
TRUE;
3546 consdata->changed =
TRUE;
3642 else if( (
SCIPisInfinity(
scip, -consdata->lhs) ||
SCIPisFeasGE(
scip, consdata->vbdcoef -
SCIPfeasFloor(
scip, consdata->vbdcoef), consdata->lhs -
SCIPfeasFloor(
scip, consdata->lhs))) && (
SCIPisInfinity(
scip, consdata->rhs) ||
SCIPisFeasGT(
scip, consdata->vbdcoef -
SCIPfeasFloor(
scip, consdata->vbdcoef), consdata->rhs -
SCIPfeasFloor(
scip, consdata->rhs))) )
3663 else if( (
SCIPisInfinity(
scip, -consdata->lhs) ||
SCIPisFeasLT(
scip, consdata->vbdcoef -
SCIPfeasFloor(
scip, consdata->vbdcoef), consdata->lhs -
SCIPfeasFloor(
scip, consdata->lhs))) && (
SCIPisInfinity(
scip, consdata->rhs) ||
SCIPisFeasLE(
scip, consdata->vbdcoef -
SCIPfeasFloor(
scip, consdata->vbdcoef), consdata->rhs -
SCIPfeasFloor(
scip, consdata->rhs))) )
3723 SCIP_Bool tightened;
3736 SCIP_Bool tightened;
3787 newcoef =
MAX(consdata->vbdcoef - consdata->rhs +
xub, consdata->lhs -
xlb);
3804 "tighten varbound %.15g <= <%s>[%.15g,%.15g] %+.15g<%s> <= %.15g to %.15g <= <%s> %+.15g<%s> <= %.15g\n",
3814 consdata->rhs =
MAX(
newrhs, consdata->lhs);
3824 consdata->tightened =
FALSE;
3826 assert(consdata->tightened);
3844 newcoef =
MIN(consdata->vbdcoef - consdata->lhs +
xlb, consdata->rhs -
xub);
3861 "tighten varbound %.15g <= <%s>[%.15g,%.15g] %+.15g<%s> <= %.15g to %.15g <= <%s> %+.15g<%s> <= %.15g\n",
3871 consdata->lhs =
MIN(
newlhs, consdata->rhs);
3881 consdata->tightened =
FALSE;
3883 assert(consdata->tightened);
3893 if( consdata->vbdcoef > 0.0 &&
SCIPisFeasGT(
scip,
xlb, consdata->lhs - consdata->vbdcoef) )
3914 SCIPdebugMsg(
scip,
"tighten binary VLB <%s>[%.15g,%.15g] %+.15g<%s> >= %.15g to <%s> %+.15g<%s> >= %.15g\n",
3935 newcoef = consdata->vbdcoef - consdata->lhs +
xlb;
3948 SCIPdebugMsg(
scip,
"tighten binary VLB <%s>[%.15g,%.15g] %+.15g<%s> >= %.15g to <%s> %+.15g<%s> >= %.15g\n",
3958 consdata->lhs =
xlb;
3975 newcoef = consdata->vbdcoef - consdata->rhs +
xub;
3988 SCIPdebugMsg(
scip,
"tighten binary VUB <%s>[%.15g,%.15g] %+.15g<%s> <= %.15g to <%s> %+.15g<%s> <= %.15g\n",
3998 consdata->rhs =
xub;
4003 else if( consdata->vbdcoef < 0.0 &&
SCIPisFeasLT(
scip,
xub, consdata->rhs - consdata->vbdcoef) )
4024 SCIPdebugMsg(
scip,
"tighten binary VUB <%s>[%.15g,%.15g] %+.15g<%s> <= %.15g to <%s> %+.15g<%s> <= %.15g\n",
4042 consdata->varboundsadded =
FALSE;
4043 consdata->changed =
TRUE;
4091 for(
c = nconss - 1;
c >= 0; --
c )
4103 if( !consdata->presolved )
4125 if( !consdata->tightened )
4148 if( consdata->vbdcoef > 0.0 )
4155 SCIP_Bool infeasible;
4156 SCIP_Bool redundant;
4159 SCIPdebugMsg(
scip,
"varbound constraint <%s>: aggregate <%s> + <%s> == 1\n",
4172 assert(consdata->lhs < 0.5);
4174 vars[0] = consdata->var;
4175 vars[1] = consdata->vbdvar;
4194 SCIP_Bool infeasible;
4195 SCIP_Bool redundant;
4198 SCIPdebugMsg(
scip,
"varbound constraint <%s>: aggregate <%s> - <%s> == 0\n",
4211 assert(consdata->lhs < -0.5);
4213 vars[0] = consdata->var;
4222 vars[1] = consdata->vbdvar;
4305 if( vals[1-
vbdind] > 0.0 )
4381 for(
c = 0;
c < nconss; ++
c )
4398 for(
c = 0;
c < nconss; ++
c )
4403 if( consdata->row !=
NULL )
4408 if( consdata->nlrow !=
NULL )
4479 *infeasible =
FALSE;
4481 for(
i = 0;
i < nconss && !(*infeasible);
i++ )
4565 for(
i = 0;
i < nconss;
i++ )
4605 for(
i = 0;
i < nconss;
i++ )
4637 for(
i = 0;
i < nconss;
i++ )
4728 else if( nchgbds > 0 )
4770 for(
i = 0;
i < nconss;
i++ )
4785 consdata->presolved =
FALSE;
4787 if( consdata->presolved )
4789 consdata->presolved =
TRUE;
4815 if( !consdata->varboundsadded )
4817 SCIP_Bool infeasible;
4826 SCIPdebugMsg(
scip,
"adding variable lower bound <%s> >= %g<%s> + %g (and potentially also <%s> %s %g<%s> + %g)\n",
4828 SCIPvarGetName(consdata->vbdvar), (consdata->vbdcoef > 0 ?
">=" :
"<="), 1.0/-consdata->vbdcoef,
4841 SCIPdebugMsg(
scip,
"adding variable upper bound <%s> <= %g<%s> + %g (and potentially also <%s> %s %g<%s> + %g)\n",
4843 SCIPvarGetName(consdata->vbdvar), (consdata->vbdcoef > 0 ?
"<=" :
">="), 1.0/-consdata->vbdcoef,
4852 consdata->varboundsadded =
TRUE;
4870 SCIP_CALL(
upgradeConss(
scip, conshdlrdata, conss, nconss, &
cutoff, naggrvars, nchgbds, nchgcoefs, nchgsides, ndelconss, naddconss) );
4923 if( consdata->vbdcoef > 0.0 )
4936 if( consdata->vbdcoef > 0.0 )
5031 const char* consname;
5050 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode, global,
valid) );
5165 initial, separate, enforce, check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
5192 vars[0] = consdata->var;
5193 vars[1] = consdata->vbdvar;
5229 consdata->presolved =
FALSE;
5235 consdata->presolved =
FALSE;
5236 consdata->tightened =
FALSE;
5301 "should pairwise constraint comparison be performed in presolving?",
5305 "maximum coefficient in varbound constraint to be added as a row into LP",
5308 "constraints/" CONSHDLR_NAME "/usebdwidening",
"should bound widening be used in conflict analysis?",
5339 SCIP_Bool modifiable,
5345 SCIP_Bool removable,
5347 SCIP_Bool stickingatnode
5358 if( conshdlr ==
NULL )
5371 SCIP_CALL(
SCIPcreateCons(
scip, cons, name, conshdlr, consdata, initial, separate, enforce, check,
propagate,
5372 local, modifiable, dynamic, removable, stickingatnode) );
5425 return consdata->lhs;
5448 return consdata->rhs;
5471 return consdata->var;
5494 return consdata->vbdvar;
5517 return consdata->vbdcoef;
5540 if( consdata->row !=
NULL )
5566 if( consdata->row !=
NULL )
5594 return consdata->row;
5601 SCIP_Bool* infeasible,
5615 if( conshdlr ==
NULL )
5619 *infeasible =
FALSE;
5628 eventhdlr = conshdlrdata->eventhdlr;
5633 for(
i = nconss - 1;
i > 0; --
i )
Constraint handler for linear constraints in their most general form, .
Constraint handler for the set partitioning / packing / covering constraints .
static SCIP_RETCODE addRelaxation(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *infeasible)
static SCIP_RETCODE dropEvents(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr)
#define DEFAULT_USEBDWIDENING
#define CONSHDLR_NEEDSCONS
#define CONSHDLR_SEPAFREQ
#define CONSHDLR_CHECKPRIORITY
static SCIP_RETCODE upgradeConss(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_CONS **conss, int nconss, SCIP_Bool *cutoff, int *naggrvars, int *nchgbds, int *nchgcoefs, int *nchgsides, int *ndelconss, int *naddconss)
static SCIP_RETCODE applyFixings(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, SCIP_Bool *cutoff, int *nchgbds, int *ndelconss, int *naddconss)
static SCIP_RETCODE consdataCreate(SCIP *scip, SCIP_CONSDATA **consdata, SCIP_VAR *var, SCIP_VAR *vbdvar, SCIP_Real vbdcoef, SCIP_Real lhs, SCIP_Real rhs)
static SCIP_RETCODE tightenCoefs(SCIP *scip, SCIP_CONS *cons, int *nchgcoefs, int *nchgsides, int *ndelconss, SCIP_Bool *cutoff, int *nchgbds)
static SCIP_RETCODE createRelaxation(SCIP *scip, SCIP_CONS *cons)
#define CONSHDLR_PROP_TIMING
static void checkRedundancySide(SCIP *scip, SCIP_VAR *var, SCIP_VAR *vbdvar, SCIP_Real coef0, SCIP_Real coef1, SCIP_Real side0, SCIP_Real side1, SCIP_Bool *sideequal, SCIP_Bool *cons0sidered, SCIP_Bool *cons1sidered, SCIP_Bool islhs)
static void conshdlrdataFree(SCIP *scip, SCIP_CONSHDLRDATA **conshdlrdata)
#define CONSHDLR_MAXPREROUNDS
static SCIP_Bool checkCons(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Bool checklprows)
#define DEFAULT_PRESOLPAIRWISE
#define CONSHDLR_SEPAPRIORITY
#define DEFAULT_MAXLPCOEF
static void prettifyConss(SCIP *scip, SCIP_CONS **conss, int nconss, int *nchgcoefs, int *nchgsides)
static SCIP_RETCODE preprocessConstraintPairs(SCIP *scip, SCIP_CONS **conss, int nconss, SCIP_Bool *cutoff, int *nchgbds, int *ndelconss, int *nchgcoefs, int *nchgsides)
static SCIP_RETCODE chgLhs(SCIP *scip, SCIP_CONS *cons, SCIP_Real lhs)
static SCIP_RETCODE analyzeConflict(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *infervar, SCIP_Real inferbd, PROPRULE proprule, SCIP_BOUNDTYPE boundtype, SCIP_Bool usebdwidening)
static SCIP_RETCODE chgRhs(SCIP *scip, SCIP_CONS *cons, SCIP_Real rhs)
#define CONSHDLR_PROPFREQ
static SCIP_RETCODE resolvePropagation(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *infervar, PROPRULE proprule, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Real inferbd, SCIP_Bool usebdwidening)
static SCIP_RETCODE propagateCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool usebdwidening, SCIP_Bool *cutoff, int *nchgbds, int *nchgsides, int *ndelconss)
#define CONSHDLR_PRESOLTIMING
static SCIP_RETCODE consdataFree(SCIP *scip, SCIP_CONSDATA **consdata)
static SCIP_RETCODE addNlrow(SCIP *scip, SCIP_CONS *cons)
#define CONSHDLR_EAGERFREQ
static SCIP_RETCODE conshdlrdataCreate(SCIP *scip, SCIP_CONSHDLRDATA **conshdlrdata, SCIP_EVENTHDLR *eventhdlr)
#define CONSHDLR_ENFOPRIORITY
static SCIP_RETCODE catchEvents(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr)
#define LINCONSUPGD_PRIORITY
static SCIP_RETCODE separateCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool usebdwidening, SCIP_SOL *sol, SCIP_RESULT *result)
#define CONSHDLR_DELAYSEPA
#define CONSHDLR_DELAYPROP
Constraint handler for variable bound constraints .
defines macros for basic operations in double-double arithmetic giving roughly twice the precision of...
#define SCIPquadprecDivQD(r, a, b)
#define SCIPquadprecProdDD(r, a, b)
#define SCIPquadprecProdQD(r, a, b)
#define SCIPquadprecSumQD(r, a, b)
#define QUAD_ASSIGN(a, constant)
#define SCIPquadprecSumDD(r, a, b)
#define SCIPquadprecSumQQ(r, a, b)
#define SCIP_VARTYPE_INTEGER_CHAR
#define SCIP_VARTYPE_IMPLINT_CHAR
#define SCIP_VARTYPE_BINARY_CHAR
#define SCIP_VARTYPE_CONTINUOUS_CHAR
SCIP_RETCODE SCIPincludeLinconsUpgrade(SCIP *scip, SCIP_DECL_LINCONSUPGD((*linconsupgd)), int priority, const char *conshdlrname)
SCIP_Real SCIPgetVbdcoefVarbound(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPchgRhsLinear(SCIP *scip, SCIP_CONS *cons, SCIP_Real rhs)
SCIP_Real SCIPgetDualfarkasVarbound(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPaddCoefLinear(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real val)
SCIP_RETCODE SCIPcreateConsBasicVarbound(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *var, SCIP_VAR *vbdvar, SCIP_Real vbdcoef, SCIP_Real lhs, SCIP_Real rhs)
SCIP_ROW * SCIPgetRowVarbound(SCIP *scip, SCIP_CONS *cons)
SCIP_VAR * SCIPgetVbdvarVarbound(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPcreateConsSetpack(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 SCIPcleanupConssVarbound(SCIP *scip, SCIP_Bool onlychecked, SCIP_Bool *infeasible, int *naddconss, int *ndelconss, int *nchgbds)
SCIP_VAR * SCIPgetVarVarbound(SCIP *scip, SCIP_CONS *cons)
#define SCIP_DECL_LINCONSUPGD(x)
SCIP_RETCODE SCIPcopyConsLinear(SCIP *scip, SCIP_CONS **cons, SCIP *sourcescip, const char *name, int nvars, SCIP_VAR **sourcevars, SCIP_Real *sourcecoefs, SCIP_Real lhs, SCIP_Real rhs, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, 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_Real SCIPgetLhsVarbound(SCIP *scip, 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_Real SCIPgetRhsVarbound(SCIP *scip, SCIP_CONS *cons)
SCIP_Real SCIPgetDualsolVarbound(SCIP *scip, SCIP_CONS *cons)
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 SCIPchgLhsLinear(SCIP *scip, SCIP_CONS *cons, SCIP_Real lhs)
SCIP_RETCODE SCIPincludeConshdlrVarbound(SCIP *scip)
SCIP_Bool SCIPisTransformed(SCIP *scip)
SCIP_Bool SCIPisStopped(SCIP *scip)
SCIP_STAGE SCIPgetStage(SCIP *scip)
int SCIPgetNIntVars(SCIP *scip)
int SCIPgetNImplVars(SCIP *scip)
SCIP_RETCODE SCIPaddCons(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPdelCons(SCIP *scip, SCIP_CONS *cons)
int SCIPgetNBinVars(SCIP *scip)
SCIP_RETCODE SCIPdelConsLocal(SCIP *scip, SCIP_CONS *cons)
void SCIPinfoMessage(SCIP *scip, FILE *file, const char *formatstr,...)
SCIP_Bool SCIPrealToRational(SCIP_Real val, SCIP_Real mindelta, SCIP_Real maxdelta, SCIP_Longint maxdnom, SCIP_Longint *nominator, SCIP_Longint *denominator)
SCIP_Real SCIPrelDiff(SCIP_Real val1, SCIP_Real val2)
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 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 SCIPaddConflictLb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx)
SCIP_RETCODE SCIPinitConflictAnalysis(SCIP *scip, SCIP_CONFTYPE conftype, SCIP_Bool iscutoffinvolved)
SCIP_RETCODE SCIPaddConflictUb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx)
SCIP_RETCODE SCIPaddConflictRelaxedLb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedlb)
SCIP_RETCODE SCIPaddConflictRelaxedUb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedub)
SCIP_Bool SCIPisConflictAnalysisApplicable(SCIP *scip)
SCIP_Real SCIPgetConflictVarUb(SCIP *scip, SCIP_VAR *var)
SCIP_Real SCIPgetConflictVarLb(SCIP *scip, SCIP_VAR *var)
SCIP_RETCODE SCIPanalyzeConflictCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *success)
int SCIPconshdlrGetNCheckConss(SCIP_CONSHDLR *conshdlr)
void SCIPconshdlrSetData(SCIP_CONSHDLR *conshdlr, SCIP_CONSHDLRDATA *conshdlrdata)
SCIP_RETCODE SCIPsetConshdlrFree(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrActive(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_CONS ** SCIPconshdlrGetCheckConss(SCIP_CONSHDLR *conshdlr)
SCIP_RETCODE SCIPsetConshdlrPresol(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPRESOL((*conspresol)), int maxprerounds, SCIP_PRESOLTIMING presoltiming)
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 SCIPsetConshdlrParse(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrGetVars(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrPrint(SCIP *scip, 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 SCIPsetConshdlrDelete(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrInitsol(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrDeactive(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_CONSHDLRDATA * SCIPconshdlrGetData(SCIP_CONSHDLR *conshdlr)
int SCIPconshdlrGetNActiveConss(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 SCIPsetConshdlrInitlp(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPsetConshdlrGetNVars(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_CONSDATA * SCIPconsGetData(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsDynamic(SCIP_CONS *cons)
SCIP_CONSHDLR * SCIPconsGetHdlr(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsInitial(SCIP_CONS *cons)
SCIP_RETCODE SCIPprintCons(SCIP *scip, SCIP_CONS *cons, FILE *file)
SCIP_Bool SCIPconsIsMarkedPropagate(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsChecked(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsDeleted(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsTransformed(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsEnforced(SCIP_CONS *cons)
SCIP_RETCODE SCIPunmarkConsPropagate(SCIP *scip, 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)
const char * SCIPconsGetName(SCIP_CONS *cons)
SCIP_RETCODE SCIPresetConsAge(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPmarkConsPropagate(SCIP *scip, SCIP_CONS *cons)
SCIP_Bool SCIPconsIsModifiable(SCIP_CONS *cons)
SCIP_RETCODE SCIPupdateConsFlags(SCIP *scip, SCIP_CONS *cons0, SCIP_CONS *cons1)
SCIP_Bool SCIPconsIsStickingAtNode(SCIP_CONS *cons)
SCIP_RETCODE SCIPreleaseCons(SCIP *scip, SCIP_CONS **cons)
SCIP_Bool SCIPconsIsSeparated(SCIP_CONS *cons)
SCIP_RETCODE SCIPincConsAge(SCIP *scip, SCIP_CONS *cons)
SCIP_Bool SCIPconsIsRemovable(SCIP_CONS *cons)
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)
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)
#define SCIPallocBufferArray(scip, ptr, num)
#define SCIPfreeBufferArray(scip, ptr)
#define SCIPduplicateBufferArray(scip, ptr, source, num)
#define SCIPfreeBlockMemory(scip, ptr)
#define SCIPallocBlockMemory(scip, ptr)
SCIP_RETCODE SCIPdelNlRow(SCIP *scip, SCIP_NLROW *nlrow)
SCIP_RETCODE SCIPaddNlRow(SCIP *scip, SCIP_NLROW *nlrow)
SCIP_Bool SCIPisNLPConstructed(SCIP *scip)
SCIP_RETCODE SCIPreleaseNlRow(SCIP *scip, SCIP_NLROW **nlrow)
SCIP_Bool SCIPnlrowIsInNLP(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_Bool SCIPinProbing(SCIP *scip)
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 SCIPaddVarToRow(SCIP *scip, SCIP_ROW *row, SCIP_VAR *var, SCIP_Real val)
SCIP_RETCODE SCIPprintRow(SCIP *scip, SCIP_ROW *row, FILE *file)
SCIP_Real SCIPgetRowSolFeasibility(SCIP *scip, SCIP_ROW *row, SCIP_SOL *sol)
SCIP_RETCODE SCIPreleaseRow(SCIP *scip, SCIP_ROW **row)
SCIP_Real SCIProwGetDualfarkas(SCIP_ROW *row)
SCIP_Bool SCIProwIsInLP(SCIP_ROW *row)
SCIP_Real SCIProwGetDualsol(SCIP_ROW *row)
SCIP_Real SCIPgetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var)
void SCIPupdateSolLPConsViolation(SCIP *scip, SCIP_SOL *sol, SCIP_Real absviol, SCIP_Real relviol)
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_Real SCIPfeasFloor(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPround(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 SCIPisFeasLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisFeasIntegral(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPfeastol(SCIP *scip)
SCIP_Real SCIPgetHugeValue(SCIP *scip)
SCIP_Bool SCIPisGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisNegative(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisFeasGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisZero(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPepsilon(SCIP *scip)
SCIP_Bool SCIPisLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisFeasPositive(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPparseReal(SCIP *scip, const char *str, SCIP_Real *value, char **endptr)
SCIP_Bool SCIPinRepropagation(SCIP *scip)
SCIP_RETCODE SCIPtightenVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
SCIP_RETCODE SCIPlockVarCons(SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, SCIP_Bool lockdown, SCIP_Bool lockup)
SCIP_Bool SCIPvarIsBinary(SCIP_VAR *var)
SCIP_RETCODE SCIPtightenVarUbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
SCIP_RETCODE SCIPchgVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)
int SCIPvarGetNLocksUpType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)
SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
SCIP_RETCODE SCIPaggregateVars(SCIP *scip, SCIP_VAR *varx, SCIP_VAR *vary, SCIP_Real scalarx, SCIP_Real scalary, SCIP_Real rhs, SCIP_Bool *infeasible, SCIP_Bool *redundant, SCIP_Bool *aggregated)
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_Real SCIPvarGetObj(SCIP_VAR *var)
SCIP_VAR * SCIPvarGetProbvar(SCIP_VAR *var)
SCIP_RETCODE SCIPtightenVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
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 SCIPaddVarVub(SCIP *scip, SCIP_VAR *var, SCIP_VAR *vubvar, SCIP_Real vubcoef, SCIP_Real vubconstant, SCIP_Bool *infeasible, int *nbdchgs)
int SCIPvarGetIndex(SCIP_VAR *var)
SCIP_RETCODE SCIPaddVarLocksType(SCIP *scip, SCIP_VAR *var, SCIP_LOCKTYPE locktype, int nlocksdown, int nlocksup)
SCIP_RETCODE SCIPaddVarVlb(SCIP *scip, SCIP_VAR *var, SCIP_VAR *vlbvar, SCIP_Real vlbcoef, SCIP_Real vlbconstant, SCIP_Bool *infeasible, int *nbdchgs)
SCIP_RETCODE SCIPunlockVarCons(SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, SCIP_Bool lockdown, SCIP_Bool lockup)
const char * SCIPvarGetName(SCIP_VAR *var)
SCIP_RETCODE SCIPreleaseVar(SCIP *scip, SCIP_VAR **var)
SCIP_Real SCIPadjustedVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real ub)
SCIP_RETCODE SCIPparseVarsLinearsum(SCIP *scip, const char *str, SCIP_VAR **vars, SCIP_Real *vals, int *nvars, int varssize, int *requiredsize, char **endptr, SCIP_Bool *success)
SCIP_Real SCIPadjustedVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real lb)
SCIP_Bool SCIPvarIsIntegral(SCIP_VAR *var)
SCIP_RETCODE SCIPgetNegatedVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **negvar)
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
SCIP_Real SCIPvarGetLbGlobal(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)
int SCIPvarGetNLocksDownType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)
SCIP_RETCODE SCIPgetTransformedVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **transvar)
SCIP_RETCODE SCIPcaptureVar(SCIP *scip, SCIP_VAR *var)
SCIP_RETCODE SCIPtightenVarLbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
void SCIPsortPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
SCIP_RETCODE SCIPskipSpace(char **s)
assert(minobj< SCIPgetCutoffbound(scip))
static SCIP_Bool propagate
memory allocation routines
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
methods for sorting joint arrays of various types
public methods for problem variables
public methods for conflict handler plugins and conflict analysis
public methods for constraint handler plugins and constraints
public methods for cuts and aggregation rows
public methods for event handler plugins and event handlers
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 the branch-and-bound tree
public methods for SCIP variables
@ SCIP_CONFTYPE_PROPAGATION
#define SCIP_DECL_CONSENFOLP(x)
#define SCIP_DECL_CONSDELETE(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_CONSENFORELAX(x)
#define SCIP_DECL_CONSPROP(x)
#define SCIP_DECL_CONSGETNVARS(x)
#define SCIP_DECL_CONSRESPROP(x)
#define SCIP_DECL_CONSACTIVE(x)
#define SCIP_DECL_CONSENFOPS(x)
#define SCIP_DECL_CONSPARSE(x)
#define SCIP_DECL_CONSTRANS(x)
#define SCIP_DECL_CONSDEACTIVE(x)
#define SCIP_DECL_CONSPRESOL(x)
#define SCIP_DECL_CONSINITLP(x)
#define SCIP_DECL_CONSLOCK(x)
#define SCIP_DECL_CONSCOPY(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_EventData SCIP_EVENTDATA
#define SCIP_EVENTTYPE_VARFIXED
#define SCIP_DECL_EVENTEXEC(x)
#define SCIP_EVENTTYPE_BOUNDTIGHTENED
enum SCIP_BoundType SCIP_BOUNDTYPE
#define SCIP_DECL_SORTPTRCOMP(x)
enum SCIP_Result SCIP_RESULT
enum SCIP_Retcode SCIP_RETCODE
#define SCIP_PRESOLTIMING_MEDIUM
@ SCIP_VARTYPE_CONTINUOUS
@ SCIP_VARSTATUS_MULTAGGR