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

SCIP Doxygen Documentation: expr.c Source File

59struct

SCIP_ExprPrintData

79

assert(expr !=

NULL

);

80

assert(*expr !=

NULL

);

81

assert((*expr)->nuses == 1);

82

assert((*expr)->quaddata ==

NULL

);

83

assert((*expr)->ownerdata ==

NULL

);

89

assert(*expr ==

NULL

);

154

assert(expr !=

NULL

);

155

assert(expr2idx !=

NULL

);

156

assert(quadexpr !=

NULL

);

157

assert(quadexprterm !=

NULL

);

162

assert((*quadexprterm)->expr == expr);

170

(*quadexprterm)->expr = expr;

171

(*quadexprterm)->sqrcoef = 0.0;

172

(*quadexprterm)->sqrexpr =

NULL

;

173

(*quadexprterm)->lincoef = 0.0;

174

(*quadexprterm)->nadjbilin = 0;

201

assert(stat !=

NULL

);

202

assert(blkmem !=

NULL

);

203

assert(expr !=

NULL

);

222 if

( soltag == 0 || expr->

evaltag

!= soltag )

258#undef SCIPexprhdlrSetCopyFreeHdlr 259#undef SCIPexprhdlrSetCopyFreeData 260#undef SCIPexprhdlrSetPrint 261#undef SCIPexprhdlrSetParse 262#undef SCIPexprhdlrSetCurvature 263#undef SCIPexprhdlrSetMonotonicity 264#undef SCIPexprhdlrSetIntegrality 265#undef SCIPexprhdlrSetHash 266#undef SCIPexprhdlrSetCompare 267#undef SCIPexprhdlrSetDiff 268#undef SCIPexprhdlrSetIntEval 269#undef SCIPexprhdlrSetSimplify 270#undef SCIPexprhdlrSetReverseProp 271#undef SCIPexprhdlrSetEstimate 272#undef SCIPexprhdlrSetGetSymdata 273#undef SCIPexprhdlrGetName 274#undef SCIPexprhdlrGetDescription 275#undef SCIPexprhdlrGetPrecedence 276#undef SCIPexprhdlrGetData 277#undef SCIPexprhdlrHasPrint 278#undef SCIPexprhdlrHasBwdiff 279#undef SCIPexprhdlrHasFwdiff 280#undef SCIPexprhdlrHasIntEval 281#undef SCIPexprhdlrHasEstimate 282#undef SCIPexprhdlrHasInitEstimates 283#undef SCIPexprhdlrHasSimplify 284#undef SCIPexprhdlrHasCurvature 285#undef SCIPexprhdlrHasMonotonicity 286#undef SCIPexprhdlrHasReverseProp 287#undef SCIPexprhdlrGetNCreated 288#undef SCIPexprhdlrGetNIntevalCalls 289#undef SCIPexprhdlrGetIntevalTime 290#undef SCIPexprhdlrGetNReversepropCalls 291#undef SCIPexprhdlrGetReversepropTime 292#undef SCIPexprhdlrGetNCutoffs 293#undef SCIPexprhdlrGetNDomainReductions 294#undef SCIPexprhdlrIncrementNDomainReductions 295#undef SCIPexprhdlrGetNEstimateCalls 296#undef SCIPexprhdlrGetEstimateTime 297#undef SCIPexprhdlrGetNBranchings 298#undef SCIPexprhdlrIncrementNBranchings 299#undef SCIPexprhdlrGetNSimplifyCalls 300#undef SCIPexprhdlrGetSimplifyTime 301#undef SCIPexprhdlrGetNSimplifications 310 unsigned int

precedence,

315

assert(exprhdlr !=

NULL

);

316

assert(name !=

NULL

);

326

(*exprhdlr)->precedence = precedence;

327

(*exprhdlr)->eval =

eval

;

328

(*exprhdlr)->data = data;

346 if

( (*exprhdlr)->freehdlr !=

NULL

)

348 SCIP_CALL

( (*exprhdlr)->freehdlr(

set

->scip, *exprhdlr, &(*exprhdlr)->

data

) );

376

assert(exprhdlr !=

NULL

);

378

exprhdlr->copyhdlr = copyhdlr;

379

exprhdlr->freehdlr = freehdlr;

389

assert(exprhdlr !=

NULL

);

391

exprhdlr->copydata = copydata;

392

exprhdlr->freedata = freedata;

401

assert(exprhdlr !=

NULL

);

403

exprhdlr->print = print;

412

assert(exprhdlr !=

NULL

);

414

exprhdlr->parse = parse;

423

assert(exprhdlr !=

NULL

);

425

exprhdlr->curvature = curvature;

434

assert(exprhdlr !=

NULL

);

436

exprhdlr->monotonicity = monotonicity;

445

assert(exprhdlr !=

NULL

);

447

exprhdlr->integrality = integrality;

456

assert(exprhdlr !=

NULL

);

458

exprhdlr->hash = hash;

467

assert(exprhdlr !=

NULL

);

469

exprhdlr->compare = compare;

480

assert(exprhdlr !=

NULL

);

482

exprhdlr->bwdiff = bwdiff;

483

exprhdlr->fwdiff = fwdiff;

484

exprhdlr->bwfwdiff = bwfwdiff;

493

assert(exprhdlr !=

NULL

);

495

exprhdlr->inteval = inteval;

504

assert(exprhdlr !=

NULL

);

506

exprhdlr->simplify = simplify;

515

assert(exprhdlr !=

NULL

);

517

exprhdlr->reverseprop = reverseprop;

526

assert(exprhdlr !=

NULL

);

528

exprhdlr->getsymdata = getsymdata;

538

assert(exprhdlr !=

NULL

);

540

exprhdlr->initestimates = initestimates;

541

exprhdlr->estimate = estimate;

549

assert(exprhdlr !=

NULL

);

551 return

exprhdlr->

name

;

559

assert(exprhdlr !=

NULL

);

561 return

exprhdlr->

desc

;

569

assert(exprhdlr !=

NULL

);

579

assert(exprhdlr !=

NULL

);

581 return

exprhdlr->

data

;

589

assert(exprhdlr !=

NULL

);

591 return

exprhdlr->print !=

NULL

;

599

assert(exprhdlr !=

NULL

);

601 return

exprhdlr->bwdiff !=

NULL

;

609

assert(exprhdlr !=

NULL

);

611 return

exprhdlr->fwdiff !=

NULL

;

619

assert(exprhdlr !=

NULL

);

621 return

exprhdlr->inteval !=

NULL

;

629

assert(exprhdlr !=

NULL

);

631 return

exprhdlr->estimate !=

NULL

;

639

assert(exprhdlr !=

NULL

);

641 return

exprhdlr->initestimates !=

NULL

;

649

assert(exprhdlr !=

NULL

);

651 return

exprhdlr->simplify !=

NULL

;

659

assert(exprhdlr !=

NULL

);

661 return

exprhdlr->curvature !=

NULL

;

669

assert(exprhdlr !=

NULL

);

671 return

exprhdlr->monotonicity !=

NULL

;

679

assert(exprhdlr !=

NULL

);

681 return

exprhdlr->reverseprop !=

NULL

;

689

assert(exprhdlr !=

NULL

);

691 return

exprhdlr->getsymdata !=

NULL

;

705

assert(exprhdlr !=

NULL

);

715

assert(exprhdlr !=

NULL

);

725

assert(exprhdlr !=

NULL

);

735

assert(exprhdlr !=

NULL

);

745

assert(exprhdlr !=

NULL

);

755

assert(exprhdlr !=

NULL

);

765

assert(exprhdlr !=

NULL

);

776

assert(exprhdlr !=

NULL

);

777

assert(nreductions >= 0);

787

assert(exprhdlr !=

NULL

);

797

assert(exprhdlr !=

NULL

);

811

assert(exprhdlr !=

NULL

);

821

assert(exprhdlr !=

NULL

);

831

assert(exprhdlr !=

NULL

);

841

assert(exprhdlr !=

NULL

);

851

assert(exprhdlr !=

NULL

);

864

assert(exprhdlr !=

NULL

);

865

assert(targetset !=

NULL

);

868 if

( exprhdlr->copyhdlr !=

NULL

)

870 SCIPsetDebugMsg

(targetset,

"including expression handler <%s> in subscip %p\n"

,

872 SCIP_CALL

( exprhdlr->copyhdlr(targetset->

scip

, exprhdlr) );

876 SCIPsetDebugMsg

(targetset,

"expression handler <%s> cannot be copied to subscip %p due " 889

assert(exprhdlr !=

NULL

);

891 if

(

set

->misc_resetstat )

924 unsigned int

parentprecedence,

928

assert(exprhdlr !=

NULL

);

930

assert(expr !=

NULL

);

931

assert(expr->

exprhdlr

== exprhdlr);

932

assert(messagehdlr !=

NULL

);

936 SCIP_CALL

( exprhdlr->print(

set

->scip, expr, stage, currentchild, parentprecedence, file) );

955

assert(currentchild >= 0);

956

assert(currentchild < expr->nchildren);

957 if

( currentchild < expr->nchildren-1 )

989 const char

*

string

,

990 const char

** endstring,

994 void

* ownercreatedata

997

assert(exprhdlr !=

NULL

);

999

assert(expr !=

NULL

);

1003 if

( exprhdlr->parse ==

NULL

)

1014 SCIP_CALL

( exprhdlr->parse(

set

->scip, exprhdlr,

string

, endstring, expr, success, ownercreate, ownercreatedata) );

1016

assert(*success || (*expr ==

NULL

));

1034

assert(exprhdlr !=

NULL

);

1036

assert(expr !=

NULL

);

1037

assert(expr->

exprhdlr

== exprhdlr);

1038

assert(success !=

NULL

);

1042 if

( exprhdlr->curvature !=

NULL

)

1044 SCIP_CALL

( exprhdlr->curvature(

set

->scip, expr, exprcurvature, success, childcurv) );

1062

assert(exprhdlr !=

NULL

);

1064

assert(expr !=

NULL

);

1065

assert(expr->

exprhdlr

== exprhdlr);

1066

assert(result !=

NULL

);

1071 if

( exprhdlr->monotonicity !=

NULL

)

1073 SCIP_CALL

( exprhdlr->monotonicity(

set

->scip, expr, childidx, result) );

1090

assert(exprhdlr !=

NULL

);

1092

assert(expr !=

NULL

);

1093

assert(expr->

exprhdlr

== exprhdlr);

1094

assert(isintegral !=

NULL

);

1096

*isintegral =

FALSE

;

1099 if

( exprhdlr->integrality !=

NULL

)

1101 SCIP_CALL

( exprhdlr->integrality(

set

->scip, expr, isintegral) );

1117 unsigned int

* hashkey,

1118 unsigned int

* childrenhashes

1121

assert(exprhdlr !=

NULL

);

1123

assert(expr !=

NULL

);

1124

assert(expr->

exprhdlr

== exprhdlr);

1125

assert(hashkey !=

NULL

);

1140 for

( i = 0; expr->

exprhdlr

->

name

[i] !=

'\0'

; i++ )

1141

*hashkey += (

unsigned int

) expr->

exprhdlr

->

name

[i];

1146 for

( i = 0; i < expr->

nchildren

; ++i )

1147

*hashkey ^= childrenhashes[i];

1170

assert(expr1 !=

NULL

);

1171

assert(expr2 !=

NULL

);

1177 return

expr1->

exprhdlr

->compare(

set

->scip, expr1, expr2);

1190 if

( compareresult != 0 )

1191 return

compareresult;

1217

assert(exprhdlr !=

NULL

);

1219

assert(expr !=

NULL

);

1220

assert(expr->

exprhdlr

== exprhdlr);

1221

assert(exprhdlr->eval !=

NULL

);

1222

assert(val !=

NULL

);

1229

assert(bufmem !=

NULL

);

1233 for

( c = 0; c < expr->

nchildren

; ++c )

1241 SCIP_CALL

( exprhdlr->eval(

set

->scip, expr, val, sol) );

1248 if

( origvals !=

NULL

)

1251 for

( c = 0; c < expr->

nchildren

; ++c )

1287

assert(exprhdlr !=

NULL

);

1289

assert(expr !=

NULL

);

1290

assert(expr->

exprhdlr

== exprhdlr);

1291

assert(derivative !=

NULL

);

1293 if

( exprhdlr->bwdiff ==

NULL

)

1299 if

( childrenvals !=

NULL

)

1304

assert(bufmem !=

NULL

);

1307 for

( c = 0; c < expr->

nchildren

; ++c )

1325 if

( childrenvals !=

NULL

)

1329 for

( c = 0; c < expr->

nchildren

; ++c )

1353

assert(exprhdlr !=

NULL

);

1355

assert(expr !=

NULL

);

1356

assert(expr->

exprhdlr

== exprhdlr);

1357

assert(dot !=

NULL

);

1359 if

( exprhdlr->fwdiff ==

NULL

)

1365 SCIP_CALL

( exprhdlr->fwdiff(

set

->scip, expr, dot, direction) );

1403

assert(exprhdlr !=

NULL

);

1405

assert(expr !=

NULL

);

1406

assert(expr->

exprhdlr

== exprhdlr);

1407

assert(exprhdlr->eval !=

NULL

);

1408

assert(val !=

NULL

);

1409

assert(dot !=

NULL

);

1416

assert(bufmem !=

NULL

);

1420 for

( c = 0; c < expr->

nchildren

; ++c )

1432

assert(bufmem !=

NULL

);

1436 for

( c = 0; c < expr->

nchildren

; ++c )

1447 SCIP_CALL

( exprhdlr->eval(

set

->scip, expr, val, sol) );

1463 if

( origdots !=

NULL

)

1466 for

( c = 0; c < expr->

nchildren

; ++c )

1473 if

( origvals !=

NULL

)

1476 for

( c = 0; c < expr->

nchildren

; ++c )

1498

assert(exprhdlr !=

NULL

);

1500

assert(expr !=

NULL

);

1501

assert(expr->

exprhdlr

== exprhdlr);

1502

assert(childidx >= 0);

1503

assert(childidx < expr->nchildren);

1504

assert(bardot !=

NULL

);

1506 if

( exprhdlr->bwfwdiff ==

NULL

)

1531 void

* intevalvardata

1534

assert(exprhdlr !=

NULL

);

1536

assert(expr !=

NULL

);

1537

assert(expr->

exprhdlr

== exprhdlr);

1538

assert(interval !=

NULL

);

1540 if

( exprhdlr->inteval !=

NULL

)

1543 SCIP_CALL

( exprhdlr->inteval(

set

->scip, expr, interval, intevalvar, intevalvardata) );

1572

assert(exprhdlr !=

NULL

);

1574

assert(expr !=

NULL

);

1575

assert(expr->

exprhdlr

== exprhdlr);

1576

assert(coefs !=

NULL

);

1577

assert(islocal !=

NULL

);

1578

assert(success !=

NULL

);

1582 if

( exprhdlr->estimate !=

NULL

)

1585 SCIP_CALL

( exprhdlr->estimate(

set

->scip, expr, localbounds, globalbounds, refpoint, overestimate, targetvalue,

1586

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

1611

assert(exprhdlr !=

NULL

);

1613

assert(expr !=

NULL

);

1614

assert(expr->

exprhdlr

== exprhdlr);

1615

assert(nreturned !=

NULL

);

1619 if

( exprhdlr->initestimates )

1622 SCIP_CALL

( exprhdlr->initestimates(

set

->scip, expr, bounds, overestimate, coefs, constant, nreturned) );

1641 void

* ownercreatedata

1644

assert(exprhdlr !=

NULL

);

1646

assert(expr !=

NULL

);

1647

assert(expr->

exprhdlr

== exprhdlr);

1648

assert(simplifiedexpr !=

NULL

);

1650 if

( exprhdlr->simplify !=

NULL

)

1653 SCIP_CALL

( exprhdlr->simplify(

set

->scip, expr, simplifiedexpr, ownercreate, ownercreatedata) );

1658 if

( expr != *simplifiedexpr )

1663

*simplifiedexpr = expr;

1689

assert(exprhdlr !=

NULL

);

1691

assert(expr !=

NULL

);

1692

assert(expr->

exprhdlr

== exprhdlr);

1694

assert(infeasible !=

NULL

);

1696

*infeasible =

FALSE

;

1698 if

( exprhdlr->reverseprop !=

NULL

)

1701 SCIP_CALL

( exprhdlr->reverseprop(

set

->scip, expr, bounds, childrenbounds, infeasible) );

1719#undef SCIPexprCapture 1721#undef SCIPexprIsValue 1723#undef SCIPexprIsProduct 1724#undef SCIPexprIsPower 1737 void

* ownercreatedata

1743

assert(blkmem !=

NULL

);

1744

assert(expr !=

NULL

);

1745

assert(exprhdlr !=

NULL

);

1746

assert(children !=

NULL

|| nchildren == 0);

1747

assert(exprdata ==

NULL

|| exprhdlr->copydata !=

NULL

);

1748

assert(exprdata ==

NULL

|| exprhdlr->freedata !=

NULL

);

1752

(*expr)->exprhdlr = exprhdlr;

1753

(*expr)->exprdata = exprdata;

1754

(*expr)->activitytag = -1;

1760 if

( nchildren > 0 )

1763

(*expr)->nchildren = nchildren;

1764

(*expr)->childrensize = nchildren;

1766 for

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

1775 if

( ownercreate !=

NULL

)

1777 SCIP_CALL

( ownercreate(

set

->scip, *expr, &(*expr)->

ownerdata

, &(*expr)->ownerfree, &(*expr)->ownerprint,

1778

&(*expr)->ownerevalactivity, ownercreatedata) );

1793

assert(blkmem !=

NULL

);

1794

assert(child !=

NULL

);

1826

assert(blkmem !=

NULL

);

1827

assert(expr !=

NULL

);

1828

assert(newchild !=

NULL

);

1829

assert(childidx >= 0);

1830

assert(childidx < expr->nchildren);

1833 if

( newchild == expr->

children

[childidx] )

1840

expr->

children

[childidx] = newchild;

1856

assert(blkmem !=

NULL

);

1857

assert(expr !=

NULL

);

1859 for

( c = 0; c < expr->

nchildren

; ++c )

1890 void

* ownercreatedata

1896 SCIP

* sourcescip =

set

->scip;

1897 SCIP

* targetscip = targetset->

scip

;

1900

assert(stat !=

NULL

);

1901

assert(blkmem !=

NULL

);

1902

assert(targetset !=

NULL

);

1903

assert(sourceexpr !=

NULL

);

1904

assert(targetexpr !=

NULL

);

1905

assert(sourcescip !=

NULL

);

1906

assert(targetscip !=

NULL

);

1924 if

( mapexpr !=

NULL

)

1926 SCIP_CALL

( mapexpr(targetscip, &exprcopy, sourcescip, expr, ownercreate, ownercreatedata, mapexprdata) );

1927 if

( exprcopy !=

NULL

)

1931

expriteruserdata.

ptrval

= exprcopy;

1941 if

( targetscip != sourcescip )

1945 if

( targetexprhdlr ==

NULL

)

1959

assert(targetexprhdlr !=

NULL

);

1965 SCIP_CALL

( expr->

exprhdlr

->copydata(targetscip, targetexprhdlr, &targetexprdata, sourcescip, expr) );

1969

targetexprdata =

NULL

;

1974

ownercreate, ownercreatedata) );

1977

expriteruserdata.

ptrval

= exprcopy;

1993 if

( childcopy ==

NULL

)

2039 void

* ownercreatedata

2045

assert(blkmem !=

NULL

);

2046

assert(expr !=

NULL

);

2047

assert(copyexpr !=

NULL

);

2068

assert(expr !=

NULL

);

2084

assert(rootexpr !=

NULL

);

2085

assert(*rootexpr !=

NULL

);

2086

assert((*rootexpr)->nuses > 0);

2088 if

( (*rootexpr)->nuses > 1 )

2090

--(*rootexpr)->nuses;

2101 if

( (*rootexpr)->ownerfree !=

NULL

)

2104

assert((*rootexpr)->ownerdata ==

NULL

);

2111 if

( (*rootexpr)->exprdata !=

NULL

)

2113

assert((*rootexpr)->exprhdlr->freedata !=

NULL

);

2114 SCIP_CALL

( (*rootexpr)->exprhdlr->freedata(

set

->scip, *rootexpr) );

2126

assert(expr !=

NULL

);

2127

assert(0 <= expr->

nuses

&& expr->

nuses

<= 2);

2139 if

( child->

nuses

> 1 )

2147

assert(child->

nuses

== 1);

2150 if

( child->ownerfree !=

NULL

)

2177

assert(child->

nuses

== 1);

2212

assert(expr !=

NULL

);

2224

assert(expr !=

NULL

);

2236

assert(expr !=

NULL

);

2248

assert(expr !=

NULL

);

2260

assert(expr !=

NULL

);

2278 unsigned int

parentprecedence;

2281

assert(blkmem !=

NULL

);

2282

assert(expr !=

NULL

);

2301

parentprecedence = 0;

2304

parentprecedence, file) );

2325

assert(stat !=

NULL

);

2326

assert(blkmem !=

NULL

);

2327

assert(printdata !=

NULL

);

2334

(*printdata)->file = file;

2336

(*printdata)->closefile =

FALSE

;

2337

(*printdata)->whattoprint = whattoprint;

2340

fputs(

"strict digraph exprgraph {\n"

, file);

2341

fputs(

"node [fontcolor=white, style=filled, rankdir=LR]\n"

, file);

2352 const char

* filename,

2359

assert(stat !=

NULL

);

2360

assert(blkmem !=

NULL

);

2361

assert(printdata !=

NULL

);

2362

assert(filename !=

NULL

);

2364

f = fopen(filename,

"w"

);

2373

(*printdata)->closefile =

TRUE

;

2390

assert(printdata !=

NULL

);

2391

assert(expr !=

NULL

);

2407 for

( c = 0; expr->

exprhdlr

->

name

[c] !=

'\0'

; ++c )

2408

color += (tolower(expr->

exprhdlr

->

name

[c]) -

'a'

) / 26.0;

2410

fprintf(printdata->file,

"n%p [fillcolor=\"%g,%g,%g\", label=\""

, (

void

*)expr, color, color, color);

2414

fprintf(printdata->file,

"%s\\n"

, expr->exprhdlr->name);

2421 for

( c = 0; c < expr->nchildren; ++c )

2424

c, 0, printdata->file) );

2425

fprintf(printdata->file,

"c%d"

, c);

2427

c, 0, printdata->file) );

2432

fputs(

"\\n"

, printdata->file);

2438

fprintf(printdata->file,

"%d uses\\n"

, expr->nuses);

2444 if

( expr->ownerprint !=

NULL

)

2446 SCIP_CALL

( expr->ownerprint(

set

->scip, printdata->file, expr, expr->ownerdata) );

2448 else if

( expr->ownerdata !=

NULL

)

2450

fprintf(printdata->file,

"owner=%p\\n"

, (

void

*)expr->ownerdata);

2457

fprintf(printdata->file,

"val=%g"

, expr->evalvalue);

2464

fputs(

"\\n"

, printdata->file);

2470

fprintf(printdata->file,

"[%g,%g]"

, expr->activity.inf, expr->activity.sup);

2477

fputs(

"\\n"

, printdata->file);

2480

fputs(

"\"]\n"

, printdata->file);

2483 for

( c = 0; c < expr->nchildren; ++c )

2484

fprintf(printdata->file,

"n%p -> n%p [label=\"c%d\"]\n"

, (

void

*)expr, (

void

*)expr->children[c], c);

2506

assert(stat !=

NULL

);

2507

assert(blkmem !=

NULL

);

2508

assert(printdata !=

NULL

);

2509

assert(*printdata !=

NULL

);

2511

file = (*printdata)->file;

2512

assert(file !=

NULL

);

2515

fputs(

"{rank=same;"

, file);

2520 if

( entry !=

NULL

)

2523

assert(expr !=

NULL

);

2526

fprintf(file,

" n%p"

, (

void

*)expr);

2529

fprintf(file,

"}\n"

);

2531

fprintf(file,

"}\n"

);

2537 if

( (*printdata)->closefile )

2538

fclose((*printdata)->file);

2559

assert(stat !=

NULL

);

2560

assert(blkmem !=

NULL

);

2561

assert(messagehdlr !=

NULL

);

2562

assert(expr !=

NULL

);

2577

nspaces = 3 * depth;

2601 if

( expr->ownerprint !=

NULL

)

2612 int

nspaces = 3 * depth;

2666

assert(stat !=

NULL

);

2667

assert(blkmem !=

NULL

);

2668

assert(expr !=

NULL

);

2671 if

( soltag != 0 && expr->

evaltag

== soltag )

2697 if

( soltag == child->

evaltag

)

2761

assert(stat !=

NULL

);

2762

assert(blkmem !=

NULL

);

2763

assert(rootexpr !=

NULL

);

2795

assert(child !=

NULL

);

2813

&derivative,

NULL

, 0.0) );

2861

assert(stat !=

NULL

);

2862

assert(blkmem !=

NULL

);

2863

assert(rootexpr !=

NULL

);

2867

rootexpr->

dot

= 0.0;

2894

assert(child !=

NULL

);

2909

&hessiandir,

NULL

) );

2961

assert(stat !=

NULL

);

2962

assert(blkmem !=

NULL

);

2963

assert(rootexpr !=

NULL

);

2965 if

( rootexpr->ownerevalactivity !=

NULL

)

3027 SCIPsetDebugMsg

(

set

,

" exprhdlr <%s>::inteval = [%.20g, %.20g]"

, expr->exprhdlr->name, expr->activity.inf,

3028

expr->activity.sup);

3037 if

( expr->isintegral && expr->nchildren > 0 )

3044 SCIPsetDebugMsg

(

set

,

" applying integrality: [%.20g, %.20g]\n"

, expr->activity.inf, expr->activity.sup);

3053 SCIPsetDebugMsg

(

set

,

"treat activity [%g,%g] as empty as beyond infinity\n"

, expr->activity.inf, expr->activity.sup);

3096 if

( exprhdlr1 == exprhdlr2 )

3118 if

( compareresult != 0 )

3119 return

compareresult;

3142 if

( compareresult != 0 )

3143 return

compareresult;

3159 if

( compareresult != 0 )

3160 return

compareresult;

3182 return

retval == 0 ? 0 : retval < 0 ? -1 : 1;

3198 void

* ownercreatedata

3204

assert(rootexpr !=

NULL

);

3205

assert(simplified !=

NULL

);

3206

assert(changed !=

NULL

);

3207

assert(infeasible !=

NULL

);

3218

*infeasible =

FALSE

;

3230

assert(newchild !=

NULL

);

3233 if

( newchild != child )

3255

assert(refexpr !=

NULL

);

3256 if

( expr != refexpr )

3259

iterdata.

ptrval

= (

void

*) refexpr;

3272

assert(*simplified !=

NULL

);

3292

assert(expr !=

NULL

);

3293

assert(symdata !=

NULL

);

3296

assert(exprhdlr !=

NULL

);

3298 if

( exprhdlr->getsymdata !=

NULL

)

3300 SCIP_CALL

( exprhdlr->getsymdata(

set

->scip, expr, symdata) );

3326 int

nbilinterms = 0;

3330

assert(blkmem !=

NULL

);

3331

assert(expr !=

NULL

);

3332

assert(isquadratic !=

NULL

);

3342

*isquadratic =

FALSE

;

3350 SCIPsetDebugMsg

(

set

,

"expr %p looks like square: fill data structures\n"

, (

void

*)expr);

3353

expr->quaddata->nquadexprs = 1;

3355

expr->quaddata->quadexprterms[0].expr = expr->children[0];

3356

expr->quaddata->quadexprterms[0].sqrcoef = 1.0;

3358

expr->quaddata->allexprsarevars =

SCIPexprIsVar

(

set

, expr->quaddata->quadexprterms[0].expr);

3360

*isquadratic =

TRUE

;

3367 SCIPsetDebugMsg

(

set

,

"expr %p looks like bilinear product: fill data structures\n"

, (

void

*)expr);

3369

expr->quaddata->nquadexprs = 2;

3375

expr->quaddata->quadexprterms[0].adjbilin[0] = 0;

3380

expr->quaddata->quadexprterms[1].adjbilin[0] = 0;

3382

expr->quaddata->nbilinexprterms = 1;

3388

expr->quaddata->allexprsarevars =

SCIPexprIsVar

(

set

, expr->quaddata->quadexprterms[0].expr)

3391

*isquadratic =

TRUE

;

3406

assert(child !=

NULL

);

3441 if

( nquadterms == 0 )

3448 SCIPsetDebugMsg

(

set

,

"expr %p looks quadratic: fill data structures\n"

, (

void

*)expr);

3472

assert(child !=

NULL

);

3487

assert(quadexprterm->

expr

== child);

3488

quadexprterm->

sqrcoef

= coef;

3505

assert(expr1 !=

NULL

&& expr2 !=

NULL

);

3509

bilinexprterm->

coef

= coef;

3512

bilinexprterm->

expr1

= expr1;

3513

bilinexprterm->

expr2

= expr2;

3517

bilinexprterm->

expr1

= expr2;

3518

bilinexprterm->

expr2

= expr1;

3523

assert(quadexprterm->

expr

== expr1);

3531

assert(quadexprterm->

expr

== expr2);

3564

assert(quadexprterm->

expr

== child);

3565

quadexprterm->

lincoef

= coef;

3579

*isquadratic =

TRUE

;

3597

assert(blkmem !=

NULL

);

3598

assert(expr !=

NULL

);

3614 for

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

3656

assert(blkmem !=

NULL

);

3657

assert(bufmem !=

NULL

);

3658

assert(messagehdlr !=

NULL

);

3659

assert(expr !=

NULL

);

3660

assert(curv !=

NULL

);

3663

assert(quaddata !=

NULL

);

3666 if

( assumevarfixed !=

NULL

)

3667

storeeigeninfo =

FALSE

;

3690 "number of quadratic variables is too large (%d) to check the curvature\n"

, n);

3701

assert((

unsigned

)nn < UINT_MAX /

sizeof

(

SCIP_Real

));

3703 if

( storeeigeninfo )

3721 for

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

3734 if

( quadexprterm.

sqrcoef

== 0.0 && ! storeeigeninfo )

3742

matrix[nvars * n + nvars] = quadexprterm.

sqrcoef

;

3778

matrix[row * n + col] = bilinexprterm.

coef

/ 2.0;

3780

matrix[col * n + row] = bilinexprterm.

coef

/ 2.0;

3787 "matrix --> don't know curvature\n"

);

3800 if

( !storeeigeninfo )

3826#undef SCIPexprGetNUses 3827#undef SCIPexprGetNChildren 3828#undef SCIPexprGetChildren 3829#undef SCIPexprGetHdlr 3830#undef SCIPexprGetData 3831#undef SCIPexprSetData 3832#undef SCIPexprGetOwnerData 3833#undef SCIPexprGetEvalValue 3834#undef SCIPexprGetEvalTag 3835#undef SCIPexprGetDerivative 3836#undef SCIPexprGetDot 3837#undef SCIPexprGetBardot 3838#undef SCIPexprGetDiffTag 3839#undef SCIPexprGetActivity 3840#undef SCIPexprGetActivityTag 3841#undef SCIPexprSetActivity 3842#undef SCIPexprGetCurvature 3843#undef SCIPexprSetCurvature 3844#undef SCIPexprIsIntegral 3845#undef SCIPexprSetIntegrality 3846#undef SCIPexprAreQuadraticExprsVariables 3854

assert(expr !=

NULL

);

3856 return

expr->

nuses

;

3864

assert(expr !=

NULL

);

3874

assert(expr !=

NULL

);

3887

assert(expr !=

NULL

);

3897

assert(expr !=

NULL

);

3913

assert(expr !=

NULL

);

3925

assert(expr !=

NULL

);

3938

assert(expr !=

NULL

);

3951

assert(expr !=

NULL

);

3964

assert(expr !=

NULL

);

3978

assert(expr !=

NULL

);

3992

assert(expr !=

NULL

);

4007

assert(expr !=

NULL

);

4020

assert(expr !=

NULL

);

4036

assert(expr !=

NULL

);

4048

assert(expr !=

NULL

);

4062

assert(expr !=

NULL

);

4073

assert(expr !=

NULL

);

4083

assert(expr !=

NULL

);

4094

assert(expr !=

NULL

);

4133

assert(expr !=

NULL

);

4136

assert(quaddata !=

NULL

);

4138 if

( constant !=

NULL

)

4140 if

( nlinexprs !=

NULL

)

4142 if

( linexprs !=

NULL

)

4144 if

( lincoefs !=

NULL

)

4146 if

( nquadexprs !=

NULL

)

4148 if

( nbilinexprs !=

NULL

)

4150 if

( eigenvalues !=

NULL

)

4152 if

( eigenvectors !=

NULL

)

4177

assert(quadexpr !=

NULL

);

4180

assert(termidx >= 0);

4181

assert(termidx < quadexpr->quaddata->nquadexprs);

4186

*expr = quadexprterm->

expr

;

4187 if

( lincoef !=

NULL

)

4188

*lincoef = quadexprterm->

lincoef

;

4189 if

( sqrcoef !=

NULL

)

4190

*sqrcoef = quadexprterm->

sqrcoef

;

4191 if

( nadjbilin !=

NULL

)

4193 if

( adjbilin !=

NULL

)

4194

*adjbilin = quadexprterm->

adjbilin

;

4195 if

( sqrexpr !=

NULL

)

4196

*sqrexpr = quadexprterm->

sqrexpr

;

4216

assert(expr !=

NULL

);

4219

assert(termidx >= 0);

4220

assert(termidx < expr->quaddata->nbilinexprterms);

4224 if

( expr1 !=

NULL

)

4225

*expr1 = bilinexprterm->

expr1

;

4226 if

( expr2 !=

NULL

)

4227

*expr2 = bilinexprterm->

expr2

;

4229

*coef = bilinexprterm->

coef

;

4231

*pos2 = bilinexprterm->

pos2

;

4232 if

( prodexpr !=

NULL

)

4233

*prodexpr = bilinexprterm->

prodexpr

;

4244

assert(expr !=

NULL

);

4275

assert(blkmem !=

NULL

);

4276

assert(expr !=

NULL

);

4277

assert(coef !=

NULL

);

4278

assert(exponents !=

NULL

);

4279

assert(factors !=

NULL

);

4286 for

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

void SCIPclockStop(SCIP_CLOCK *clck, SCIP_SET *set)

void SCIPclockStart(SCIP_CLOCK *clck, SCIP_SET *set)

SCIP_Real SCIPclockGetTime(SCIP_CLOCK *clck)

void SCIPclockReset(SCIP_CLOCK *clck)

void SCIPclockFree(SCIP_CLOCK **clck)

SCIP_RETCODE SCIPclockCreate(SCIP_CLOCK **clck, SCIP_CLOCKTYPE clocktype)

internal methods for clocks and timing issues

#define SCIP_INTERVAL_INFINITY

#define SCIP_LONGINT_FORMAT

#define SCIP_CALL_FINALLY(x, y)

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 SCIPexprhdlrBwDiffExpr(SCIP_EXPRHDLR *exprhdlr, SCIP_SET *set, BMS_BUFMEM *bufmem, SCIP_EXPR *expr, int childidx, SCIP_Real *derivative, SCIP_Real *childrenvals, SCIP_Real exprval)

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

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

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)

static SCIP_RETCODE freeExpr(BMS_BLKMEM *blkmem, SCIP_EXPR **expr)

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

SCIP_RETCODE SCIPexprhdlrFree(SCIP_EXPRHDLR **exprhdlr, SCIP_SET *set, BMS_BLKMEM *blkmem)

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)

void SCIPexprhdlrInit(SCIP_EXPRHDLR *exprhdlr, SCIP_SET *set)

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

SCIP_RETCODE SCIPexprhdlrCopyInclude(SCIP_EXPRHDLR *exprhdlr, SCIP_SET *targetset)

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)

SCIP_RETCODE SCIPexprhdlrFwDiffExpr(SCIP_EXPRHDLR *exprhdlr, SCIP_SET *set, SCIP_EXPR *expr, SCIP_Real *dot, SCIP_SOL *direction)

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)

static SCIP_RETCODE quadDetectProcessExpr(SCIP_EXPR *expr, SCIP_HASHMAP *seenexpr, int *nquadterms, int *nlinterms)

SCIP_RETCODE SCIPexprhdlrBwFwDiffExpr(SCIP_EXPRHDLR *exprhdlr, SCIP_SET *set, SCIP_EXPR *expr, int childidx, SCIP_Real *bardot, SCIP_SOL *direction)

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)

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

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)

static SCIP_RETCODE quadDetectGetQuadexprterm(BMS_BLKMEM *blkmem, SCIP_EXPR *expr, SCIP_HASHMAP *expr2idx, SCIP_HASHMAP *seenexpr, SCIP_QUADEXPR *quadexpr, SCIP_QUADEXPR_QUADTERM **quadexprterm)

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)

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

void SCIPhashmapFree(SCIP_HASHMAP **hashmap)

int SCIPhashmapGetImageInt(SCIP_HASHMAP *hashmap, void *origin)

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

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

int SCIPhashmapGetNEntries(SCIP_HASHMAP *hashmap)

SCIP_HASHMAPENTRY * SCIPhashmapGetEntry(SCIP_HASHMAP *hashmap, int entryidx)

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

void * SCIPhashmapEntryGetOrigin(SCIP_HASHMAPENTRY *entry)

SCIP_Bool SCIPhashmapExists(SCIP_HASHMAP *hashmap, void *origin)

SCIP_RETCODE SCIPhashmapInsertInt(SCIP_HASHMAP *hashmap, void *origin, int image)

SCIP_RETCODE SCIPhashmapSetImageInt(SCIP_HASHMAP *hashmap, void *origin, int image)

unsigned int SCIPcalcFibHash(SCIP_Real v)

const char * SCIPexprhdlrGetName(SCIP_EXPRHDLR *exprhdlr)

SCIP_Real SCIPexprhdlrGetEstimateTime(SCIP_EXPRHDLR *exprhdlr)

SCIP_Bool SCIPexprhdlrHasSimplify(SCIP_EXPRHDLR *exprhdlr)

SCIP_Longint SCIPexprhdlrGetNDomainReductions(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_Bool SCIPexprhdlrHasCurvature(SCIP_EXPRHDLR *exprhdlr)

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

void SCIPexprhdlrIncrementNDomainReductions(SCIP_EXPRHDLR *exprhdlr, int nreductions)

SCIP_EXPRHDLRDATA * SCIPexprhdlrGetData(SCIP_EXPRHDLR *exprhdlr)

SCIP_Real SCIPexprhdlrGetReversepropTime(SCIP_EXPRHDLR *exprhdlr)

unsigned int SCIPexprhdlrGetPrecedence(SCIP_EXPRHDLR *exprhdlr)

void SCIPexprhdlrIncrementNBranchings(SCIP_EXPRHDLR *exprhdlr)

SCIP_Longint SCIPexprhdlrGetNReversepropCalls(SCIP_EXPRHDLR *exprhdlr)

SCIP_DECL_SORTPTRCOMP(SCIPexprhdlrComp)

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

const char * SCIPexprhdlrGetDescription(SCIP_EXPRHDLR *exprhdlr)

SCIP_Bool SCIPexprhdlrHasFwdiff(SCIP_EXPRHDLR *exprhdlr)

SCIP_Bool SCIPexprhdlrHasGetSymData(SCIP_EXPRHDLR *exprhdlr)

SCIP_Bool SCIPexprhdlrHasMonotonicity(SCIP_EXPRHDLR *exprhdlr)

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

SCIP_Bool SCIPexprhdlrHasReverseProp(SCIP_EXPRHDLR *exprhdlr)

unsigned int SCIPexprhdlrGetNCreated(SCIP_EXPRHDLR *exprhdlr)

SCIP_Bool SCIPexprhdlrHasInitEstimates(SCIP_EXPRHDLR *exprhdlr)

SCIP_Longint SCIPexprhdlrGetNBranchings(SCIP_EXPRHDLR *exprhdlr)

SCIP_Bool SCIPexprhdlrHasPrint(SCIP_EXPRHDLR *exprhdlr)

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

void SCIPexprhdlrSetParse(SCIP_EXPRHDLR *exprhdlr, SCIP_DECL_EXPRPARSE((*parse)))

SCIP_Longint SCIPexprhdlrGetNSimplifyCalls(SCIP_EXPRHDLR *exprhdlr)

SCIP_Real SCIPexprhdlrGetIntevalTime(SCIP_EXPRHDLR *exprhdlr)

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_Bool SCIPexprhdlrHasEstimate(SCIP_EXPRHDLR *exprhdlr)

SCIP_Real SCIPexprhdlrGetSimplifyTime(SCIP_EXPRHDLR *exprhdlr)

void SCIPexprhdlrSetCompare(SCIP_EXPRHDLR *exprhdlr, SCIP_DECL_EXPRCOMPARE((*compare)))

SCIP_Longint SCIPexprhdlrGetNIntevalCalls(SCIP_EXPRHDLR *exprhdlr)

SCIP_Longint SCIPexprhdlrGetNSimplifications(SCIP_EXPRHDLR *exprhdlr)

SCIP_Longint SCIPexprhdlrGetNCutoffs(SCIP_EXPRHDLR *exprhdlr)

SCIP_Bool SCIPexprhdlrHasIntEval(SCIP_EXPRHDLR *exprhdlr)

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

SCIP_Bool SCIPexprhdlrHasBwdiff(SCIP_EXPRHDLR *exprhdlr)

SCIP_Longint SCIPexprhdlrGetNEstimateCalls(SCIP_EXPRHDLR *exprhdlr)

void SCIPexprSetActivity(SCIP_EXPR *expr, SCIP_INTERVAL activity, SCIP_Longint activitytag)

void SCIPexprSetData(SCIP_EXPR *expr, SCIP_EXPRDATA *exprdata)

int SCIPexprGetNChildren(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_Real SCIPgetExponentExprPow(SCIP_EXPR *expr)

SCIP_Bool SCIPexpriterIsEnd(SCIP_EXPRITER *iterator)

void SCIPexprSetCurvature(SCIP_EXPR *expr, SCIP_EXPRCURV curvature)

SCIP_EXPR * SCIPexpriterSkipDFS(SCIP_EXPRITER *iterator)

SCIP_EXPR_OWNERDATA * SCIPexprGetOwnerData(SCIP_EXPR *expr)

SCIP_Real SCIPexprGetDerivative(SCIP_EXPR *expr)

SCIP_Longint SCIPexprGetEvalTag(SCIP_EXPR *expr)

SCIP_Bool SCIPexprIsIntegral(SCIP_EXPR *expr)

SCIP_Bool SCIPexprAreQuadraticExprsVariables(SCIP_EXPR *expr)

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_Real * SCIPgetCoefsExprSum(SCIP_EXPR *expr)

SCIP_EXPRITER_USERDATA SCIPexpriterGetCurrentUserData(SCIP_EXPRITER *iterator)

SCIP_Real SCIPgetCoefExprProduct(SCIP_EXPR *expr)

SCIP_EXPR * SCIPexpriterGetCurrent(SCIP_EXPRITER *iterator)

void SCIPexpriterSetStagesDFS(SCIP_EXPRITER *iterator, SCIP_EXPRITER_STAGE stopstages)

SCIP_Real SCIPexprGetDot(SCIP_EXPR *expr)

SCIP_EXPRDATA * SCIPexprGetData(SCIP_EXPR *expr)

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_EXPR * SCIPexpriterGetParentDFS(SCIP_EXPRITER *iterator)

SCIP_Real SCIPgetValueExprValue(SCIP_EXPR *expr)

void SCIPexpriterSetCurrentUserData(SCIP_EXPRITER *iterator, SCIP_EXPRITER_USERDATA userdata)

SCIP_Real SCIPexprGetEvalValue(SCIP_EXPR *expr)

SCIP_Longint SCIPexprGetActivityTag(SCIP_EXPR *expr)

SCIP_EXPR * SCIPexpriterGetNext(SCIP_EXPRITER *iterator)

SCIP_Real SCIPexprGetBardot(SCIP_EXPR *expr)

SCIP_EXPR ** SCIPexprGetChildren(SCIP_EXPR *expr)

SCIP_Real SCIPgetConstantExprSum(SCIP_EXPR *expr)

SCIP_VAR * SCIPgetVarExprVar(SCIP_EXPR *expr)

SCIP_INTERVAL SCIPexprGetActivity(SCIP_EXPR *expr)

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_EXPRITER_USERDATA SCIPexpriterGetChildUserDataDFS(SCIP_EXPRITER *iterator)

SCIP_EXPRITER_STAGE SCIPexpriterGetStageDFS(SCIP_EXPRITER *iterator)

SCIP_RETCODE SCIPexpriterInit(SCIP_EXPRITER *iterator, SCIP_EXPR *expr, SCIP_EXPRITER_TYPE type, SCIP_Bool allowrevisit)

int SCIPexprGetNUses(SCIP_EXPR *expr)

SCIP_EXPRITER_USERDATA SCIPexpriterGetExprUserData(SCIP_EXPRITER *iterator, SCIP_EXPR *expr)

SCIP_Longint SCIPexprGetDiffTag(SCIP_EXPR *expr)

SCIP_EXPRHDLR * SCIPexprGetHdlr(SCIP_EXPR *expr)

SCIP_EXPR * SCIPexpriterGetChildExprDFS(SCIP_EXPRITER *iterator)

void SCIPintervalSetEntire(SCIP_Real infinity, SCIP_INTERVAL *resultant)

void SCIPintervalSetEmpty(SCIP_INTERVAL *resultant)

SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)

const char * SCIPvarGetName(SCIP_VAR *var)

SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)

SCIP_Bool SCIPlapackIsAvailable(void)

SCIP_RETCODE SCIPlapackComputeEigenvalues(BMS_BUFMEM *bufmem, SCIP_Bool geteigenvectors, int N, SCIP_Real *a, SCIP_Real *w)

interface methods for lapack functions

#define BMSduplicateBlockMemoryArray(mem, ptr, source, num)

#define BMSfreeBlockMemory(mem, ptr)

#define BMSallocBlockMemory(mem, ptr)

#define BMSfreeBlockMemoryArrayNull(mem, ptr, num)

#define BMSduplicateMemoryArray(ptr, source, num)

#define BMSfreeBufferMemoryArray(mem, ptr)

#define BMSfreeMemoryArray(ptr)

#define BMSallocBlockMemoryArray(mem, ptr, num)

#define BMSfreeBlockMemoryArray(mem, ptr, num)

#define BMSreallocBlockMemoryArray(mem, ptr, oldnum, newnum)

#define BMSallocClearBlockMemoryArray(mem, ptr, num)

#define BMSallocBufferMemoryArray(mem, ptr, num)

#define BMSallocClearBlockMemory(mem, ptr)

#define BMSallocClearBufferMemoryArray(mem, ptr, num)

struct BMS_BlkMem BMS_BLKMEM

#define BMSfreeMemoryArrayNull(ptr)

void SCIPmessageFPrintVerbInfo(SCIP_MESSAGEHDLR *messagehdlr, SCIP_VERBLEVEL verblevel, SCIP_VERBLEVEL msgverblevel, FILE *file, const char *formatstr,...)

void SCIPmessageFPrintInfo(SCIP_MESSAGEHDLR *messagehdlr, FILE *file, const char *formatstr,...)

void SCIPmessagePrintWarning(SCIP_MESSAGEHDLR *messagehdlr, const char *formatstr,...)

public methods for message output

public data structures and miscellaneous methods

public methods for problem variables

SCIP_Real SCIPsetFloor(SCIP_SET *set, SCIP_Real val)

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

SCIP_Real SCIPsetCeil(SCIP_SET *set, SCIP_Real val)

SCIP_Bool SCIPsetIsPositive(SCIP_SET *set, SCIP_Real val)

SCIP_Real SCIPsetFrac(SCIP_SET *set, SCIP_Real val)

SCIP_Bool SCIPsetIsInfinity(SCIP_SET *set, SCIP_Real val)

int SCIPsetCalcMemGrowSize(SCIP_SET *set, int num)

SCIP_Bool SCIPsetIsNegative(SCIP_SET *set, SCIP_Real val)

internal methods for global SCIP settings

#define SCIPsetDebugMsgPrint

internal methods for storing primal CIP solutions

SCIP_EXPR_OWNERDATA * ownerdata

SCIP_Longint nsimplifycalls

SCIP_Longint nestimatecalls

SCIP_CLOCK * simplifytime

SCIP_CLOCK * estimatetime

SCIP_Longint nintevalcalls

SCIP_Longint nbranchscores

SCIP_Bool curvaturechecked

SCIP_QUADEXPR_QUADTERM * quadexprterms

SCIP_Bool eigeninfostored

SCIP_Bool allexprsarevars

SCIP_QUADEXPR_BILINTERM * bilinexprterms

SCIP_Longint exprlastdifftag

structure definitions related to algebraic expressions

datastructures for global SCIP settings

datastructures for problem statistics

internal methods for branch and bound tree

#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_EXPRPRINT_EXPRSTRING

#define SCIP_DECL_EXPRFREEDATA(x)

#define SCIP_EXPR_MAXINITESTIMATES

#define SCIP_DECL_EXPRPARSE(x)

#define SCIP_DECL_EXPRBWDIFF(x)

#define SCIP_DECL_EXPRINTEVAL(x)

#define SCIP_EXPRPRINT_OWNER

#define SCIP_EXPRPRINT_ACTIVITYTAG

#define SCIP_DECL_EXPRMONOTONICITY(x)

#define SCIP_EXPRITER_VISITINGCHILD

struct SCIP_Expr_OwnerData SCIP_EXPR_OWNERDATA

unsigned int SCIP_EXPRPRINT_WHAT

#define SCIP_DECL_EXPR_INTEVALVAR(x)

#define SCIP_DECL_EXPRCOMPARE(x)

#define SCIP_DECL_EXPRSIMPLIFY(x)

#define SCIP_DECL_EXPREVAL(x)

#define SCIP_DECL_EXPRFWDIFF(x)

#define SCIP_EXPRPRINT_ACTIVITY

#define SCIP_DECL_EXPRHASH(x)

#define SCIP_DECL_EXPRCOPYHDLR(x)

#define SCIP_DECL_EXPRPRINT(x)

#define SCIP_EXPRPRINT_EVALVALUE

#define SCIP_DECL_EXPRFREEHDLR(x)

#define SCIP_DECL_EXPR_MAPEXPR(x)

#define SCIP_EXPRPRINT_EXPRHDLR

#define SCIP_EXPRPRINT_EVALTAG

#define SCIP_DECL_EXPRINTEGRALITY(x)

#define SCIP_EXPRPRINT_NUSES

#define SCIP_EXPRITER_VISITEDCHILD

#define SCIP_DECL_EXPRGETSYMDATA(x)

struct SCIP_ExprPrintData SCIP_EXPRPRINTDATA

#define SCIP_DECL_EXPRCOPYDATA(x)

#define SCIP_EXPRITER_LEAVEEXPR

#define SCIP_EXPRITER_ALLSTAGES

#define SCIP_DECL_EXPRESTIMATE(x)

#define SCIP_EXPRITER_ENTEREXPR

unsigned int SCIP_EXPRITER_STAGE

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