82#define PROP_NAME "obbt"
83#define PROP_DESC "optimization-based bound tightening propagator"
84#define PROP_TIMING SCIP_PROPTIMING_AFTERLPLOOP
85#define PROP_PRIORITY -1000000
87#define PROP_DELAY TRUE
90#define DEFAULT_CREATE_GENVBOUNDS TRUE
91#define DEFAULT_FILTERING_NORM TRUE
93#define DEFAULT_APPLY_FILTERROUNDS FALSE
95#define DEFAULT_APPLY_TRIVIALFITLERING TRUE
96#define DEFAULT_GENVBDSDURINGFILTER TRUE
97#define DEFAULT_DUALFEASTOL 1e-9
99#define DEFAULT_CONDITIONLIMIT -1.0
100#define DEFAULT_BOUNDSTREPS 0.001
101#define DEFAULT_FILTERING_MIN 2
103#define DEFAULT_ITLIMITFACTOR 10.0
105#define DEFAULT_MINITLIMIT 5000L
106#define DEFAULT_ONLYNONCONVEXVARS TRUE
107#define DEFAULT_TIGHTINTBOUNDSPROBING TRUE
109#define DEFAULT_TIGHTCONTBOUNDSPROBING FALSE
111#define DEFAULT_ORDERINGALGO 1
113#define OBBT_SCOREBASE 5
114#define GENVBOUND_PROP_NAME "genvbounds"
116#define DEFAULT_SEPARATESOL FALSE
119#define DEFAULT_SEPAMINITER 0
120#define DEFAULT_SEPAMAXITER 10
121#define DEFAULT_GENVBDSDURINGSEPA TRUE
122#define DEFAULT_PROPAGATEFREQ 0
124#define DEFAULT_CREATE_BILININEQS TRUE
125#define DEFAULT_CREATE_LINCONS FALSE
126#define DEFAULT_ITLIMITFAC_BILININEQS 3.0
127#define DEFAULT_MINNONCONVEXITY 1e-1
128#define DEFAULT_RANDSEED 149
178 SCIP_Longint lastnode;
179 SCIP_Longint npropagatedomreds;
180 SCIP_Longint nprobingiterations;
181 SCIP_Longint nfilterlpiters;
182 SCIP_Longint minitlimit;
183 SCIP_Longint itlimitbilin;
184 SCIP_Longint itusedbilin;
185 SCIP_Real dualfeastol;
187 SCIP_Real conditionlimit;
188 SCIP_Real boundstreps;
189 SCIP_Real itlimitfactor;
191 SCIP_Real itlimitfactorbilin;
192 SCIP_Real minnonconvexity;
193 SCIP_Bool applyfilterrounds;
194 SCIP_Bool applytrivialfilter;
195 SCIP_Bool genvbdsduringfilter;
197 SCIP_Bool genvbdsduringsepa;
198 SCIP_Bool creategenvbounds;
201 SCIP_Bool onlynonconvexvars;
202 SCIP_Bool tightintboundsprobing;
204 SCIP_Bool tightcontboundsprobing;
206 SCIP_Bool separatesol;
209 SCIP_Bool createbilinineqs;
210 SCIP_Bool createlincons;
219 int ntrivialfiltered;
221 int ngenvboundsprobing;
222 int ngenvboundsaggrfil;
223 int ngenvboundstrivfil;
230 int propagatecounter;
265 SCIPwarningMessage(
scip,
" error while solving LP in obbt propagator; LP solve terminated with code <%d>\n", retcode);
354 propdata->cutoffrow = row;
411 assert((counter == 0 && coef == 0.0) || (counter == 1 && coef != 0.0));
502 if( propdata->normalize )
612 if( propdata->cutoffrow ==
NULL )
701 for(
k = 0;
k < ncoefs; ++
k )
742 assert(propdata->lastidx >= 0 && propdata->lastidx < propdata->nbounds);
745 if( propdata->lastidx !=
i )
749 tmp = propdata->bounds[
i];
750 propdata->bounds[
i] = propdata->bounds[propdata->lastidx];
751 propdata->bounds[propdata->lastidx] =
tmp;
754 propdata->lastidx -= 1;
949 SCIPdebugMsg(
scip,
"can't filter using existing lp solution since it was not solved to optimality\n");
954 for(
i = propdata->nbounds - 1;
i >= 0; --
i )
961 bound = propdata->bounds[
i];
1013 assert(propdata->nprobingiterations >= 0);
1026 propdata->ngenvboundstrivfil += 1;
1037 if( propdata->lastidx >= 0 )
1046 for(
i = propdata->lastbilinidx;
i < propdata->nbilinbounds; ++
i )
1075 for(
j = 0;
j < 4; ++
j )
1092 SCIPdebugMessage(
"filtered corners %d for (%s,%s) = (%g,%g) in [%g,%g]x[%g,%g]\n",
1140 assert(propdata->nfilterlpiters >= 0);
1144 SCIPdebugMsg(
scip,
"skipping filter round since the LP was not solved to optimality\n");
1151 for(
i = 0;
i < propdata->nbounds;
i++ )
1158 bound = propdata->bounds[
i];
1161 if(
bound->filtered )
1212 assert(propdata->nfilterlpiters >= 0);
1225 propdata->ngenvboundsaggrfil += 1;
1309 for(
i = 0;
i < propdata->nbounds;
i++ )
1312 && !propdata->bounds[
i]->done )
1335 SCIPdebugMsg(
scip,
"filtered %d more bounds in lower bounds round\n", nfiltered);
1365 for(
i = 0;
i < propdata->nbounds;
i++ )
1389 SCIPdebugMsg(
scip,
"filtered %d more bounds in upper bounds round\n", nfiltered);
1427 for(
i = 0;
i < propdata->nbounds;
i++ )
1431 SCIP_Bool tightened;
1433 bound = propdata->bounds[
i];
1479 SCIP_Bool* tightened
1630 for(
k = 0;
k <= propdata->lastidx; ++
k )
1642 if( propdata->orderingalgo == 0 )
1686 for(
i = 0;
i <= propdata->sepamaxiter; ++
i )
1694 SCIP_Bool tightened;
1720 if(
inroot && propdata->genvboundprop !=
NULL && propdata->genvbdsduringsepa )
1724 propdata->ngenvboundsprobing += found ? 1 : 0;
1732 SCIPdebugMsg(
scip,
"apply separation - tightened=%u oldval=%e newval=%e\n", tightened, oldval,
1739 if( !tightened &&
i >= propdata->sepaminiter )
1781 if( propdata->bounds[0]->done || propdata->bounds[0]->filtered )
1788 propdata->lastidx = 0;
1789 while( propdata->lastidx < propdata->nbounds - 1 && !propdata->bounds[propdata->lastidx]->done &&
1790 !propdata->bounds[propdata->lastidx]->filtered )
1791 ++propdata->lastidx;
1841 propdata->nsolvedbounds++;
1876 && propdata->genvboundprop !=
NULL )
1883 propdata->ngenvboundsprobing += 1;
1932 if( propdata->applytrivialfilter )
1935 SCIPdebugMsg(
scip,
"filtered %d bounds via inspecting present LP solution\n", nfiltered);
1936 propdata->ntrivialfiltered += nfiltered;
1939 propdata->propagatecounter +=
success ? 1 : 0;
1942 if( propdata->propagatefreq != 0 && propdata->propagatecounter >= propdata->propagatefreq )
1944 SCIP_Longint ndomredsfound;
1950 propdata->npropagatedomreds += ndomredsfound;
1951 propdata->propagatecounter = 0;
2021 propdata->lastidx = -1;
2026 if( propdata->propagatefreq > 0 )
2033 for(
i = 0;
i < propdata->nbounds;
i++ )
2068 SCIPdebugMsg(
scip,
"filtered %d bounds via inspecting present LP solution\n", nfiltered);
2069 propdata->ntrivialfiltered += nfiltered;
2089 SCIPwarningMessage(
scip,
"obbt propagator could not set condition limit in LP solver - running without\n");
2111 if( propdata->applyfilterrounds )
2148 assert(propdata->propagatefreq > 0);
2149 for(
i = 0;
i < propdata->nbounds; ++
i )
2199 if( propdata->cutoffrow !=
NULL )
2251 SCIP_Real* constant,
2290 signx = (xs >
xt) ? 1.0 : -1.0;
2297 side = scale * (xs/(
xt-xs) - ys/(
yt-ys));
2310 SCIPwarningMessage(
scip,
"Error while solving LP in quadratic constraint handler; LP solve terminated with" \
2332 *constant = (*xcoef) *
xval + (*ycoef) *
yval;
2411 if( propdata->nbilinbounds <= 0 ||
SCIPgetDepth(
scip) != 0 || propdata->lastbilinidx >= propdata->nbilinbounds )
2414 SCIPdebugMsg(
scip,
"call applyObbtBilinear starting from %d\n", propdata->lastbilinidx);
2453 for(
i = propdata->lastbilinidx;
i < propdata->nbilinbounds
2455 && (propdata->itlimitbilin < 0 || propdata->itlimitbilin > propdata->itusedbilin )
2465 SCIPdebugMsg(
scip,
"process %d: %s %s done=%u filtered=%d nunderest=%d noverest=%d\n",
i,
2480 for(
k = 0;
k < 4; ++
k )
2512 SCIP_CALL(
solveBilinearLP(
scip,
x,
y, xs, ys,
xt,
yt, &
xcoef, &
ycoef, &constant, -1L,
2539 if( propdata->createlincons &&
nnonzduals > 1 )
2545 SCIP_Real rhs = constant;
2563 propdata->lastbilinidx =
i;
2570 if( propdata->cutoffrow !=
NULL )
2743 propdata->boundssize = 2 *
nvars;
2761 propdata->bounds[
bdidx]->newval = 0.0;
2775 propdata->bounds[
bdidx]->newval = 0.0;
2785 propdata->nbounds =
bdidx;
2790 if( propdata->nbounds > 0 && conshdlr !=
NULL && propdata->createbilinineqs )
2807 propdata->bilinboundssize = nexprs;
2808 propdata->nbilinbounds = 0;
2811 for(
i = 0;
i < nexprs; ++
i )
2832 bilinbound = propdata->bilinbounds[propdata->nbilinbounds];
2843 ++(propdata->nbilinbounds);
2850 if( propdata->nbilinbounds > 1 )
2863 if( propdata->nbounds <= 0 )
2865 assert(propdata->nbounds == 0);
2866 assert(propdata->boundssize >= 0 );
2872 if( propdata->nbounds > 0 )
2920 propdata->bounds =
NULL;
2921 propdata->nbounds = -1;
2922 propdata->boundssize = 0;
2923 propdata->cutoffrow =
NULL;
2924 propdata->lastnode = -1;
2929 SCIPdebugMsg(
scip,
"creating genvbounds: %s\n", propdata->genvboundprop !=
NULL ?
"true" :
"false");
2979 if( propdata->nbounds == -1 )
2992 assert(propdata->nbounds >= 0);
2996 if( propdata->nbounds <= 0 )
3020 if( propdata->itlimitfactor > 0.0 )
3022 propdata->minitlimit);
3031 if( propdata->createbilinineqs )
3034 if( propdata->itlimitbilin == 0
L )
3037 propdata->itlimitbilin = (
itlimit < 0 || propdata->itlimitfactorbilin < 0)
3076 propdata->randnumgen =
NULL;
3082 "FILTER-LP: %" SCIP_LONGINT_FORMAT " NGENVB(dive): %d NGENVB(aggr.): %d NGENVB(triv.) %d\n",
3083 propdata->nprobingiterations, propdata->nfiltered, propdata->ntrivialfiltered, propdata->nsolvedbounds,
3084 propdata->nfilterlpiters, propdata->ngenvboundsprobing, propdata->ngenvboundsaggrfil, propdata->ngenvboundstrivfil);
3087 if( propdata->bilinboundssize > 0 )
3089 for(
i = propdata->nbilinbounds - 1;
i >= 0; --
i )
3100 propdata->bilinboundssize = 0;
3101 propdata->nbilinbounds = 0;
3105 if( propdata->nbounds > 0 )
3108 for(
i = propdata->nbounds - 1;
i >= 0;
i-- )
3115 propdata->nbounds = -1;
3116 propdata->itlimitbilin = 0;
3117 propdata->itusedbilin = 0;
3158 propdata->nprobingiterations = 0;
3159 propdata->nfiltered = 0;
3160 propdata->ntrivialfiltered = 0;
3161 propdata->nsolvedbounds = 0;
3162 propdata->ngenvboundsprobing = 0;
3163 propdata->ngenvboundsaggrfil = 0;
3164 propdata->ngenvboundstrivfil = 0;
3165 propdata->nfilterlpiters = 0;
3166 propdata->lastidx = -1;
3167 propdata->propagatecounter = 0;
3168 propdata->npropagatedomreds = 0;
3181 "should obbt try to provide genvbounds if possible?",
3185 "should coefficients in filtering be normalized w.r.t. the domains sizes?",
3189 "try to filter bounds in so-called filter rounds by solving auxiliary LPs?",
3193 "try to filter bounds with the LP solution after each solve?",
3197 "should we try to generate genvbounds during trivial and aggressive filtering?",
3201 "try to create genvbounds during separation process?",
3205 "minimal number of filtered bounds to apply another filter round",
3209 "multiple of root node LP iterations used as total LP iteration limit for obbt (<= 0: no limit )",
3213 "multiple of OBBT LP limit used as total LP iteration limit for solving bilinear inequality LPs (< 0 for no limit)",
3217 "minimum absolute value of nonconvex eigenvalues for a bilinear term",
3221 "minimum LP iteration limit",
3225 "feasibility tolerance for reduced costs used in obbt; this value is used if SCIP's dual feastol is greater",
3229 "maximum condition limit used in LP solver (-1.0: no limit)",
3233 "minimal relative improve for strengthening bounds",
3237 "only apply obbt on non-convex variables",
3241 "should integral bounds be tightened during the probing mode?",
3245 "should continuous bounds be tightened during the probing mode?",
3249 "solve auxiliary LPs in order to find valid inequalities for bilinear terms?",
3253 "create linear constraints from inequalities for bilinear terms?",
3257 "select the type of ordering algorithm which should be used (0: no special ordering, 1: greedy, 2: greedy reverse)",
3261 "should the obbt LP solution be separated?",
3265 "minimum number of iteration spend to separate an obbt LP solution",
3269 "maximum number of iteration spend to separate an obbt LP solution",
3273 "trigger a propagation round after that many bound tightenings (0: no propagation)",
Constraint handler for linear constraints in their most general form, .
constraint handler for nonlinear constraints specified by algebraic expressions
int SCIPgetExprNLocksPosNonlinear(SCIP_EXPR *expr)
SCIP_HASHMAP * SCIPgetVarExprHashmapNonlinear(SCIP_CONSHDLR *conshdlr)
SCIP_VAR * SCIPgetExprAuxVarNonlinear(SCIP_EXPR *expr)
unsigned int SCIPgetExprNSepaUsesActivityNonlinear(SCIP_EXPR *expr)
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)
int SCIPgetExprNLocksNegNonlinear(SCIP_EXPR *expr)
int SCIPgetSubscipDepth(SCIP *scip)
SCIP_Bool SCIPisStopped(SCIP *scip)
SCIP_STAGE SCIPgetStage(SCIP *scip)
const char * SCIPgetProbName(SCIP *scip)
SCIP_RETCODE SCIPgetVarsData(SCIP *scip, SCIP_VAR ***vars, int *nvars, int *nbinvars, int *nintvars, int *nimplvars, int *ncontvars)
int SCIPgetNVars(SCIP *scip)
SCIP_RETCODE SCIPaddCons(SCIP *scip, SCIP_CONS *cons)
SCIP_VAR ** SCIPgetVars(SCIP *scip)
void * SCIPhashmapGetImage(SCIP_HASHMAP *hashmap, void *origin)
SCIP_Bool SCIPhashmapExists(SCIP_HASHMAP *hashmap, void *origin)
void SCIPwarningMessage(SCIP *scip, const char *formatstr,...)
int SCIPgetNExprsBilinear(SCIP_NLHDLR *nlhdlr)
SCIP_RETCODE SCIPaddIneqBilinear(SCIP *scip, SCIP_NLHDLR *nlhdlr, SCIP_EXPR *expr, SCIP_Real xcoef, SCIP_Real ycoef, SCIP_Real constant, SCIP_Bool *success)
SCIP_EXPR ** SCIPgetExprsBilinear(SCIP_NLHDLR *nlhdlr)
SCIP_Real SCIPrelDiff(SCIP_Real val1, SCIP_Real val2)
SCIP_RETCODE SCIPgenVBoundAdd(SCIP *scip, SCIP_PROP *genvboundprop, SCIP_VAR **vars, SCIP_VAR *var, SCIP_Real *coefs, int ncoefs, SCIP_Real coefcutoffbound, SCIP_Real constant, SCIP_BOUNDTYPE boundtype)
SCIP_RETCODE SCIPaddLongintParam(SCIP *scip, const char *name, const char *desc, SCIP_Longint *valueptr, SCIP_Bool isadvanced, SCIP_Longint defaultvalue, SCIP_Longint minvalue, SCIP_Longint maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
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 SCIPgetRealParam(SCIP *scip, const char *name, SCIP_Real *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 SCIPgetIntParam(SCIP *scip, const char *name, int *value)
SCIP_RETCODE SCIPsetRealParam(SCIP *scip, const char *name, SCIP_Real value)
SCIP_RETCODE SCIPincludePropObbt(SCIP *scip)
SCIP_BASESTAT SCIPcolGetBasisStatus(SCIP_COL *col)
int SCIPconshdlrGetNConss(SCIP_CONSHDLR *conshdlr)
SCIP_CONSHDLR * SCIPfindConshdlr(SCIP *scip, const char *name)
SCIP_RETCODE SCIPreleaseCons(SCIP *scip, SCIP_CONS **cons)
SCIP_RETCODE SCIPseparateSol(SCIP *scip, SCIP_SOL *sol, SCIP_Bool pretendroot, SCIP_Bool allowlocal, SCIP_Bool onlydelayed, SCIP_Bool *delayed, SCIP_Bool *cutoff)
int SCIPgetNCuts(SCIP *scip)
int SCIPexprGetNChildren(SCIP_EXPR *expr)
SCIP_RETCODE SCIPreleaseExpr(SCIP *scip, SCIP_EXPR **expr)
SCIP_Bool SCIPisExprVar(SCIP *scip, SCIP_EXPR *expr)
SCIP_EXPR ** SCIPexprGetChildren(SCIP_EXPR *expr)
void SCIPcaptureExpr(SCIP_EXPR *expr)
SCIP_ROW ** SCIPgetLPRows(SCIP *scip)
int SCIPgetNLPRows(SCIP *scip)
SCIP_LPSOLSTAT SCIPgetLPSolstat(SCIP *scip)
SCIP_Bool SCIPallColsInLP(SCIP *scip)
SCIP_Real SCIPgetLPObjval(SCIP *scip)
#define SCIPfreeBlockMemoryArray(scip, ptr, num)
#define SCIPallocBufferArray(scip, ptr, num)
#define SCIPfreeBufferArray(scip, ptr)
#define SCIPallocBlockMemoryArray(scip, ptr, num)
#define SCIPfreeBlockMemory(scip, ptr)
#define SCIPfreeBufferArrayNull(scip, ptr)
#define SCIPallocBlockMemory(scip, ptr)
SCIP_Bool SCIPisNLPConstructed(SCIP *scip)
int SCIPgetNNLPVars(SCIP *scip)
SCIP_RETCODE SCIPgetNLPVarsNonlinearity(SCIP *scip, int *nlcount)
SCIP_NLHDLR * SCIPfindNlhdlrNonlinear(SCIP_CONSHDLR *conshdlr, const char *name)
SCIP_Longint SCIPnodeGetNumber(SCIP_NODE *node)
SCIP_RETCODE SCIPaddRowProbing(SCIP *scip, SCIP_ROW *row)
SCIP_RETCODE SCIPapplyCutsProbing(SCIP *scip, SCIP_Bool *cutoff)
SCIP_RETCODE SCIPchgVarUbProbing(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
SCIP_RETCODE SCIPchgVarLbProbing(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
SCIP_RETCODE SCIPpropagateProbing(SCIP *scip, int maxproprounds, SCIP_Bool *cutoff, SCIP_Longint *ndomredsfound)
SCIP_RETCODE SCIPchgVarObjProbing(SCIP *scip, SCIP_VAR *var, SCIP_Real newobj)
SCIP_RETCODE SCIPbacktrackProbing(SCIP *scip, int probingdepth)
SCIP_Bool SCIPinProbing(SCIP *scip)
SCIP_RETCODE SCIPstartProbing(SCIP *scip)
SCIP_Real SCIPgetVarObjProbing(SCIP *scip, SCIP_VAR *var)
SCIP_RETCODE SCIPnewProbingNode(SCIP *scip)
SCIP_RETCODE SCIPsolveProbingLP(SCIP *scip, int itlim, SCIP_Bool *lperror, SCIP_Bool *cutoff)
SCIP_PROP * SCIPfindProp(SCIP *scip, const char *name)
void SCIPpropSetData(SCIP_PROP *prop, SCIP_PROPDATA *propdata)
SCIP_RETCODE SCIPsetPropCopy(SCIP *scip, SCIP_PROP *prop,)
SCIP_PROPDATA * SCIPpropGetData(SCIP_PROP *prop)
SCIP_RETCODE SCIPsetPropExitsol(SCIP *scip, SCIP_PROP *prop,)
const char * SCIPpropGetName(SCIP_PROP *prop)
SCIP_RETCODE SCIPsetPropResprop(SCIP *scip, SCIP_PROP *prop,)
SCIP_RETCODE SCIPsetPropFree(SCIP *scip, SCIP_PROP *prop,)
SCIP_RETCODE SCIPsetPropInitsol(SCIP *scip, SCIP_PROP *prop,)
SCIP_RETCODE SCIPincludePropBasic(SCIP *scip, SCIP_PROP **propptr, const char *name, const char *desc, int priority, int freq, SCIP_Bool delay, SCIP_PROPTIMING timingmask, SCIP_DECL_PROPEXEC((*propexec)), SCIP_PROPDATA *propdata)
SCIP_RETCODE SCIPcacheRowExtensions(SCIP *scip, SCIP_ROW *row)
SCIP_RETCODE SCIPflushRowExtensions(SCIP *scip, SCIP_ROW *row)
SCIP_RETCODE SCIPaddVarToRow(SCIP *scip, SCIP_ROW *row, SCIP_VAR *var, SCIP_Real val)
SCIP_RETCODE SCIPreleaseRow(SCIP *scip, SCIP_ROW **row)
SCIP_RETCODE SCIPcreateEmptyRowUnspec(SCIP *scip, SCIP_ROW **row, const char *name, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)
SCIP_Bool SCIProwIsInLP(SCIP_ROW *row)
SCIP_Real SCIProwGetDualsol(SCIP_ROW *row)
SCIP_Longint SCIPgetNRootLPIterations(SCIP *scip)
SCIP_Real SCIPgetCutoffbound(SCIP *scip)
SCIP_Longint SCIPgetNLPIterations(SCIP *scip)
SCIP_Bool SCIPisUbBetter(SCIP *scip, SCIP_Real newub, SCIP_Real oldlb, SCIP_Real oldub)
SCIP_Bool SCIPisFeasGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Real SCIPinfinity(SCIP *scip)
SCIP_Real SCIPchgRelaxfeastol(SCIP *scip, SCIP_Real relaxfeastol)
SCIP_Bool SCIPisFeasEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisPositive(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisLbBetter(SCIP *scip, SCIP_Real newlb, SCIP_Real oldlb, SCIP_Real oldub)
SCIP_Bool SCIPisFeasZero(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPfloor(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisHugeValue(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisFeasLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Real SCIPfeastol(SCIP *scip)
SCIP_Real SCIPdualfeastol(SCIP *scip)
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 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_RETCODE SCIPchgDualfeastol(SCIP *scip, SCIP_Real dualfeastol)
SCIP_Bool SCIPinRepropagation(SCIP *scip)
int SCIPgetDepth(SCIP *scip)
SCIP_NODE * SCIPgetCurrentNode(SCIP *scip)
SCIP_RETCODE SCIPtightenVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
SCIP_COL * SCIPvarGetCol(SCIP_VAR *var)
SCIP_Bool SCIPvarIsBinary(SCIP_VAR *var)
SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)
SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
SCIP_Real SCIPvarGetObj(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_Real SCIPvarGetUbGlobal(SCIP_VAR *var)
int SCIPvarGetProbindex(SCIP_VAR *var)
const char * SCIPvarGetName(SCIP_VAR *var)
SCIP_Bool SCIPvarIsIntegral(SCIP_VAR *var)
SCIP_Real SCIPvarGetLPSol(SCIP_VAR *var)
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
SCIP_Real SCIPgetVarRedcost(SCIP *scip, SCIP_VAR *var)
SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)
SCIP_Bool SCIPallowWeakDualReds(SCIP *scip)
SCIP_Real SCIPrandomGetReal(SCIP_RANDNUMGEN *randnumgen, SCIP_Real minrandval, SCIP_Real maxrandval)
void SCIPsortDownPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
int SCIPsnprintf(char *t, int len, const char *s,...)
SCIPfreeRandom(scip, &heurdata->randnumgen)
static SCIP_LPSOLSTAT lpsolstat
SCIPcreateRandom(scip, &heurdata->randnumgen, DEFAULT_RANDSEED, TRUE))
assert(minobj< SCIPgetCutoffbound(scip))
#define BMSclearMemory(ptr)
#define BMSclearMemoryArray(ptr, num)
bilinear nonlinear handler
generalized variable bounds propagator
static SCIP_Real getFilterCoef(SCIP *scip, SCIP_PROPDATA *propdata, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype)
#define GENVBOUND_PROP_NAME
static SCIP_VAR * bilinboundGetY(BILINBOUND *bilinbound)
#define DEFAULT_APPLY_FILTERROUNDS
#define DEFAULT_BOUNDSTREPS
#define DEFAULT_DUALFEASTOL
#define DEFAULT_SEPAMINITER
static SCIP_RETCODE filterExistingLP(SCIP *scip, SCIP_PROPDATA *propdata, int *nfiltered, BOUND *currbound)
#define DEFAULT_FILTERING_MIN
#define DEFAULT_MINNONCONVEXITY
static unsigned int getScore(SCIP *scip, BOUND *bound, int nlcount, int maxnlcount)
#define DEFAULT_SEPAMAXITER
static SCIP_Real bilinboundGetScore(SCIP *scip, SCIP_RANDNUMGEN *randnumgen, BILINBOUND *bilinbound)
static SCIP_RETCODE initBounds(SCIP *scip, SCIP_PROPDATA *propdata)
#define DEFAULT_CONDITIONLIMIT
static int nextBound(SCIP *scip, SCIP_PROPDATA *propdata, SCIP_Bool convexphase)
static SCIP_RETCODE tightenBoundProbing(SCIP *scip, BOUND *bound, SCIP_Real newval, SCIP_Bool *tightened)
static SCIP_Real evalBound(SCIP *scip, BOUND *bound)
#define DEFAULT_TIGHTINTBOUNDSPROBING
static SCIP_Bool includeVarGenVBound(SCIP *scip, SCIP_VAR *var)
#define DEFAULT_MINITLIMIT
#define DEFAULT_ITLIMITFACTOR
#define DEFAULT_PROPAGATEFREQ
static int bilinboundGetLocksNeg(BILINBOUND *bilinbound)
static SCIP_RETCODE filterBounds(SCIP *scip, SCIP_PROPDATA *propdata, SCIP_Longint itlimit)
#define DEFAULT_ORDERINGALGO
#define DEFAULT_GENVBDSDURINGSEPA
static SCIP_RETCODE addObjCutoff(SCIP *scip, SCIP_PROPDATA *propdata)
#define DEFAULT_APPLY_TRIVIALFITLERING
#define DEFAULT_SEPARATESOL
static SCIP_RETCODE solveLP(SCIP *scip, int itlimit, SCIP_Bool *error, SCIP_Bool *optimal)
#define DEFAULT_FILTERING_NORM
static void getCorners(SCIP_VAR *x, SCIP_VAR *y, CORNER corner, SCIP_Real *xs, SCIP_Real *ys, SCIP_Real *xt, SCIP_Real *yt)
static int getIterationsLeft(SCIP *scip, SCIP_Longint nolditerations, SCIP_Longint itlimit)
static SCIP_RETCODE filterRound(SCIP *scip, SCIP_PROPDATA *propdata, int itlimit, int *nfiltered, SCIP_Real *objcoefs, int *objcoefsinds, int nobjcoefs)
static SCIP_RETCODE sortBounds(SCIP *scip, SCIP_PROPDATA *propdata)
#define DEFAULT_CREATE_BILININEQS
#define DEFAULT_CREATE_LINCONS
#define DEFAULT_TIGHTCONTBOUNDSPROBING
static SCIP_VAR * bilinboundGetX(BILINBOUND *bilinbound)
#define DEFAULT_CREATE_GENVBOUNDS
static SCIP_RETCODE setObjProbing(SCIP *scip, SCIP_PROPDATA *propdata, BOUND *bound, SCIP_Real coef)
#define DEFAULT_ITLIMITFAC_BILININEQS
#define DEFAULT_ONLYNONCONVEXVARS
static SCIP_RETCODE findNewBounds(SCIP *scip, SCIP_PROPDATA *propdata, SCIP_Longint *nleftiterations, SCIP_Bool convexphase)
static SCIP_Bool varIsFixedLocal(SCIP *scip, SCIP_VAR *var)
static SCIP_RETCODE solveBilinearLP(SCIP *scip, SCIP_VAR *x, SCIP_VAR *y, SCIP_Real xs, SCIP_Real ys, SCIP_Real xt, SCIP_Real yt, SCIP_Real *xcoef, SCIP_Real *ycoef, SCIP_Real *constant, SCIP_Longint iterlim, int *nnonzduals)
static SCIP_RETCODE applyObbt(SCIP *scip, SCIP_PROPDATA *propdata, SCIP_Longint itlimit, SCIP_RESULT *result)
static SCIP_RETCODE applyObbtBilinear(SCIP *scip, SCIP_PROPDATA *propdata, SCIP_Longint itlimit, SCIP_RESULT *result)
#define DEFAULT_GENVBDSDURINGFILTER
static SCIP_RETCODE createGenVBound(SCIP *scip, SCIP_PROPDATA *propdata, BOUND *bound, SCIP_Bool *found)
static SCIP_RETCODE applyBoundChgs(SCIP *scip, SCIP_PROPDATA *propdata, SCIP_RESULT *result)
static void getCorner(SCIP_VAR *x, SCIP_VAR *y, CORNER corner, SCIP_Real *px, SCIP_Real *py)
static int bilinboundGetLocksPos(BILINBOUND *bilinbound)
static SCIP_RETCODE getNLPVarsNonConvexity(SCIP *scip, unsigned int *nccounts)
static SCIP_RETCODE applySeparation(SCIP *scip, SCIP_PROPDATA *propdata, BOUND *currbound, SCIP_Longint *nleftiterations, SCIP_Bool *success)
static SCIP_Bool varIsInteresting(SCIP *scip, SCIP_VAR *var, int nlcount)
static void exchangeBounds(SCIP_PROPDATA *propdata, int i)
optimization-based bound tightening propagator
public methods for managing constraints
public methods for LP management
public methods for message output
#define SCIPstatisticMessage
public data structures and miscellaneous methods
methods for sorting joint arrays of various types
public methods for NLP management
public methods for propagators
public methods for branch and bound tree
public methods for problem variables
public methods for constraint handler plugins and constraints
public methods for problem copies
public methods for cuts and aggregation rows
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 propagator plugins
public methods for random numbers
public methods for querying solving statistics
public methods for the branch-and-bound tree
public methods for SCIP variables
enum SCIP_LPSolStat SCIP_LPSOLSTAT
enum SCIP_BoundType SCIP_BOUNDTYPE
@ SCIP_LPSOLSTAT_NOTSOLVED
@ SCIP_LPSOLSTAT_TIMELIMIT
@ SCIP_LPSOLSTAT_UNBOUNDEDRAY
@ SCIP_LPSOLSTAT_INFEASIBLE
@ SCIP_LPSOLSTAT_OBJLIMIT
@ SCIP_LPSOLSTAT_ITERLIMIT
enum SCIP_BaseStat SCIP_BASESTAT
#define SCIP_DECL_SORTPTRCOMP(x)
#define SCIP_DECL_PROPCOPY(x)
#define SCIP_DECL_PROPINITSOL(x)
#define SCIP_DECL_PROPFREE(x)
#define SCIP_DECL_PROPEXITSOL(x)
#define SCIP_DECL_PROPRESPROP(x)
struct SCIP_PropData SCIP_PROPDATA
#define SCIP_DECL_PROPEXEC(x)
enum SCIP_Result SCIP_RESULT
enum SCIP_Retcode SCIP_RETCODE
@ SCIP_VARTYPE_CONTINUOUS