51#define EXPRHDLR_NAME "prod"
52#define EXPRHDLR_DESC "product expression"
53#define EXPRHDLR_PRECEDENCE 50000
54#define EXPRHDLR_HASHKEY SCIPcalcFibHash(54949.0)
61#define debugSimplify printf
63#define debugSimplify while( FALSE ) printf
76 SCIP_Real coefficient;
79struct SCIP_ExprhdlrData
83 SCIP_Bool expandalways;
104 SCIP_Real ret = *(SCIP_Real*)funcdata;
107 for(
i = 0;
i < nargs; ++
i )
116 SCIP_Real simplifiedcoef,
118 SCIP_Bool expandalways,
122 void* ownercreatedata
137 newnode->
next = *list;
155 *list = (*list)->
next;
189 (*newnode)->expr =
expr;
190 (*newnode)->next =
NULL;
210 debugSimplify(
"building expr list from %d expressions\n", nexprs);
211 for(
i = nexprs - 1;
i >= 0; --
i )
247 if( *exprlist ==
NULL )
251 while( current !=
NULL )
256 current = current->
next;
275 void* ownercreatedata
288 for(
i = 0;
i < nchildren; ++
i )
290 children[
i] = exprlist->
expr;
291 exprlist = exprlist->
next;
315 SCIP_Real* simplifiedcoef,
340 debugSimplify(
"[simplifyFactor] seeing a product: include its children\n");
354 debugSimplify(
"[simplifyFactor] seeing a sum of the form coef * child : take coef and child apart\n");
400 void* ownercreatedata
407 if( tomerge ==
NULL )
410 if( *finalchildren ==
NULL )
412 *finalchildren = tomerge;
416 tomergenode = tomerge;
417 current = *finalchildren;
420 while( tomergenode !=
NULL && current !=
NULL )
428 SCIP_Bool issignpower1;
429 SCIP_Bool issignpower2;
460 SCIP_CALL( SCIPcallExprSimplify(
scip, sum, &simplifiedsum, ownercreate, ownercreatedata) );
468 SCIP_CALL( SCIPcallExprSimplify(
scip, expexpr, &simplifiedexp, ownercreate, ownercreatedata) );
478 tomergenode->
expr = simplifiedexp;
482 tomergenode = tomergenode->
next;
486 if( current == *finalchildren )
491 current = *finalchildren;
497 current = current->
next;
498 previous->
next = current;
510 issignpower1 =
FALSE;
520 base1 = current->
expr;
522 issignpower1 =
FALSE;
528 issignpower2 =
FALSE;
538 base2 = tomergenode->
expr;
540 issignpower2 =
FALSE;
548 if( !issignpower1 && !issignpower2 )
562 else if( issignpower1 ^ issignpower2 )
567 if( (
int)expo2 % 2 == 0 )
586 else if( !
EPSISINT(expo1+expo2, 0.0) )
600 if(
EPSISINT(expo1+expo2, 0.0) && (
int)(expo1+expo2)%2 == 0 )
620 SCIP_CALL( SCIPcallExprSimplify(
scip, power, &simplifiedpower, ownercreate, ownercreatedata) );
625 tomergenode->
expr = simplifiedpower;
631 tomergenode = tomergenode->
next;
635 if( current == *finalchildren )
640 current = *finalchildren;
646 current = current->
next;
647 previous->
next = current;
661 if( compareres == -1 )
665 current = current->
next;
673 if( current == *finalchildren )
677 tomergenode = tomergenode->
next;
679 previous = *finalchildren;
686 tomergenode = tomergenode->
next;
688 previous->
next = aux;
696 if( tomergenode ==
NULL )
704 if( *finalchildren ==
NULL )
707 *finalchildren = tomergenode;
713 previous->
next = tomergenode;
727 SCIP_Real* simplifiedcoef,
731 void* ownercreatedata
739 unsimplifiedchildren =
NULL;
745 *finalchildren =
NULL;
746 while( unsimplifiedchildren !=
NULL )
771 if( *simplifiedcoef == 0.0 )
791 SCIP_Real simplifiedcoef,
795 void* ownercreatedata
799 if( finalchildren ==
NULL )
806 if( finalchildren->
next ==
NULL && simplifiedcoef == 1.0 )
808 *simplifiedexpr = finalchildren->
expr;
823 SCIP_CALL( SCIPcallExprSimplify(
scip, sum, simplifiedexpr, ownercreate, ownercreatedata) );
835 SCIP_Real simplifiedcoef,
839 void* ownercreatedata
852 entropicchild = finalchildren->
next->
expr;
859 entropicchild = finalchildren->
expr;
863 if( entropicchild !=
NULL )
867 simplifiedcoef *= -1.0;
872 if( simplifiedcoef != 1.0 )
878 *simplifiedexpr = entropy;
896 SCIP_Real simplifiedcoef,
898 SCIP_Bool expandalways,
901 void* ownercreatedata
935 for(
i = 0;
i < nchildren2; ++
i )
955 for(
i = 0;
i < nchildren1; ++
i )
971 for( j = 0; j < nchildren1; ++j )
978 for( k = 0; k < nchildren2; ++k )
981 SCIP_Real factorscoef;
990 debugSimplify(
"multiplying %g expr1 * %g expr2\n", coef1, coef2);
999 factorscoef = coef1 * coef2;
1001 assert(factorscoef != 0.0);
1003#ifdef SIMPLIFY_DEBUG
1008 debugSimplify(
"Building product from simplified factors\n");
1009 node = finalfactors;
1011 while( node !=
NULL )
1026#ifdef SIMPLIFY_DEBUG
1027 debugSimplify(
"%g expr1 * %g expr2 = %g * product\n", coef1, coef2, coef1 * coef2);
1040 SCIP_CALL( SCIPcallExprSimplify(
scip, expanded, simplifiedexpr, ownercreate, ownercreatedata) );
1059 sum = finalchildren->
expr;
1060 factors[0] = finalchildren->
next->
expr;
1066 factors[0] = finalchildren->
expr;
1074 for( j = 0; j < nchildren; ++j )
1098 SCIP_CALL( SCIPcallExprSimplify(
scip, expanded, simplifiedexpr, ownercreate, ownercreatedata) );
1113 SCIP_Real simplifiedcoef,
1117 void* ownercreatedata
1129 for( n = finalchildren; n !=
NULL; n = n->
next )
1133 if( sum_node ==
NULL )
1143 if( sum_node ==
NULL || nfactors == 0 )
1148 for( n = finalchildren, j = 0; n !=
NULL; n = n->
next )
1150 factors[j++] = n->
expr;
1165 SCIP_Real termcoef = 1.0;
1182 for( j = 0; j < nchildren; ++j )
1206 SCIP_CALL( SCIPcallExprSimplify(
scip, expanded, simplifiedexpr, ownercreate, ownercreatedata) );
1221 SCIP_Real simplifiedcoef,
1223 SCIP_Bool expandalways,
1227 void* ownercreatedata
1230 EXPRNODE* finalchildren = *simplifiedfactors;
1235 *simplifiedexpr =
NULL;
1238 if( *simplifiedexpr !=
NULL )
1241 SCIP_CALL(
enforceSP12(
scip, simplifiedcoef, *simplifiedfactors, expandalways, simplifiedexpr, ownercreate, ownercreatedata) );
1242 if( *simplifiedexpr !=
NULL )
1248 if( *simplifiedexpr !=
NULL )
1253 if( *simplifiedexpr !=
NULL )
1257 if( simplifiedcoef != 1.0 )
1268 SCIP_CALL( SCIPcallExprSimplify(
scip, sum, simplifiedexpr, ownercreate, ownercreatedata) );
1297 SCIP_Real constantfactor,
1298 SCIP_Real* refpoint,
1299 SCIP_Bool overestimate,
1300 SCIP_Real targetvalue,
1302 SCIP_Real* constant,
1314 assert(constantfactor != 0.0);
1324 for(
i = 0, nfixed = 0;
i < nfactors; ++
i )
1334 box[2*
i] = bounds[
i].
inf;
1335 box[2*
i+1] = bounds[
i].
sup;
1337 xstar[
i] = refpoint !=
NULL ? refpoint[
i] : 0.5 * (box[2*
i] + box[2*
i+1]);
1346 overestimate, prodfunction, &constantfactor, xstar, box, nfactors, targetvalue, success, coefs, constant) );
1379 SCIP_Real simplifiedcoef;
1387#ifdef SIMPLIFY_DEBUG
1396 &finalchildren, &changed, ownercreate, ownercreatedata) );
1398#ifdef SIMPLIFY_DEBUG
1403 debugSimplify(
"Building product from simplified factors\n");
1404 node = finalchildren;
1406 while( node !=
NULL )
1422 if( *simplifiedexpr ==
NULL )
1424 *simplifiedexpr =
expr;
1464 for(
i = nchildren1 - 1, j = nchildren2 - 1;
i >= 0 && j >= 0; --
i, --j )
1467 if( compareresult != 0 )
1468 return compareresult;
1578 if( exprdata->coefficient != 1.0 )
1595 if( exprdata->coefficient != 1.0 || currentchild > 0 )
1644 *hashkey ^= childrenhashes[
c];
1662 *val = exprdata->coefficient;
1780 if(
i ==
c ||
i == childidx )
1915 SCIPdebugMsg(
scip,
"child %d = %g in [%g, %g]\n",
c, refpoint[
c], localbounds[
c].inf, localbounds[
c].sup);
1927 if( nchildren == 2 )
1929 SCIP_Real refpointx;
1930 SCIP_Real refpointy;
1935 refpointx = refpoint[0];
1936 bndx = localbounds[0];
1940 refpointy = refpoint[1];
1941 bndy = localbounds[1];
1954 bndy.
inf, bndy.
sup, refpointy, overestimate, &coefs[0], &coefs[1], constant,
1964 if( exprhdlrdata->conshdlr !=
NULL )
1967 targetvalue, coefs, constant, success) );
1971 SCIPdebugMsg(
scip,
"no cons_nonlinear included in SCIP, cannot estimate vertex-polyhedral product function\n");
1983 SCIP_Bool success =
TRUE;
1996 if( nchildren == 2 )
2007 bndy.
inf, bndy.
sup, (bndy.
inf + bndy.
sup ) / 2.0, overestimate, &coefs[0][0], &coefs[0][1],
2008 constant, &success);
2017 if( exprhdlrdata->conshdlr !=
NULL )
2024 SCIPdebugMsg(
scip,
"no cons_nonlinear included in SCIP, cannot estimate vertex-polyhedral product function\n");
2051 *infeasible =
FALSE;
2081 childbounds = childrenbounds[j];
2091 childbounds = childrenbounds[
i];
2101 SCIPdebugMsg(
scip,
"child %d: solved [%g,%g]*x = [%g,%g] with x in [%g,%g] -> x = [%g,%g]\n",
i, otherfactor.
inf, otherfactor.
sup,
2102 bounds.inf, bounds.sup,
2103 childrenbounds[
i].inf, childrenbounds[
i].sup,
2104 childbounds.
inf, childbounds.
sup);
2205 *isintegral =
EPSISINT(exprdata->coefficient, 0.0);
2228 (*symdata)->nconstants = 1;
2229 (*symdata)->ncoefficients = 0;
2268 "whether to expand products of a sum and several factors in simplify",
2280 SCIP_Real coefficient,
2282 void* ownercreatedata
2289 exprdata->coefficient = coefficient;
2311 return exprdata->coefficient;
constraint handler for nonlinear constraints specified by algebraic expressions
#define SCIP_INTERVAL_INFINITY
absolute expression handler
handler for -x*log(x) expressions
exponential expression handler
power and signed power expression handlers
static SCIP_RETCODE buildSimplifiedProduct(SCIP *scip, SCIP_Real simplifiedcoef, EXPRNODE **simplifiedfactors, SCIP_Bool expandalways, SCIP_Bool changed, SCIP_EXPR **simplifiedexpr, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)
static int listLength(EXPRNODE *list)
static SCIP_RETCODE enforceSP11(SCIP *scip, SCIP_Real simplifiedcoef, EXPRNODE *finalchildren, SCIP_EXPR **simplifiedexpr, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)
static SCIP_RETCODE enforceSP12(SCIP *scip, SCIP_Real simplifiedcoef, EXPRNODE *finalchildren, SCIP_Bool expandalways, SCIP_EXPR **simplifiedexpr, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)
static SCIP_RETCODE enforceSP10(SCIP *scip, SCIP_Real simplifiedcoef, EXPRNODE *finalchildren, SCIP_EXPR **simplifiedexpr, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)
static SCIP_RETCODE simplifyFactor(SCIP *scip, SCIP_EXPR *factor, SCIP_Real *simplifiedcoef, EXPRNODE **simplifiedfactor, SCIP_Bool *changed)
static SCIP_RETCODE createExprProductFromExprlist(SCIP *scip, EXPRNODE *exprlist, SCIP_Real coef, SCIP_EXPR **expr, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)
static SCIP_RETCODE createExprNode(SCIP *scip, SCIP_EXPR *expr, EXPRNODE **newnode)
static EXPRNODE * listPopFirst(EXPRNODE **list)
static void insertFirstList(EXPRNODE *newnode, EXPRNODE **list)
static SCIP_RETCODE simplifyMultiplyChildren(SCIP *scip, SCIP_EXPR **exprs, int nexprs, SCIP_Real *simplifiedcoef, EXPRNODE **finalchildren, SCIP_Bool *changed, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)
static SCIP_RETCODE enforceSP12b(SCIP *scip, SCIP_Real simplifiedcoef, EXPRNODE *finalchildren, SCIP_EXPR **simplifiedexpr, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)
static SCIP_RETCODE freeExprlist(SCIP *scip, EXPRNODE **exprlist)
static SCIP_RETCODE freeExprNode(SCIP *scip, EXPRNODE **node)
#define EXPRHDLR_PRECEDENCE
static SCIP_RETCODE createExprlistFromExprs(SCIP *scip, SCIP_EXPR **exprs, int nexprs, EXPRNODE **list)
static SCIP_RETCODE mergeProductExprlist(SCIP *scip, EXPRNODE *tomerge, EXPRNODE **finalchildren, EXPRNODE **unsimplifiedchildren, SCIP_Bool *changed, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)
static SCIP_RETCODE estimateVertexPolyhedralProduct(SCIP *scip, SCIP_CONSHDLR *conshdlr, int nfactors, SCIP_INTERVAL *bounds, SCIP_Real constantfactor, SCIP_Real *refpoint, SCIP_Bool overestimate, SCIP_Real targetvalue, SCIP_Real *coefs, SCIP_Real *constant, SCIP_Bool *success)
product expression handler
constant value expression handler
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)
#define SCIP_MAXVERTEXPOLYDIM
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 SCIPappendExprSumExpr(SCIP *scip, SCIP_EXPR *expr, SCIP_EXPR *child, SCIP_Real childcoef)
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 SCIPcreateExprEntropy(SCIP *scip, SCIP_EXPR **expr, SCIP_EXPR *child, 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 SCIPincludeExprhdlrProduct(SCIP *scip)
void SCIPinfoMessage(SCIP *scip, FILE *file, const char *formatstr,...)
#define SCIPdebugMsgPrint
void SCIPaddBilinMcCormick(SCIP *scip, SCIP_Real bilincoef, SCIP_Real lbx, SCIP_Real ubx, SCIP_Real refpointx, SCIP_Real lby, SCIP_Real uby, SCIP_Real refpointy, SCIP_Bool overestimate, SCIP_Real *lincoefx, SCIP_Real *lincoefy, SCIP_Real *linconstant, SCIP_Bool *success)
unsigned int SCIPcalcFibHash(SCIP_Real v)
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)
SCIP_CONSHDLR * SCIPfindConshdlr(SCIP *scip, const char *name)
const char * SCIPexprhdlrGetName(SCIP_EXPRHDLR *exprhdlr)
void SCIPexprhdlrSetCompare(SCIP_EXPRHDLR *exprhdlr,)
void SCIPexprhdlrSetIntegrality(SCIP_EXPRHDLR *exprhdlr,)
void SCIPexprhdlrSetCurvature(SCIP_EXPRHDLR *exprhdlr,)
SCIP_EXPRHDLR * SCIPgetExprhdlrProduct(SCIP *scip)
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,)
void SCIPexprhdlrSetGetSymdata(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)),)
void SCIPexprhdlrSetPrint(SCIP_EXPRHDLR *exprhdlr,)
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)
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_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)
SCIP_Real SCIPgetCoefExprProduct(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_EXPRDATA * SCIPexprGetData(SCIP_EXPR *expr)
SCIP_EXPRCURV SCIPexprcurvMultiply(SCIP_Real factor, SCIP_EXPRCURV curvature)
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_INTERVAL SCIPexprGetActivity(SCIP_EXPR *expr)
void SCIPcaptureExpr(SCIP_EXPR *expr)
int SCIPexprGetNUses(SCIP_EXPR *expr)
SCIP_RETCODE SCIPdismantleExpr(SCIP *scip, FILE *file, 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 SCIPintervalSolveUnivariateQuadExpression(SCIP_Real infinity, SCIP_INTERVAL *resultant, SCIP_INTERVAL sqrcoeff, SCIP_INTERVAL lincoeff, SCIP_INTERVAL rhs, SCIP_INTERVAL xbnds)
void SCIPintervalIntersect(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 SCIPintervalMul(SCIP_Real infinity, SCIP_INTERVAL *resultant, SCIP_INTERVAL operand1, SCIP_INTERVAL operand2)
SCIP_Real SCIPintervalGetSup(SCIP_INTERVAL interval)
void SCIPintervalSetEmpty(SCIP_INTERVAL *resultant)
#define SCIPallocClearBlockMemory(scip, ptr)
#define SCIPduplicateBlockMemory(scip, ptr, source)
#define SCIPallocBufferArray(scip, ptr, num)
#define SCIPfreeBufferArray(scip, ptr)
#define SCIPallocBlockMemoryArray(scip, ptr, num)
#define SCIPfreeBlockMemory(scip, ptr)
#define SCIPallocBlockMemory(scip, ptr)
SCIP_Bool SCIPisRelEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Real SCIPinfinity(SCIP *scip)
SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisZero(SCIP *scip, SCIP_Real val)
assert(minobj< SCIPgetCutoffbound(scip))
bilinear nonlinear handler
public functions to work with algebraic expressions
public data structures and miscellaneous methods
structs for symmetry computations
#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_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_EXPRGETSYMDATA(x)
#define SCIP_DECL_EXPRCOPYDATA(x)
#define SCIP_EXPRITER_LEAVEEXPR
#define SCIP_DECL_EXPRESTIMATE(x)
#define SCIP_EXPRITER_ENTEREXPR
enum SCIP_Retcode SCIP_RETCODE