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
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 )
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 )
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;
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",
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;
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 )
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)) )
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 )
1310 SCIPdebugMsg(
scip,
"problem has no binary variables, not running perspective detection\n");
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) );
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 )
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 )
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 )
1664 indicator = nlhdlrexprdata->indicators[
i];
1668 doprobingind = doprobing;
1673 &nprobingvars, &doprobingind,
result) );
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 )
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 )
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",
#define DEFAULT_MAXPROPROUNDS
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)
struct SCIP_Interval SCIP_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))
struct SCVarData SCVARDATA
assert(minobj< SCIPgetCutoffbound(scip))
static SCIP_Bool propagate
#define BMSclearMemory(ptr)
private functions of nonlinear handlers of nonlinear constraints
#define NLHDLR_DETECTPRIORITY
#define NLHDLR_ENFOPRIORITY
static SCIP_RETCODE varIsSemicontinuous(SCIP *scip, SCIP_VAR *var, SCIP_HASHMAP *scvars, SCIP_Bool *result)
static SCIP_RETCODE tightenOnBounds(SCIP_NLHDLREXPRDATA *nlhdlrexprdata, SCIP_HASHMAP *scvars, SCIP_VAR *indicator)
#define DEFAULT_MINVIOLPROBING
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)
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
struct SCIP_Expr SCIP_EXPR
struct SCIP_ExprIter SCIP_EXPRITER
struct SCIP_RowPrep SCIP_ROWPREP
struct SCIP_HashMap SCIP_HASHMAP
struct SCIP_HashMapEntry SCIP_HASHMAPENTRY
struct SCIP_PtrArray SCIP_PTRARRAY
struct SCIP_BoolArray SCIP_BOOLARRAY
#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)
struct SCIP_Nlhdlr SCIP_NLHDLR
#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