45#define EXPRHDLR_NAME "sum"
46#define EXPRHDLR_DESC "summation with coefficients and a constant"
47#define EXPRHDLR_PRECEDENCE 40000
48#define EXPRHDLR_HASHKEY SCIPcalcFibHash(47161.0)
53#define debugSimplify printf
55#define debugSimplify while( FALSE ) printf
66 SCIP_Real* coefficients;
80 SCIP_Real* coefficients,
85 assert(ncoefficients >= 0);
89 if( coefficients !=
NULL )
98 for(
i = 0;
i < ncoefficients; ++
i )
99 (*exprdata)->coefficients[
i] = 1.0;
102 (*exprdata)->coefssize = ncoefficients;
103 (*exprdata)->constant = constant;
120 void* ownercreatedata
139 expr = children[idx];
207 if( expchild !=
NULL )
215 SCIP_Real expconstant;
223 expconstant = log(coef);
228 expconstant = log(-coef);
237 SCIP_CALL( SCIPcallExprSimplify(
scip, sum, &simplifiedsum, ownercreate, ownercreatedata) );
245 SCIP_CALL( SCIPcallExprSimplify(
scip, exponential, &simplifiedexp, ownercreate, ownercreatedata) );
265 SCIP_CALL( SCIPcallExprSimplify(
scip, prod, &simplifiedprod, ownercreate, ownercreatedata) );
291 SCIP_Real expconstant;
299 expconstant = log(coef);
304 expconstant = log(-coef);
313 SCIP_CALL( SCIPcallExprSimplify(
scip, sum, &simplifiedsum, ownercreate, ownercreatedata) );
321 SCIP_CALL( SCIPcallExprSimplify(
scip, exponential, &simplifiedexp, ownercreate, ownercreatedata) );
369 SCIP_Real* newcoefs =
NULL;
371 SCIP_Real newconstant;
393 for(
i = 0;
i < nchildren;
i++ )
422 if( coefs[0] == 0.0 )
429 *simplifiedexpr = children[0];
431 *simplifiedexpr = changed ? duplicate : expr;
440 for(
i = 0;
i < nchildren;
i++ )
443 sortdata.
exprs = children;
444 SCIPsortInd(order, sortExprComp, (
void*)&sortdata, nchildren);
449 for(
i = 0;
i < nchildren; ++
i )
451 newchildren[
i] = children[order[
i]];
452 newcoefs[
i] = coefs[order[
i]];
461 for(
i = 0;
i < nchildren;
i++ )
464 if( newcoefs[
i] == 0.0 )
483 newcoefs[
i+1] += newcoefs[
i];
488 newchildren[nnewchildren] = newchildren[
i];
489 newcoefs[nnewchildren] = newcoefs[
i];
496 debugSimplify(
"what to do? finalchildren has length %d\n", nnewchildren);
499 if( nnewchildren == 0 )
501 debugSimplify(
"[sum] got empty list, return value %g\n", newconstant);
508 if( nnewchildren == 1 && newcoefs[0] == 1.0 && newconstant == 0.0 )
510 *simplifiedexpr = newchildren[0];
520 ownercreate, ownercreatedata) );
525 *simplifiedexpr = expr;
555 (*symdata)->nconstants = 1;
556 (*symdata)->ncoefficients = exprdata->coefssize;
559 (*symdata)->constants[0] = exprdata->constant;
562 for(
i = 0;
i < exprdata->coefssize; ++
i )
563 (*symdata)->coefficients[
i] = exprdata->coefficients[
i];
566 for(
i = 0;
i < exprdata->coefssize; ++
i )
610 for(
i = nchildren1 - 1, j = nchildren2 - 1;
i >= 0 && j >= 0; --
i, --j )
613 if( compareresult != 0 )
614 return compareresult;
618 if( (coefs1 ? coefs1[
i] : 1.0) < (coefs2 ? coefs2[j] : 1.0) )
620 if( (coefs1 ? coefs1[
i] : 1.0) > (coefs2 ? coefs2[j] : 1.0) )
643 if( const1 < const2 )
645 if( const1 > const2 )
674 sourceexprdata->coefficients, sourceexprdata->constant) );
721 if( exprdata->constant != 0.0 )
732 coef = exprdata->coefficients[currentchild];
738 if( exprdata->constant != 0.0 || currentchild > 0 )
743 else if( coef == -1.0 )
751 SCIPinfoMessage(
scip, file, (exprdata->constant != 0.0 || currentchild > 0) ?
"%+g*" :
"%g*", coef);
788 *val = exprdata->constant;
879 if( exprdata->coefficients[
c] == 1.0 )
919 *constant = exprdata->constant;
944 *constant = exprdata->constant;
978 exprdata->coefficients, exprdata->constant, bounds, newbounds, infeasible);
980 if( !*infeasible && nreductions > 0 )
1071 *isintegral =
EPSISINT(exprdata->constant, 0.0);
1119 SCIP_Real* coefficients,
1122 void* ownercreatedata
1147 exprdata->constant = constant;
1171 assert(exprdata->coefssize > nchildren);
1172 exprdata->coefficients[nchildren] = childcoef;
1194 exprdata->coefficients[
i] *= constant;
1195 exprdata->constant *= constant;
1206 void* ownercreatedata
1209 SCIP_Real constant1;
1210 SCIP_Real constant2;
1235 if( constant1 != 0.0 )
1237 for( i2 = 0; i2 < nchildren2; ++i2 )
1243 for( i1 = 0; i1 < nchildren1; ++i1 )
1253 if( constant2 != 0.0 )
1259 for( i2 = 0; i2 < nchildren2; ++i2 )
1270 termfactors[0] = child1;
1271 termfactors[1] = child2;
1277 SCIP_Bool infeasible;
1285 termprodsimplified = termprod;
1297 SCIP_Bool infeasible;
1302 *product = prodsimplified;
1320 void* ownercreatedata
1335 SCIP_Bool haveconst;
1342 int multinomialcoef;
1346 SCIP_Real newtermcoef;
1359 haveconst = constant != 0.0;
1360 nterms = nchildren + (haveconst ? 1 : 0);
1375 for(
i = 1;
i <= exponent; ++
i )
1376 factorials[
i] = factorials[
i-1] *
i;
1380 for(
i = 0;
i < nchildren; ++
i )
1384 childrenpower[
i][1] = children[
i];
1385 for( k = 2; k <= exponent; ++k )
1391 SCIP_Bool infeasible;
1397 childrenpower[
i][k] = simplified;
1408 multinomialcoef = factorials[exponent];
1413 multinomialcoef /= factorials[beta[
i]];
1423 newtermcoef = multinomialcoef;
1429 if(
i ==
nterms-1 && haveconst )
1432 newtermcoef *= pow(constant, (
double)beta[
i]);
1437 newtermcoef *= pow(coefs[
i], (
double)beta[
i]);
1466 SCIP_Bool infeasible;
1472 newterm = simplified;
1483 while( beta[betapos] == 0 )
1486 if( betapos ==
nterms-1 )
1494 while( beta[betapos] == 0 );
1502 beta[betapos+1] = restsum;
1505 if( beta[betapos] > 0 )
1518 SCIP_Bool infeasible;
1527 for(
i = nchildren-1;
i >= 0; --
i )
1530 for( k = exponent; k >= 2; --k )
1563 return exprdata->coefficients;
1578 return exprdata->constant;
#define SCIP_INTERVAL_INFINITY
exponential expression handler
power and signed power expression handlers
product expression handler
static SCIP_RETCODE createData(SCIP *scip, SCIP_EXPRDATA **exprdata, int ncoefficients, SCIP_Real *coefficients, SCIP_Real constant)
static SCIP_RETCODE simplifyTerm(SCIP *scip, SCIP_EXPR *duplicate, int idx, SCIP_Bool *changed, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)
#define EXPRHDLR_PRECEDENCE
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)
void SCIPsetConstantExprSum(SCIP_EXPR *expr, SCIP_Real constant)
void SCIPmultiplyByConstantExprSum(SCIP_EXPR *expr, SCIP_Real constant)
SCIP_RETCODE SCIPpowerExprSum(SCIP *scip, SCIP_EXPR **result, SCIP_EXPR *base, int exponent, SCIP_Bool simplify, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)
SCIP_RETCODE SCIPappendExprSumExpr(SCIP *scip, SCIP_EXPR *expr, SCIP_EXPR *child, SCIP_Real childcoef)
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_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 SCIPmultiplyBySumExprSum(SCIP *scip, SCIP_EXPR **product, SCIP_EXPR *factor1, SCIP_EXPR *factor2, SCIP_Bool simplify, 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 SCIPincludeExprhdlrSum(SCIP *scip)
void SCIPinfoMessage(SCIP *scip, FILE *file, const char *formatstr,...)
#define SCIPdebugMsgPrint
unsigned int SCIPcalcFibHash(SCIP_Real v)
const char * SCIPexprhdlrGetName(SCIP_EXPRHDLR *exprhdlr)
void SCIPexprhdlrSetCompare(SCIP_EXPRHDLR *exprhdlr,)
void SCIPexprhdlrSetIntegrality(SCIP_EXPRHDLR *exprhdlr,)
void SCIPexprhdlrSetCurvature(SCIP_EXPRHDLR *exprhdlr,)
void SCIPexprhdlrSetIntEval(SCIP_EXPRHDLR *exprhdlr,)
void SCIPexprhdlrSetMonotonicity(SCIP_EXPRHDLR *exprhdlr,)
void SCIPexprhdlrSetReverseProp(SCIP_EXPRHDLR *exprhdlr,)
void SCIPexprhdlrSetHash(SCIP_EXPRHDLR *exprhdlr,)
SCIP_EXPRHDLR * SCIPgetExprhdlrSum(SCIP *scip)
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)
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_Bool SCIPisExprProduct(SCIP *scip, SCIP_EXPR *expr)
SCIP_Bool SCIPisExprSum(SCIP *scip, SCIP_EXPR *expr)
SCIP_Bool SCIPexprIsIntegral(SCIP_EXPR *expr)
SCIP_RETCODE SCIPreplaceExprChild(SCIP *scip, SCIP_EXPR *expr, int childidx, SCIP_EXPR *newchild)
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_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_Real SCIPexprGetEvalValue(SCIP_EXPR *expr)
SCIP_EXPR ** SCIPexprGetChildren(SCIP_EXPR *expr)
SCIP_Real SCIPgetConstantExprSum(SCIP_EXPR *expr)
SCIP_INTERVAL SCIPexprGetActivity(SCIP_EXPR *expr)
SCIP_RETCODE SCIPduplicateExpr(SCIP *scip, SCIP_EXPR *expr, SCIP_EXPR **copyexpr, SCIP_DECL_EXPR_MAPEXPR((*mapexpr)), void *mapexprdata, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)
void SCIPcaptureExpr(SCIP_EXPR *expr)
SCIP_RETCODE SCIPsimplifyExpr(SCIP *scip, SCIP_EXPR *rootexpr, SCIP_EXPR **simplified, SCIP_Bool *changed, SCIP_Bool *infeasible, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)
SCIP_EXPRHDLR * SCIPexprGetHdlr(SCIP_EXPR *expr)
void SCIPintervalSet(SCIP_INTERVAL *resultant, SCIP_Real value)
SCIP_Bool SCIPintervalIsEmpty(SCIP_Real infinity, SCIP_INTERVAL operand)
void SCIPintervalMulScalar(SCIP_Real infinity, SCIP_INTERVAL *resultant, SCIP_INTERVAL operand1, SCIP_Real operand2)
int SCIPintervalPropagateWeightedSum(SCIP_Real infinity, int noperands, SCIP_INTERVAL *operands, SCIP_Real *weights, SCIP_Real constant, SCIP_INTERVAL rhs, SCIP_INTERVAL *resultants, SCIP_Bool *infeasible)
void SCIPintervalAdd(SCIP_Real infinity, SCIP_INTERVAL *resultant, SCIP_INTERVAL operand1, SCIP_INTERVAL operand2)
void SCIPintervalSetEmpty(SCIP_INTERVAL *resultant)
#define SCIPfreeBlockMemoryArray(scip, ptr, num)
#define SCIPensureBlockMemoryArray(scip, ptr, arraysizeptr, minsize)
#define SCIPallocClearBufferArray(scip, ptr, num)
#define SCIPallocBufferArray(scip, ptr, num)
#define SCIPfreeBufferArray(scip, ptr)
#define SCIPallocBlockMemoryArray(scip, ptr, num)
#define SCIPfreeBlockMemory(scip, ptr)
#define SCIPfreeBufferArrayNull(scip, ptr)
#define SCIPallocBlockMemory(scip, ptr)
#define SCIPduplicateBlockMemoryArray(scip, ptr, source, num)
SCIP_Bool SCIPisEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
void SCIPsortInd(int *indarray, SCIP_DECL_SORTINDCOMP((*indcomp)), void *dataptr, int len)
assert(minobj< SCIPgetCutoffbound(scip))
static volatile int nterms
#define BMScopyMemoryArray(ptr, source, num)
#define BMSclearMemoryArray(ptr, num)
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_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_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
#define SCIP_DECL_SORTINDCOMP(x)
enum SCIP_Retcode SCIP_RETCODE