RetroSearch Browse

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

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

SCIP Doxygen Documentation: scip_expr.c Source File

87

assert(sourcescip !=

NULL

);

88

assert(sourceexpr !=

NULL

);

89

assert(targetscip !=

NULL

);

90

assert(targetexpr !=

NULL

);

91

assert(mapexprdata !=

NULL

);

102

assert(targetvar !=

NULL

);

142#define debugParse printf 144#define debugParse while( FALSE ) printf 153 const char

** newpos,

156 void

* ownercreatedata

169 const char

** newpos,

172 void

* ownercreatedata

175 debugParse

(

"parsing base from %s\n"

, expr);

210 debugParse

(

"First time parsing variable <%s>, creating varexpr and adding it to hashmap\n"

SCIPvarGetName

(var));

218 else if

( *expr ==

'('

)

221 SCIP_CALL

(

parseExpr

(

scip

, vartoexprvarmap, ++expr, newpos, basetree, ownercreate, ownercreatedata) );

227 SCIPerrorMessage

(

"Read a '(', parsed expression inside --> expecting closing ')'. Got <%c>: rest of string <%s>\n"

, *expr, expr);

232 debugParse

(

"Done parsing expression, continue with <%s>\n"

, expr);

234 else if

( isdigit(*expr) )

243 debugParse

(

"Parsed value %g, creating a value-expression.\n"

, value);

246 else if

( isalpha(*expr) )

256 while

( *expr !=

'('

&& *expr !=

'\0'

&& !isspace(*expr)

257

&& !( *expr ==

'\\'

&& *(expr+1) !=

'\0'

&& strchr(

SCIP_SPACECONTROL

, *(expr+1)) ) )

259

operatorname[i] = *expr;

263

operatorname[i] =

'\0'

;

268 SCIPerrorMessage

(

"Expected '(' after operator name <%s>, but got %s.\n"

, operatorname, expr);

276 if

( exprhdlr ==

NULL

)

278 SCIPerrorMessage

(

"No expression handler with name <%s> found.\n"

, operatorname);

287 SCIPerrorMessage

(

"Error while expression handler <%s> was parsing %s\n"

, operatorname, expr);

288

assert(*basetree ==

NULL

);

294

assert(*expr ==

')'

);

302 SCIPerrorMessage

(

"Expected a number, (expression), <varname>, Opname(Opexpr), instead got <%c> from %s\n"

, *expr, expr);

322 const char

** newpos,

325 void

* ownercreatedata

331 debugParse

(

"parsing factor from %s\n"

, expr);

378 SCIPerrorMessage

(

"error in parsing exponent: expected ')', received <%c> from <%s>\n"

, *expr, expr);

389 if

( isdigit(*expr) )

400 SCIPerrorMessage

(

"error in parsing exponent, expected a digit, received <%c> from <%s>\n"

, *expr, expr);

406 debugParse

(

"parsed the exponent %g\n"

, exponent);

420 if

( exponent != 1.0 )

427

*factortree = basetree;

442 const char

** newpos,

445 void

* ownercreatedata

450 debugParse

(

"parsing term from %s\n"

, expr);

459 debugParse

(

"back to parsing Term, continue parsing from %s\n"

, expr);

463 if

( *expr ==

'*'

|| *expr ==

'/'

)

475

isdivision = (*expr ==

'/'

) ?

TRUE

FALSE

;

477 debugParse

(

"while parsing term, read char %c\n"

, *expr);

480

retcode =

parseFactor

(

scip

, isdivision, vartoexprvarmap, expr, newpos, &factortree, ownercreate, ownercreatedata);

497 while

( *expr ==

'*'

|| *expr ==

'/'

);

502

*termtree = factortree;

521 const char

** newpos,

524 void

* ownercreatedata

530 debugParse

(

"parsing expression %s\n"

, expr);

537 if

( *expr ==

'+'

|| *expr ==

'-'

)

539 debugParse

(

"while parsing expression, read char %c\n"

, *expr);

540

sign = *expr ==

'+'

? 1.0 : -1.0;

547 debugParse

(

"back to parsing expression (we have the following term), continue parsing from %s\n"

, expr);

551 if

( *expr ==

'+'

|| *expr ==

'-'

)

577 if

( **newpos ==

'<'

)

586 else if

( **newpos ==

'*'

)

596

coef = (*expr ==

'+'

) ? 1.0 : -1.0;

602

coef = (*expr ==

'+'

) ? 1.0 : -1.0;

606 debugParse

(

"while parsing expression, read coefficient %g\n"

, coef);

608

retcode =

parseTerm

(

scip

, vartoexprvarmap, expr, newpos, &termtree, ownercreate, ownercreatedata);

624

}

while

( *expr ==

'+'

|| *expr ==

'-'

);

631

assert(sign == -1.0);

636

*exprtree = termtree;

665

assert(expr !=

NULL

);

666

assert(key2expr !=

NULL

);

667

assert(newexpr !=

NULL

);

670

multihashlist =

NULL

;

676 if

( *newexpr ==

NULL

)

682 else if

( expr != *newexpr )

690

assert(expr == *newexpr);

723

assert(data !=

NULL

);

727

assert(expr1 !=

NULL

);

728

assert(expr2 !=

NULL

);

741

assert(expr !=

NULL

);

744

assert(data !=

NULL

);

764 unsigned int

* childrenhashes;

765 int

childrenhashessize;

769

assert(expr !=

NULL

);

770

assert(hashiterator !=

NULL

);

772

childrenhashessize = 5;

779 if

( nvisitedexprs !=

NULL

)

812#undef SCIPgetExprhdlrs 813#undef SCIPgetNExprhdlrs 814#undef SCIPfindExprhdlr 815#undef SCIPgetExprhdlrVar 816#undef SCIPgetExprhdlrValue 817#undef SCIPgetExprhdlrSum 818#undef SCIPgetExprhdlrProduct 819#undef SCIPgetExprhdlrPower 833 unsigned int

precedence,

840

assert(exprhdlr !=

NULL

);

842 SCIP_CALL

(

SCIPcheckStage

(

scip

"SCIPincludeExprhdlr"

TRUE

FALSE

) );

845

assert(*exprhdlr !=

NULL

);

860 return scip

->set->exprhdlrs;

871 return scip

->set->nexprhdlrs;

894 return scip

->set->exprhdlrvar;

905 return scip

->set->exprhdlrval;

916 return scip

->set->exprhdlrsum;

927 return scip

->set->exprhdlrproduct;

938 return scip

->set->exprhdlrpow;

948#undef SCIPappendExprChild 949#undef SCIPreplaceExprChild 950#undef SCIPremoveExprChildren 951#undef SCIPduplicateExpr 952#undef SCIPduplicateExprShallow 953#undef SCIPcaptureExpr 954#undef SCIPreleaseExpr 956#undef SCIPisExprValue 958#undef SCIPisExprProduct 959#undef SCIPisExprPower 962#undef SCIPgetExprNewSoltag 963#undef SCIPevalExprGradient 964#undef SCIPevalExprHessianDir 965#undef SCIPevalExprActivity 966#undef SCIPcompareExpr 967#undef SCIPsimplifyExpr 968#undef SCIPcallExprCurvature 969#undef SCIPcallExprMonotonicity 970#undef SCIPcallExprEval 971#undef SCIPcallExprEvalFwdiff 972#undef SCIPcallExprInteval 973#undef SCIPcallExprEstimate 974#undef SCIPcallExprInitestimates 975#undef SCIPcallExprSimplify 976#undef SCIPcallExprReverseprop 977#undef SCIPcallExprGetSymData 989 void

* ownercreatedata

1010 void

* ownercreatedata

1014

assert(expr !=

NULL

);

1015

assert(exprhdlr !=

NULL

);

1017 if

( child1 !=

NULL

&& child2 !=

NULL

)

1025 else if

( child2 ==

NULL

)

1051 void

* ownercreatedata

1059

assert(expr !=

NULL

);

1060

assert(nlinvars == 0 || (linvars !=

NULL

&& lincoefs !=

NULL

));

1061

assert(nquadterms == 0 || (quadvars1 !=

NULL

&& quadvars2 !=

NULL

&& quadcoefs !=

NULL

));

1068 for

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

1070

assert(quadvars1 !=

NULL

&& quadvars1[i] !=

NULL

);

1071

assert(quadvars2 !=

NULL

&& quadvars2[i] !=

NULL

);

1074 if

( quadvars1[i] == quadvars2[i] )

1108

coefs[i] = quadcoefs[i];

1112 for

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

1114

assert(linvars !=

NULL

&& linvars[i] !=

NULL

);

1123

coefs[nquadterms + i] = lincoefs[i];

1130 for

( i = 0; i < nquadterms + nlinvars; ++i )

1132

assert(children[i] !=

NULL

);

1155 void

* ownercreatedata

1159

assert(expr !=

NULL

);

1160

assert(nfactors >= 0);

1163 if

( nfactors == 0 )

1167 else if

( nfactors == 1 )

1170 if

( exponents ==

NULL

|| exponents[0] == 1.0 )

1198 for

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

1201 if

( exponents ==

NULL

|| exponents[i] == 1.0 )

1220 for

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

1222

assert(children[i] !=

NULL

);

1295 void

* ownercreatedata

1302

expr, copyexpr, mapexpr, mapexprdata, ownercreate, ownercreatedata) );

1313 void

* ownercreatedata

1331 void

* ownercreatedata,

1349

copydata.

varmap

= varmap;

1351

copydata.

global

= global;

1355

assert(sourcescip !=

NULL

);

1356

assert(sourcescip->

mem

NULL

);

1357

assert(targetscip !=

NULL

);

1358

assert(targetscip->

mem

NULL

);

1362

expr, copyexpr, copyVarExpr, &copydata, ownercreate, ownercreatedata) );

1364

*valid = copydata.

valid

;

1390 const char

* exprstr,

1391 const char

** finalpos,

1393 void

* ownercreatedata

1396 const char

* finalpos_;

1405

retcode =

parseExpr

(

scip

, vartoexprvarmap, exprstr, &finalpos_, expr, ownercreate, ownercreatedata);

1409 if

( finalpos !=

NULL

)

1410

*finalpos = finalpos_;

1527 const char

* filename,

1582#if _POSIX_C_SOURCE < 2 1591

assert(expr !=

NULL

);

1594

f = popen(

"dot -Tps | gv --media=a3 -"

"w"

);

1664 return

++(

scip

->stat->exprlastsoltag);

1756 unsigned int

* hashval

1763

assert(expr !=

NULL

);

1764

assert(hashval !=

NULL

);

1787 void

* ownercreatedata

1806

assert(expr !=

NULL

);

1807

assert(symdata !=

NULL

);

1839 int

nvisitedexprs = 0;

1843

assert(exprs !=

NULL

);

1844

assert(nexprs >= 0);

1845

assert(replacedroot !=

NULL

);

1847

*replacedroot =

FALSE

;

1857 for

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

1859

assert(exprs[i] !=

NULL

);

1867

hashCommonSubexprGetKey, hashCommonSubexprEq, hashCommonSubexprKeyval, (

void

*)&hashdata) );

1871 for

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

1880 if

( newroot !=

NULL

)

1882

assert(newroot != exprs[i]);

1885 SCIPdebugMsg

(

scip

"replacing common root expression of %dth expr: %p -> %p\n"

, i, (

void

*)exprs[i], (

void

*)newroot);

1892

*replacedroot =

TRUE

;

1904

assert(child !=

NULL

);

1910 if

( newchild !=

NULL

)

1912

assert(child != newchild);

1915 SCIPdebugMsg

(

scip

"replacing common child expression %p -> %p\n"

, (

void

*)child, (

void

*)newchild);

1957

assert(expr !=

NULL

);

1983 for

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

2002

curv = trialcurv[i];

2032

assert(expr !=

NULL

);

2075

assert(expr !=

NULL

);

2076

assert(nvars !=

NULL

);

2114

assert(expr !=

NULL

);

2115

assert(varexprs !=

NULL

);

2116

assert(nvarexprs !=

NULL

);

2124

assert(expr !=

NULL

);

2128

varexprs[(*nvarexprs)++] = expr;

2201

assert(childrenvalues !=

NULL

);

2202

assert(val !=

NULL

);

2232

childrenvalues,

NULL

, direction,

NULL

) );

2263

overestimate, targetvalue, coefs, constant, islocal, success, branchcand) );

2279

constant, nreturned) );

2325

assert(expr !=

NULL

);

2326

assert(symdata !=

NULL

);

2339#undef SCIPcreateExpriter 2340#undef SCIPfreeExpriter 2372#undef SCIPcheckExprQuadratic 2373#undef SCIPfreeExprQuadratic 2374#undef SCIPcomputeExprQuadraticCurvature 2432

assert(expr !=

NULL

);

2437 for

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

2444 for

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

2456

auxvalue += (lincoef + sqrcoef * solval) * solval;

2460 for

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

2491

assert(expr !=

NULL

);

2498 for

( c = 0; c < nlinexprs; ++c )

2502 if

( c < nlinexprs - 1 )

2508 for

( c = 0; c < nquadexprs; ++c )

2519 if

( c < nquadexprs - 1 )

2524 if

( nbilinexprs == 0 )

2531 for

( c = 0; c < nbilinexprs; ++c )

2543 if

( c < nbilinexprs - 1 )

2549 for

( c = 0; c < nquadexprs; ++c )

2561 for

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

2573 if

( i < nadjbilin - 1 )

2605

expr, curv, assumevarfixed, storeeigeninfo) );

2616#undef SCIPgetExprMonomialData

SCIP_RETCODE SCIPcheckStage(SCIP *scip, const char *method, SCIP_Bool init, SCIP_Bool problem, SCIP_Bool transforming, SCIP_Bool transformed, SCIP_Bool initpresolve, SCIP_Bool presolving, SCIP_Bool exitpresolve, SCIP_Bool presolved, SCIP_Bool initsolve, SCIP_Bool solving, SCIP_Bool solved, SCIP_Bool exitsolve, SCIP_Bool freetrans, SCIP_Bool freescip)

#define SCIP_SPACECONTROL

#define SCIP_CALL_TERMINATE(retcode, x, TERM)

SCIP_RETCODE SCIPexprPrint(SCIP_SET *set, SCIP_STAT *stat, BMS_BLKMEM *blkmem, SCIP_MESSAGEHDLR *messagehdlr, FILE *file, SCIP_EXPR *expr)

SCIP_Bool SCIPexprIsPower(SCIP_SET *set, SCIP_EXPR *expr)

SCIP_RETCODE SCIPexprEvalActivity(SCIP_SET *set, SCIP_STAT *stat, BMS_BLKMEM *blkmem, SCIP_EXPR *rootexpr)

SCIP_RETCODE SCIPexprPrintDotInit(SCIP_SET *set, SCIP_STAT *stat, BMS_BLKMEM *blkmem, SCIP_EXPRPRINTDATA **printdata, FILE *file, SCIP_EXPRPRINT_WHAT whattoprint)

SCIP_RETCODE SCIPexprhdlrIntegralityExpr(SCIP_EXPRHDLR *exprhdlr, SCIP_SET *set, SCIP_EXPR *expr, SCIP_Bool *isintegral)

SCIP_RETCODE SCIPexprCopy(SCIP_SET *set, SCIP_STAT *stat, BMS_BLKMEM *blkmem, SCIP_SET *targetset, SCIP_STAT *targetstat, BMS_BLKMEM *targetblkmem, SCIP_EXPR *sourceexpr, SCIP_EXPR **targetexpr, SCIP_DECL_EXPR_MAPEXPR((*mapexpr)), void *mapexprdata, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)

SCIP_RETCODE SCIPexprPrintDotInit2(SCIP_SET *set, SCIP_STAT *stat, BMS_BLKMEM *blkmem, SCIP_EXPRPRINTDATA **printdata, const char *filename, SCIP_EXPRPRINT_WHAT whattoprint)

SCIP_RETCODE SCIPexprSimplify(SCIP_SET *set, SCIP_STAT *stat, BMS_BLKMEM *blkmem, SCIP_EXPR *rootexpr, SCIP_EXPR **simplified, SCIP_Bool *changed, SCIP_Bool *infeasible, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)

SCIP_RETCODE SCIPexprhdlrInitEstimatesExpr(SCIP_EXPRHDLR *exprhdlr, SCIP_SET *set, SCIP_EXPR *expr, SCIP_INTERVAL *bounds, SCIP_Bool overestimate, SCIP_Real *coefs[SCIP_EXPR_MAXINITESTIMATES], SCIP_Real constant[SCIP_EXPR_MAXINITESTIMATES], int *nreturned)

SCIP_RETCODE SCIPexprComputeQuadraticCurvature(SCIP_SET *set, BMS_BLKMEM *blkmem, BMS_BUFMEM *bufmem, SCIP_MESSAGEHDLR *messagehdlr, SCIP_EXPR *expr, SCIP_EXPRCURV *curv, SCIP_HASHMAP *assumevarfixed, SCIP_Bool storeeigeninfo)

SCIP_RETCODE SCIPexprGetSymData(SCIP_SET *set, SCIP_EXPR *expr, SYM_EXPRDATA **symdata)

SCIP_RETCODE SCIPexprhdlrSimplifyExpr(SCIP_EXPRHDLR *exprhdlr, SCIP_SET *set, SCIP_EXPR *expr, SCIP_EXPR **simplifiedexpr, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)

SCIP_RETCODE SCIPexprEvalGradient(SCIP_SET *set, SCIP_STAT *stat, BMS_BLKMEM *blkmem, SCIP_EXPR *rootexpr, SCIP_SOL *sol, SCIP_Longint soltag)

SCIP_RETCODE SCIPexprReplaceChild(SCIP_SET *set, SCIP_STAT *stat, BMS_BLKMEM *blkmem, SCIP_EXPR *expr, int childidx, SCIP_EXPR *newchild)

SCIP_RETCODE SCIPexprhdlrReversePropExpr(SCIP_EXPRHDLR *exprhdlr, SCIP_SET *set, SCIP_EXPR *expr, SCIP_INTERVAL bounds, SCIP_INTERVAL *childrenbounds, SCIP_Bool *infeasible)

SCIP_Bool SCIPexprIsVar(SCIP_SET *set, SCIP_EXPR *expr)

SCIP_RETCODE SCIPexprCheckQuadratic(SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_EXPR *expr, SCIP_Bool *isquadratic)

SCIP_RETCODE SCIPexprhdlrPrintExpr(SCIP_EXPRHDLR *exprhdlr, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_EXPR *expr, SCIP_EXPRITER_STAGE stage, int currentchild, unsigned int parentprecedence, FILE *file)

SCIP_RETCODE SCIPexprEvalHessianDir(SCIP_SET *set, SCIP_STAT *stat, BMS_BLKMEM *blkmem, SCIP_EXPR *rootexpr, SCIP_SOL *sol, SCIP_Longint soltag, SCIP_SOL *direction)

int SCIPexprCompare(SCIP_SET *set, SCIP_EXPR *expr1, SCIP_EXPR *expr2)

SCIP_RETCODE SCIPexprhdlrMonotonicityExpr(SCIP_EXPRHDLR *exprhdlr, SCIP_SET *set, SCIP_EXPR *expr, int childidx, SCIP_MONOTONE *result)

SCIP_RETCODE SCIPexprhdlrEvalExpr(SCIP_EXPRHDLR *exprhdlr, SCIP_SET *set, BMS_BUFMEM *bufmem, SCIP_EXPR *expr, SCIP_Real *val, SCIP_Real *childrenvals, SCIP_SOL *sol)

SCIP_RETCODE SCIPexprRemoveChildren(SCIP_SET *set, SCIP_STAT *stat, BMS_BLKMEM *blkmem, SCIP_EXPR *expr)

SCIP_RETCODE SCIPexprhdlrHashExpr(SCIP_EXPRHDLR *exprhdlr, SCIP_SET *set, SCIP_EXPR *expr, unsigned int *hashkey, unsigned int *childrenhashes)

SCIP_Bool SCIPexprIsValue(SCIP_SET *set, SCIP_EXPR *expr)

void SCIPexprCapture(SCIP_EXPR *expr)

SCIP_RETCODE SCIPexprhdlrIntEvalExpr(SCIP_EXPRHDLR *exprhdlr, SCIP_SET *set, SCIP_EXPR *expr, SCIP_INTERVAL *interval, SCIP_DECL_EXPR_INTEVALVAR((*intevalvar)), void *intevalvardata)

SCIP_RETCODE SCIPexprPrintDotFinal(SCIP_SET *set, SCIP_STAT *stat, BMS_BLKMEM *blkmem, SCIP_EXPRPRINTDATA **printdata)

SCIP_RETCODE SCIPexprAppendChild(SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_EXPR *expr, SCIP_EXPR *child)

SCIP_RETCODE SCIPexprDuplicateShallow(SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_EXPR *expr, SCIP_EXPR **copyexpr, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)

SCIP_RETCODE SCIPexprhdlrParseExpr(SCIP_EXPRHDLR *exprhdlr, SCIP_SET *set, const char *string, const char **endstring, SCIP_EXPR **expr, SCIP_Bool *success, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)

SCIP_RETCODE SCIPexprGetMonomialData(SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_EXPR *expr, SCIP_Real *coef, SCIP_Real *exponents, SCIP_EXPR **factors)

SCIP_RETCODE SCIPexprhdlrCurvatureExpr(SCIP_EXPRHDLR *exprhdlr, SCIP_SET *set, SCIP_EXPR *expr, SCIP_EXPRCURV exprcurvature, SCIP_Bool *success, SCIP_EXPRCURV *childcurv)

SCIP_RETCODE SCIPexprDismantle(SCIP_SET *set, SCIP_STAT *stat, BMS_BLKMEM *blkmem, SCIP_MESSAGEHDLR *messagehdlr, FILE *file, SCIP_EXPR *expr)

SCIP_RETCODE SCIPexprCreate(SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_EXPR **expr, SCIP_EXPRHDLR *exprhdlr, SCIP_EXPRDATA *exprdata, int nchildren, SCIP_EXPR **children, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)

SCIP_Bool SCIPexprIsProduct(SCIP_SET *set, SCIP_EXPR *expr)

SCIP_RETCODE SCIPexprPrintDot(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_EXPRPRINTDATA *printdata, SCIP_EXPR *expr)

SCIP_Bool SCIPexprIsSum(SCIP_SET *set, SCIP_EXPR *expr)

SCIP_RETCODE SCIPexprRelease(SCIP_SET *set, SCIP_STAT *stat, BMS_BLKMEM *blkmem, SCIP_EXPR **rootexpr)

SCIP_RETCODE SCIPexprhdlrEstimateExpr(SCIP_EXPRHDLR *exprhdlr, SCIP_SET *set, SCIP_EXPR *expr, SCIP_INTERVAL *localbounds, SCIP_INTERVAL *globalbounds, SCIP_Real *refpoint, SCIP_Bool overestimate, SCIP_Real targetvalue, SCIP_Real *coefs, SCIP_Real *constant, SCIP_Bool *islocal, SCIP_Bool *success, SCIP_Bool *branchcand)

SCIP_RETCODE SCIPexprhdlrEvalFwDiffExpr(SCIP_EXPRHDLR *exprhdlr, SCIP_SET *set, BMS_BUFMEM *bufmem, SCIP_EXPR *expr, SCIP_Real *val, SCIP_Real *dot, SCIP_Real *childrenvals, SCIP_SOL *sol, SCIP_Real *childrendirs, SCIP_SOL *direction)

SCIP_RETCODE SCIPexprhdlrCreate(BMS_BLKMEM *blkmem, SCIP_EXPRHDLR **exprhdlr, const char *name, const char *desc, unsigned int precedence, SCIP_DECL_EXPREVAL((*eval)), SCIP_EXPRHDLRDATA *data)

void SCIPexprFreeQuadratic(BMS_BLKMEM *blkmem, SCIP_EXPR *expr)

SCIP_RETCODE SCIPexprEval(SCIP_SET *set, SCIP_STAT *stat, BMS_BLKMEM *blkmem, SCIP_EXPR *expr, SCIP_SOL *sol, SCIP_Longint soltag)

private functions to work with algebraic expressions

void SCIPexpriterFree(SCIP_EXPRITER **iterator)

SCIP_RETCODE SCIPexpriterCreate(SCIP_STAT *stat, BMS_BLKMEM *blkmem, SCIP_EXPRITER **iterator)

power and signed power expression handlers

product expression handler

constant value expression handler

variable expression handler

static SCIP_RETCODE eval(SCIP *scip, SCIP_EXPR *expr, SCIP_EXPRINTDATA *exprintdata, const vector< Type > &x, Type &val)

SCIP_RETCODE SCIPgetVarCopy(SCIP *sourcescip, SCIP *targetscip, SCIP_VAR *sourcevar, SCIP_VAR **targetvar, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, SCIP_Bool *success)

SCIP_RETCODE SCIPcreateExprVar(SCIP *scip, SCIP_EXPR **expr, SCIP_VAR *var, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)

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 SCIPappendExprSumExpr(SCIP *scip, SCIP_EXPR *expr, SCIP_EXPR *child, SCIP_Real childcoef)

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)

int SCIPgetNVars(SCIP *scip)

void SCIPhashmapFree(SCIP_HASHMAP **hashmap)

void * SCIPhashmapGetImage(SCIP_HASHMAP *hashmap, void *origin)

SCIP_RETCODE SCIPhashmapInsert(SCIP_HASHMAP *hashmap, void *origin, void *image)

SCIP_RETCODE SCIPhashmapCreate(SCIP_HASHMAP **hashmap, BMS_BLKMEM *blkmem, int mapsize)

SCIP_Bool SCIPhashmapExists(SCIP_HASHMAP *hashmap, void *origin)

void SCIPinfoMessage(SCIP *scip, FILE *file, const char *formatstr,...)

void SCIPmultihashFree(SCIP_MULTIHASH **multihash)

SCIP_RETCODE SCIPmultihashInsert(SCIP_MULTIHASH *multihash, void *element)

SCIP_RETCODE SCIPmultihashCreate(SCIP_MULTIHASH **multihash, BMS_BLKMEM *blkmem, int tablesize, SCIP_DECL_HASHGETKEY((*hashgetkey)), SCIP_DECL_HASHKEYEQ((*hashkeyeq)), SCIP_DECL_HASHKEYVAL((*hashkeyval)), void *userptr)

void * SCIPmultihashRetrieveNext(SCIP_MULTIHASH *multihash, SCIP_MULTIHASHLIST **multihashlist, void *key)

int SCIPgetNExprhdlrs(SCIP *scip)

SCIP_Bool SCIPexprhdlrHasCurvature(SCIP_EXPRHDLR *exprhdlr)

SCIP_EXPRHDLR * SCIPgetExprhdlrProduct(SCIP *scip)

SCIP_EXPRHDLR * SCIPgetExprhdlrVar(SCIP *scip)

SCIP_EXPRHDLR ** SCIPgetExprhdlrs(SCIP *scip)

SCIP_EXPRHDLR * SCIPgetExprhdlrValue(SCIP *scip)

SCIP_EXPRHDLR * SCIPgetExprhdlrSum(SCIP *scip)

SCIP_RETCODE SCIPincludeExprhdlr(SCIP *scip, SCIP_EXPRHDLR **exprhdlr, const char *name, const char *desc, unsigned int precedence, SCIP_DECL_EXPREVAL((*eval)), SCIP_EXPRHDLRDATA *data)

SCIP_EXPRHDLR * SCIPgetExprhdlrPower(SCIP *scip)

SCIP_EXPRHDLR * SCIPfindExprhdlr(SCIP *scip, const char *name)

SCIP_DECL_EXPRMONOTONICITY(SCIPcallExprMonotonicity)

SCIP_RETCODE SCIPcreateExprQuadratic(SCIP *scip, SCIP_EXPR **expr, int nlinvars, SCIP_VAR **linvars, SCIP_Real *lincoefs, int nquadterms, SCIP_VAR **quadvars1, SCIP_VAR **quadvars2, SCIP_Real *quadcoefs, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)

SCIP_RETCODE SCIPcreateExprMonomial(SCIP *scip, SCIP_EXPR **expr, int nfactors, SCIP_VAR **vars, SCIP_Real *exponents, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)

SCIP_RETCODE SCIPgetSymDataExpr(SCIP *scip, SCIP_EXPR *expr, SYM_EXPRDATA **symdata)

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)

SCIP_RETCODE SCIPevalExprHessianDir(SCIP *scip, SCIP_EXPR *expr, SCIP_SOL *sol, SCIP_Longint soltag, SCIP_SOL *direction)

SCIP_RETCODE SCIPevalExpr(SCIP *scip, SCIP_EXPR *expr, SCIP_SOL *sol, SCIP_Longint soltag)

int SCIPexprGetNChildren(SCIP_EXPR *expr)

SCIP_DECL_EXPRINTEVAL(SCIPcallExprInteval)

SCIP_RETCODE SCIPprintExprQuadratic(SCIP *scip, SCIP_EXPR *expr)

void SCIPexprGetQuadraticBilinTerm(SCIP_EXPR *expr, int termidx, SCIP_EXPR **expr1, SCIP_EXPR **expr2, SCIP_Real *coef, int *pos2, SCIP_EXPR **prodexpr)

SCIP_RETCODE SCIPcomputeExprIntegrality(SCIP *scip, SCIP_EXPR *expr)

SCIP_DECL_EXPRPRINT(SCIPcallExprPrint)

SCIP_Bool SCIPisExprProduct(SCIP *scip, SCIP_EXPR *expr)

SCIP_RETCODE SCIPevalExprGradient(SCIP *scip, SCIP_EXPR *expr, SCIP_SOL *sol, SCIP_Longint soltag)

SCIP_RETCODE SCIPprintExprDotInit2(SCIP *scip, SCIP_EXPRPRINTDATA **printdata, const char *filename, SCIP_EXPRPRINT_WHAT whattoprint)

SCIP_Bool SCIPexpriterIsEnd(SCIP_EXPRITER *iterator)

SCIP_Longint SCIPgetExprNewSoltag(SCIP *scip)

void SCIPexprSetCurvature(SCIP_EXPR *expr, SCIP_EXPRCURV curvature)

SCIP_EXPR * SCIPexpriterSkipDFS(SCIP_EXPRITER *iterator)

SCIP_Bool SCIPisExprSum(SCIP *scip, SCIP_EXPR *expr)

SCIP_RETCODE SCIPgetExprMonomialData(SCIP *scip, SCIP_EXPR *expr, SCIP_Real *coef, SCIP_Real *exponents, SCIP_EXPR **factors)

SCIP_RETCODE SCIPgetExprNVars(SCIP *scip, SCIP_EXPR *expr, int *nvars)

SCIP_RETCODE SCIPduplicateExprShallow(SCIP *scip, SCIP_EXPR *expr, SCIP_EXPR **copyexpr, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)

void SCIPexprGetQuadraticData(SCIP_EXPR *expr, SCIP_Real *constant, int *nlinexprs, SCIP_EXPR ***linexprs, SCIP_Real **lincoefs, int *nquadexprs, int *nbilinexprs, SCIP_Real **eigenvalues, SCIP_Real **eigenvectors)

SCIP_RETCODE SCIPreplaceExprChild(SCIP *scip, SCIP_EXPR *expr, int childidx, SCIP_EXPR *newchild)

SCIP_Bool SCIPisExprValue(SCIP *scip, SCIP_EXPR *expr)

SCIP_RETCODE SCIPcreateExpr2(SCIP *scip, SCIP_EXPR **expr, SCIP_EXPRHDLR *exprhdlr, SCIP_EXPRDATA *exprdata, SCIP_EXPR *child1, SCIP_EXPR *child2, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)

void SCIPfreeExprQuadratic(SCIP *scip, SCIP_EXPR *expr)

SCIP_RETCODE SCIPprintExprDot(SCIP *scip, SCIP_EXPRPRINTDATA *printdata, SCIP_EXPR *expr)

int SCIPcompareExpr(SCIP *scip, SCIP_EXPR *expr1, SCIP_EXPR *expr2)

SCIP_RETCODE SCIPreleaseExpr(SCIP *scip, SCIP_EXPR **expr)

SCIP_EXPR * SCIPexpriterGetCurrent(SCIP_EXPRITER *iterator)

void SCIPexpriterSetStagesDFS(SCIP_EXPRITER *iterator, SCIP_EXPRITER_STAGE stopstages)

SCIP_Bool SCIPisExprVar(SCIP *scip, 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 SCIPhashExpr(SCIP *scip, SCIP_EXPR *expr, unsigned int *hashval)

SCIP_RETCODE SCIPcomputeExprQuadraticCurvature(SCIP *scip, SCIP_EXPR *expr, SCIP_EXPRCURV *curv, SCIP_HASHMAP *assumevarfixed, SCIP_Bool storeeigeninfo)

SCIP_DECL_EXPRGETSYMDATA(SCIPcallExprGetSymData)

SCIP_DECL_EXPRCURVATURE(SCIPcallExprCurvature)

SCIP_RETCODE SCIPcallExprEval(SCIP *scip, SCIP_EXPR *expr, SCIP_Real *childrenvalues, SCIP_Real *val)

SCIP_EXPR * SCIPexpriterRestartDFS(SCIP_EXPRITER *iterator, SCIP_EXPR *expr)

SCIP_RETCODE SCIPcreateExpriter(SCIP *scip, SCIP_EXPRITER **iterator)

SCIP_RETCODE SCIPcallExprEvalFwdiff(SCIP *scip, SCIP_EXPR *expr, SCIP_Real *childrenvalues, SCIP_Real *direction, SCIP_Real *val, SCIP_Real *dot)

void SCIPexprSetIntegrality(SCIP_EXPR *expr, SCIP_Bool isintegral)

SCIP_RETCODE SCIPprintExpr(SCIP *scip, SCIP_EXPR *expr, FILE *file)

SCIP_EXPRCURV SCIPexprGetCurvature(SCIP_EXPR *expr)

SCIP_Real SCIPgetValueExprValue(SCIP_EXPR *expr)

void SCIPexpriterSetCurrentUserData(SCIP_EXPRITER *iterator, SCIP_EXPRITER_USERDATA userdata)

SCIP_Bool SCIPisExprPower(SCIP *scip, SCIP_EXPR *expr)

SCIP_RETCODE SCIPreplaceCommonSubexpressions(SCIP *scip, SCIP_EXPR **exprs, int nexprs, SCIP_Bool *replacedroot)

SCIP_EXPR * SCIPexpriterGetNext(SCIP_EXPRITER *iterator)

SCIP_DECL_EXPRSIMPLIFY(SCIPcallExprSimplify)

SCIP_RETCODE SCIPcheckExprQuadratic(SCIP *scip, SCIP_EXPR *expr, SCIP_Bool *isquadratic)

SCIP_EXPR ** SCIPexprGetChildren(SCIP_EXPR *expr)

SCIP_RETCODE SCIPprintExprDotFinal(SCIP *scip, SCIP_EXPRPRINTDATA **printdata)

SCIP_RETCODE SCIPprintExprDotInit(SCIP *scip, SCIP_EXPRPRINTDATA **printdata, FILE *file, SCIP_EXPRPRINT_WHAT whattoprint)

SCIP_DECL_EXPRESTIMATE(SCIPcallExprEstimate)

SCIP_RETCODE SCIPcopyExpr(SCIP *sourcescip, SCIP *targetscip, SCIP_EXPR *expr, SCIP_EXPR **copyexpr, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, SCIP_Bool *valid)

SCIP_VAR * SCIPgetVarExprVar(SCIP_EXPR *expr)

SCIP_RETCODE SCIPshowExpr(SCIP *scip, SCIP_EXPR *expr)

SCIP_Real SCIPevalExprQuadratic(SCIP *scip, SCIP_EXPR *expr, SCIP_SOL *sol)

SCIP_RETCODE SCIPcomputeExprCurvature(SCIP *scip, SCIP_EXPR *expr)

SCIP_DECL_EXPRREVERSEPROP(SCIPcallExprReverseprop)

void SCIPexprGetQuadraticQuadTerm(SCIP_EXPR *quadexpr, int termidx, SCIP_EXPR **expr, SCIP_Real *lincoef, SCIP_Real *sqrcoef, int *nadjbilin, int **adjbilin, SCIP_EXPR **sqrexpr)

int SCIPexpriterGetChildIdxDFS(SCIP_EXPRITER *iterator)

SCIP_DECL_EXPRINITESTIMATES(SCIPcallExprInitestimates)

void SCIPfreeExpriter(SCIP_EXPRITER **iterator)

SCIP_EXPRITER_STAGE SCIPexpriterGetStageDFS(SCIP_EXPRITER *iterator)

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 SCIPexpriterInit(SCIP_EXPRITER *iterator, SCIP_EXPR *expr, SCIP_EXPRITER_TYPE type, SCIP_Bool allowrevisit)

SCIP_RETCODE SCIPgetExprVarExprs(SCIP *scip, SCIP_EXPR *expr, SCIP_EXPR **varexprs, int *nvarexprs)

SCIP_EXPRITER_USERDATA SCIPexpriterGetExprUserData(SCIP_EXPRITER *iterator, SCIP_EXPR *expr)

SCIP_RETCODE SCIPdismantleExpr(SCIP *scip, FILE *file, SCIP_EXPR *expr)

SCIP_RETCODE SCIPremoveExprChildren(SCIP *scip, 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_RETCODE SCIPevalExprActivity(SCIP *scip, SCIP_EXPR *expr)

SCIP_EXPRHDLR * SCIPexprGetHdlr(SCIP_EXPR *expr)

SCIP_EXPR * SCIPexpriterGetChildExprDFS(SCIP_EXPRITER *iterator)

int SCIPcalcMemGrowSize(SCIP *scip, int num)

#define SCIPallocBufferArray(scip, ptr, num)

#define SCIPreallocBufferArray(scip, ptr, num)

#define SCIPfreeBufferArray(scip, ptr)

SCIP_Real SCIPgetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var)

SCIP_RETCODE SCIPparseVarName(SCIP *scip, const char *str, SCIP_VAR **var, char **endptr)

const char * SCIPvarGetName(SCIP_VAR *var)

SCIP_Bool SCIPstrToRealValue(const char *str, SCIP_Real *value, char **endptr)

SCIP_RETCODE SCIPskipSpace(char **s)

#define BMSreallocBufferMemoryArray(mem, ptr, num)

#define BMSfreeBufferMemoryArray(mem, ptr)

#define BMSallocBufferMemoryArray(mem, ptr, num)

internal miscellaneous methods

BMS_BLKMEM * SCIPblkmem(SCIP *scip)

public methods for problem variables

public methods for problem copies

static SCIP_RETCODE parseFactor(SCIP *scip, SCIP_Bool isdenominator, SCIP_HASHMAP *vartoexprvarmap, const char *expr, const char **newpos, SCIP_EXPR **factortree, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)

static SCIP_DECL_HASHKEYVAL(hashCommonSubexprKeyval)

static SCIP_RETCODE parseExpr(SCIP *scip, SCIP_HASHMAP *vartoexprvarmap, const char *expr, const char **newpos, SCIP_EXPR **exprtree, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)

static SCIP_DECL_HASHGETKEY(hashCommonSubexprGetKey)

static SCIP_RETCODE hashExpr(SCIP_SET *set, BMS_BUFMEM *bufmem, SCIP_EXPR *expr, SCIP_EXPRITER *hashiterator, int *nvisitedexprs)

static SCIP_DECL_EXPR_MAPEXPR(copyVarExpr)

static SCIP_RETCODE findEqualExpr(SCIP_SET *set, SCIP_EXPR *expr, SCIP_MULTIHASH *key2expr, SCIP_EXPR **newexpr)

static SCIP_RETCODE parseBase(SCIP *scip, SCIP_HASHMAP *vartoexprvarmap, const char *expr, const char **newpos, SCIP_EXPR **basetree, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)

static SCIP_RETCODE parseTerm(SCIP *scip, SCIP_HASHMAP *vartoexprvarmap, const char *expr, const char **newpos, SCIP_EXPR **termtree, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)

static SCIP_DECL_HASHKEYEQ(hashCommonSubexprEq)

public functions to work with algebraic expressions

public methods for memory management

public methods for message handling

public methods for global and local (sub)problems

public methods for solutions

public methods for SCIP variables

SCIP_EXPRHDLR * SCIPsetFindExprhdlr(SCIP_SET *set, const char *name)

SCIP_RETCODE SCIPsetIncludeExprhdlr(SCIP_SET *set, SCIP_EXPRHDLR *exprhdlr)

int SCIPsetCalcMemGrowSize(SCIP_SET *set, int num)

internal methods for global SCIP settings

SCIP_EXPRITER * hashiterator

datastructures for block memory pools and memory buffers

SCIP main data structure.

datastructures for problem statistics

#define SCIP_DECL_EXPR_OWNERCREATE(x)

struct SCIP_ExprhdlrData SCIP_EXPRHDLRDATA

struct SCIP_ExprData SCIP_EXPRDATA

#define SCIP_EXPRITER_VISITINGCHILD

unsigned int SCIP_EXPRPRINT_WHAT

#define SCIP_DECL_EXPREVAL(x)

struct SCIP_ExprPrintData SCIP_EXPRPRINTDATA

#define SCIP_EXPRITER_LEAVEEXPR

#define SCIP_EXPRPRINT_ALL

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