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 )
1256 if( nlhdlrdata->scvars !=
NULL )
1288 SCIP_Bool success =
FALSE;
1290 SCIP_Bool hassepabelow =
FALSE;
1291 SCIP_Bool hassepaabove =
FALSE;
1292 SCIP_Bool hasnondefault =
FALSE;
1310 SCIPdebugMsg(
scip,
"problem has no binary variables, not running perspective detection\n");
1318 SCIP_Bool sepabelowusesactivity;
1319 SCIP_Bool sepaaboveusesactivity;
1329 hasnondefault =
TRUE;
1336 hassepabelow =
TRUE;
1339 hassepaabove =
TRUE;
1347 SCIPdebugMsg(
scip,
"sum expr only has default exprhdlr, not running perspective detection\n");
1354 if( !hassepabelow && !hassepaabove )
1356 SCIPdebugMsg(
scip,
"no nlhdlr separates without using activity, not running perspective detection\n");
1368 if( nlhdlrdata->scvars ==
NULL )
1377 (*nlhdlrexprdata)->varssize = (*nlhdlrexprdata)->nvars;
1379 for(
i = 0;
i < (*nlhdlrexprdata)->nvars; ++
i )
1385 SCIPsortPtr((
void**) (*nlhdlrexprdata)->vars, SCIPvarComp, (*nlhdlrexprdata)->nvars);
1394 assert((*nlhdlrexprdata)->nindicators > 0);
1410 SCIP_CALL( nlhdlrFreeExprDataPerspective(
scip, nlhdlr, expr, nlhdlrexprdata) );
1423 SCIP_Real auxvarvalue;
1424 SCIP_Real enfoauxval;
1432 *auxvalue = auxvarvalue;
1449 SCIP_CALL( SCIPnlhdlrEvalaux(
scip, nlhdlr2, expr, nlhdlr2exprdata, &enfoauxval,
sol) );
1455 maxdiff =
REALABS(enfoauxval - auxvarvalue);
1456 *auxvalue = enfoauxval;
1469 sindicators = nlhdlrexprdata->nindicators;
1475 if( nlhdlrexprdata->nindicators == 0 )
1480 else if( nlhdlrexprdata->nindicators < sindicators )
1512 SCIP_Bool doprobing;
1524 SCIPinfoMessage(
scip,
NULL,
"enforcement method of perspective nonlinear handler called for expr %p: ", (
void*)expr);
1527 for(
i = 0;
i < nlhdlrexprdata->nvars; ++
i )
1542 if( nlhdlrexprdata->nindicators == 0 )
1549 if( branchcandonly )
1574 SCIP_Real nlhdlr2auxvalue;
1575 SCIP_Real violation;
1576 SCIP_Bool violbelow;
1577 SCIP_Bool violabove;
1578 SCIP_Bool sepausesactivity =
FALSE;
1580 SCIPgetExprEnfoDataNonlinear(expr, j, &nlhdlr2, &nlhdlr2exprdata, &nlhdlr2participate, !overestimate ? &sepausesactivity :
NULL, overestimate ? &sepausesactivity:
NULL, &nlhdlr2auxvalue);
1582 if( nlhdlr2 == nlhdlr )
1594 if( nlhdlrdata->convexonly && sepausesactivity )
1603 assert(violation >= 0.0);
1605 if( (overestimate && !violabove) || (!overestimate && !violbelow) )
1612 enfoposs[nenfos] = j;
1616 if( sepausesactivity && violation >= nlhdlrdata->minviolprobing )
1628 if( nlhdlrdata->probingfreq == -1 || (nlhdlrdata->probingfreq == 0 &&
SCIPgetDepth(
scip) != 0) ||
1629 (nlhdlrdata->probingfreq > 0 &&
SCIPgetDepth(
scip) % nlhdlrdata->probingfreq != 0) )
1633 if( nlhdlrdata->probingonlyinsepa && addbranchscores )
1650 for(
i = 0;
i < nlhdlrexprdata->nindicators && !stop; ++
i )
1659 SCIP_Bool doprobingind;
1662 SCIP_Bool adjrefpoint;
1664 indicator = nlhdlrexprdata->indicators[
i];
1668 doprobingind = doprobing;
1673 &nprobingvars, &doprobingind,
result) );
1693 SCIP_Bool cutoff_probing =
FALSE;
1700 for( v = 0; v < nlhdlrexprdata->nvars; ++v )
1709 sol, &solcopy, &cutoff_probing) );
1712 for( v = 0; v < nlhdlrexprdata->nvars; ++v )
1725 if( cutoff_probing )
1750 indval =
MAX(solval, 0.1);
1754 for( v = 0; v < nlhdlrexprdata->nvars; ++v )
1759 scvdata =
getSCVarDataInd(nlhdlrdata->scvars, nlhdlrexprdata->vars[v], indicator, &pos);
1762 if( scvdata ==
NULL )
1767 + scvdata->
vals0[pos]) );
1769 for( v = 0; v < nlhdlrexprdata->nindicators; ++v )
1784 for( j = 0; j < nenfos; ++j )
1786 SCIP_Bool addedbranchscores2j;
1789 SCIP_Real nlhdlr2auxvalue;
1800 SCIP_CALL( SCIPnlhdlrEvalaux(
scip, nlhdlr2, expr, nlhdlr2exprdata, &nlhdlr2auxvalue, soladj) );
1803 SCIP_CALL( SCIPnlhdlrEstimate(
scip, conshdlr, nlhdlr2, expr,
1804 nlhdlr2exprdata, soladj,
1806 FALSE, rowpreps2, &success2, &addedbranchscores2j) );
1810 SCIP_CALL( SCIPnlhdlrEstimate(
scip, conshdlr, nlhdlr2, expr,
1811 nlhdlr2exprdata, solcopy,
1813 FALSE, rowpreps2, &success2, &addedbranchscores2j) );
1819 assert((success2 && minidx <= maxidx) || (!success2 && minidx > maxidx));
1822 for(
r = minidx;
r <= maxidx; ++
r )
1825 SCIP_Real* rowprepcoefs;
1853 if(
REALABS( rowprepcoefs[v]) > maxcoef )
1855 maxcoef =
REALABS(rowprepcoefs[v]);
1858 scvdata =
getSCVarDataInd(nlhdlrdata->scvars, rowprepvars[v], indicator, &pos);
1861 if( scvdata ==
NULL )
1864 cst0 -= rowprepcoefs[v] * scvdata->
vals0[pos];
1938 SCIPerrorMessage(
"estimate called by perspective nonlinear handler returned invalid result <%d>\n", resultr);
1957 if( solcopy !=
sol )
1990 "maximal number of propagation rounds in probing",
1994 "minimal relative reduction in a variable's domain for applying probing",
1998 "minimal violation w.r.t. auxiliary variables for applying probing",
2002 "whether to do probing only in separation",
2006 "probing frequency (-1 - no probing, 0 - root node only)",
2010 "whether perspective cuts are added only for convex expressions",
2014 "whether variable semicontinuity is used to tighten variable bounds",
2018 "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)
unsigned int SCIP_NLHDLR_METHOD
#define SCIP_DECL_NLHDLREXIT(x)
#define SCIP_DECL_NLHDLRFREEEXPRDATA(x)
#define SCIP_DECL_NLHDLRDETECT(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