A RetroSearch Logo

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Search Query:

Showing content from https://scip.zib.de/doc/html/expr__sum_8c_source.php below:

SCIP Doxygen Documentation: expr_sum.c Source File

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 84

assert(exprdata !=

NULL

);

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

129

assert(duplicate !=

NULL

);

132

assert(changed !=

NULL

);

139

expr = children[idx];

140

assert(expr !=

NULL

);

197

assert(child !=

NULL

);

207 if

( expchild !=

NULL

)

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) );

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) );

379

assert(expr !=

NULL

);

380

assert(simplifiedexpr !=

NULL

);

390

assert(duplicate !=

NULL

);

393 for

( i = 0; i < nchildren; i++ )

413 if

( nchildren == 0 )

420 if

( nchildren == 1 )

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;

548

assert(expr !=

NULL

);

551

assert(exprdata !=

NULL

);

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) )

642

assert(i == -1 && j == -1);

643 if

( const1 < const2 )

645 if

( const1 > const2 )

667

assert(targetexprdata !=

NULL

);

668

assert(sourceexpr !=

NULL

);

671

assert(sourceexprdata !=

NULL

);

674

sourceexprdata->coefficients, sourceexprdata->constant) );

685

assert(expr !=

NULL

);

688

assert(exprdata !=

NULL

);

704

assert(expr !=

NULL

);

707

assert(exprdata !=

NULL

);

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) ?

"%+.15g*"

:

"%.15g*"

, coef);

782

assert(expr !=

NULL

);

785

assert(exprdata !=

NULL

);

788

*val = exprdata->constant;

807

assert(expr !=

NULL

);

808

assert(dot !=

NULL

);

811

assert(exprdata !=

NULL

);

828

assert(expr !=

NULL

);

843

assert(bardot !=

NULL

);

858

assert(expr !=

NULL

);

861

assert(exprdata !=

NULL

);

879 if

( exprdata->coefficients[c] == 1.0 )

908

assert(expr !=

NULL

);

911

assert(coefs[0] !=

NULL

);

912

assert(constant !=

NULL

);

913

assert(nreturned !=

NULL

);

916

assert(exprdata !=

NULL

);

919

*constant = exprdata->constant;

932

assert(expr !=

NULL

);

934

assert(islocal !=

NULL

);

935

assert(success !=

NULL

);

936

assert(branchcand !=

NULL

);

939

assert(exprdata !=

NULL

);

944

*constant = exprdata->constant;

966

assert(expr !=

NULL

);

967

assert(infeasible !=

NULL

);

970

assert(nchildren > 0);

973

assert(exprdata !=

NULL

);

978

exprdata->coefficients, exprdata->constant, bounds, newbounds, infeasible);

980 if

( !*infeasible && nreductions > 0 )

996

assert(expr !=

NULL

);

997

assert(hashkey !=

NULL

);

998

assert(childrenhashes !=

NULL

);

1001

assert(exprdata !=

NULL

);

1008

*hashkey ^=

SCIPcalcFibHash

(exprdata->coefficients[c]) ^ childrenhashes[c];

1022

assert(expr !=

NULL

);

1023

assert(childcurv !=

NULL

);

1024

assert(success !=

NULL

);

1027

assert(exprdata !=

NULL

);

1044

assert(expr !=

NULL

);

1045

assert(result !=

NULL

);

1049

assert(exprdata !=

NULL

);

1064

assert(expr !=

NULL

);

1065

assert(isintegral !=

NULL

);

1068

assert(exprdata !=

NULL

);

1071

*isintegral =

EPSISINT

(exprdata->constant, 0.0);

1076

assert(child !=

NULL

);

1093

assert(exprhdlr !=

NULL

);

1122 void

* ownercreatedata

1142

assert(expr !=

NULL

);

1145

assert(exprdata !=

NULL

);

1147

exprdata->constant = constant;

1161

assert(expr !=

NULL

);

1165

assert(exprdata !=

NULL

);

1171

assert(exprdata->coefssize > nchildren);

1172

exprdata->coefficients[nchildren] = childcoef;

1188

assert(expr !=

NULL

);

1191

assert(exprdata !=

NULL

);

1194

exprdata->coefficients[i] *= constant;

1195

exprdata->constant *= constant;

1206 void

* ownercreatedata

1217

assert(product !=

NULL

);

1218

assert(factor1 !=

NULL

);

1220

assert(factor2 !=

NULL

);

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;

1281

assert(!infeasible);

1285

termprodsimplified = termprod;

1300

assert(!infeasible);

1302

*product = prodsimplified;

1320 void

* ownercreatedata

1342 int

multinomialcoef;

1349

assert(result !=

NULL

);

1350

assert(base !=

NULL

);

1351

assert(exponent > 1);

1353

assert(exponent > 1.0);

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 )

1395

assert(!infeasible);

1397

childrenpower[i][k] = simplified;

1408

multinomialcoef = factorials[exponent];

1409 for

( i = 0; i <

nterms

; ++i )

1411

assert(beta[i] >= 0);

1412

assert(beta[i] <= exponent);

1413

multinomialcoef /= factorials[beta[i]];

1417 for

( i = 0; i <

nterms

; ++i )

1423

newtermcoef = multinomialcoef;

1424 for

( i = 0; i <

nterms

; ++i )

1429 if

( i ==

nterms

-1 && haveconst )

1432

newtermcoef *= pow(constant, (

double

)beta[i]);

1437

newtermcoef *= pow(coefs[i], (

double

)beta[i]);

1470

assert(!infeasible);

1472

newterm = simplified;

1483 while

( beta[betapos] == 0 )

1486 if

( betapos ==

nterms

-1 )

1494 while

( beta[betapos] == 0 );

1497 for

( i = betapos+1; i <

nterms

; ++i )

1502

beta[betapos+1] = restsum;

1505 if

( beta[betapos] > 0 )

1522

assert(!infeasible);

1524

*result = simplified;

1527 for

( i = nchildren-1; i >= 0; --i )

1530 for

( k = exponent; k >= 2; --k )

1558

assert(expr !=

NULL

);

1561

assert(exprdata !=

NULL

);

1563 return

exprdata->coefficients;

1573

assert(expr !=

NULL

);

1576

assert(exprdata !=

NULL

);

1578 return

exprdata->constant;

#define SCIP_INTERVAL_INFINITY

exponential expression handler

power and signed power expression handlers

product expression handler

static SCIP_DECL_EXPRPRINT(printSum)

static SCIP_DECL_EXPRCOPYHDLR(copyhdlrSum)

static SCIP_DECL_EXPRBWDIFF(bwdiffSum)

static SCIP_DECL_EXPREVAL(evalSum)

static SCIP_DECL_SORTINDCOMP(sortExprComp)

static SCIP_DECL_EXPRFREEDATA(freedataSum)

static SCIP_DECL_EXPRCOMPARE(compareSum)

static SCIP_DECL_EXPRINTEGRALITY(integralitySum)

static SCIP_DECL_EXPRINTEVAL(intevalSum)

static SCIP_RETCODE createData(SCIP *scip, SCIP_EXPRDATA **exprdata, int ncoefficients, SCIP_Real *coefficients, SCIP_Real constant)

static SCIP_DECL_EXPRREVERSEPROP(reversepropSum)

static SCIP_DECL_EXPRESTIMATE(estimateSum)

static SCIP_DECL_EXPRBWFWDIFF(bwfwdiffSum)

static SCIP_DECL_EXPRHASH(hashSum)

static SCIP_DECL_EXPRCURVATURE(curvatureSum)

static SCIP_DECL_EXPRGETSYMDATA(getSymDataSum)

static SCIP_RETCODE simplifyTerm(SCIP *scip, SCIP_EXPR *duplicate, int idx, SCIP_Bool *changed, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)

static SCIP_DECL_EXPRINITESTIMATES(initEstimatesSum)

static SCIP_DECL_EXPRSIMPLIFY(simplifySum)

#define EXPRHDLR_PRECEDENCE

static SCIP_DECL_EXPRMONOTONICITY(monotonicitySum)

static SCIP_DECL_EXPRFWDIFF(fwdiffSum)

static SCIP_DECL_EXPRCOPYDATA(copydataSum)

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 SCIPexprhdlrSetIntegrality(SCIP_EXPRHDLR *exprhdlr, SCIP_DECL_EXPRINTEGRALITY((*integrality)))

void SCIPexprhdlrSetCopyFreeData(SCIP_EXPRHDLR *exprhdlr, SCIP_DECL_EXPRCOPYDATA((*copydata)), SCIP_DECL_EXPRFREEDATA((*freedata)))

void SCIPexprhdlrSetPrint(SCIP_EXPRHDLR *exprhdlr, SCIP_DECL_EXPRPRINT((*print)))

void SCIPexprhdlrSetGetSymdata(SCIP_EXPRHDLR *exprhdlr, SCIP_DECL_EXPRGETSYMDATA((*getsymdata)))

void SCIPexprhdlrSetHash(SCIP_EXPRHDLR *exprhdlr, SCIP_DECL_EXPRHASH((*hash)))

void SCIPexprhdlrSetCopyFreeHdlr(SCIP_EXPRHDLR *exprhdlr, SCIP_DECL_EXPRCOPYHDLR((*copyhdlr)), SCIP_DECL_EXPRFREEHDLR((*freehdlr)))

void SCIPexprhdlrSetDiff(SCIP_EXPRHDLR *exprhdlr, SCIP_DECL_EXPRBWDIFF((*bwdiff)), SCIP_DECL_EXPRFWDIFF((*fwdiff)), SCIP_DECL_EXPRBWFWDIFF((*bwfwdiff)))

void SCIPexprhdlrSetReverseProp(SCIP_EXPRHDLR *exprhdlr, SCIP_DECL_EXPRREVERSEPROP((*reverseprop)))

void SCIPexprhdlrSetEstimate(SCIP_EXPRHDLR *exprhdlr, SCIP_DECL_EXPRINITESTIMATES((*initestimates)), SCIP_DECL_EXPRESTIMATE((*estimate)))

void SCIPexprhdlrSetMonotonicity(SCIP_EXPRHDLR *exprhdlr, SCIP_DECL_EXPRMONOTONICITY((*monotonicity)))

SCIP_EXPRHDLR * SCIPgetExprhdlrSum(SCIP *scip)

void SCIPexprhdlrSetIntEval(SCIP_EXPRHDLR *exprhdlr, SCIP_DECL_EXPRINTEVAL((*inteval)))

void SCIPexprhdlrSetCurvature(SCIP_EXPRHDLR *exprhdlr, SCIP_DECL_EXPRCURVATURE((*curvature)))

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 SCIPexprhdlrSetCompare(SCIP_EXPRHDLR *exprhdlr, SCIP_DECL_EXPRCOMPARE((*compare)))

void SCIPexprhdlrSetSimplify(SCIP_EXPRHDLR *exprhdlr, SCIP_DECL_EXPRSIMPLIFY((*simplify)))

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)

static volatile int nterms

#define BMScopyMemoryArray(ptr, source, num)

#define BMSclearMemoryArray(ptr, num)

structs for symmetry computations

#define SCIP_DECL_EXPR_OWNERCREATE(x)

struct SCIP_ExprData SCIP_EXPRDATA

#define SCIP_EXPRITER_VISITINGCHILD

#define SCIP_EXPRITER_VISITEDCHILD

#define SCIP_EXPRITER_LEAVEEXPR

#define SCIP_EXPRITER_ENTEREXPR

enum SCIP_Retcode SCIP_RETCODE

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4