RetroSearch Browse

);

141

*root = 0.39821689389382575186;

150 else if

( exponent <= 2.0 )

155 for

( iter = 0; iter < 1000; ++iter )

157

polyval = (exponent - 1.0) * pow(*root, exponent) + exponent * pow(*root, exponent - 1.0) - 1.0;

162

gradval = (exponent - 1.0) * exponent * (pow(*root, exponent - 1.0) + pow(*root, exponent - 2.0));

167

*root -= polyval / gradval;

177 SCIPdebugMsg

(

"root for %g is %.20g, certainty = %g\n"

, exponent, *root, polyval);

196

assert(exponent < -1.0);

197

assert(root !=

);

201 for

( iter = 0; iter < 1000; ++iter )

203

polyval = (exponent - 1.0) * pow(*root, exponent) - exponent * pow(*root, exponent - 1.0) + 1.0;

208

gradval = (exponent - 1.0) * exponent * (pow(*root, exponent - 1.0) - pow(*root, exponent - 2.0));

213

*root -= polyval / gradval;

223 SCIPdebugMsg

(

"root for %g is %.20g, certainty = %g\n"

, exponent, *root, polyval);

237

assert(exprdata !=

);

241

(*exprdata)->exponent = exponent;

270

assert(constant !=

);

271

assert(slope !=

);

272

assert(success !=

);

273

assert(xref != 0.0 || exponent > 0.0);

282 if

( !

(exponent, 0.0) && !signpower && xref < 0.0 )

285

xrefpow = pow(signpower ?

(xref) : xref, exponent - 1.0);

294

*constant = (1.0 - exponent) * xrefpow * xref;

295

*slope = exponent * xrefpow;

318

assert(constant !=

);

319

assert(slope !=

);

320

assert(success !=

);

321

assert(xlb >= 0.0 ||

(exponent, 0.0) || signpower);

322

assert(xub >= 0.0 ||

(exponent, 0.0) || signpower);

323

assert(exponent != 1.0);

338

*constant = pow(xlb, exponent);

350

*constant = pow(xlb, exponent);

357 else if

( xlb == 0.0 && exponent > 0.0 )

360

*slope = pow(xub, exponent-1.0);

363 else if

( xub == 0.0 && exponent > 0.0 )

370

*slope = pow(-xlb, exponent-1.0);

372

*slope = pow(xlb, exponent-1.0);

375 else if

(

SCIPisEQ

(

, xlb, xub) && (!signpower || xlb >= 0.0 || xub <= 0.0) )

404 if

( signpower && xub <= 0.0 )

410

xlb_n = pow(xlb, exponent);

411

xlb_n1 = pow(xlb, exponent - 1.0);

412

xlb_n2 = pow(xlb, exponent - 2.0);

414

*slope = 0.5*exponent * ((3.0-exponent) * xlb_n1 + (exponent-1.0) * xlb_n2 * xub);

415

*constant = (1.0 - 0.5*exponent*(3.0-exponent)) * xlb_n - 0.5*exponent*(exponent-1.0) * xlb_n1 * xub;

417 if

( signpower && xub <= 0.0 )

426

lbval =

(xlb) * pow(

(xlb), exponent);

428

lbval = pow(xlb, exponent);

433

ubval =

(xub) * pow(

(xub), exponent);

435

ubval = pow(xub, exponent);

442 if

( lbval == ubval )

445

*slope = (ubval - lbval) / (xub - xlb);

446

*constant = lbval - *slope * xlb;

501

assert(constant !=

);

502

assert(slope !=

);

503

assert(islocal !=

);

504

assert(success !=

);

505

assert((exponent >= 0.0 &&

(exponent/2.0, 0.0)) || (exponent > 1.0 && xlb >= 0.0));

573

assert(constant !=

);

574

assert(slope !=

);

575

assert(islocal !=

);

576

assert(branchcand !=

);

577

assert(*branchcand ==

);

578

assert(success !=

);

579

assert(exponent >= 1.0);

581

assert(xubglobal <= 0.0 || (root > 0.0 && root < 1.0));

610

*branchcand =

;

636

*islocal = xref < -root * xlbglobal;

639

*branchcand =

;

655

*islocal = xref > -root * xubglobal;

658

*branchcand =

;

721

assert(constant !=

);

722

assert(slope !=

);

723

assert(islocal !=

);

724

assert(branchcand !=

);

725

assert(*branchcand ==

);

726

assert(success !=

);

727

assert(exponent < 0.0);

728

assert(

(exponent/2.0, 0.0) || xlb >= 0.0);

734 if

( xlb >= 0.0 || xub <= 0.0 )

739 if

( xref < 0.0 && xlb >= 0.0 )

741 else if

( xref > 0.0 && xub <= 0.0 )

753

xref = 0.9 * xlb + 0.1 * xub;

761

xref = 0.1 * xlb + 0.9 * xub;

774

*branchcand =

;

784 if

( xref > 0.0 && xlbglobal < 0.0 )

786

assert(xubglobal > 0.0);

789

*islocal = xref < xlbglobal * root;

791 else if

( xref < 0.0 && xubglobal > 0.0 )

793

assert(xlbglobal < 0.0);

796

*islocal = xref > xubglobal * root;

804

*islocal = xlbglobal * xubglobal < 0.0;

824

constant, slope, islocal, branchcand, success);

849 if

( xref <= xlb * root )

865

*islocal = xref < xlbglobal * root;

866

*branchcand =

;

874 if

( xlb < 0.0 && xub > 0.0 )

932

assert(constant !=

);

933

assert(slope !=

);

934

assert(islocal !=

);

935

assert(branchcand !=

);

936

assert(*branchcand ==

);

937

assert(success !=

);

938

assert(exponent < 0.0);

939

assert(

((exponent-1.0)/2.0, 0.0));

967

xref = 0.1*xlb + 0.9*xub;

977

*islocal = xlbglobal * xubglobal < 0.0;

980

*branchcand =

;

1015

assert(exprdata !=

);

1016

assert(coef !=

);

1017

assert(constant !=

);

1018

assert(success !=

);

1019

assert(islocal !=

);

1020

assert(branchcand !=

);

1022

isinteger =

(exponent, 0.0);

1023

iseven = isinteger &&

(exponent / 2.0, 0.0);

1025 if

( exponent == 2.0 )

1042

*branchcand =

;

1045 else if

( exponent > 0.0 && iseven )

1047 estimateParabola

(

, exponent, overestimate, childlb, childub, refpoint, constant, coef, islocal, success);

1049

*branchcand = *islocal;

1051 else if

( exponent > 1.0 && childlb >= 0.0 )

1054 if

( refpoint < 0.0 )

1057 estimateParabola

(

, exponent, overestimate, childlb, childub, refpoint, constant, coef, islocal, success);

1060

*branchcand = *islocal;

1065 if

( !*islocal && !iseven && childglb < 0.0 )

1075

*islocal = refpoint < exprdata->root * (-childglb);

1079 else if

( exponent > 1.0 )

1082 if

( exprdata->root ==

SCIP_INVALID

&& childgub > 0.0 )

1087

-childglb, childgub, constant, coef, islocal, branchcand, success);

1089 else if

( exponent < 0.0 && (iseven || childlb >= 0.0) )

1097

childglb, childgub, constant, coef, islocal, branchcand, success);

1099 else if

( exponent < 0.0 )

1102

assert(childlb < 0.0);

1106

constant, coef, islocal, branchcand, success);

1110

assert(exponent < 1.0);

1111

assert(exponent > 0.0);

1113 SCIPestimateRoot

(

, exponent, overestimate, childlb, childub, refpoint, constant, coef, islocal, success);

1116

*branchcand = *islocal;

1134

assert(refpoints !=

);

1139 if

( ub > -maxabsbnd )

1140

lb =

MAX

(lb, -maxabsbnd);

1141 if

( lb < maxabsbnd )

1142

ub =

MIN

(ub, maxabsbnd);

1150

refpoints[0] = (7.0 * lb + ub) / 8.0;

1151

refpoints[1] = (lb + ub) / 2.0;

1152

refpoints[2] = (lb + 7.0 * ub) / 8.0;

1172

assert(refpoints !=

);

1184

lb = -ub * exprdata->root - 1.0;

1186

ub = -lb * exprdata->root + 1.0;

1188 if

( underestimate )

1194 if

( -lb * exprdata->root < ub - 2.0 )

1196 if

( -lb * exprdata->root < ub - 4.0 )

1197

refpoints[1] = (-lb * exprdata->root + ub) / 2.0;

1200 if

( !underestimate )

1206 if

( -ub * exprdata->root > lb + 2.0 )

1208 if

( -ub * exprdata->root > lb + 4.0 )

1209

refpoints[1] = (lb - ub * exprdata->root) / 2.0;

1235

assert(exprdata !=

);

1236

assert(refpointsunder !=

&& refpointsover !=

);

1238

exponent = exprdata->exponent;

1243

mixedsign = lb < 0.0 && ub > 0.0;

1250 if

( (exponent > 1.0 && (lb >= 0 || even)) || (exponent < 0.0 && lb >= 0) || (exponent < 0.0 && even && ub <= 0.0) )

1256 else if

( ub <= 0 || (exponent > 0.0 && exponent < 1.0) )

1259 if

( underestimate )

1264

(exponent < 0.0 && even && mixedsign) )

1267

refpointsunder[0] = (lb + ub) / 2.0;

1269 else if

( exponent > 1.0 && !even && mixedsign )

1280

refpointsover[0] = (lb + ub) / 2.0;

1283 else if

( exponent > 1.0 && !even && mixedsign )

1313 if

( compareresult != 0 )

1314 return

compareresult;

1319 return

expo1 == expo2 ? 0 : expo1 < expo2 ? -1 : 1;

1336

assert(expr !=

);

1337

assert(simplifiedexpr !=

);

1341

assert(exprhdlr !=

);

1344

assert(exprhdlrdata !=

);

1347

assert(base !=

);

1351 SCIPdebugPrintf

(

"[simplifyPow] simplifying power with expo %g\n"

, exponent);

1354 if

( exponent == 0.0 )

1364 if

( exponent == 1.0 )

1367

*simplifiedexpr = base;

1385 if

( baseval < 0.0 && fmod(exponent, 1.0) != 0.0 && baseval > -

SCIPepsilon

(

) )

1389

assert(baseval >= 0.0 || fmod(exponent, 1.0) == 0.0);

1390

assert(baseval != 0.0 || exponent != 0.0);

1392 if

( baseval != 0.0 || exponent > 0.0 )

1414 SCIP_CALL

( SCIPcallExprSimplify(

, prod, &simplifiedprod, ownercreate, ownercreatedata) );

1422 SCIP_CALL

( SCIPcallExprSimplify(

, exponential, simplifiedexpr, ownercreate, ownercreatedata) );

1436

assert(basevar !=

);

1443

*simplifiedexpr = base;

1462 SCIP_CALL

( simplifyPow(

, newpow, simplifiedexpr, ownercreate, ownercreatedata) );

1486 SCIP_CALL

( simplifyPow(

, aux, &simplifiedaux, ownercreate, ownercreatedata) );

1496 SCIP_CALL

( SCIPcallExprSimplify(

, auxproduct, simplifiedexpr, ownercreate, ownercreatedata) );

1511 SCIPdebugPrintf

(

"[simplifyPow] seeing a sum with one term, exponent %g\n"

, exponent);

1520 SCIP_CALL

( simplifyPow(

, aux, &simplifiedaux, ownercreate, ownercreatedata) );

1526 SCIP_CALL

( SCIPcallExprSimplify(

, aux, simplifiedexpr, ownercreate, ownercreatedata) );

1538 if

(

SCIPisExprSum

(

, base) && exponent == 2.0 && exprhdlrdata->expandmaxexponent >= 2 )

1542 int

nexpandedchildren;

1551

nexpandedchildren = nchildren * (nchildren + 1) / 2 + nchildren;

1555 for

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

1563 for

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

1570 SCIP_CALL

( SCIPcallExprSimplify(

, expansionchild, &expandedchildren[i*(i+1)/2 + j],

1571

ownercreate, ownercreatedata) );

1580 SCIP_CALL

( SCIPcallExprSimplify(

, expansionchild, &expandedchildren[i*(i+1)/2 + i], ownercreate,

1585 for

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

1592

constant *= constant;

1595

ownercreate, ownercreatedata) );

1596 SCIP_CALL

( SCIPcallExprSimplify(

, expansion, simplifiedexpr, ownercreate,

1602 for

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

1613 if

(

SCIPisExprSum

(

, base) && exponent > 2.0 && exponent <= exprhdlrdata->expandmaxexponent )

1638 SCIPdebugPrintf

(

"[simplifyPow] seeing a sum with one term, exponent %g\n"

, exponent);

1646 SCIP_CALL

( simplifyPow(

, aux, &simplifiedaux, ownercreate, ownercreatedata) );

1654 SCIP_CALL

( SCIPcallExprSimplify(

, aux, simplifiedexpr, ownercreate, ownercreatedata) );

1681 SCIP_CALL

( simplifyPow(

, aux, &simplifiedaux, ownercreate, ownercreatedata) );

1691 SCIP_CALL

( SCIPcallExprSimplify(

, auxproduct, simplifiedexpr, ownercreate, ownercreatedata) );

1708

newexponent = baseexponent * exponent;

1718 if

( !

(newexponent, 0.0) ||

1720

(

(baseexponent, 0.0) && ((

int

)baseexponent) % 2 == 0) )

1724 if

(

(baseexponent, 0.0) && ((

int

)baseexponent) % 2 == 0 &&

1725

(newexponent, 0.0) || ((

int

)newexponent) % 2 == 1) )

1735 SCIP_CALL

( SCIPcallExprSimplify(

, aux, &simplifiedaux, ownercreate, ownercreatedata) );

1746 SCIP_CALL

( simplifyPow(

, aux, simplifiedexpr, ownercreate, ownercreatedata) );

1754

*simplifiedexpr = expr;

1769

assert(expr !=

);

1772

assert(exprdata !=

);

1776

(*symdata)->nconstants = 1;

1777

(*symdata)->ncoefficients = 0;

1780

(*symdata)->constants[0] = exprdata->exponent;

1798

assert(exprhdlrdata !=

);

1799

assert(*exprhdlrdata !=

);

1812

assert(targetexprdata !=

);

1813

assert(sourceexpr !=

);

1816

assert(sourceexprdata !=

);

1818

*targetexprdata =

;

1831

assert(expr !=

);

1834

assert(exprdata !=

);

1847

assert(expr !=

);

1861

assert(currentchild == 0);

1870 if

( exponent >= 0.0 )

1894

assert(expr !=

);

1901

*val = pow(base, exponent);

1906 if

( !

SCIPisFinite

(*val) || *val == HUGE_VAL || *val == -HUGE_VAL )

1924

assert(expr !=

);

1929

assert(child !=

);

1934

assert(exponent != 0.0);

1957

assert(expr !=

);

1960

assert(childidx == 0);

1963

assert(child !=

);

1968

assert(exponent != 0.0);

1971 if

( exponent > 0.0 && exponent < 2.0 &&

SCIPexprGetEvalValue

(child) == 0.0 && exponent != 1.0 )

1987

assert(expr !=

);

1989

assert(childidx == 0);

1992

assert(child !=

);

1999

assert(exponent != 0.0);

2002 if

( exponent > 0.0 && exponent < 1.0 && childval == 0.0 )

2005

*val = exponent * pow(childval, exponent - 1.0);

2017

assert(expr !=

);

2024 if

( exponent < 0.0 )

2028

assert(exprhdlrdata !=

);

2030 if

( exprhdlrdata->minzerodistance > 0.0 )

2033 if

( childinterval.

> -exprhdlrdata->minzerodistance && childinterval.

< exprhdlrdata->minzerodistance )

2038 "Check your model formulation or use option expr/" POWEXPRHDLR_NAME "/minzerodistance to avoid this warning.\n"

2039

exponent, childinterval.

, exprhdlrdata->minzerodistance);

2043

exprhdlrdata->warnedonpole =

;

2045

childinterval.

= exprhdlrdata->minzerodistance;

2047 else if

( childinterval.

< exprhdlrdata->minzerodistance

2048

&& childinterval.

> -exprhdlrdata->minzerodistance )

2053 "Check your model formulation or use option expr/" POWEXPRHDLR_NAME "/minzerodistance to avoid this warning.\n"

2054

exponent, childinterval.

, -exprhdlrdata->minzerodistance);

2058

exprhdlrdata->warnedonpole =

;

2060

childinterval.

= -exprhdlrdata->minzerodistance;

2076 if

( exponent < 0.0 && childinterval.

== 0.0 && childinterval.

== 0.0 )

2094

assert(expr !=

);

2097

assert(refpoint !=

);

2098

assert(coefs !=

);

2099

assert(constant !=

);

2100

assert(islocal !=

);

2101

assert(branchcand !=

);

2102

assert(*branchcand ==

);

2103

assert(success !=

);

2109

assert(child !=

);

2118

childlb = localbounds[0].inf;

2119

childub = localbounds[0].sup;

2122

exponent = exprdata->exponent;

2123

assert(exponent != 1.0 && exponent != 0.0);

2128 if

( childlb == childub )

2131

*constant = pow(childlb, exponent);

2133

*islocal = globalbounds[0].inf != globalbounds[0].sup;

2134

*branchcand =

;

2138

isinteger =

(exponent, 0.0);

2141 if

( !isinteger && childlb < 0.0 )

2149

assert(isinteger || childlb >= 0.0);

2153

constant, success, islocal, branchcand) );

2167

assert(expr !=

);

2171

child = childrenbounds[0];

2173 SCIPdebugMsg

(

"reverseprop x^%g in [%.15g,%.15g], x = [%.15g,%.15g]"

, exponent, bounds.inf, bounds.sup,

2174

child.

, child.

);

2178

*infeasible =

;

2185 if

( !

(exponent, 0.0) && child.

< 0.0 )

2201 if

( exponent < 0.0 )

2206

assert(exprhdlrdata !=

);

2208 if

( exprhdlrdata->minzerodistance > 0.0 )

2214 if

( interval.

> -exprhdlrdata->minzerodistance && interval.

< exprhdlrdata->minzerodistance )

2219 "Check your model formulation or use option expr/" POWEXPRHDLR_NAME "/minzerodistance to avoid this warning.\n"

2220

exponent, interval.

, exprhdlrdata->minzerodistance);

2224

exprhdlrdata->warnedonpole =

;

2226

interval.

= exprhdlrdata->minzerodistance;

2228 else if

( interval.

< exprhdlrdata->minzerodistance && interval.

> -exprhdlrdata->minzerodistance )

2233 "Check your model formulation or use option expr/" POWEXPRHDLR_NAME "/minzerodistance to avoid this warning.\n"

2234

exponent, interval.

, -exprhdlrdata->minzerodistance);

2238

exprhdlrdata->warnedonpole =

;

2240

interval.

= -exprhdlrdata->minzerodistance;

2247

childrenbounds[0] = interval;

2271

assert(expr !=

);

2274

assert(child !=

);

2276

childlb = bounds[0].inf;

2277

childub = bounds[0].sup;

2282 SCIPdebugMsg

(

"skip initestimates as child seems essentially fixed [%.15g,%.15g]\n"

, childlb, childub);

2287

exponent = exprdata->exponent;

2288

assert(exponent != 1.0 && exponent != 0.0);

2290

isinteger =

(exponent, 0.0);

2293 if

( !isinteger && childlb < 0.0 )

2301

assert(isinteger || childlb >= 0.0);

2311 if

( (overest[i] && !overestimate) || (!overest[i] && overestimate) )

2314

assert(overest[i] || i < 3);

2315

refpoint = overest[i] ? refpointsover[i % 3] : refpointsunder[i % 3];

2324 SCIPexprIsIntegral

(child), refpoint, exponent, coefs[*nreturned], &constant[*nreturned],

2325

&success, &islocal, &branchcand) );

2329 SCIPdebugMsg

(

"initestimate x^%g for base in [%g,%g] at ref=%g, over:%u -> %g*x+%g\n"

, exponent,

2330

childlb, childub, refpoint, overest[i], coefs[*nreturned][0], constant[*nreturned]);

2343

assert(expr !=

);

2345

assert(hashkey !=

);

2346

assert(childrenhashes !=

);

2350

*hashkey ^= childrenhashes[0];

2364

assert(expr !=

);

2366

assert(childcurv !=

);

2367

assert(success !=

);

2372

assert(child !=

);

2395

assert(expr !=

);

2396

assert(result !=

);

2398

assert(childidx == 0);

2408

expisint =

(exponent, 0.0);

2412 SCIP_Bool

expisodd = ceil(exponent/2) != exponent/2;

2417 if

( exponent >= 0.0 )

2421 else if

( inf >= 0.0 || sup <= 0.0 )

2430 else if

( sup <= 0.0 )

2456

assert(expr !=

);

2457

assert(isintegral !=

);

2460

*isintegral =

;

2463

assert(child !=

);

2470

assert(exponent != 0.0);

2471

expisint =

(exponent, 0.0);

2474

*isintegral = expisint && exponent >= 0.0;

2488

assert(expr !=

);

2489

assert(simplifiedexpr !=

);

2493

assert(base !=

);

2496 SCIPdebugPrintf

(

"[simplifySignpower] simplifying power with expo %g\n"

, exponent);

2497

assert(exponent >= 1.0);

2500 if

( exponent == 1.0 )

2503

*simplifiedexpr = base;

2517

ownercreate, ownercreatedata) );

2539 SCIP_CALL

( SCIPcallExprSimplify(

, prod, &simplifiedprod, ownercreate, ownercreatedata) );

2547 SCIP_CALL

( SCIPcallExprSimplify(

, exponential, simplifiedexpr, ownercreate, ownercreatedata) );

2554 if

(

(exponent, 0.0) && ((

int

)exponent) % 2 == 1 )

2564 SCIP_CALL

( simplifyPow(

, aux, simplifiedexpr, ownercreate, ownercreatedata) );

2578

assert(basevar !=

);

2582

*simplifiedexpr = base;

2605

assert(((

int

)exponent) % 2 == 0 );

2609

ownercreate, ownercreatedata) );

2610 SCIP_CALL

( simplifySignpower(

, aux, simplifiedexpr, ownercreate, ownercreatedata) );

2626 SCIPdebugPrintf

(

"[simplifySignpower] seeing a sum with one term, exponent %g\n"

, exponent);

2633

ownercreate, ownercreatedata) );

2635 SCIP_CALL

( simplifySignpower(

, aux, &simplifiedaux, ownercreate, ownercreatedata) );

2641 SCIP_CALL

( SCIPcallExprSimplify(

, aux, simplifiedexpr, ownercreate, ownercreatedata) );

2648

*simplifiedexpr = expr;

2669

assert(expr !=

);

2681

assert(currentchild == 0);

2706

assert(expr !=

);

2711

assert(childexpr !=

);

2713 string

= *endstring;

2714 while

( *

string

' '

)

2717 if

( *

string

','

)

2719 SCIPerrorMessage

(

"Expected comma after first argument of signpower().\n"

);

2726 SCIPerrorMessage

(

"Expected numeric exponent for second argument of signpower().\n"

);

2738

assert(*expr !=

);

2756

assert(expr !=

);

2763

*val =

(base) * pow(

(base), exponent);

2768 if

( !

SCIPisFinite

(*val) || *val == HUGE_VAL || *val == -HUGE_VAL )

2782

assert(expr !=

);

2784

assert(childidx == 0);

2787

assert(child !=

);

2794

assert(exponent >= 1.0);

2796

*val = exponent * pow(

(childval), exponent - 1.0);

2807

assert(expr !=

);

2834

assert(expr !=

);

2837

assert(refpoint !=

);

2838

assert(coefs !=

);

2839

assert(constant !=

);

2840

assert(islocal !=

);

2841

assert(branchcand !=

);

2842

assert(*branchcand ==

);

2843

assert(success !=

);

2847 SCIPdebugMsg

(

"%sestimation of signed x^%g at x=%g\n"

, overestimate ?

"over"

"under"

2854

childlb = localbounds[0].inf;

2855

childub = localbounds[0].sup;

2857

childglb = globalbounds[0].inf;

2858

childgub = globalbounds[0].sup;

2861

exponent = exprdata->exponent;

2862

assert(exponent > 1.0);

2867 if

( childlb == childub )

2870

*constant =

(childlb)*pow(

(childlb), exponent);

2872

*islocal = childglb != childgub;

2873

*branchcand =

;

2877 if

( childlb >= 0.0 )

2882

*branchcand = *islocal;

2887 if

( !*islocal && childglb < 0.0 )

2897

*islocal = *refpoint < exprdata->root * (-childglb);

2904 if

( exprdata->root ==

SCIP_INVALID

&& childgub > 0.0 )

2909

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

2933

assert(expr !=

);

2937

childlb = bounds[0].inf;

2938

childub = bounds[0].sup;

2943 SCIPdebugMsg

(

"skip initestimates as child seems essentially fixed [%.15g,%.15g]\n"

, childlb, childub);

2948

exponent = exprdata->exponent;

2949

assert(exponent > 1.0);

2951 if

( childlb >= 0.0 )

2953 if

( !overestimate )

2956

refpointsover[0] = (childlb + childub) / 2.0;

2958 else if

( childub <= 0.0 )

2961

refpointsunder[0] = (childlb + childub) / 2.0;

2973 if

( (overest[i] && !overestimate) || (!overest[i] && overestimate) )

2976

assert(overest[i] || i < 3);

2977

refpoint = overest[i] ? refpointsover[i % 3] : refpointsunder[i % 3];

2984 estimateParabola

(

, exponent, overest[i], childlb, childub, refpoint, &constant[*nreturned], coefs[*nreturned],

2985

&islocal, &success);

2996

childlb, childub, &constant[*nreturned], coefs[*nreturned], &islocal,

2997

&branchcand, &success);

3016

assert(expr !=

);

3021 SCIPdebugMsg

(

"reverseprop signpow(x,%g) in [%.15g,%.15g]"

, exponent, bounds.inf, bounds.sup);

3032 if

( exprecip.

== exprecip.

)

3046

childrenbounds[0] = interval;

3056

assert(expr !=

);

3058

assert(hashkey !=

);

3059

assert(childrenhashes !=

);

3063

*hashkey ^= childrenhashes[0];

3076

assert(expr !=

);

3078

assert(childcurv !=

);

3079

assert(success !=

);

3083

assert(child !=

);

3092

*success = childinterval.

>= 0.0;

3098

*success = childinterval.

<= 0.0;

3111

assert(expr !=

);

3112

assert(result !=

);

3129

evalPow, exprhdlrdata) );

3130

assert(exprhdlr !=

);

3148 "minimal distance from zero to enforce for child in bound tightening"

3152 "maximal exponent when to expand power of sum in simplify"

3153

&exprhdlrdata->expandmaxexponent,

, 2, 1, INT_MAX,

) );

3156 "whether a fractional exponent is distributed onto factors on power of product"

3171

assert(exprhdlr !=

);

3199 void

* ownercreatedata

3204

assert(expr !=

);

3205

assert(child !=

);

3208

assert(exprdata !=

);

3223 void

* ownercreatedata

3228

assert(expr !=

);

3229

assert(child !=

);

3233

assert(exprdata !=

);

3236

ownercreate, ownercreatedata) );

3247

assert(expr !=

);

3264

assert(lincoef !=

);

3265

assert(linconstant !=

);

3266

assert(success !=

);

3268 if

( sqrcoef == 0.0 )

3283

tmp = sqrcoef * refpoint;

3291

*lincoef += 2.0 * tmp;

3293

*linconstant -= tmp;

3306

coef = sqrcoef * (2.0 * f + 1.0);

3307

constant = -sqrcoef * f * (f + 1.0);

3316

*linconstant += constant;

3338

assert(lincoef !=

);

3339

assert(linconstant !=

);

3340

assert(success !=

);

3342 if

( sqrcoef == 0.0 )

3355

coef = sqrcoef * (lb + ub);

3356

constant = -sqrcoef * lb * ub;

3364

*linconstant += constant;

3410

assert(constant !=

);

3411

assert(slope !=

);

3412

assert(islocal !=

);

3413

assert(success !=

);

3414

assert(exponent > 0.0);

3415

assert(exponent < 1.0);

3418 if

( !overestimate )

3443

xref = 0.5 * xlb + 0.5 * xub;

3462

assert(expr !=

);

3465

assert(exprdata !=