RetroSearch Browse

);

151

assert(nlhdlrexpr !=

);

152

assert(origexpr !=

);

157

*nlhdlrexpr = origexpr;

168

assert(*nlhdlrexpr !=

);

196

assert(nlhdlrexpr !=

);

202 if

( nchildren == 0 )

205 for

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

226

assert(args !=

);

228

assert(evaldata !=

);

230#ifdef SCIP_MORE_DEBUG 233 for

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

235#ifdef SCIP_MORE_DEBUG 257

assert(exprstack !=

);

258

assert(initsize > 0);

275

assert(exprstack !=

);

290

assert(exprstack !=

);

295

assert(exprs !=

);

315

assert(exprstack !=

);

327

assert(exprstack !=

);

351

assert(nlexpr !=

);

352

assert(stack !=

);

353

assert(nlexpr2origexpr !=

);

354

assert(success !=

);

358 if

( !nlhdlrdata->cvxquadratic )

370

assert(expr !=

);

382 if

( nquadexprs <= 1 )

386 if

( isrootexpr && !nlhdlrdata->detectsum && nbilinexprs == 0 )

395 if

( presentcurv != wantedcurv )

400 if

( !nlhdlrdata->detectsum )

408 for

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

414 if

( nadjbilin == 0 )

416

assert(sqrexpr !=

);

436

assert(child !=

);

463 if

( nlhdlrdata->extendedform )

471 if

( lonelysquares !=

)

495

assert(nlexpr !=

);

496

assert(stack !=

);

497

assert(nlexpr2origexpr !=

);

498

assert(success !=

);

502 if

( !nlhdlrdata->cvxsignomial )

509

assert(expr !=

);

519 for

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

522

assert(child !=

);

539

nfactors, exponents, bounds, curv) )

553 for

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

556

assert(child !=

);

566 if

( nlhdlrdata->extendedform )

625

assert(nlexpr !=

);

626

assert(stack !=

);

627

assert(nlexpr2origexpr !=

);

628

assert(success !=

);

632 if

( !nlhdlrdata->cvxprodcomp )

639

assert(expr !=

);

645 for

( fidx = 0; fidx <= 1; ++fidx )

664#ifndef NLHDLR_CONVEX_UNITTEST 679#ifdef SCIP_MORE_DEBUG 693 if

( hbounds.

< 0.0 && hbounds.

> 0.0 )

704 SCIP_CALL

( SCIPcallExprMonotonicity(

, f, 0, &fmonotonicity) );

725 if

( hbounds.

>= 0 )

730 if

( fbounds.

< 0.0 )

740 if

( fbounds.

> 0.0 )

757 if

( hbounds.

<= 0 )

762 if

( fbounds.

< 0.0 )

772 if

( fbounds.

> 0.0 )

788#ifndef NLHDLR_CONVEX_UNITTEST 795 if

( nlhdlrdata->extendedform )

832

assert(nlexpr !=

);

833

assert(stack !=

);

834

assert(nlexpr2origexpr !=

);

835

assert(success !=

);

838

assert(origexpr !=

);

841 if

( nchildren == 0 )

857 if

( isrootexpr && !nlhdlrdata->detectsum &&

SCIPisExprSum

(

, nlexpr) && nchildren > 1 )

864#ifdef SCIP_MORE_DEBUG 880 if

( nlhdlrdata->extendedform )

883 for

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

906static DECL_CURVCHECK

((*CURVCHECKS[])) = { curvCheckProductComposite, curvCheckSignomial, curvCheckQuadratic, curvCheckExprhdlr };

908static const int NCURVCHECKS

sizeof

(CURVCHECKS) /

sizeof

(

void

*);

927

assert(expr !=

);

933 if

( nchildren <= 1 )

936 for

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

972

assert(nlhdlrdata !=

);

973

assert(rootnlexpr !=

);

974

assert(nlexpr2origexpr !=

);

975

assert(nleafs !=

);

976

assert(rootexpr !=

);

983 if

( curvsuccess !=

)

984

*curvsuccess =

;

992

assert(nlexpr !=

);

1010#ifdef SCIP_MORE_DEBUG 1022 for

( method = 0; method <

NCURVCHECKS

; ++method )

1024 SCIP_CALL

( CURVCHECKS[method](

, nlexpr, isrootexpr, &stack, nlexpr2origexpr, nlhdlrdata, assumevarfixed, &success) );

1040

assert(stack.

stackpos

>= oldstackpos);

1042

isrootexpr =

;

1048 if

( stack.

stackpos

== oldstackpos )

1054

*curvsuccess =

;

1060 if

( !nlhdlrdata->isnlhdlrconvex && *rootnlexpr !=

)

1076

assert(child !=

);

1087#ifdef SCIP_MORE_DEBUG 1089 SCIPinfoMessage

(

"... is a multivariate linear sum that we'll treat as auxvar instead (postprocess)\n"

);

1110 if

( *rootnlexpr !=

)

1161

assert(nlhdlrexprdata !=

);

1162

assert(nlhdlrexprdata->nlexpr !=

);

1163

assert(nlhdlrexprdata->nlexpr2origexpr !=

);

1167

assert(nlhdlrexprdata->nleafs > 0);

1168

assert(nlhdlrexprdata->leafexprs ==

);

1172

nlhdlrexprdata->nleafs = 0;

1183

assert(nlexpr !=

);

1192

assert(origexpr !=

);

1205

assert(var !=

);

1242

assert(nlhdlrexprdata->nleafs > 0);

1255 if

( entry ==

)

1259

assert(leaf !=

);

1264

assert(idx < nlhdlrexprdata->nleafs);

1266

nlhdlrexprdata->leafexprs[idx] = leaf;

1293

assert(expr !=

);

1294

assert(nlhdlrexprdata !=

);

1295

assert(*nlhdlrexprdata ==

);

1296

assert(nlexpr !=

);

1297

assert(nlexpr2origexpr !=

);

1303

(*nlhdlrexprdata)->nlexpr = nlexpr;

1304

(*nlhdlrexprdata)->nlexpr2origexpr = nlexpr2origexpr;

1305

(*nlhdlrexprdata)->nleafs = nleafs;

1327

assert(origexpr !=

);

1394

assert(nlhdlr !=

);

1395

assert(nlhdlrexprdata !=

);

1396

assert(rowprep !=

);

1397

assert(success !=

);

1409 for

( i = 0; i < nlhdlrexprdata->nleafs; ++i )

1412

assert(var !=

);

1421

assert(nlhdlrdata !=

);

1423 if

( nlhdlrdata->evalsol ==

)

1429

evaldata.

evalsol

= nlhdlrdata->evalsol;

1436 for

( i = 0; i < nlhdlrexprdata->nleafs; ++i )

1439

assert(var !=

);

1444 SCIPdebugMsg

(

"lower bound at -infinity, no estimate possible\n"

);

1451 SCIPdebugMsg

(

"upper bound at +infinity, no estimate possible\n"

);

1459

xstar[i] = 0.5 * (box[2*i] + box[2*i+1]);

1475

xstar, box, nlhdlrexprdata->nleafs, targetvalue, success,

SCIProwprepGetCoefs

(rowprep), &facetconstant) );

1485 for

( i = 0; i < nlhdlrexprdata->nleafs; ++i )

1517

assert(nlhdlrexprdata !=

);

1518

assert(rowprep !=

);

1519

assert(success !=

);

1521

nlexpr = nlhdlrexprdata->nlexpr;

1522

assert(nlexpr !=

);

1530 SCIPdebugMsg

(

"gradient evaluation error for %p\n"

, (

void

*)nlexpr);

1540 for

( i = 0; i < nlhdlrexprdata->nleafs; ++i )

1550 SCIPdebugMsg

(

"gradient evaluation error for component %d of %p\n"

, i, (

void

*)nlexpr);

1555

assert(var !=

);

1588

assert(nlhdlrexprdata !=

);

1589

assert(rowprep !=

);

1590

assert(success !=

);

1607

assert(nlhdlrdata !=

);

1610 if

( nlhdlrdata->maxperturb == 0.0 )

1612 SCIPdebugMsg

(

"gradient evaluation error, perturbation disabled\n"

);

1616 SCIPdebugMsg

(

"gradient evaluation error, try perturbed point\n"

);

1618 if

( nlhdlrdata->evalsol ==

)

1623 if

( nlhdlrdata->randnumgen ==

)

1628 for

( i = 0; i < nlhdlrexprdata->nleafs; ++i )

1637

assert(var !=

);

1642

val =

MIN

(ub,

MAX

(lb, val));

1644

p =

SCIPrandomGetReal

(nlhdlrdata->randnumgen, -nlhdlrdata->maxperturb, nlhdlrdata->maxperturb);

1651 if

( val + p <= lb )

1653 else if

( val + p >= ub )

1661 if

( val <= lb || val >= ub )

1691

assert(nlhdlrexprdata !=

);

1692

assert(nlhdlrexprdata->nleafs == 1);

1693

assert(rowprep !=

);

1694

assert(success !=

);

1696

nlexpr = nlhdlrexprdata->nlexpr;

1697

assert(nlexpr !=

);

1702

assert(nlhdlrdata !=

);

1705

assert(var !=

);

1737

assert(left != right);

1740 if

( nlhdlrdata->evalsol ==

)

1767 SCIPdebugMsg

(

"f(%g)=%g, f(%g)=%g\n"

, left, fleft, right, fright);

1799

assert(nlhdlrdata !=

);

1800

assert(*nlhdlrdata !=

);

1801

assert((*nlhdlrdata)->evalsol ==

);

1802

assert((*nlhdlrdata)->randnumgen ==

);

1814

assert(nlhdlrexprdata !=

);

1815

assert(*nlhdlrexprdata !=

);

1833

assert(nlhdlrdata !=

);

1835 if

( nlhdlrdata->evalsol !=

)

1840 if

( nlhdlrdata->randnumgen !=

)

1856

assert(nlhdlr !=

);

1857

assert(expr !=

);

1858

assert(enforcing !=

);

1859

assert(participating !=

);

1860

assert(nlhdlrexprdata !=

);

1871

assert(nlhdlrdata !=

);

1872

assert(nlhdlrdata->isnlhdlrconvex);

1874 SCIPdebugMsg

(

"nlhdlr_convex detect for expr %p\n"

, (

void

*)expr);

1886 if

( nlexpr !=

)

1892 SCIPdebugMsg

(

"detected expr %p to be convex -> can enforce expr <= auxvar\n"

, (

void

*)expr);

1904 if

( nlexpr !=

)

1910 SCIPdebugMsg

(

"detected expr %p to be concave -> can enforce expr >= auxvar\n"

, (

void

*)expr);

1915

*enforcing |= *participating;

1917

assert(*participating || nlexpr ==

);

1918 if

( !*participating )

1936

assert(nlhdlrexprdata !=

);

1937

assert(nlhdlrexprdata->nlexpr !=

);

1938

assert(auxvalue !=

);

1962

assert(expr !=

);

1963

assert(nlhdlrexprdata !=

);

1968

nlexpr = nlhdlrexprdata->nlexpr;

1969

assert(nlexpr !=

);

1977

overestimate =

;

1979

underestimate =

;

1980 if

( !overestimate && !underestimate )

1989

*infeasible =

;

1991 for

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

1994

lambda = 0.1 * (k+1);

1996 for

( i = 0; i < nlhdlrexprdata->nleafs; ++i )

2039 SCIPdebugMsg

(

"failed to cleanup rowprep numerics for k = %d\n"

, k);

2045

overestimate ?

"over"

"under"

, (

void

*)expr, k);

2073

assert(expr !=

);

2074

assert(nlhdlrexprdata !=

);

2075

assert(nlhdlrexprdata->nlexpr !=

);

2076

assert(rowpreps !=

);

2077

assert(success !=

);

2079

assert(

SCIPhashmapGetImage

(nlhdlrexprdata->nlexpr2origexpr, (

void

*)nlhdlrexprdata->nlexpr) == expr);

2088

*addedbranchscores =

;

2097 if

( nlhdlrexprdata->nleafs == 1 &&

SCIPexprIsIntegral

(nlhdlrexprdata->leafexprs[0]) )

2102

overestimate ?

"over"

"under"

2104

sol !=

"sol"

"lp"

2114

overestimate ?

"over"

"under"

2116

sol !=

"sol"

"lp"

2140

assert(expr !=

);

2141

assert(nlhdlrexprdata !=

);

2142

assert(nlhdlrexprdata->nlexpr !=

);

2143

assert(

SCIPhashmapGetImage

(nlhdlrexprdata->nlexpr2origexpr, (

void

*)nlhdlrexprdata->nlexpr) == expr);

2144

assert(sol !=

);

2151

assert(underestimate == !overestimate);

2158 if

( nlhdlrexprdata->nleafs == 1 &&

SCIPexprIsIntegral

(nlhdlrexprdata->leafexprs[0]) )

2163

overestimate ?

"over"

"under"

, (

void

*)expr,

SCIPsolGetIndex

(sol));

2172

overestimate ?

"over"

"under"

, (

void

*)expr,

SCIPsolGetIndex

(sol));

2201

assert(targetscip !=

);

2202

assert(sourcenlhdlr !=

);

2221

nlhdlrdata->isnlhdlrconvex =

;

2222

nlhdlrdata->evalsol =

;

2223

nlhdlrdata->randnumgen =

;

2227

assert(nlhdlr !=

);

2230 "whether to run convexity detection when the root of an expression is a non-quadratic sum"

2234 "whether to create extended formulations instead of looking for maximal convex expressions"

2238 "maximal relative perturbation of non-differentiable reference point"

2242 "whether to use convexity check on quadratics"

2246 "whether to use convexity check on signomials"

2250 "whether to use convexity check on product composition f(h)*h"

2254 "whether to also handle trivial convex expressions"

2278

assert(nlhdlrdata !=

);

2279

assert(nlhdlrdata->randnumgen ==

);

2281 if

( nlhdlrdata->evalsol !=

)

2299

assert(nlhdlr !=

);

2300

assert(expr !=

);

2301

assert(enforcing !=

);

2302

assert(participating !=

);

2303

assert(nlhdlrexprdata !=

);

2314

assert(nlhdlrdata !=

);

2315

assert(!nlhdlrdata->isnlhdlrconvex);

2317 SCIPdebugMsg

(

"nlhdlr_concave detect for expr %p\n"

, (

void

*)expr);

2332 SCIPdebugMsg

(

"Too many variables (%d) in constructed expression. Will not be able to estimate. Rejecting.\n"

, nleafs);

2336 if

( nlexpr !=

)

2342 SCIPdebugMsg

(

"detected expr %p to be concave -> can enforce expr <= auxvar\n"

, (

void

*)expr);

2357 SCIPdebugMsg

(

"Too many variables (%d) in constructed expression. Will not be able to estimate. Rejecting.\n"

, nleafs);

2361 if

( nlexpr !=

)

2367 SCIPdebugMsg

(

"detected expr %p to be convex -> can enforce expr >= auxvar\n"

, (

void

*)expr);

2372

*enforcing |= *participating;

2374

assert(*participating || nlexpr ==

);

2375 if

( !*participating )

2400

assert(expr !=

);

2401

assert(nlhdlrexprdata !=

);

2403

nlexpr = nlhdlrexprdata->nlexpr;

2404

assert(nlexpr !=

);

2414

overestimate =

;

2416

underestimate =

;

2417 if

( !overestimate && !underestimate )

2442

overestimate ?

"over"

"under"

, (

void

*)expr);

2454 if

( rowprep !=

)

2467

assert(expr !=

);

2468

assert(nlhdlrexprdata !=

);

2469

assert(nlhdlrexprdata->nlexpr !=

);

2470

assert(rowpreps !=

);

2471

assert(success !=

);

2473

assert(

SCIPhashmapGetImage

(nlhdlrexprdata->nlexpr2origexpr, (

void

*)nlhdlrexprdata->nlexpr) == expr);

2482

*addedbranchscores =

;

2493

overestimate ?

"over"

"under"

2495

sol !=

"sol"

"lp"

2503 if

( addbranchscores )

2525 if

( !overestimate )

2526

violation =

MAX

(0.0, auxvalue - auxval);

2528

violation =

MAX

(0.0, auxval - auxvalue);

2530

assert(violation >= 0.0);

2533 if

( nlhdlrexprdata->nleafs == 1 )

2548 for

( c = 0; c < nlhdlrexprdata->nleafs; ++c )

2564

assert(targetscip !=

);

2565

assert(sourcenlhdlr !=

);

2584

nlhdlrdata->isnlhdlrconvex =

;

2585

nlhdlrdata->evalsol =

;

2586

nlhdlrdata->randnumgen =

;

2590

assert(nlhdlr !=

);

2593 "whether to run convexity detection when the root of an expression is a sum"

2597

nlhdlrdata->extendedform =

;

2600 "whether to use convexity check on quadratics"

2604 "whether to use convexity check on signomials"

2608 "whether to use convexity check on product composition f(h)*h"

2612 "whether to also handle trivial convex expressions"

2641

assert(expr !=

);

2643

assert(success !=

);

2649

nlhdlrdata.isnlhdlrconvex =

;

2650

nlhdlrdata.evalsol =

;

2651

nlhdlrdata.detectsum =

;

2652

nlhdlrdata.extendedform =

;

2653

nlhdlrdata.cvxquadratic =

;

2654

nlhdlrdata.cvxsignomial =

;

2655

nlhdlrdata.cvxprodcomp =

;

2656

nlhdlrdata.handletrivial =

;

2661 if

( rootnlexpr !=