49#define POWEXPRHDLR_NAME "pow"
50#define POWEXPRHDLR_DESC "power expression"
51#define POWEXPRHDLR_PRECEDENCE 55000
52#define POWEXPRHDLR_HASHKEY SCIPcalcFibHash(21163.0)
54#define SIGNPOWEXPRHDLR_NAME "signpower"
55#define SIGNPOWEXPRHDLR_DESC "signed power expression"
56#define SIGNPOWEXPRHDLR_PRECEDENCE 56000
57#define SIGNPOWEXPRHDLR_HASHKEY SCIPcalcFibHash(21163.1)
59#define INITLPMAXPOWVAL 1e+06
70#define SIGN(x) ((x) >= 0.0 ? 1.0 : -1.0)
72#define SIGNPOW_ROOTS_KNOWN 10
81 0.41421356237309504880,
83 0.56042566045031785945,
84 0.60582958618826802099,
85 0.64146546982884663257,
86 0.67033204760309682774,
87 0.69428385661425826738,
88 0.71453772716733489700,
89 0.73192937842370733350
93struct SCIP_ExprhdlrData
95 SCIP_Real minzerodistance;
96 SCIP_Bool warnedonpole;
137 *root = 0.39821689389382575186;
146 else if( exponent <= 2.0 )
153 polyval = (exponent - 1.0) *
pow(*root, exponent) + exponent *
pow(*root, exponent - 1.0) - 1.0;
158 gradval = (exponent - 1.0) * exponent * (
pow(*root, exponent - 1.0) +
pow(*root, exponent - 2.0));
199 polyval = (exponent - 1.0) *
pow(*root, exponent) - exponent *
pow(*root, exponent - 1.0) + 1.0;
204 gradval = (exponent - 1.0) * exponent * (
pow(*root, exponent - 1.0) -
pow(*root, exponent - 2.0));
237 (*exprdata)->exponent = exponent;
334 *constant =
pow(
xlb, exponent);
346 *constant =
pow(
xlb, exponent);
353 else if(
xlb == 0.0 && exponent > 0.0 )
356 *slope =
pow(
xub, exponent-1.0);
359 else if(
xub == 0.0 && exponent > 0.0 )
366 *slope =
pow(-
xlb, exponent-1.0);
368 *slope =
pow(
xlb, exponent-1.0);
410 *slope = 0.5*exponent * ((3.0-exponent) *
xlb_n1 + (exponent-1.0) *
xlb_n2 *
xub);
411 *constant = (1.0 - 0.5*exponent*(3.0-exponent)) *
xlb_n - 0.5*exponent*(exponent-1.0) *
xlb_n1 *
xub;
485 SCIP_Bool overestimate,
501 assert((exponent >= 0.0 &&
EPSISINT(exponent/2.0, 0.0)) || (exponent > 1.0 &&
xlb >= 0.0));
553 SCIP_Bool overestimate,
563 SCIP_Bool* branchcand,
701 SCIP_Bool overestimate,
711 SCIP_Bool* branchcand,
730 if(
xlb >= 0.0 ||
xub <= 0.0 )
737 else if(
xref > 0.0 &&
xub <= 0.0 )
912 SCIP_Bool overestimate,
922 SCIP_Bool* branchcand,
1017 SCIP_Bool overestimate,
1021 SCIP_Real* constant,
1077 SCIP_Bool overestimate,
1086 SCIP_Real* constant,
1090 SCIP_Bool* branchcand
1094 SCIP_Bool isinteger;
1105 isinteger =
EPSISINT(exponent, 0.0);
1108 if( exponent == 2.0 )
1125 *branchcand =
FALSE;
1128 else if( exponent > 0.0 &&
iseven )
1134 else if( exponent > 1.0 &&
childlb >= 0.0 )
1162 else if( exponent > 1.0 )
1182 else if( exponent < 0.0 )
1251 SCIP_Bool underestimate,
1267 lb = -ub * exprdata->root - 1.0;
1269 ub = -lb * exprdata->root + 1.0;
1277 if( -lb * exprdata->root < ub - 2.0 )
1279 if( -lb * exprdata->root < ub - 4.0 )
1280 refpoints[1] = (-lb * exprdata->root + ub) / 2.0;
1283 if( !underestimate )
1289 if( -ub * exprdata->root > lb + 2.0 )
1291 if( -ub * exprdata->root > lb + 4.0 )
1292 refpoints[1] = (lb - ub * exprdata->root) / 2.0;
1307 SCIP_Bool underestimate,
1308 SCIP_Bool overestimate
1321 exponent = exprdata->exponent;
1339 else if( ub <= 0 || (exponent > 0.0 && exponent < 1.0) )
1425 SCIPdebugPrintf(
"[simplifyPow] simplifying power with expo %g\n", exponent);
1428 if( exponent == 0.0 )
1438 if( exponent == 1.0 )
1466 if(
baseval != 0.0 || exponent > 0.0 )
1571 SCIPdebugPrintf(
"[simplifyPow] seeing a sum with one term, exponent %g\n", exponent);
1615 for(
i = 0;
i < nchildren; ++
i )
1623 for(
j = 0;
j <
i; ++
j )
1645 for(
i = 0;
i < nchildren; ++
i )
1652 constant *= constant;
1687 SCIPdebugPrintf(
"[simplifyPow] seeing a sum with one term, exponent %g\n", exponent);
1852 assert(currentchild == 0);
1861 if( exponent >= 0.0 )
1962 if( exponent > 0.0 && exponent < 2.0 &&
SCIPexprGetEvalValue(child) == 0.0 && exponent != 1.0 )
1993 if( exponent > 0.0 && exponent < 1.0 &&
childval == 0.0 )
2015 if( exponent < 0.0 )
2029 "Check your model formulation or use option expr/" POWEXPRHDLR_NAME "/minzerodistance to avoid this warning.\n",
2044 "Check your model formulation or use option expr/" POWEXPRHDLR_NAME "/minzerodistance to avoid this warning.\n",
2082 SCIP_Bool isinteger;
2113 exponent = exprdata->exponent;
2114 assert(exponent != 1.0 && exponent != 0.0);
2124 *
islocal = globalbounds[0].inf != globalbounds[0].sup;
2125 *branchcand =
FALSE;
2129 isinteger =
EPSISINT(exponent, 0.0);
2132 if( !isinteger &&
childlb < 0.0 )
2164 SCIPdebugMsg(
scip,
"reverseprop x^%g in [%.15g,%.15g], x = [%.15g,%.15g]", exponent, bounds.inf, bounds.sup,
2192 if( exponent < 0.0 )
2210 "Check your model formulation or use option expr/" POWEXPRHDLR_NAME "/minzerodistance to avoid this warning.\n",
2224 "Check your model formulation or use option expr/" POWEXPRHDLR_NAME "/minzerodistance to avoid this warning.\n",
2252 SCIP_Bool isinteger;
2253 SCIP_Bool branchcand;
2278 exponent = exprdata->exponent;
2279 assert(exponent != 1.0 && exponent != 0.0);
2281 isinteger =
EPSISINT(exponent, 0.0);
2284 if( !isinteger &&
childlb < 0.0 )
2320 SCIPdebugMsg(
scip,
"initestimate x^%g for base in [%g,%g] at ref=%g, over:%u -> %g*x+%g\n", exponent,
2408 if( exponent >= 0.0 )
2412 else if( inf >= 0.0 || sup <= 0.0 )
2421 else if( sup <= 0.0 )
2451 *isintegral =
FALSE;
2465 *isintegral =
expisint && exponent >= 0.0;
2487 SCIPdebugPrintf(
"[simplifySignpower] simplifying power with expo %g\n", exponent);
2491 if( exponent == 1.0 )
2545 if(
EPSISINT(exponent, 0.0) && ((
int)exponent) % 2 == 1 )
2596 assert(((
int)exponent) % 2 == 0 );
2617 SCIPdebugPrintf(
"[simplifySignpower] seeing a sum with one term, exponent %g\n", exponent);
2672 assert(currentchild == 0);
2705 while( *
string ==
' ' )
2708 if( *
string !=
',' )
2717 SCIPerrorMessage(
"Expected numeric exponent for second argument of signpower().\n");
2838 SCIPdebugMsg(
scip,
"%sestimation of signed x^%g at x=%g\n", overestimate ?
"over" :
"under",
2852 exponent = exprdata->exponent;
2864 *branchcand =
FALSE;
2914 SCIP_Bool branchcand;
2939 exponent = exprdata->exponent;
3012 SCIPdebugMsg(
scip,
"reverseprop signpow(x,%g) in [%.15g,%.15g]", exponent, bounds.inf, bounds.sup);
3138 "minimal distance from zero to enforce for child in bound tightening",
3249 if( sqrcoef == 0.0 )
3272 *lincoef += 2.0 *
tmp;
3287 coef = sqrcoef * (2.0 * f + 1.0);
3288 constant = -sqrcoef * f * (f + 1.0);
3323 if( sqrcoef == 0.0 )
3336 coef = sqrcoef * (lb + ub);
3337 constant = -sqrcoef * lb * ub;
3362 return exprdata->exponent;
#define SCIP_INTERVAL_INFINITY
absolute expression handler
exponential expression handler
#define SIGNPOWEXPRHDLR_PRECEDENCE
#define POWEXPRHDLR_PRECEDENCE
void SCIPaddSquareLinearization(SCIP *scip, SCIP_Real sqrcoef, SCIP_Real refpoint, SCIP_Bool isint, SCIP_Real *lincoef, SCIP_Real *linconstant, SCIP_Bool *success)
static SCIP_RETCODE chooseRefpointsPow(SCIP *scip, SCIP_EXPRDATA *exprdata, SCIP_Real lb, SCIP_Real ub, SCIP_Real *refpointsunder, SCIP_Real *refpointsover, SCIP_Bool underestimate, SCIP_Bool overestimate)
static void estimateSignedpower(SCIP *scip, SCIP_Real exponent, SCIP_Real root, SCIP_Bool overestimate, SCIP_Real xlb, SCIP_Real xub, SCIP_Real xref, SCIP_Real xlbglobal, SCIP_Real xubglobal, SCIP_Real *constant, SCIP_Real *slope, SCIP_Bool *islocal, SCIP_Bool *branchcand, SCIP_Bool *success)
static void computeTangent(SCIP *scip, SCIP_Bool signpower, SCIP_Real exponent, SCIP_Real xref, SCIP_Real *constant, SCIP_Real *slope, SCIP_Bool *success)
#define SIGNPOWEXPRHDLR_NAME
static void estimateRoot(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)
#define SIGNPOWEXPRHDLR_HASHKEY
static SCIP_RETCODE buildPowEstimator(SCIP *scip, SCIP_EXPRDATA *exprdata, SCIP_Bool overestimate, SCIP_Real childlb, SCIP_Real childub, SCIP_Real childglb, SCIP_Real childgub, SCIP_Bool childintegral, SCIP_Real refpoint, SCIP_Real exponent, SCIP_Real *coef, SCIP_Real *constant, SCIP_Bool *success, SCIP_Bool *islocal, SCIP_Bool *branchcand)
static void estimateParabola(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)
static SCIP_RETCODE createData(SCIP *scip, SCIP_EXPRDATA **exprdata, SCIP_Real exponent)
void SCIPaddSquareSecant(SCIP *scip, SCIP_Real sqrcoef, SCIP_Real lb, SCIP_Real ub, SCIP_Real *lincoef, SCIP_Real *linconstant, SCIP_Bool *success)
static SCIP_RETCODE addSignpowerRefpoints(SCIP *scip, SCIP_EXPRDATA *exprdata, SCIP_Real lb, SCIP_Real ub, SCIP_Real exponent, SCIP_Bool underestimate, SCIP_Real *refpoints)
#define SIGNPOW_ROOTS_KNOWN
static void estimateHyperbolaPositive(SCIP *scip, SCIP_Real exponent, SCIP_Real root, SCIP_Bool overestimate, SCIP_Real xlb, SCIP_Real xub, SCIP_Real xref, SCIP_Real xlbglobal, SCIP_Real xubglobal, SCIP_Real *constant, SCIP_Real *slope, SCIP_Bool *islocal, SCIP_Bool *branchcand, SCIP_Bool *success)
#define POWEXPRHDLR_HASHKEY
static SCIP_RETCODE computeSignpowerRoot(SCIP *scip, SCIP_Real *root, SCIP_Real exponent)
static void estimateHyperbolaMixed(SCIP *scip, SCIP_Real exponent, SCIP_Bool overestimate, SCIP_Real xlb, SCIP_Real xub, SCIP_Real xref, SCIP_Real xlbglobal, SCIP_Real xubglobal, SCIP_Real *constant, SCIP_Real *slope, SCIP_Bool *islocal, SCIP_Bool *branchcand, SCIP_Bool *success)
#define SIGNPOWEXPRHDLR_DESC
static void addTangentRefpoints(SCIP *scip, SCIP_Real exponent, SCIP_Real lb, SCIP_Real ub, SCIP_Real *refpoints)
static SCIP_RETCODE computeHyperbolaRoot(SCIP *scip, SCIP_Real *root, SCIP_Real exponent)
static SCIP_Real signpow_roots[SIGNPOW_ROOTS_KNOWN+1]
static void computeSecant(SCIP *scip, SCIP_Bool signpower, SCIP_Real exponent, SCIP_Real xlb, SCIP_Real xub, SCIP_Real *constant, SCIP_Real *slope, SCIP_Bool *success)
power and signed power expression handlers
product expression handler
constant value expression handler
SCIP_RETCODE SCIPcreateExprProduct(SCIP *scip, SCIP_EXPR **expr, int nchildren, SCIP_EXPR **children, SCIP_Real coefficient, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)
SCIP_RETCODE SCIPcreateExprAbs(SCIP *scip, SCIP_EXPR **expr, SCIP_EXPR *child, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)
SCIP_RETCODE SCIPcreateExprSignpower(SCIP *scip, SCIP_EXPR **expr, SCIP_EXPR *child, SCIP_Real exponent, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)
SCIP_Bool SCIPisExprExp(SCIP *scip, SCIP_EXPR *expr)
SCIP_RETCODE SCIPcreateExprExp(SCIP *scip, SCIP_EXPR **expr, SCIP_EXPR *child, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)
SCIP_Bool SCIPisExprSignpower(SCIP *scip, SCIP_EXPR *expr)
SCIP_RETCODE SCIPcreateExprSum(SCIP *scip, SCIP_EXPR **expr, int nchildren, SCIP_EXPR **children, SCIP_Real *coefficients, SCIP_Real constant, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)
SCIP_RETCODE SCIPcreateExprValue(SCIP *scip, SCIP_EXPR **expr, SCIP_Real value, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)
SCIP_RETCODE SCIPcreateExprPow(SCIP *scip, SCIP_EXPR **expr, SCIP_EXPR *child, SCIP_Real exponent, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)
SCIP_RETCODE SCIPincludeExprhdlrSignpower(SCIP *scip)
SCIP_RETCODE SCIPincludeExprhdlrPow(SCIP *scip)
void SCIPinfoMessage(SCIP *scip, FILE *file, const char *formatstr,...)
SCIP_VERBLEVEL SCIPgetVerbLevel(SCIP *scip)
#define SCIPdebugMsgPrint
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)
const char * SCIPexprhdlrGetName(SCIP_EXPRHDLR *exprhdlr)
void SCIPexprhdlrSetCompare(SCIP_EXPRHDLR *exprhdlr,)
void SCIPexprhdlrSetIntegrality(SCIP_EXPRHDLR *exprhdlr,)
void SCIPexprhdlrSetCurvature(SCIP_EXPRHDLR *exprhdlr,)
void SCIPexprhdlrSetParse(SCIP_EXPRHDLR *exprhdlr,)
SCIP_EXPRHDLRDATA * SCIPexprhdlrGetData(SCIP_EXPRHDLR *exprhdlr)
void SCIPexprhdlrSetIntEval(SCIP_EXPRHDLR *exprhdlr,)
void SCIPexprhdlrSetMonotonicity(SCIP_EXPRHDLR *exprhdlr,)
void SCIPexprhdlrSetReverseProp(SCIP_EXPRHDLR *exprhdlr,)
void SCIPexprhdlrSetHash(SCIP_EXPRHDLR *exprhdlr,)
SCIP_RETCODE SCIPincludeExprhdlr(SCIP *scip, SCIP_EXPRHDLR **exprhdlr, const char *name, const char *desc, unsigned int precedence, SCIP_DECL_EXPREVAL((*eval)), SCIP_EXPRHDLRDATA *data)
void SCIPexprhdlrSetSimplify(SCIP_EXPRHDLR *exprhdlr,)
void SCIPexprhdlrSetDiff(SCIP_EXPRHDLR *exprhdlr, SCIP_DECL_EXPRBWDIFF((*bwdiff)), SCIP_DECL_EXPRFWDIFF((*fwdiff)),)
void SCIPexprhdlrSetCopyFreeHdlr(SCIP_EXPRHDLR *exprhdlr, SCIP_DECL_EXPRCOPYHDLR((*copyhdlr)),)
SCIP_EXPRHDLR * SCIPgetExprhdlrPower(SCIP *scip)
void SCIPexprhdlrSetPrint(SCIP_EXPRHDLR *exprhdlr,)
SCIP_EXPRHDLR * SCIPfindExprhdlr(SCIP *scip, const char *name)
void SCIPexprhdlrSetCopyFreeData(SCIP_EXPRHDLR *exprhdlr, SCIP_DECL_EXPRCOPYDATA((*copydata)),)
void SCIPexprhdlrSetEstimate(SCIP_EXPRHDLR *exprhdlr, SCIP_DECL_EXPRINITESTIMATES((*initestimates)),)
SCIP_RETCODE SCIPcreateExpr(SCIP *scip, SCIP_EXPR **expr, SCIP_EXPRHDLR *exprhdlr, SCIP_EXPRDATA *exprdata, int nchildren, SCIP_EXPR **children, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)
SCIP_RETCODE SCIPappendExprChild(SCIP *scip, SCIP_EXPR *expr, SCIP_EXPR *child)
void SCIPexprSetData(SCIP_EXPR *expr, SCIP_EXPRDATA *exprdata)
int SCIPexprGetNChildren(SCIP_EXPR *expr)
SCIP_Real SCIPgetExponentExprPow(SCIP_EXPR *expr)
SCIP_Bool SCIPisExprProduct(SCIP *scip, SCIP_EXPR *expr)
SCIP_EXPRCURV SCIPexprcurvPowerInv(SCIP_INTERVAL basebounds, SCIP_Real exponent, SCIP_EXPRCURV powercurv)
SCIP_Bool SCIPisExprSum(SCIP *scip, SCIP_EXPR *expr)
SCIP_Bool SCIPexprIsIntegral(SCIP_EXPR *expr)
SCIP_Real * SCIPgetCoefsExprSum(SCIP_EXPR *expr)
SCIP_Bool SCIPisExprValue(SCIP *scip, SCIP_EXPR *expr)
int SCIPcompareExpr(SCIP *scip, SCIP_EXPR *expr1, SCIP_EXPR *expr2)
SCIP_RETCODE SCIPreleaseExpr(SCIP *scip, SCIP_EXPR **expr)
SCIP_Real SCIPexprGetDot(SCIP_EXPR *expr)
SCIP_Bool SCIPisExprVar(SCIP *scip, SCIP_EXPR *expr)
SCIP_EXPRDATA * SCIPexprGetData(SCIP_EXPR *expr)
SCIP_RETCODE SCIPparseExpr(SCIP *scip, SCIP_EXPR **expr, const char *exprstr, const char **finalpos, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)
SCIP_RETCODE SCIPprintExpr(SCIP *scip, SCIP_EXPR *expr, FILE *file)
SCIP_Real SCIPgetValueExprValue(SCIP_EXPR *expr)
SCIP_Bool SCIPisExprPower(SCIP *scip, SCIP_EXPR *expr)
SCIP_Real SCIPexprGetEvalValue(SCIP_EXPR *expr)
SCIP_EXPR ** SCIPexprGetChildren(SCIP_EXPR *expr)
SCIP_Real SCIPgetConstantExprSum(SCIP_EXPR *expr)
SCIP_VAR * SCIPgetVarExprVar(SCIP_EXPR *expr)
SCIP_INTERVAL SCIPexprGetActivity(SCIP_EXPR *expr)
void SCIPcaptureExpr(SCIP_EXPR *expr)
SCIP_RETCODE SCIPevalExprActivity(SCIP *scip, SCIP_EXPR *expr)
SCIP_EXPRHDLR * SCIPexprGetHdlr(SCIP_EXPR *expr)
SCIP_Real SCIPintervalGetInf(SCIP_INTERVAL interval)
SCIP_Bool SCIPintervalIsEntire(SCIP_Real infinity, SCIP_INTERVAL operand)
void SCIPintervalSignPowerScalar(SCIP_Real infinity, SCIP_INTERVAL *resultant, SCIP_INTERVAL operand1, SCIP_Real operand2)
void SCIPintervalUnify(SCIP_INTERVAL *resultant, SCIP_INTERVAL operand1, SCIP_INTERVAL operand2)
void SCIPintervalSet(SCIP_INTERVAL *resultant, SCIP_Real value)
SCIP_Bool SCIPintervalIsEmpty(SCIP_Real infinity, SCIP_INTERVAL operand)
void SCIPintervalPowerScalarInverse(SCIP_Real infinity, SCIP_INTERVAL *resultant, SCIP_INTERVAL basedomain, SCIP_Real exponent, SCIP_INTERVAL image)
void SCIPintervalSetBounds(SCIP_INTERVAL *resultant, SCIP_Real inf, SCIP_Real sup)
void SCIPintervalReciprocal(SCIP_Real infinity, SCIP_INTERVAL *resultant, SCIP_INTERVAL operand)
void SCIPintervalPowerScalar(SCIP_Real infinity, SCIP_INTERVAL *resultant, SCIP_INTERVAL operand1, SCIP_Real operand2)
SCIP_Real SCIPintervalGetSup(SCIP_INTERVAL interval)
void SCIPintervalSetEmpty(SCIP_INTERVAL *resultant)
#define SCIPallocClearBlockMemory(scip, ptr)
#define SCIPallocBufferArray(scip, ptr, num)
#define SCIPfreeBufferArray(scip, ptr)
#define SCIPfreeBlockMemory(scip, ptr)
#define SCIPallocBlockMemory(scip, ptr)
SCIP_Bool SCIPisGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisIntegral(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisFeasEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisPositive(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisFeasZero(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPfloor(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisNegative(SCIP *scip, SCIP_Real val)
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 SCIPparseReal(SCIP *scip, const char *str, SCIP_Real *value, char **endptr)
SCIP_Bool SCIPvarIsBinary(SCIP_VAR *var)
assert(minobj< SCIPgetCutoffbound(scip))
public functions to work with algebraic expressions
#define SCIP_DECL_EXPR_OWNERCREATE(x)
#define SCIP_DECL_EXPRREVERSEPROP(x)
#define SCIP_DECL_EXPRINITESTIMATES(x)
#define SCIP_DECL_EXPRBWFWDIFF(x)
#define SCIP_DECL_EXPRCURVATURE(x)
struct SCIP_ExprhdlrData SCIP_EXPRHDLRDATA
struct SCIP_ExprData SCIP_EXPRDATA
#define SCIP_DECL_EXPRFREEDATA(x)
#define SCIP_EXPR_MAXINITESTIMATES
#define SCIP_DECL_EXPRPARSE(x)
#define SCIP_DECL_EXPRBWDIFF(x)
#define SCIP_DECL_EXPRINTEVAL(x)
#define SCIP_DECL_EXPRMONOTONICITY(x)
#define SCIP_EXPRITER_VISITINGCHILD
#define SCIP_DECL_EXPRCOMPARE(x)
#define SCIP_DECL_EXPRSIMPLIFY(x)
#define SCIP_DECL_EXPREVAL(x)
#define SCIP_DECL_EXPRFWDIFF(x)
#define SCIP_DECL_EXPRHASH(x)
#define SCIP_DECL_EXPRCOPYHDLR(x)
#define SCIP_DECL_EXPRPRINT(x)
#define SCIP_DECL_EXPRFREEHDLR(x)
#define SCIP_DECL_EXPRINTEGRALITY(x)
#define SCIP_EXPRITER_VISITEDCHILD
#define SCIP_DECL_EXPRCOPYDATA(x)
#define SCIP_EXPRITER_LEAVEEXPR
#define SCIP_DECL_EXPRESTIMATE(x)
#define SCIP_EXPRITER_ENTEREXPR
enum SCIP_Retcode SCIP_RETCODE