40#define NLHDLR_NAME "perspective"
41#define NLHDLR_DESC "perspective handler for expressions"
42#define NLHDLR_DETECTPRIORITY -20
43#define NLHDLR_ENFOPRIORITY 125
45#define DEFAULT_MAXPROPROUNDS 1
46#define DEFAULT_MINDOMREDUCTION 0.1
47#define DEFAULT_MINVIOLPROBING 1e-05
48#define DEFAULT_PROBINGONLYINSEPA TRUE
49#define DEFAULT_PROBINGFREQ 1
50#define DEFAULT_CONVEXONLY FALSE
51#define DEFAULT_TIGHTENBOUNDS TRUE
52#define DEFAULT_ADJREFPOINT TRUE
84struct SCIP_NlhdlrExprData
101 SCIP_Real mindomreduction;
102 SCIP_Real minviolprobing;
103 SCIP_Bool probingonlyinsepa;
105 SCIP_Bool convexonly;
106 SCIP_Bool tightenbounds;
107 SCIP_Bool adjrefpoint;
127 if( nlhdlrexprdata->nindicators != 0 )
130 for( v = nlhdlrexprdata->nindicators - 1; v >= 0; --v )
138 for( v = nlhdlrexprdata->nvars - 1; v >= 0; --v )
157 assert(pos >= 0 && pos < nlexprdata->nindicators);
160 for(
i = pos;
i < nlexprdata->nindicators - 1; ++
i )
162 nlexprdata->indicators[
i] = nlexprdata->indicators[
i+1];
165 --nlexprdata->nindicators;
191 if( nlhdlrexprdata->nvars + 1 > nlhdlrexprdata->varssize )
195 nlhdlrexprdata->varssize = newsize;
197 assert(nlhdlrexprdata->nvars + 1 <= nlhdlrexprdata->varssize);
199 nlhdlrexprdata->vars[nlhdlrexprdata->nvars] = auxvar;
202 ++(nlhdlrexprdata->nvars);
259 for(
i = scvdata->
nbnds;
i > pos; --
i )
268 scvdata->
bvars[pos] = indicator;
269 scvdata->
vals0[pos] = val0;
270 scvdata->
lbs1[pos] = lb1;
271 scvdata->
ubs1[pos] = ub1;
297 if( scvdata !=
NULL )
336 SCIP_Real* vlbconstants;
337 SCIP_Real* vubconstants;
349 if( scvdata !=
NULL )
373 for(
c = 0;
c < nvlbs; ++
c )
382 lb0 =
MAX(vlbconstants[
c], glb);
383 lb1 =
MAX(vlbconstants[
c] + vlbcoefs[
c], glb);
386 if( vubvars !=
NULL )
395 ub0 =
MIN(vubconstants[pos], gub);
396 ub1 =
MIN(vubconstants[pos] + vubcoefs[pos], gub);
409 if( scvdata ==
NULL )
420 for(
c = 0;
c < nvubs; ++
c )
437 ub0 =
MIN(vubconstants[
c], gub);
438 ub1 =
MIN(vubconstants[
c] + vubcoefs[
c], gub);
444 if( scvdata ==
NULL )
453 if( scvdata !=
NULL )
457 for(
c = 0;
c < scvdata->
nbnds; ++
c )
495 SCIP_Bool* nonlinear;
500 if( nlhdlrexprdata->nvars == 0 )
559 nonlinear[pos] =
TRUE;
588 for( v = 0; v < nlhdlrexprdata->nvars; ++v )
599 for( v = 0; v < nlhdlrexprdata->nvars; ++v )
603 if( nonlinear !=
NULL && !nonlinear[v] )
611 if( indicators ==
NULL )
614 nbnds0 = scvdata->
nbnds;
615 nindicators = nbnds0;
620 SCIPvarComp, (
void**)indicators, &nindicators);
624 if( indicators !=
NULL && nindicators == 0 )
632 if( indicators ==
NULL )
636 assert(nindicators > 0 && nindicators <= nbnds0);
638 if( nindicators < nbnds0 )
643 for( v = 0; v < nindicators; ++v )
647 nlhdlrexprdata->indicators = indicators;
648 nlhdlrexprdata->nindicators = nindicators;
673 SCIP_Real* origvals0;
690 norigvars = nlhdlrexprdata->nvars;
692 for(
i = nlhdlrexprdata->nindicators - 1;
i >= 0; --
i )
697 for( v = 0; v < norigvars; ++v )
702 scvdata =
getSCVarDataInd(nlhdlrdata->scvars, origvars[v], nlhdlrexprdata->indicators[
i], &pos);
703 if( scvdata ==
NULL )
710 origvals0[v] = scvdata->
vals0[pos];
718 SCIPdebugMsg(
scip,
"expression evaluation failed for %p, removing indicator %s\n",
738 SCIP_Bool issc =
TRUE;
755 nlhdlrexprdata->indicators[
i], &pos);
756 issc = scvdata !=
NULL;
780 for( v = 0; v < nchildvarexprs; ++v )
802 if( scvdata ==
NULL )
809 scvdata->
bndssize = nlhdlrexprdata->nindicators;
849 SCIP_Bool* cutoff_probing
862 if( *solcopy ==
sol )
865 for( v = 0; v < nlhdlrexprdata->nvars; ++v )
869 for( v = 0; v < nlhdlrexprdata->nindicators; ++v )
885 for( v = 0; v < nprobingvars; ++v )
902 SCIP_Longint ndomreds;
929 SCIP_Real* probinglb,
930 SCIP_Real* probingub,
932 SCIP_Bool* reduceddom
941 SCIP_Bool bndchgsuccess;
964 if( scvdata ==
NULL )
969 sclb = indvalue ? scvdata->
lbs1[pos] : scvdata->
vals0[pos];
970 scub = indvalue ? scvdata->
ubs1[pos] : scvdata->
vals0[pos];
985 *reduceddom += bndchgsuccess;
991 else if( nlhdlrdata->tightenbounds &&
1007 *reduceddom += bndchgsuccess;
1022 *reduceddom += bndchgsuccess;
1028 else if( nlhdlrdata->tightenbounds &&
1044 *reduceddom += bndchgsuccess;
1056 if( doprobing && indvalue && (((scub - sclb) / (locub - loclb)) <= 1.0 - nlhdlrdata->mindomreduction ||
1057 (sclb >= 0.0 && loclb < 0.0) || (scub <= 0.0 && locub > 0.0)) )
1088 SCIP_Bool* doprobing,
1099 SCIP_Bool reduceddom;
1115 for(
b = 0;
b < 2; ++
b )
1117 for( v = 0; v < nlhdlrexprdata->nvars; ++v )
1128 var = nlhdlrexprdata->vars[v];
1131 &probingub, *doprobing, &reduceddom) );
1139 else if( reduceddom )
1154 (*probingvars)[*nprobingvars] =
var;
1155 (*probingdoms)[*nprobingvars].inf = probinglb;
1156 (*probingdoms)[*nprobingvars].sup = probingub;
1189 for( v = 0; v < nlhdlrexprdata->nvars; ++v )
1191 var = nlhdlrexprdata->vars[v];
1196 if( scvdata !=
NULL )
1265 if( nlhdlrdata->scvars !=
NULL )
1297 SCIP_Bool success =
FALSE;
1299 SCIP_Bool hassepabelow =
FALSE;
1300 SCIP_Bool hassepaabove =
FALSE;
1301 SCIP_Bool hasnondefault =
FALSE;
1319 SCIPdebugMsg(
scip,
"problem has no binary variables, not running perspective detection\n");
1327 SCIP_Bool sepabelowusesactivity;
1328 SCIP_Bool sepaaboveusesactivity;
1338 hasnondefault =
TRUE;
1345 hassepabelow =
TRUE;
1348 hassepaabove =
TRUE;
1356 SCIPdebugMsg(
scip,
"sum expr only has default exprhdlr, not running perspective detection\n");
1363 if( !hassepabelow && !hassepaabove )
1365 SCIPdebugMsg(
scip,
"no nlhdlr separates without using activity, not running perspective detection\n");
1377 if( nlhdlrdata->scvars ==
NULL )
1386 (*nlhdlrexprdata)->varssize = (*nlhdlrexprdata)->nvars;
1388 for(
i = 0;
i < (*nlhdlrexprdata)->nvars; ++
i )
1394 SCIPsortPtr((
void**) (*nlhdlrexprdata)->vars, SCIPvarComp, (*nlhdlrexprdata)->nvars);
1403 assert((*nlhdlrexprdata)->nindicators > 0);
1419 SCIP_CALL( nlhdlrFreeExprDataPerspective(
scip, nlhdlr, expr, nlhdlrexprdata) );
1432 SCIP_Real auxvarvalue;
1433 SCIP_Real enfoauxval;
1441 *auxvalue = auxvarvalue;
1458 SCIP_CALL( SCIPnlhdlrEvalaux(
scip, nlhdlr2, expr, nlhdlr2exprdata, &enfoauxval,
sol) );
1464 maxdiff =
REALABS(enfoauxval - auxvarvalue);
1465 *auxvalue = enfoauxval;
1478 sindicators = nlhdlrexprdata->nindicators;
1484 if( nlhdlrexprdata->nindicators == 0 )
1489 else if( nlhdlrexprdata->nindicators < sindicators )
1504 SCIPerrorMessage(
"method of perspective nonlinear handler not implemented yet\n");
1534 SCIP_Bool doprobing;
1546 SCIPinfoMessage(
scip,
NULL,
"enforcement method of perspective nonlinear handler called for expr %p: ", (
void*)expr);
1549 for(
i = 0;
i < nlhdlrexprdata->nvars; ++
i )
1564 if( nlhdlrexprdata->nindicators == 0 )
1571 if( branchcandonly )
1596 SCIP_Real nlhdlr2auxvalue;
1597 SCIP_Real violation;
1598 SCIP_Bool violbelow;
1599 SCIP_Bool violabove;
1600 SCIP_Bool sepausesactivity =
FALSE;
1602 SCIPgetExprEnfoDataNonlinear(expr, j, &nlhdlr2, &nlhdlr2exprdata, &nlhdlr2participate, !overestimate ? &sepausesactivity :
NULL, overestimate ? &sepausesactivity:
NULL, &nlhdlr2auxvalue);
1604 if( nlhdlr2 == nlhdlr )
1616 if( nlhdlrdata->convexonly && sepausesactivity )
1625 assert(violation >= 0.0);
1627 if( (overestimate && !violabove) || (!overestimate && !violbelow) )
1634 enfoposs[nenfos] = j;
1638 if( sepausesactivity && violation >= nlhdlrdata->minviolprobing )
1650 if( nlhdlrdata->probingfreq == -1 || (nlhdlrdata->probingfreq == 0 &&
SCIPgetDepth(
scip) != 0) ||
1651 (nlhdlrdata->probingfreq > 0 &&
SCIPgetDepth(
scip) % nlhdlrdata->probingfreq != 0) )
1655 if( nlhdlrdata->probingonlyinsepa && addbranchscores )
1672 for(
i = 0;
i < nlhdlrexprdata->nindicators && !stop; ++
i )
1681 SCIP_Bool doprobingind;
1684 SCIP_Bool adjrefpoint;
1686 indicator = nlhdlrexprdata->indicators[
i];
1690 doprobingind = doprobing;
1695 &nprobingvars, &doprobingind,
result) );
1715 SCIP_Bool cutoff_probing;
1722 for( v = 0; v < nlhdlrexprdata->nvars; ++v )
1731 sol, &solcopy, &cutoff_probing) );
1734 for( v = 0; v < nlhdlrexprdata->nvars; ++v )
1747 if( cutoff_probing )
1772 indval =
MAX(solval, 0.1);
1776 for( v = 0; v < nlhdlrexprdata->nvars; ++v )
1781 scvdata =
getSCVarDataInd(nlhdlrdata->scvars, nlhdlrexprdata->vars[v], indicator, &pos);
1784 if( scvdata ==
NULL )
1789 + scvdata->
vals0[pos]) );
1791 for( v = 0; v < nlhdlrexprdata->nindicators; ++v )
1806 for( j = 0; j < nenfos; ++j )
1808 SCIP_Bool addedbranchscores2j;
1811 SCIP_Real nlhdlr2auxvalue;
1822 SCIP_CALL( SCIPnlhdlrEvalaux(
scip, nlhdlr2, expr, nlhdlr2exprdata, &nlhdlr2auxvalue, soladj) );
1825 SCIP_CALL( SCIPnlhdlrEstimate(
scip, conshdlr, nlhdlr2, expr,
1826 nlhdlr2exprdata, soladj,
1828 FALSE, rowpreps2, &success2, &addedbranchscores2j) );
1832 SCIP_CALL( SCIPnlhdlrEstimate(
scip, conshdlr, nlhdlr2, expr,
1833 nlhdlr2exprdata, solcopy,
1835 FALSE, rowpreps2, &success2, &addedbranchscores2j) );
1841 assert((success2 && minidx <= maxidx) || (!success2 && minidx > maxidx));
1844 for(
r = minidx;
r <= maxidx; ++
r )
1847 SCIP_Real* rowprepcoefs;
1875 if(
REALABS( rowprepcoefs[v]) > maxcoef )
1877 maxcoef =
REALABS(rowprepcoefs[v]);
1880 scvdata =
getSCVarDataInd(nlhdlrdata->scvars, rowprepvars[v], indicator, &pos);
1883 if( scvdata ==
NULL )
1886 cst0 -= rowprepcoefs[v] * scvdata->
vals0[pos];
1960 SCIPerrorMessage(
"estimate called by perspective nonlinear handler returned invalid result <%d>\n", resultr);
1979 if( solcopy !=
sol )
2012 "maximal number of propagation rounds in probing",
2016 "minimal relative reduction in a variable's domain for applying probing",
2020 "minimal violation w.r.t. auxiliary variables for applying probing",
2024 "whether to do probing only in separation",
2028 "probing frequency (-1 - no probing, 0 - root node only)",
2032 "whether perspective cuts are added only for convex expressions",
2036 "whether variable semicontinuity is used to tighten variable bounds",
2040 "whether to adjust the reference point",
constraint handler for nonlinear constraints specified by algebraic expressions
void SCIPcomputeArraysIntersectionPtr(void **array1, int narray1, void **array2, int narray2, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void **intersectarray, int *nintersectarray)
unsigned int SCIPgetExprNAuxvarUsesNonlinear(SCIP_EXPR *expr)
void SCIPgetExprEnfoDataNonlinear(SCIP_EXPR *expr, int idx, SCIP_NLHDLR **nlhdlr, SCIP_NLHDLREXPRDATA **nlhdlrexprdata, SCIP_NLHDLR_METHOD *nlhdlrparticipation, SCIP_Bool *sepabelowusesactivity, SCIP_Bool *sepaaboveusesactivity, SCIP_Real *auxvalue)
void SCIPsetExprEnfoAuxValueNonlinear(SCIP_EXPR *expr, int idx, SCIP_Real auxvalue)
SCIP_VAR * SCIPgetExprAuxVarNonlinear(SCIP_EXPR *expr)
SCIP_RETCODE SCIPprocessRowprepNonlinear(SCIP *scip, SCIP_NLHDLR *nlhdlr, SCIP_CONS *cons, SCIP_EXPR *expr, SCIP_ROWPREP *rowprep, SCIP_Bool overestimate, SCIP_VAR *auxvar, SCIP_Real auxvalue, SCIP_Bool allowweakcuts, SCIP_Bool branchscoresuccess, SCIP_Bool inenforcement, SCIP_SOL *sol, SCIP_RESULT *result)
int SCIPgetExprNEnfosNonlinear(SCIP_EXPR *expr)
SCIP_RETCODE SCIPgetExprAbsAuxViolationNonlinear(SCIP *scip, SCIP_EXPR *expr, SCIP_Real auxvalue, SCIP_SOL *sol, SCIP_Real *viol, SCIP_Bool *violunder, SCIP_Bool *violover)
int SCIPgetSubscipDepth(SCIP *scip)
int SCIPgetNVars(SCIP *scip)
int SCIPgetNBinVars(SCIP *scip)
void SCIPhashmapFree(SCIP_HASHMAP **hashmap)
void * SCIPhashmapEntryGetImage(SCIP_HASHMAPENTRY *entry)
int SCIPhashmapGetImageInt(SCIP_HASHMAP *hashmap, void *origin)
void * SCIPhashmapGetImage(SCIP_HASHMAP *hashmap, void *origin)
SCIP_RETCODE SCIPhashmapInsert(SCIP_HASHMAP *hashmap, void *origin, void *image)
int SCIPhashmapGetNEntries(SCIP_HASHMAP *hashmap)
SCIP_HASHMAPENTRY * SCIPhashmapGetEntry(SCIP_HASHMAP *hashmap, int entryidx)
SCIP_RETCODE SCIPhashmapCreate(SCIP_HASHMAP **hashmap, BMS_BLKMEM *blkmem, int mapsize)
SCIP_RETCODE SCIPhashmapSetImageInt(SCIP_HASHMAP *hashmap, void *origin, int image)
void SCIPinfoMessage(SCIP *scip, FILE *file, const char *formatstr,...)
#define SCIPdebugMsgPrint
SCIP_RETCODE SCIPincludeNlhdlrPerspective(SCIP *scip)
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 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)
int SCIPgetPtrarrayMinIdx(SCIP *scip, SCIP_PTRARRAY *ptrarray)
SCIP_Bool SCIPgetBoolarrayVal(SCIP *scip, SCIP_BOOLARRAY *boolarray, int idx)
SCIP_RETCODE SCIPclearPtrarray(SCIP *scip, SCIP_PTRARRAY *ptrarray)
void * SCIPgetPtrarrayVal(SCIP *scip, SCIP_PTRARRAY *ptrarray, int idx)
SCIP_RETCODE SCIPfreePtrarray(SCIP *scip, SCIP_PTRARRAY **ptrarray)
SCIP_RETCODE SCIPfreeBoolarray(SCIP *scip, SCIP_BOOLARRAY **boolarray)
int SCIPgetPtrarrayMaxIdx(SCIP *scip, SCIP_PTRARRAY *ptrarray)
SCIP_RETCODE SCIPsetPtrarrayVal(SCIP *scip, SCIP_PTRARRAY *ptrarray, int idx, void *val)
SCIP_RETCODE SCIPcreateBoolarray(SCIP *scip, SCIP_BOOLARRAY **boolarray)
SCIP_RETCODE SCIPsetBoolarrayVal(SCIP *scip, SCIP_BOOLARRAY *boolarray, int idx, SCIP_Bool val)
SCIP_RETCODE SCIPcreatePtrarray(SCIP *scip, SCIP_PTRARRAY **ptrarray)
SCIP_RETCODE SCIPevalExpr(SCIP *scip, SCIP_EXPR *expr, SCIP_SOL *sol, SCIP_Longint soltag)
int SCIPexprGetNChildren(SCIP_EXPR *expr)
SCIP_Bool SCIPexpriterIsEnd(SCIP_EXPRITER *iterator)
SCIP_Bool SCIPisExprSum(SCIP *scip, SCIP_EXPR *expr)
SCIP_RETCODE SCIPgetExprNVars(SCIP *scip, SCIP_EXPR *expr, int *nvars)
SCIP_RETCODE SCIPreleaseExpr(SCIP *scip, SCIP_EXPR **expr)
SCIP_EXPR * SCIPexpriterGetCurrent(SCIP_EXPRITER *iterator)
SCIP_Bool SCIPisExprVar(SCIP *scip, SCIP_EXPR *expr)
SCIP_RETCODE SCIPcreateExpriter(SCIP *scip, SCIP_EXPRITER **iterator)
SCIP_RETCODE SCIPprintExpr(SCIP *scip, SCIP_EXPR *expr, FILE *file)
SCIP_Real SCIPexprGetEvalValue(SCIP_EXPR *expr)
SCIP_EXPR * SCIPexpriterGetNext(SCIP_EXPRITER *iterator)
SCIP_EXPR ** SCIPexprGetChildren(SCIP_EXPR *expr)
SCIP_VAR * SCIPgetVarExprVar(SCIP_EXPR *expr)
void SCIPfreeExpriter(SCIP_EXPRITER **iterator)
SCIP_RETCODE SCIPexpriterInit(SCIP_EXPRITER *iterator, SCIP_EXPR *expr, SCIP_EXPRITER_TYPE type, SCIP_Bool allowrevisit)
SCIP_RETCODE SCIPgetExprVarExprs(SCIP *scip, SCIP_EXPR *expr, SCIP_EXPR **varexprs, int *nvarexprs)
SCIP_Real SCIPintervalGetInf(SCIP_INTERVAL interval)
SCIP_Real SCIPintervalGetSup(SCIP_INTERVAL interval)
#define SCIPfreeBlockMemoryArray(scip, ptr, num)
#define SCIPallocClearBlockMemory(scip, ptr)
#define SCIPallocClearBufferArray(scip, ptr, num)
int SCIPcalcMemGrowSize(SCIP *scip, int num)
#define SCIPallocBufferArray(scip, ptr, num)
#define SCIPreallocBufferArray(scip, ptr, num)
#define SCIPfreeBufferArray(scip, ptr)
#define SCIPduplicateBufferArray(scip, ptr, source, num)
#define SCIPallocBlockMemoryArray(scip, ptr, num)
#define SCIPreallocBlockMemoryArray(scip, ptr, oldnum, newnum)
#define SCIPfreeBlockMemory(scip, ptr)
#define SCIPfreeBlockMemoryArrayNull(scip, ptr, num)
#define SCIPfreeBufferArrayNull(scip, ptr)
#define SCIPallocBlockMemory(scip, ptr)
#define SCIPduplicateBlockMemoryArray(scip, ptr, source, num)
void SCIPnlhdlrSetInitExit(SCIP_NLHDLR *nlhdlr, SCIP_DECL_NLHDLRINIT((*init)),)
SCIP_NLHDLRDATA * SCIPnlhdlrGetData(SCIP_NLHDLR *nlhdlr)
void SCIPnlhdlrSetFreeExprData(SCIP_NLHDLR *nlhdlr,)
const char * SCIPnlhdlrGetName(SCIP_NLHDLR *nlhdlr)
SCIP_Bool SCIPnlhdlrHasEstimate(SCIP_NLHDLR *nlhdlr)
void SCIPnlhdlrSetSepa(SCIP_NLHDLR *nlhdlr, SCIP_DECL_NLHDLRINITSEPA((*initsepa)), SCIP_DECL_NLHDLRENFO((*enfo)), SCIP_DECL_NLHDLRESTIMATE((*estimate)),)
void SCIPnlhdlrSetFreeHdlrData(SCIP_NLHDLR *nlhdlr,)
void SCIPnlhdlrSetCopyHdlr(SCIP_NLHDLR *nlhdlr,)
SCIP_RETCODE SCIPincludeNlhdlrNonlinear(SCIP *scip, SCIP_NLHDLR **nlhdlr, const char *name, const char *desc, int detectpriority, int enfopriority, SCIP_DECL_NLHDLRDETECT((*detect)), SCIP_DECL_NLHDLREVALAUX((*evalaux)), SCIP_NLHDLRDATA *nlhdlrdata)
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_Bool SCIPinProbing(SCIP *scip)
SCIP_RETCODE SCIPstartProbing(SCIP *scip)
SCIP_RETCODE SCIPnewProbingNode(SCIP *scip)
SCIP_RETCODE SCIPsetSolVals(SCIP *scip, SCIP_SOL *sol, int nvars, SCIP_VAR **vars, SCIP_Real *vals)
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_Bool SCIPisFeasEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisFeasLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Real SCIPfeastol(SCIP *scip)
SCIP_Bool SCIPisGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisFeasGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
int SCIPgetDepth(SCIP *scip)
SCIP_RETCODE SCIPtightenVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
int SCIPvarGetNVlbs(SCIP_VAR *var)
SCIP_Real * SCIPvarGetVlbCoefs(SCIP_VAR *var)
SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)
SCIP_Real SCIPvarGetUbLocal(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)
const char * SCIPvarGetName(SCIP_VAR *var)
SCIP_RETCODE SCIPreleaseVar(SCIP *scip, SCIP_VAR **var)
SCIP_Real * SCIPvarGetVlbConstants(SCIP_VAR *var)
int SCIPvarGetNVubs(SCIP_VAR *var)
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
SCIP_Bool SCIPvarIsRelaxationOnly(SCIP_VAR *var)
SCIP_VAR ** SCIPvarGetVlbVars(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_Real * SCIPvarGetVubConstants(SCIP_VAR *var)
SCIP_VAR ** SCIPvarGetVubVars(SCIP_VAR *var)
SCIP_Real * SCIPvarGetVubCoefs(SCIP_VAR *var)
SCIP_RETCODE SCIPcaptureVar(SCIP *scip, SCIP_VAR *var)
SCIP_VAR ** SCIProwprepGetVars(SCIP_ROWPREP *rowprep)
SCIP_Real SCIProwprepGetSide(SCIP_ROWPREP *rowprep)
SCIP_Real * SCIProwprepGetCoefs(SCIP_ROWPREP *rowprep)
char * SCIProwprepGetName(SCIP_ROWPREP *rowprep)
void SCIProwprepAddConstant(SCIP_ROWPREP *rowprep, SCIP_Real constant)
SCIP_RETCODE SCIPaddRowprepTerm(SCIP *scip, SCIP_ROWPREP *rowprep, SCIP_VAR *var, SCIP_Real coef)
int SCIProwprepGetNVars(SCIP_ROWPREP *rowprep)
void SCIPfreeRowprep(SCIP *scip, SCIP_ROWPREP **rowprep)
void SCIPprintRowprep(SCIP *scip, SCIP_ROWPREP *rowprep, FILE *file)
SCIP_Bool SCIPsortedvecFindPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *val, int len, int *pos)
void SCIPsortPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
SCIPfreeSol(scip, &heurdata->sol))
SCIPcreateSol(scip, &heurdata->sol, heur))
assert(minobj< SCIPgetCutoffbound(scip))
static SCIP_Bool propagate
#define BMSclearMemory(ptr)
private functions of nonlinear handlers of nonlinear constraints
static SCIP_RETCODE varIsSemicontinuous(SCIP *scip, SCIP_VAR *var, SCIP_HASHMAP *scvars, SCIP_Bool *result)
#define NLHDLR_DETECTPRIORITY
static SCIP_RETCODE tightenOnBounds(SCIP_NLHDLREXPRDATA *nlhdlrexprdata, SCIP_HASHMAP *scvars, SCIP_VAR *indicator)
#define DEFAULT_MINVIOLPROBING
#define NLHDLR_ENFOPRIORITY
static SCIP_RETCODE freeNlhdlrExprData(SCIP *scip, SCIP_NLHDLREXPRDATA *nlhdlrexprdata)
static SCIP_RETCODE startProbing(SCIP *scip, SCIP_NLHDLRDATA *nlhdlrdata, SCIP_NLHDLREXPRDATA *nlhdlrexprdata, SCIP_VAR *indicator, SCIP_VAR **probingvars, SCIP_INTERVAL *probingdoms, int nprobingvars, SCIP_SOL *sol, SCIP_SOL **solcopy, SCIP_Bool *cutoff_probing)
static SCIP_RETCODE removeIndicator(SCIP *scip, SCIP_NLHDLREXPRDATA *nlexprdata, int pos)
static SCIP_RETCODE exprIsSemicontinuous(SCIP *scip, SCIP_NLHDLRDATA *nlhdlrdata, SCIP_NLHDLREXPRDATA *nlhdlrexprdata, SCIP_EXPR *expr, SCIP_Bool *res)
#define DEFAULT_TIGHTENBOUNDS
#define DEFAULT_ADJREFPOINT
static SCIP_RETCODE analyseVarOnoffBounds(SCIP *scip, SCIP_NLHDLRDATA *nlhdlrdata, SCIP_VAR *var, SCIP_VAR *indicator, SCIP_Bool indvalue, SCIP_Bool *infeas, SCIP_Real *probinglb, SCIP_Real *probingub, SCIP_Bool doprobing, SCIP_Bool *reduceddom)
#define DEFAULT_MINDOMREDUCTION
#define DEFAULT_PROBINGFREQ
static SCIP_RETCODE addAuxVar(SCIP *scip, SCIP_NLHDLREXPRDATA *nlhdlrexprdata, SCIP_HASHMAP *auxvarmap, SCIP_VAR *auxvar)
#define DEFAULT_PROBINGONLYINSEPA
#define DEFAULT_CONVEXONLY
static SCIP_RETCODE analyseOnoffBounds(SCIP *scip, SCIP_NLHDLRDATA *nlhdlrdata, SCIP_NLHDLREXPRDATA *nlhdlrexprdata, SCIP_VAR *indicator, SCIP_VAR ***probingvars, SCIP_INTERVAL **probingdoms, int *nprobingvars, SCIP_Bool *doprobing, SCIP_RESULT *result)
static SCIP_RETCODE addSCVarIndicator(SCIP *scip, SCVARDATA *scvdata, SCIP_VAR *indicator, SCIP_Real val0, SCIP_Real lb1, SCIP_Real ub1)
static SCIP_RETCODE computeOffValues(SCIP *scip, SCIP_NLHDLRDATA *nlhdlrdata, SCIP_NLHDLREXPRDATA *nlhdlrexprdata, SCIP_EXPR *expr)
#define DEFAULT_MAXPROPROUNDS
static SCVARDATA * getSCVarDataInd(SCIP_HASHMAP *scvars, SCIP_VAR *var, SCIP_VAR *indicator, int *pos)
perspective nonlinear handler
BMS_BLKMEM * SCIPblkmem(SCIP *scip)
preparation of a linear inequality to become a SCIP_ROW
public methods for solutions
#define SCIP_NLHDLR_METHOD_SEPAABOVE
#define SCIP_DECL_NLHDLREVALAUX(x)
struct SCIP_NlhdlrData SCIP_NLHDLRDATA
#define SCIP_NLHDLR_METHOD_SEPABOTH
#define SCIP_DECL_NLHDLRCOPYHDLR(x)
#define SCIP_DECL_NLHDLRINIT(x)
unsigned int SCIP_NLHDLR_METHOD
#define SCIP_DECL_NLHDLREXIT(x)
#define SCIP_DECL_NLHDLRFREEEXPRDATA(x)
#define SCIP_DECL_NLHDLRDETECT(x)
#define SCIP_DECL_NLHDLREXITSEPA(x)
#define SCIP_DECL_NLHDLRINITSEPA(x)
#define SCIP_DECL_NLHDLRFREEHDLRDATA(x)
struct SCIP_NlhdlrExprData SCIP_NLHDLREXPRDATA
#define SCIP_DECL_NLHDLRENFO(x)
#define SCIP_NLHDLR_METHOD_SEPABELOW
enum SCIP_Result SCIP_RESULT
enum SCIP_Retcode SCIP_RETCODE