31#ifdef SCIP_SIGCUT_DEBUG
50#define NLHDLR_NAME "signomial"
51#define NLHDLR_DESC "handler for signomial expressions"
52#define NLHDLR_DETECTPRIORITY 30
53#define NLHDLR_ENFOPRIORITY 30
56#define NLHDLR_MAXNUNDERVARS 14
57#define NLHDLR_MINCUTSCALE 1e-5
73struct SCIP_NlhdlrExprData
116#ifdef SCIP_SIGCUT_DEBUG
129 SCIPdebugMsg(
scip,
" #all variables: %d, #positive exponent variables: %d, #negative exponent variables: %d, auxvar: %s \n expr: ",
134 if( !nlhdlrexprdata->isstorecapture )
142 for(
int i = 0;
i < nlhdlrexprdata->nvars - 1;
i++ )
150 if( nlhdlrexprdata->nposvars == 0 )
156 for(
int i = 0;
i < nlhdlrexprdata->nvars;
i++ )
157 if( nlhdlrexprdata->signs[
i] )
163 if( nlhdlrexprdata->nnegvars == 0 )
169 for(
int i = 0;
i < nlhdlrexprdata->nvars;
i++ )
171 if( !nlhdlrexprdata->signs[
i] )
173 if(
i == nlhdlrexprdata->nvars - 1 )
204 int nvars = (*nlhdlrexprdata)->nvars;
214 *nlhdlrexprdata =
NULL;
256 auxvar = nlhdlrexprdata->vars[nlhdlrexprdata->nfactors];
260 if(
vars[
i] == auxvar )
279 if(
vars[
i] == auxvar )
300 assert(!nlhdlrexprdata->isstorecapture);
303 for(
c = 0;
c < nlhdlrexprdata->nfactors; ++
c )
316 nlhdlrexprdata->isstorecapture =
TRUE;
335 assert(nlhdlrexprdata->isstorecapture);
340 for(
c = 0;
c < nlhdlrexprdata->nfactors;
c++ )
349 nlhdlrexprdata->intervals[
c].inf = inf;
350 nlhdlrexprdata->intervals[
c].sup =
MAX(sup, inf + 0.1);
351 powinf =
pow(inf, nlhdlrexprdata->exponents[
c]);
352 powsup =
pow(sup, nlhdlrexprdata->exponents[
c]);
381 nlhdlrexprdata =
evaldata->nlhdlrexprdata;
383#ifdef SCIP_MORE_DEBUG
387 for(
i = 0,
j = 0;
i < nlhdlrexprdata->nvars; ++
i )
389 if( nlhdlrexprdata->signs[
i] !=
evaldata->sign )
392 val *=
pow(args[
j], nlhdlrexprdata->refexponents[
i]);
410 SCIP_Bool overestimate,
429 for(
i = 0;
i < nlhdlrexprdata->nvars; ++
i )
431 if( nlhdlrexprdata->signs[
i] !=
sign )
434 if( !
SCIPisRelEQ(
scip, nlhdlrexprdata->intervals[
i].inf, nlhdlrexprdata->intervals[
i].sup) )
449 for(
i = 0;
i < nlhdlrexprdata->nvars; ++
i )
451 if( nlhdlrexprdata->signs[
i] !=
sign )
454 scale =
i == (nlhdlrexprdata->nvars - 1) ? nlhdlrexprdata->coef : 1.0;
456 funcval *=
pow(val, nlhdlrexprdata->refexponents[
i]);
465 nsignvars =
sign ? nlhdlrexprdata->nposvars : nlhdlrexprdata->nnegvars;
481 for(
i = 0;
i < nlhdlrexprdata->nvars; ++
i )
483 if( nlhdlrexprdata->signs[
i] ==
sign )
486 SCIP_Real scale =
i == (nlhdlrexprdata->nvars - 1) ? nlhdlrexprdata->coef : 1;
488 SCIP_Real
refexponent = nlhdlrexprdata->refexponents[
i];
501 SCIP_Bool
islocal = !overestimate;
511 else if(
nsignvars == 2 && !overestimate )
528 SCIP_Real
xstar[2] = {0.0, 0.0};;
529 SCIP_Real scale[2] = {0.0, 0.0};;
530 SCIP_Real
box[4] = {0.0, 0.0, 0.0, 0.0};
534 for(
i = 0;
i < nlhdlrexprdata->nvars; ++
i )
536 if( nlhdlrexprdata->signs[
i] !=
sign )
538 box[2 *
j] = nlhdlrexprdata->intervals[
i].inf;
539 box[2 *
j + 1] = nlhdlrexprdata->intervals[
i].sup;
541 scale[
j] =
i == (nlhdlrexprdata->nvars - 1) ? nlhdlrexprdata->coef : 1;
542 vars[
j] = nlhdlrexprdata->vars[
i];
603 SCIP_Real targetvalue,
627 nsignvars =
sign ? nlhdlrexprdata->nposvars : nlhdlrexprdata->nnegvars;
630 evaldata.nlhdlrexprdata = nlhdlrexprdata;
636 xstar = nlhdlrexprdata->xstar;
637 box = nlhdlrexprdata->box;
639 for(
i = 0;
i < nlhdlrexprdata->nvars; ++
i )
641 if( nlhdlrexprdata->signs[
i] !=
sign )
644 box[2 *
j] = nlhdlrexprdata->intervals[
i].inf;
645 box[2 *
j + 1] = nlhdlrexprdata->intervals[
i].sup;
646 scale =
i == (nlhdlrexprdata->nvars - 1) ? nlhdlrexprdata->coef : 1.0;
665 for(
i = 0;
i < nlhdlrexprdata->nvars; ++
i )
667 if( nlhdlrexprdata->signs[
i] !=
sign )
669 scale =
i == (nlhdlrexprdata->nvars - 1) ? nlhdlrexprdata->coef : 1.0;
711 for(
i = 0;
i < nlhdlrexprdata->nvars; ++
i )
713 if( nlhdlrexprdata->signs[
i] !=
sign )
715 scale =
i == (nlhdlrexprdata->nvars - 1) ? nlhdlrexprdata->coef : 1.0;
726 for(
i = 0;
i < nlhdlrexprdata->nvars; ++
i )
728 if( nlhdlrexprdata->signs[
i] !=
sign )
730 scale =
i == (nlhdlrexprdata->nvars - 1) ? nlhdlrexprdata->coef : 1.0;
731 var = nlhdlrexprdata->vars[
i];
773 if( !nlhdlrexprdata->isstorecapture )
810 for(
i = 0;
i < nlhdlrexprdata->nvars;
i++ )
812 if( nlhdlrexprdata->signs[
i] ==
oversign )
814 scale =
i == (nlhdlrexprdata->nvars - 1) ? nlhdlrexprdata->coef : 1.0;
819#ifdef SCIP_SIGCUT_DEBUG
824 SCIPinfoMessage(
scip,
NULL,
" Auxvalue: %f, targetvalue: %f, %sestimate.", auxvalue, targetvalue, overestimate ?
"over" :
"under");
827 for(
i = 0;
i < nlhdlrexprdata->nvars;
i++ )
831 scale =
i == (nlhdlrexprdata->nvars - 1) ? nlhdlrexprdata->coef : 1.0;
909 (*nlhdlrexprdata)->nfactors =
nf;
910 (*nlhdlrexprdata)->nvars =
nvars;
920 for(
c = 0;
c <
nf;
c++ )
951 (*nlhdlrexprdata)->isstorecapture =
FALSE;
956 for(
c = 0;
c <
nf;
c++ )
960 if( (*nlhdlrexprdata)->exponents[
c] > 0.0 )
964 (*nlhdlrexprdata)->signs[
c] =
TRUE;
971 (*nlhdlrexprdata)->signs[
c] =
FALSE;
975 (*nlhdlrexprdata)->signs[
nf] =
FALSE;
976 (*nlhdlrexprdata)->nposvars =
nposvars;
977 (*nlhdlrexprdata)->nnegvars =
nf -
nposvars + 1;
982 for(
c = 0;
c <
nf;
c++ )
984 if( (*nlhdlrexprdata)->signs[
c] )
985 (*nlhdlrexprdata)->refexponents[
c] = (*nlhdlrexprdata)->exponents[
c] / normalize;
987 (*nlhdlrexprdata)->refexponents[
c] = -(*nlhdlrexprdata)->exponents[
c] / normalize;
989 (*nlhdlrexprdata)->refexponents[
nf] = 1.0 / normalize;
992 for(
c = 0;
c <
nf;
c++ )
999 if( *nlhdlrexprdata !=
NULL )
1004#ifdef SCIP_SIGCUT_DEBUG
1007 SCIPdebugMsg(
scip,
"scip depth: %d, step: %d, expr pointer: %p, expr data pointer: %p, detected expr: total vars (exps) %d ",
1024 *auxvalue = nlhdlrexprdata->coef;
1025 for(
c = 0;
c < nlhdlrexprdata->nfactors; ++
c )
1035 *auxvalue *=
pow(val, nlhdlrexprdata->exponents[
c]);
1078 for(
c = 0;
c < (*nlhdlrexprdata)->nfactors;
c++ )
1084 if( (*nlhdlrexprdata)->isstorecapture )
1086 for(
c = 0;
c < (*nlhdlrexprdata)->nvars;
c++ )
1088 if( (*nlhdlrexprdata)->vars[
c] !=
NULL )
1132 "maximum number of variables when underestimating a concave power function",
1135 "minimum scale factor when scaling a cut",
constraint handler for nonlinear constraints specified by algebraic expressions
void SCIPestimateRoot(SCIP *scip, SCIP_Real exponent, SCIP_Bool overestimate, SCIP_Real xlb, SCIP_Real xub, SCIP_Real xref, SCIP_Real *constant, SCIP_Real *slope, SCIP_Bool *islocal, SCIP_Bool *success)
power and signed power expression handlers
variable expression handler
SCIP_VAR * SCIPgetExprAuxVarNonlinear(SCIP_EXPR *expr)
SCIP_RETCODE SCIPregisterExprUsageNonlinear(SCIP *scip, SCIP_EXPR *expr, SCIP_Bool useauxvar, SCIP_Bool useactivityforprop, SCIP_Bool useactivityforsepabelow, SCIP_Bool useactivityforsepaabove)
SCIP_RETCODE SCIPcomputeFacetVertexPolyhedralNonlinear(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_Bool overestimate, SCIP_DECL_VERTEXPOLYFUN((*function)), void *fundata, SCIP_Real *xstar, SCIP_Real *box, int nallvars, SCIP_Real targetvalue, SCIP_Bool *success, SCIP_Real *facetcoefs, SCIP_Real *facetconstant)
#define SCIP_DECL_VERTEXPOLYFUN(f)
int SCIPgetSubscipDepth(SCIP *scip)
SCIP_STAGE SCIPgetStage(SCIP *scip)
void SCIPinfoMessage(SCIP *scip, FILE *file, const char *formatstr,...)
SCIP_RETCODE SCIPincludeNlhdlrSignomial(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 SCIPsetPtrarrayVal(SCIP *scip, SCIP_PTRARRAY *ptrarray, int idx, void *val)
int SCIPexprGetNChildren(SCIP_EXPR *expr)
SCIP_Bool SCIPisExprProduct(SCIP *scip, SCIP_EXPR *expr)
SCIP_RETCODE SCIPgetExprMonomialData(SCIP *scip, SCIP_EXPR *expr, SCIP_Real *coef, SCIP_Real *exponents, SCIP_EXPR **factors)
SCIP_RETCODE SCIPreleaseExpr(SCIP *scip, SCIP_EXPR **expr)
SCIP_RETCODE SCIPprintExpr(SCIP *scip, SCIP_EXPR *expr, FILE *file)
void SCIPcaptureExpr(SCIP_EXPR *expr)
#define SCIPfreeBlockMemoryArray(scip, ptr, num)
#define SCIPallocClearBlockMemory(scip, ptr)
#define SCIPallocClearBlockMemoryArray(scip, ptr, num)
#define SCIPallocBlockMemoryArray(scip, ptr, num)
#define SCIPfreeBlockMemory(scip, ptr)
#define SCIPfreeBlockMemoryArrayNull(scip, ptr, num)
#define SCIPallocBlockMemory(scip, ptr)
SCIP_NLHDLRDATA * SCIPnlhdlrGetData(SCIP_NLHDLR *nlhdlr)
void SCIPnlhdlrSetFreeExprData(SCIP_NLHDLR *nlhdlr,)
const char * SCIPnlhdlrGetName(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_Real SCIPgetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var)
SCIP_Bool SCIPisRelEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisPositive(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisGT(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 SCIPvarGetUbLocal(SCIP_VAR *var)
const char * SCIPvarGetName(SCIP_VAR *var)
SCIP_RETCODE SCIPreleaseVar(SCIP *scip, SCIP_VAR **var)
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
SCIP_RETCODE SCIPcaptureVar(SCIP *scip, SCIP_VAR *var)
SCIP_VAR ** SCIProwprepGetVars(SCIP_ROWPREP *rowprep)
SCIP_Real SCIProwprepGetSide(SCIP_ROWPREP *rowprep)
SCIP_RETCODE SCIPensureRowprepSize(SCIP *scip, SCIP_ROWPREP *rowprep, int size)
SCIP_Real * SCIProwprepGetCoefs(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)
SCIP_RETCODE SCIPcreateRowprep(SCIP *scip, SCIP_ROWPREP **rowprep, SCIP_SIDETYPE sidetype, SCIP_Bool local)
int SCIProwprepGetNVars(SCIP_ROWPREP *rowprep)
void SCIProwprepAddSide(SCIP_ROWPREP *rowprep, SCIP_Real side)
void SCIPfreeRowprep(SCIP *scip, SCIP_ROWPREP **rowprep)
assert(minobj< SCIPgetCutoffbound(scip))
#define BMSclearMemory(ptr)
#define NLHDLR_DETECTPRIORITY
#define NLHDLR_MAXNUNDERVARS
#define NLHDLR_ENFOPRIORITY
#define NLHDLR_MINCUTSCALE
signomial nonlinear handler
preparation of a linear inequality to become a SCIP_ROW
public functions of nonlinear handlers of nonlinear constraints
static void printSignomial(SCIP *scip, FILE *file, char *linebuffer, int *linecnt, SCIP_EXPR *expr, SCIP_Real coef, SCIP_Bool needsign)
public functions to work with algebraic expressions
#define SCIP_DECL_NLHDLREVALAUX(x)
#define SCIP_DECL_NLHDLRESTIMATE(x)
struct SCIP_NlhdlrData SCIP_NLHDLRDATA
#define SCIP_NLHDLR_METHOD_SEPABOTH
#define SCIP_DECL_NLHDLRCOPYHDLR(x)
#define SCIP_DECL_NLHDLRFREEEXPRDATA(x)
#define SCIP_DECL_NLHDLRDETECT(x)
#define SCIP_DECL_NLHDLRFREEHDLRDATA(x)
struct SCIP_NlhdlrExprData SCIP_NLHDLREXPRDATA
enum SCIP_Retcode SCIP_RETCODE