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__product_8c_source.php below:

SCIP Doxygen Documentation: expr_product.c Source File

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 79struct

SCIP_ExprhdlrData

107 for

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

122 void

* ownercreatedata

134

assert(list !=

NULL

);

135

assert(newnode !=

NULL

);

137

newnode->

next

= *list;

149

assert(list !=

NULL

);

155

*list = (*list)->

next

;

173 while

( (list=list->

next

) !=

NULL

)

189

(*newnode)->expr =

expr

;

190

(*newnode)->next =

NULL

;

207

assert(*list ==

NULL

);

210 debugSimplify

(

"building expr list from %d expressions\n"

, nexprs);

211 for

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

218

assert(nexprs > 1 || (*list)->next ==

NULL

);

230

assert(node !=

NULL

&& *node !=

NULL

);

247 if

( *exprlist ==

NULL

)

251 while

( current !=

NULL

)

256

current = current->

next

;

259

assert(current ==

NULL

);

275 void

* ownercreatedata

288 for

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

290

children[i] = exprlist->

expr

;

291

exprlist = exprlist->

next

;

294

assert(exprlist ==

NULL

);

320

assert(simplifiedfactor !=

NULL

);

321

assert(*simplifiedfactor ==

NULL

);

322

assert(factor !=

NULL

);

323

assert(changed !=

NULL

);

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

)

434

assert(previous ==

NULL

|| previous->

next

== current);

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 )

488

assert(previous ==

NULL

);

490

assert(aux == current);

491

current = *finalchildren;

495

assert(previous !=

NULL

);

497

current = current->

next

;

498

previous->

next

= current;

510

issignpower1 =

FALSE

;

516

issignpower1 =

TRUE

;

520

base1 = current->

expr

;

522

issignpower1 =

FALSE

;

528

issignpower2 =

FALSE

;

534

issignpower2 =

TRUE

;

538

base2 = tomergenode->

expr

;

540

issignpower2 =

FALSE

;

548 if

( !issignpower1 && !issignpower2 )

551#ifdef SCIP_DISABLED_CODE 563 else if

( issignpower1 ^ issignpower2 )

568 if

( (

int

)expo2 % 2 == 0 )

587 else if

( !

EPSISINT

(expo1+expo2, 0.0) )

601 if

(

EPSISINT

(expo1+expo2, 0.0) && (

int

)(expo1+expo2)%2 == 0 )

621 SCIP_CALL

( SCIPcallExprSimplify(

scip

, power, &simplifiedpower, ownercreate, ownercreatedata) );

626

tomergenode->

expr

= simplifiedpower;

632

tomergenode = tomergenode->

next

;

636 if

( current == *finalchildren )

638

assert(previous ==

NULL

);

640

assert(aux == current);

641

current = *finalchildren;

645

assert(previous !=

NULL

);

647

current = current->

next

;

648

previous->

next

= current;

662 if

( compareres == -1 )

666

current = current->

next

;

671

assert(compareres == 1);

674 if

( current == *finalchildren )

676

assert(previous ==

NULL

);

678

tomergenode = tomergenode->

next

;

680

previous = *finalchildren;

684

assert(previous !=

NULL

);

687

tomergenode = tomergenode->

next

;

689

previous->

next

= aux;

690

aux->

next

= current;

697 if

( tomergenode ==

NULL

)

700

assert(current ==

NULL

);

705 if

( *finalchildren ==

NULL

)

707

assert(previous ==

NULL

);

708

*finalchildren = tomergenode;

714

previous->

next

= tomergenode;

732 void

* ownercreatedata

740

unsimplifiedchildren =

NULL

;

746

*finalchildren =

NULL

;

747 while

( unsimplifiedchildren !=

NULL

)

753

assert(first !=

NULL

);

772 if

( *simplifiedcoef == 0.0 )

777

assert(*finalchildren ==

NULL

);

796 void

* ownercreatedata

800 if

( finalchildren ==

NULL

)

807 if

( finalchildren->

next

==

NULL

&& simplifiedcoef == 1.0 )

809

*simplifiedexpr = finalchildren->

expr

;

824 SCIP_CALL

( SCIPcallExprSimplify(

scip

, sum, simplifiedexpr, ownercreate, ownercreatedata) );

840 void

* ownercreatedata

853

entropicchild = finalchildren->

next

->

expr

;

860

entropicchild = finalchildren->

expr

;

864 if

( entropicchild !=

NULL

)

868

simplifiedcoef *= -1.0;

873 if

( simplifiedcoef != 1.0 )

879

*simplifiedexpr = entropy;

902 void

* ownercreatedata

936 for

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

956 for

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

972 for

( j = 0; j < nchildren1; ++j )

979 for

( k = 0; k < nchildren2; ++k )

991 debugSimplify

(

"multiplying %g expr1 * %g expr2\n"

, coef1, coef2);

1000

factorscoef = coef1 * coef2;

1002

assert(factorscoef != 0.0);

1004#ifdef SIMPLIFY_DEBUG 1009 debugSimplify

(

"Building product from simplified factors\n"

);

1010

node = finalfactors;

1012 while

( node !=

NULL

)

1017

node = node->

next

;

1024

assert(finalfactors ==

NULL

);

1025

assert(term !=

NULL

);

1027#ifdef SIMPLIFY_DEBUG 1028 debugSimplify

(

"%g expr1 * %g expr2 = %g * product\n"

, coef1, coef2, coef1 * coef2);

1041 SCIP_CALL

( SCIPcallExprSimplify(

scip

, expanded, simplifiedexpr, ownercreate, ownercreatedata) );

1060

sum = finalchildren->

expr

;

1061

factors[0] = finalchildren->

next

->

expr

;

1066

sum = finalchildren->

next

->

expr

;

1067

factors[0] = finalchildren->

expr

;

1075 for

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

1088

assert(termcoef != 0.0);

1091

assert(finalfactors ==

NULL

);

1092

assert(term !=

NULL

);

1099 SCIP_CALL

( SCIPcallExprSimplify(

scip

, expanded, simplifiedexpr, ownercreate, ownercreatedata) );

1118 void

* ownercreatedata

1130 for

( n = finalchildren; n !=

NULL

; n = n->

next

)

1134 if

( sum_node ==

NULL

)

1144 if

( sum_node ==

NULL

|| nfactors == 0 )

1149 for

( n = finalchildren, j = 0; n !=

NULL

; n = n->

next

)

1150 if

( n != sum_node )

1151

factors[j++] = n->

expr

;

1160 if

( nfactors == 1 )

1172

assert(termcoef != 0.0);

1175

assert(finalfactors ==

NULL

);

1176

assert(term !=

NULL

);

1183 for

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

1196

assert(termcoef != 0.0);

1199

assert(finalfactors ==

NULL

);

1200

assert(term !=

NULL

);

1207 SCIP_CALL

( SCIPcallExprSimplify(

scip

, expanded, simplifiedexpr, ownercreate, ownercreatedata) );

1228 void

* ownercreatedata

1231 EXPRNODE

* finalchildren = *simplifiedfactors;

1236

*simplifiedexpr =

NULL

;

1238 SCIP_CALL

(

enforceSP11

(

scip

, simplifiedcoef, *simplifiedfactors, simplifiedexpr, ownercreate, ownercreatedata) );

1239 if

( *simplifiedexpr !=

NULL

)

1242 SCIP_CALL

(

enforceSP12

(

scip

, simplifiedcoef, *simplifiedfactors, expandalways, simplifiedexpr, ownercreate, ownercreatedata) );

1243 if

( *simplifiedexpr !=

NULL

)

1249 if

( *simplifiedexpr !=

NULL

)

1253 SCIP_CALL

(

enforceSP10

(

scip

, simplifiedcoef, *simplifiedfactors, simplifiedexpr, ownercreate, ownercreatedata) );

1254 if

( *simplifiedexpr !=

NULL

)

1258 if

( simplifiedcoef != 1.0 )

1269 SCIP_CALL

( SCIPcallExprSimplify(

scip

, sum, simplifiedexpr, ownercreate, ownercreatedata) );

1312

assert(conshdlr !=

NULL

);

1313

assert(nfactors > 0);

1314

assert(bounds !=

NULL

);

1315

assert(constantfactor != 0.0);

1316

assert(coefs !=

NULL

);

1317

assert(constant !=

NULL

);

1318

assert(success !=

NULL

);

1325 for

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

1335

box[2*i] = bounds[i].

inf

;

1336

box[2*i+1] = bounds[i].

sup

;

1338

xstar[i] = refpoint !=

NULL

? refpoint[i] : 0.5 * (box[2*i] + box[2*i+1]);

1347

overestimate, prodfunction, &constantfactor, xstar, box, nfactors, targetvalue, success, coefs, constant) );

1384

assert(simplifiedexpr !=

NULL

);

1388#ifdef SIMPLIFY_DEBUG 1397

&finalchildren, &changed, ownercreate, ownercreatedata) );

1399#ifdef SIMPLIFY_DEBUG 1404 debugSimplify

(

"Building product from simplified factors\n"

);

1405

node = finalchildren;

1407 while

( node !=

NULL

)

1412

node = node->

next

;

1421

assert(finalchildren ==

NULL

);

1423 if

( *simplifiedexpr ==

NULL

)

1425

*simplifiedexpr =

expr

;

1430

assert(*simplifiedexpr !=

NULL

);

1465 for

( i = nchildren1 - 1, j = nchildren2 - 1; i >= 0 && j >= 0; --i, --j )

1468 if

( compareresult != 0 )

1469 return

compareresult;

1488

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

1512

assert(exprhdlr !=

NULL

);

1513

assert(exprhdlrdata !=

NULL

);

1514

assert(*exprhdlrdata !=

NULL

);

1517

assert(*exprhdlrdata ==

NULL

);

1528

assert(targetexprdata !=

NULL

);

1529

assert(sourceexpr !=

NULL

);

1532

assert(sourceexprdata !=

NULL

);

1548

assert(exprdata !=

NULL

);

1566

assert(exprdata !=

NULL

);

1579 if

( exprdata->coefficient != 1.0 )

1596 if

( exprdata->coefficient != 1.0 || currentchild > 0 )

1635

assert(hashkey !=

NULL

);

1636

assert(childrenhashes !=

NULL

);

1639

assert(exprdata !=

NULL

);

1645

*hashkey ^= childrenhashes[c];

1661

assert(exprdata !=

NULL

);

1663

*val = exprdata->coefficient;

1685

assert(dot !=

NULL

);

1743

assert(bardot !=

NULL

);

1748

assert(partialchild !=

NULL

);

1760 if

( c == childidx )

1781 if

( i == c || i == childidx )

1805

assert(child !=

NULL

);

1823 if

( i == childidx )

1844

assert(exprdata !=

NULL

);

1892

assert(refpoint !=

NULL

);

1893

assert(coefs !=

NULL

);

1894

assert(constant !=

NULL

);

1895

assert(islocal !=

NULL

);

1896

assert(branchcand !=

NULL

);

1897

assert(*branchcand ==

TRUE

);

1898

assert(success !=

NULL

);

1901

assert(exprdata !=

NULL

);

1916 SCIPdebugMsg

(

scip

,

"child %d = %g in [%g, %g]\n"

, c, refpoint[c], localbounds[c].inf, localbounds[c].sup);

1928 if

( nchildren == 2 )

1936

refpointx = refpoint[0];

1937

bndx = localbounds[0];

1941

refpointy = refpoint[1];

1942

bndy = localbounds[1];

1946

refpointx =

MIN

(

MAX

(refpointx, bndx.

inf

), bndx.

sup

);

1947

refpointy =

MIN

(

MAX

(refpointy, bndy.

inf

), bndy.

sup

);

1955

bndy.

inf

, bndy.

sup

, refpointy, overestimate, &coefs[0], &coefs[1], constant,

1963

assert(exprhdlrdata !=

NULL

);

1965 if

( exprhdlrdata->conshdlr !=

NULL

)

1968

targetvalue, coefs, constant, success) );

1972 SCIPdebugMsg

(

scip

,

"no cons_nonlinear included in SCIP, cannot estimate vertex-polyhedral product function\n"

);

1990

assert(nreturned !=

NULL

);

1995

assert(exprdata !=

NULL

);

1997 if

( nchildren == 2 )

2008

bndy.

inf

, bndy.

sup

, (bndy.

inf

+ bndy.

sup

) / 2.0, overestimate, &coefs[0][0], &coefs[0][1],

2009

constant, &success);

2016

assert(exprhdlrdata !=

NULL

);

2018 if

( exprhdlrdata->conshdlr !=

NULL

)

2025 SCIPdebugMsg

(

scip

,

"no cons_nonlinear included in SCIP, cannot estimate vertex-polyhedral product function\n"

);

2049

assert(infeasible !=

NULL

);

2050

assert(childrenbounds !=

NULL

);

2052

*infeasible =

FALSE

;

2065

assert(exprdata !=

NULL

);

2082

childbounds = childrenbounds[j];

2085

*infeasible =

TRUE

;

2092

childbounds = childrenbounds[i];

2095

*infeasible =

TRUE

;

2102 SCIPdebugMsg

(

scip

,

"child %d: solved [%g,%g]*x = [%g,%g] with x in [%g,%g] -> x = [%g,%g]\n"

, i, otherfactor.

inf

, otherfactor.

sup

,

2103

bounds.inf, bounds.sup,

2104

childrenbounds[i].inf, childrenbounds[i].sup,

2105

childbounds.

inf

, childbounds.

sup

);

2111

*infeasible =

TRUE

;

2126

assert(success !=

NULL

);

2152

assert(result !=

NULL

);

2154

assert(childidx >= 0);

2167 if

( i == childidx )

2184 if

( nneg % 2 == 0 )

2201

assert(isintegral !=

NULL

);

2204

assert(exprdata !=

NULL

);

2206

*isintegral =

EPSISINT

(exprdata->coefficient, 0.0);

2211

assert(child !=

NULL

);

2225

assert(symdata !=

NULL

);

2229

(*symdata)->nconstants = 1;

2230

(*symdata)->ncoefficients = 0;

2251

assert(exprhdlr !=

NULL

);

2269 "whether to expand products of a sum and several factors in simplify"

,

2283 void

* ownercreatedata

2290

exprdata->coefficient = coefficient;

2310

assert(exprdata !=

NULL

);

2312 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_DECL_EXPRHASH(hashProduct)

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_DECL_EXPRCURVATURE(curvatureProduct)

static SCIP_DECL_EXPRESTIMATE(estimateProduct)

static SCIP_RETCODE enforceSP11(SCIP *scip, SCIP_Real simplifiedcoef, EXPRNODE *finalchildren, SCIP_EXPR **simplifiedexpr, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)

static SCIP_DECL_EXPRSIMPLIFY(simplifyProduct)

static SCIP_DECL_EXPRINTEVAL(intevalProduct)

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_DECL_EXPRFREEDATA(freedataProduct)

static SCIP_DECL_EXPRPRINT(printProduct)

static SCIP_DECL_EXPRFREEHDLR(freehdlrProduct)

static SCIP_RETCODE simplifyFactor(SCIP *scip, SCIP_EXPR *factor, SCIP_Real *simplifiedcoef, EXPRNODE **simplifiedfactor, SCIP_Bool *changed)

static SCIP_DECL_EXPRGETSYMDATA(getSymDataProduct)

static SCIP_RETCODE createExprProductFromExprlist(SCIP *scip, EXPRNODE *exprlist, SCIP_Real coef, SCIP_EXPR **expr, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)

static SCIP_DECL_EXPRINITESTIMATES(initestimatesProduct)

static SCIP_RETCODE createExprNode(SCIP *scip, SCIP_EXPR *expr, EXPRNODE **newnode)

static EXPRNODE * listPopFirst(EXPRNODE **list)

static SCIP_DECL_EXPRCOPYDATA(copydataProduct)

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)

static SCIP_DECL_EXPRBWFWDIFF(bwfwdiffProduct)

static SCIP_DECL_EXPRINTEGRALITY(integralityProduct)

static SCIP_DECL_EXPRCOMPARE(compareProduct)

#define EXPRHDLR_PRECEDENCE

static SCIP_DECL_VERTEXPOLYFUN(prodfunction)

static SCIP_RETCODE createExprlistFromExprs(SCIP *scip, SCIP_EXPR **exprs, int nexprs, EXPRNODE **list)

static SCIP_DECL_EXPREVAL(evalProduct)

static SCIP_DECL_EXPRFWDIFF(fwdiffProduct)

static SCIP_DECL_EXPRMONOTONICITY(monotonicityProduct)

static SCIP_RETCODE mergeProductExprlist(SCIP *scip, EXPRNODE *tomerge, EXPRNODE **finalchildren, EXPRNODE **unsimplifiedchildren, SCIP_Bool *changed, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)

static SCIP_DECL_EXPRCOPYHDLR(copyhdlrProduct)

static SCIP_DECL_EXPRREVERSEPROP(reversepropProduct)

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)

static SCIP_DECL_EXPRBWDIFF(bwdiffProduct)

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

SCIP_EXPRHDLR * SCIPgetExprhdlrProduct(SCIP *scip)

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

SCIP_EXPRHDLRDATA * SCIPexprhdlrGetData(SCIP_EXPRHDLR *exprhdlr)

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

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)

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)

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)

struct SCIP_ExprhdlrData SCIP_EXPRHDLRDATA

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