A RetroSearch Logo

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

Search Query:

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

SCIP Doxygen Documentation: nlp.c Source File

70#define EVENTHDLR_NAME "nlpEventHdlr" 71#define EVENTHDLR_DESC "handles all events necessary for maintaining NLP data" 72#define ADDNAMESTONLPI 0 127

assert(nlrow !=

NULL

);

128

assert(var !=

NULL

);

140

assert(nlp !=

NULL

);

153

assert(idx >= 0 && idx < nlp->nvars);

156

assert(idx >= 0 && idx < nlp->nvars_solver);

176

assert(sourcescip !=

NULL

);

177

assert(sourcescip == targetscip);

178

assert(sourceexpr !=

NULL

);

179

assert(targetexpr !=

NULL

);

180

assert(*targetexpr ==

NULL

);

181

assert(mapexprdata !=

NULL

);

193

assert(nlpidx < nlp->nvars);

212

assert(nlrow !=

NULL

);

224

assert(nlp !=

NULL

);

234 SCIP_CALL

(

SCIPexprCopy

(

set

, stat, blkmem,

set

, stat, blkmem, nlrow->

expr

, &nlpiexpr, mapvar2varidx, (

void

*)nlp,

NULL

,

NULL

) );

252

assert(nlrow !=

NULL

);

256

assert(nlp !=

NULL

);

290

assert(nlrow !=

NULL

);

302

assert(nlp !=

NULL

);

339

assert(nlp !=

NULL

);

340

assert(nlrow !=

NULL

);

342

assert(incr == 1 || incr == -1);

376

assert(nlrow !=

NULL

);

397

assert(nlrow !=

NULL

);

398

assert(var !=

NULL

);

418

assert(nlrow !=

NULL

);

419

assert(0 <= oldpos && oldpos < nlrow->nlinvars);

420

assert(0 <= newpos && newpos < nlrow->nlinvars);

423 if

( oldpos == newpos )

447

assert(nlrow !=

NULL

);

448

assert(blkmem !=

NULL

);

449

assert(var !=

NULL

);

472 SCIPsetDebugMsg

(

set

,

"added linear coefficient %g * <%s> at position %d to nonlinear row <%s>\n"

,

478#ifdef SCIP_DISABLED_CODE 496

assert(nlrow !=

NULL

);

497

assert(blkmem !=

NULL

);

498

assert(var !=

NULL

);

506 if

( constant != 0.0 )

551

assert(pos < nlrow->nlinvars);

552

assert(nlrow->

linvars

[pos] == var);

574

assert(nlrow !=

NULL

);

576

assert(0 <= pos && pos < nlrow->nlinvars);

602

assert(nlrow !=

NULL

);

603

assert(0 <= pos && pos < nlrow->nlinvars);

636

assert(nlrow !=

NULL

);

638

assert(stat !=

NULL

);

682

assert(nlrow !=

NULL

);

683

assert(blkmem !=

NULL

);

685

assert(pos < nlrow->nlinvars);

698 if

( nlrow->

lincoefs

[pos] == 0.0 )

703 if

( pos < nlrow->nlinvars )

716 if

( oldconstant != nlrow->

constant

)

783

assert(nlrow !=

NULL

);

787 for

( i = 0; i <

MIN

(oldlen, nlrow->

nlinvars

); ++i )

823

nlrow->

expr

= simplified;

861

assert(nlrow !=

NULL

);

862

assert(var !=

NULL

);

915

assert(nlrow !=

NULL

);

916

assert(blkmem !=

NULL

);

918

assert(name !=

NULL

);

920

assert(nlinvars == 0 || linvars !=

NULL

);

921

assert(nlinvars == 0 || lincoefs !=

NULL

);

928

(*nlrow)->constant = constant;

931 for

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

933

assert(linvars[i] !=

NULL

);

939

(*nlrow)->nlinvars = nlinvars;

940

(*nlrow)->linvarssize = nlinvars;

945

(*nlrow)->linvarssorted =

FALSE

;

949

(*nlrow)->linvars =

NULL

;

950

(*nlrow)->lincoefs =

NULL

;

951

(*nlrow)->linvarssorted =

TRUE

;

958 SCIP_CALL

(

SCIPexprCopy

(

set

, stat, blkmem,

set

, stat, blkmem, expr, &(*nlrow)->expr,

NULL

,

NULL

,

NULL

,

NULL

) );

962

(*nlrow)->expr =

NULL

;

966

(*nlrow)->lhs =

MIN

(lhs, rhs);

967

(*nlrow)->rhs =

MAX

(lhs, rhs);

972

(*nlrow)->validactivitynlp =

FALSE

;

974

(*nlrow)->validpsactivitydomchg =

FALSE

;

977

(*nlrow)->validactivitybdsdomchg =

FALSE

;

978

(*nlrow)->nlpindex = -1;

979

(*nlrow)->nlpiindex = -1;

981

(*nlrow)->dualsol = 0.0;

982

(*nlrow)->curvature = curvature;

1002

assert(nlrow !=

NULL

);

1003

assert(blkmem !=

NULL

);

1005

assert(sourcenlrow !=

NULL

);

1010

sourcenlrow->

expr

,

1014

(*nlrow)->activity = sourcenlrow->

activity

;

1018

(*nlrow)->minactivity = sourcenlrow->

minactivity

;

1019

(*nlrow)->maxactivity = sourcenlrow->

maxactivity

;

1039

assert(nlrow !=

NULL

);

1040

assert(blkmem !=

NULL

);

1042

assert(row !=

NULL

);

1053 for

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

1056

assert(rowvars[i] !=

NULL

);

1067 else if

( rownz == 1 )

1103

assert(nlrow !=

NULL

);

1106 if

( nlrow->

name

!=

NULL

&& nlrow->

name

[0] !=

'\0'

)

1118 for

( i = 0; i < nlrow->

nlinvars

; ++i )

1146

assert(nlrow !=

NULL

);

1147

assert(nlrow->

nuses

>= 0);

1161

assert(blkmem !=

NULL

);

1162

assert(nlrow !=

NULL

);

1163

assert(*nlrow !=

NULL

);

1164

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

1166 SCIPsetDebugMsg

(

set

,

"release nonlinear row <%s> with nuses=%d\n"

, (*nlrow)->name, (*nlrow)->nuses);

1168 if

( (*nlrow)->nuses > 0 )

1176

assert((*nlrow)->nuses == 0);

1177

assert((*nlrow)->nlpindex == -1);

1178

assert((*nlrow)->nlpiindex == -1);

1185 if

( (*nlrow)->expr !=

NULL

)

1206

assert(nlrow !=

NULL

);

1218

assert(num <= nlrow->linvarssize);

1282

assert(nlrow !=

NULL

);

1283

assert(var !=

NULL

);

1295

assert(0 <= pos && pos < nlrow->nlinvars);

1296

assert(nlrow->

linvars

[pos] == var);

1317

assert(nlrow !=

NULL

);

1318

assert(nlp !=

NULL

);

1319

assert(var !=

NULL

);

1352

assert(nlrow !=

NULL

);

1353

assert(blkmem !=

NULL

);

1370 SCIP_CALL

(

SCIPexprCopy

(

set

, stat, blkmem,

set

, stat, blkmem, expr, &nlrow->

expr

,

NULL

,

NULL

,

NULL

,

NULL

) );

1380

assert(!infeasible);

1383

nlrow->

expr

= simplified;

1406

assert(nlrow !=

NULL

);

1426

assert(nlrow !=

NULL

);

1452

assert(nlrow !=

NULL

);

1477

assert(nlrow !=

NULL

);

1516

assert(nlrow !=

NULL

);

1517

assert(stat !=

NULL

);

1518

assert(nlp !=

NULL

);

1522 SCIPerrorMessage

(

"do not have NLP solution for computing NLP activity\n"

);

1527 for

( i = 0; i < nlrow->

nlinvars

; ++i )

1567

assert(nlrow !=

NULL

);

1568

assert(stat !=

NULL

);

1569

assert(activity !=

NULL

);

1599

assert(nlrow !=

NULL

);

1600

assert(feasibility !=

NULL

);

1603

*feasibility =

MIN

(nlrow->

rhs

- activity, activity - nlrow->

lhs

);

1623

assert(nlrow !=

NULL

);

1624

assert(stat !=

NULL

);

1627 for

( i = 0; i < nlrow->

nlinvars

; ++i )

1668

assert(nlrow !=

NULL

);

1669

assert(stat !=

NULL

);

1670

assert(pseudoactivity !=

NULL

);

1701

assert(nlrow !=

NULL

);

1702

assert(stat !=

NULL

);

1703

assert(pseudofeasibility !=

NULL

);

1706

*pseudofeasibility =

MIN

(nlrow->

rhs

- pseudoactivity, pseudoactivity - nlrow->

lhs

);

1725

assert(nlrow !=

NULL

);

1727

assert(stat !=

NULL

);

1728

assert(activity !=

NULL

);

1731 for

( i = 0; i < nlrow->

nlinvars

; ++i )

1741

*activity += nlrow->

lincoefs

[i] * val1;

1754

*activity =

MAX

(*activity, -inf);

1755

*activity =

MIN

(*activity, +inf);

1772

assert(nlrow !=

NULL

);

1773

assert(feasibility !=

NULL

);

1777

*feasibility =

MIN

(nlrow->

rhs

- activity, activity - nlrow->

lhs

);

1792

assert(nlrow !=

NULL

);

1794

assert(stat !=

NULL

);

1806 if

( minactivity !=

NULL

)

1808 if

( maxactivity !=

NULL

)

1826

assert(nlrow !=

NULL

);

1828

assert(isredundant !=

NULL

);

1832

*isredundant =

TRUE

;

1835

*isredundant =

FALSE

;

1842#undef SCIPnlrowGetConstant 1843#undef SCIPnlrowGetNLinearVars 1844#undef SCIPnlrowGetLinearVars 1845#undef SCIPnlrowGetLinearCoefs 1846#undef SCIPnlrowGetExpr 1847#undef SCIPnlrowGetLhs 1848#undef SCIPnlrowGetRhs 1849#undef SCIPnlrowGetCurvature 1850#undef SCIPnlrowGetName 1851#undef SCIPnlrowGetNLPPos 1852#undef SCIPnlrowIsInNLP 1853#undef SCIPnlrowGetDualsol 1861

assert(nlrow !=

NULL

);

1871

assert(nlrow !=

NULL

);

1881

assert(nlrow !=

NULL

);

1891

assert(nlrow !=

NULL

);

1901

assert(nlrow !=

NULL

);

1903 return

nlrow->

expr

;

1911

assert(nlrow !=

NULL

);

1913 return

nlrow->

lhs

;

1921

assert(nlrow !=

NULL

);

1923 return

nlrow->

rhs

;

1931

assert(nlrow !=

NULL

);

1940

assert(nlrow !=

NULL

);

1942 return

nlrow->

name

;

1950

assert(nlrow !=

NULL

);

1960

assert(nlrow !=

NULL

);

1973

assert(nlrow !=

NULL

);

1996

assert(nlp !=

NULL

);

1997

assert(nlrow !=

NULL

);

2040

assert(nlp !=

NULL

);

2041

assert(blkmem !=

NULL

);

2043

assert(nlrows !=

NULL

|| nnlrows == 0);

2048 for

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

2061 for

( i = 0; i < nlrow->

nlinvars

; ++i )

2120

assert(nlp !=

NULL

);

2121

assert(0 <= oldpos && oldpos < nlp->nnlrows);

2122

assert(0 <= newpos && newpos < nlp->nnlrows);

2125 if

( oldpos == newpos )

2152

assert(nlp !=

NULL

);

2153

assert(blkmem !=

NULL

);

2156

assert(pos < nlp->nnlrows);

2160

nlrow = nlp->

nlrows

[pos];

2161

assert(nlrow !=

NULL

);

2211

assert(nlp !=

NULL

);

2212

assert(var !=

NULL

);

2269

assert(nlp !=

NULL

);

2270

assert(var !=

NULL

);

2332

assert(nlp !=

NULL

);

2333

assert(blkmem !=

NULL

);

2335

assert(vars !=

NULL

|| nvars == 0);

2336

assert(!nlp->

indiving

|| nvars == 0);

2344 for

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

2392

nlp->

nvars

+= nvars;

2408

assert(nlp !=

NULL

);

2409

assert(0 <= oldpos && oldpos < nlp->nvars);

2410

assert(0 <= newpos && newpos < nlp->nvars);

2411

assert(nlp->

vars

[oldpos] !=

NULL

);

2413 if

( oldpos == newpos )

2417

nlp->

vars

[newpos] = nlp->

vars

[oldpos];

2449

assert(nlp !=

NULL

);

2450

assert(blkmem !=

NULL

);

2453

assert(pos < nlp->nvars);

2456

var = nlp->

vars

[pos];

2457

assert(var !=

NULL

);

2461 for

( i = 0; i < nlp->

nnlrows

; ++i )

2466

nlrow = nlp->

nlrows

[i];

2467

assert(nlrow !=

NULL

);

2473 for

( j = 0; j < nlrow->

nlinvars

; ++j )

2474

assert( nlrow->

linvars

[j] != var );

2501

assert(nlpipos < nlp->nvars_solver);

2539

assert(nlp !=

NULL

);

2540

assert(var !=

NULL

);

2546 for

( i = 0; i < nlp->

nnlrows

; ++i )

2569

assert(nlp !=

NULL

);

2571

assert(nlrow !=

NULL

);

2572

assert(linidxs !=

NULL

);

2582 for

( i = 0; i < nlrow->

nlinvars

; ++i )

2585

assert(var !=

NULL

);

2590

assert((*linidxs)[i] >= 0);

2608

assert(nlp !=

NULL

);

2609

assert(blkmem !=

NULL

);

2622

assert(num <= nlp->sizevars_solver);

2636

assert(nlp !=

NULL

);

2637

assert(blkmem !=

NULL

);

2650

assert(num <= nlp->sizenlrows_solver);

2668

assert(nlp !=

NULL

);

2669

assert(blkmem !=

NULL

);

2708

assert(rowset[j] <= j);

2709 if

( rowset[j] < 0 )

2714 else if

( rowset[j] < j )

2761

assert(nlp !=

NULL

);

2762

assert(blkmem !=

NULL

);

2802

assert(colset[i] <= i);

2803 if

( colset[i] < 0 )

2808 else if

( colset[i] < i)

2814

assert(varpos >= 0);

2815

assert(varpos < nlp->nvars);

2862 const char

** names;

2864

assert(nlp !=

NULL

);

2865

assert(blkmem !=

NULL

);

2876 for

( i = 0; i < nlp->

nnlrows

; ++i )

2900 for

( i = 0; i < nlp->

nnlrows

; ++i )

2902

nlrow = nlp->

nlrows

[i];

2903

assert(nlrow !=

NULL

);

2908

assert(c < nlp->nunflushednlrowadd);

2917

lhss[c] = nlrow->

lhs

;

2918

rhss[c] = nlrow->

rhs

;

2926 if

( rhss[c] < lhss[c] )

2938 SCIP_CALL

(

SCIPexprCopy

(

set

, stat, blkmem,

set

, stat, blkmem, nlrow->

expr

, &exprs[c], mapvar2varidx, (

void

*)nlp,

NULL

,

NULL

) );

2944

names[c] = nlrow->

name

;

2960

nlinvars, linidxs, lincoefs,

2966 if

( linidxs[c] !=

NULL

)

2968 if

( exprs[c] !=

NULL

)

3004 const char

** names;

3006

assert(nlp !=

NULL

);

3007

assert(blkmem !=

NULL

);

3016 for

( i = 0; i < nlp->

nvars

; ++i )

3036 for

( i = 0; i < nlp->

nvars

; ++i )

3041

assert(c < nlp->nunflushedvaradd);

3096

assert(nlp !=

NULL

);

3097

assert(blkmem !=

NULL

);

3123

lincoefs[nz] = coef;

3128

nz, linindices, lincoefs,

3155

assert(nlp !=

NULL

);

3156

assert(blkmem !=

NULL

);

3158

assert(stat !=

NULL

);

3190

assert(nlpidx >= 0);

3191

assert(nlpidx < nlp->nvars);

3223

nlrowdualvals =

NULL

;

3224

varlbdualvals =

NULL

;

3225

varubdualvals =

NULL

;

3229

assert(primalvals !=

NULL

|| nlp->

nvars

== 0);

3230

assert((varlbdualvals !=

NULL

) == (varubdualvals !=

NULL

));

3235 for

( i = 0; i < nlp->

nvars

; ++i )

3247 for

( i = 0; i < nlp->

nvars

; ++i )

3263 for

( i = 0; i < nlp->

nnlrows

; ++i )

3273 if

( varlbdualvals !=

NULL

)

3275 for

( i = 0; i < nlp->

nvars

; ++i )

3285 else if

( nlp->

nvars

> 0 )

3310

assert(nlp !=

NULL

);

3311

assert(blkmem !=

NULL

);

3313

assert(stat !=

NULL

);

3325 SCIPsetDebugMsg

(

set

,

"NLP globally infeasible, unbounded, or worse -> no solution values -> no fractional variables\n"

);

3353

maxpriority = INT_MIN;

3356 for

( i = 0; i < nlp->

nvars

; ++i )

3358

var = nlp->

vars

[i];

3359

assert(var !=

NULL

);

3407 if

( branchpriority > maxpriority )

3412 if

( insertpos != 0 )

3420

maxpriority = branchpriority;

3422 else if

( branchpriority == maxpriority )

3441 SCIPsetDebugMsg

(

set

,

" -> candidate %d: var=<%s>, sol=%g, frac=%g, prio=%d (max: %d) -> pos %d\n"

,

3463

assert(eventhdlr !=

NULL

);

3464

assert(event !=

NULL

);

3465

assert(eventdata !=

NULL

);

3522

assert(blkmem !=

NULL

);

3549

assert(nlp !=

NULL

);

3550

assert(blkmem !=

NULL

);

3552

assert(stat !=

NULL

);

3553

assert(name !=

NULL

);

3558 if

(

set

->nnlpis > 0 )

3560

assert(

set

->nlp_solver !=

NULL

);

3561 if

(

set

->nlp_solver[0] ==

'\0'

)

3563

assert(

set

->nlpis !=

NULL

);

3566 if

( !

set

->nlpissorted )

3569

(*nlp)->solver =

set

->nlpis[0];

3574 if

( (*nlp)->solver ==

NULL

)

3580

assert((*nlp)->solver !=

NULL

);

3587

(*nlp)->solver =

NULL

;

3588

(*nlp)->problem =

NULL

;

3592

(*nlp)->nunflushedvaradd = 0;

3593

(*nlp)->nunflushedvardel = 0;

3594

(*nlp)->nunflushednlrowadd = 0;

3595

(*nlp)->nunflushednlrowdel = 0;

3596

(*nlp)->indiving =

FALSE

;

3600

(*nlp)->sizevars = 0;

3601

(*nlp)->vars =

NULL

;

3604

(*nlp)->nvars_solver = 0;

3605

(*nlp)->sizevars_solver = 0;

3606

(*nlp)->varmap_nlp2nlpi =

NULL

;

3607

(*nlp)->varmap_nlpi2nlp =

NULL

;

3610

(*nlp)->nnlrows = 0;

3611

(*nlp)->sizenlrows = 0;

3612

(*nlp)->nlrows =

NULL

;

3613

(*nlp)->nnlrowlinear = 0;

3614

(*nlp)->nnlrowconvexineq = 0;

3615

(*nlp)->nnlrownonconvexineq = 0;

3616

(*nlp)->nnlrownonlineareq = 0;

3618

(*nlp)->nnlrows_solver = 0;

3619

(*nlp)->sizenlrows_solver = 0;

3620

(*nlp)->nlrowmap_nlpi2nlp =

NULL

;

3623

(*nlp)->objflushed =

TRUE

;

3624

(*nlp)->divingobj =

NULL

;

3627

(*nlp)->haveinitguess =

FALSE

;

3628

(*nlp)->initialguess =

NULL

;

3634

(*nlp)->varlbdualvals =

NULL

;

3635

(*nlp)->varubdualvals =

NULL

;

3639 if

( (*nlp)->eventhdlr ==

NULL

)

3646

(*nlp)->eventhdlr, (

SCIP_EVENTDATA

*)(*nlp), &(*nlp)->globalfilterpos) );

3649

(*nlp)->fracvars =

NULL

;

3650

(*nlp)->fracvarssol =

NULL

;

3651

(*nlp)->fracvarsfrac =

NULL

;

3652

(*nlp)->nfracvars = 0;

3653

(*nlp)->npriofracvars = 0;

3654

(*nlp)->fracvarssize = 0;

3655

(*nlp)->validfracvars = -1;

3673

assert(nlp !=

NULL

);

3674

assert(*nlp !=

NULL

);

3675

assert(blkmem !=

NULL

);

3686

(*nlp)->eventhdlr, (

SCIP_EVENTDATA

*)(*nlp), (*nlp)->globalfilterpos) );

3689

assert((*nlp)->nnlrows == 0);

3690

assert((*nlp)->nnlrows_solver == 0);

3691

assert((*nlp)->nvars == 0);

3692

assert((*nlp)->nvars_solver == 0);

3693

assert((*nlp)->initialguess ==

NULL

);

3710 if

( (*nlp)->problem !=

NULL

)

3735

assert(nlp !=

NULL

);

3736

assert(blkmem !=

NULL

);

3750 for

(i = nlp->

nnlrows

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

3755 for

(i = nlp->

nvars

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

3770

assert(nlp !=

NULL

);

3782

assert(nlp !=

NULL

);

3783

assert(blkmem !=

NULL

);

3803

assert(num <= nlp->sizevars);

3816

assert(nlp !=

NULL

);

3817

assert(blkmem !=

NULL

);

3819

assert(var !=

NULL

);

3843

assert(nlp !=

NULL

);

3844

assert(blkmem !=

NULL

);

3846

assert(vars !=

NULL

|| nvars == 0);

3872

assert(nlp !=

NULL

);

3873

assert(blkmem !=

NULL

);

3875

assert(var !=

NULL

);

3904

assert(nlp !=

NULL

);

3905

assert(blkmem !=

NULL

);

3918

assert(num <= nlp->sizenlrows);

3935

assert(nlp !=

NULL

);

3936

assert(nlrow !=

NULL

);

3962

assert(nlp !=

NULL

);

3963

assert(nlrows !=

NULL

|| nnlrows == 0);

3991

assert(nlp !=

NULL

);

3992

assert(blkmem !=

NULL

);

3994

assert(nlrow !=

NULL

);

4022

assert(nlp !=

NULL

);

4023

assert(blkmem !=

NULL

);

4064

assert(nlp !=

NULL

);

4065

assert(blkmem !=

NULL

);

4067

assert(stat !=

NULL

);

4084

assert(nlp !=

NULL

);

4102

assert(nlp !=

NULL

);

4103

assert(pseudoobjval !=

NULL

);

4114

*pseudoobjval = 0.0;

4115 for

( i = 0; i < nlp->

nvars

; ++i )

4136

assert(nlp !=

NULL

);

4143 if

( fracvars !=

NULL

)

4145 if

( fracvarssol !=

NULL

)

4147 if

( fracvarsfrac !=

NULL

)

4149 if

( nfracvars !=

NULL

)

4151 if

( npriofracvars !=

NULL

)

4169

assert(nlp !=

NULL

);

4170

assert(blkmem !=

NULL

);

4172

assert(stat !=

NULL

);

4186 for

( i = 0; i < nlp->

nnlrows

; ++i )

4211

assert(nlp !=

NULL

);

4212

assert(blkmem !=

NULL

);

4217 if

( initguess ==

NULL

)

4253

assert(nlp !=

NULL

);

4255 if

( fname !=

NULL

)

4257

file = fopen(fname,

"w"

);

4273 for

( i = 0; i < nlp->

nvars

; ++i )

4279 for

( i = 0; i < nlp->

nnlrows

; ++i )

4286 if

( fname !=

NULL

)

4299

assert(nlp !=

NULL

);

4309

assert(nlp !=

NULL

);

4311 return

nlp->

nvars

;

4329

assert(nlp !=

NULL

);

4330

assert(nlcount !=

NULL

|| nlp->

nvars

== 0);

4336 for

( c = 0; c < nlp->

nnlrows

; ++c )

4338

nlrow = nlp->

nlrows

[c];

4339

assert(nlrow !=

NULL

);

4353

assert(varidx < nlp->nvars);

4354

assert(nlcount !=

NULL

);

4382

assert(nlp !=

NULL

);

4388 for

( c = 0; c < nlp->

nnlrows

&& !*result; ++c )

4390

nlrow = nlp->

nlrows

[c];

4391

assert(nlrow !=

NULL

);

4416

assert(nlp !=

NULL

);

4426

assert(nlp !=

NULL

);

4436

assert(nlp !=

NULL

);

4446

assert(nlp !=

NULL

);

4456 int

* nnonconvexineq,

4460

assert(nlp !=

NULL

);

4462 if

( nlinear !=

NULL

)

4465 if

( nconvexineq !=

NULL

)

4468 if

( nnonconvexineq !=

NULL

)

4480

assert(nlp !=

NULL

);

4490

assert(nlp !=

NULL

);

4500

assert(nlp !=

NULL

);

4510

assert(nlp !=

NULL

);

4520

assert(nlp !=

NULL

);

4532

assert(nlp !=

NULL

);

4535

assert(statistics !=

NULL

);

4551

assert(nlp !=

NULL

);

4568

assert(nlp !=

NULL

);

4580 SCIPerrorMessage

(

"Cannot start diving if no NLP solver is available\n"

);

4604

assert(nlp !=

NULL

);

4621 for

( i = 0; i < nlp->

nvars

; ++i )

4666

assert(nlp !=

NULL

);

4667

assert(var !=

NULL

);

4689 for

( i = 0; i < nlp->

nvars

; ++i )

4721

assert(nlp !=

NULL

);

4722

assert(var !=

NULL

);

4752

assert(nlp !=

NULL

);

4753

assert(vars !=

NULL

|| nvars == 0);

4755

assert(lbs !=

NULL

|| nvars == 0);

4756

assert(ubs !=

NULL

|| nvars == 0);

4765 for

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

4772

assert(poss[i] >= 0);

void SCIPclockStop(SCIP_CLOCK *clck, SCIP_SET *set)

void SCIPclockStart(SCIP_CLOCK *clck, SCIP_SET *set)

internal methods for clocks and timing issues

#define SCIP_CALL_TERMINATE(retcode, x, TERM)

#define SCIP_LONGINT_FORMAT

SCIP_RETCODE SCIPeventhdlrCreate(SCIP_EVENTHDLR **eventhdlr, SCIP_SET *set, const char *name, const char *desc, SCIP_DECL_EVENTCOPY((*eventcopy)), SCIP_DECL_EVENTFREE((*eventfree)), SCIP_DECL_EVENTINIT((*eventinit)), SCIP_DECL_EVENTEXIT((*eventexit)), SCIP_DECL_EVENTINITSOL((*eventinitsol)), SCIP_DECL_EVENTEXITSOL((*eventexitsol)), SCIP_DECL_EVENTDELETE((*eventdelete)), SCIP_DECL_EVENTEXEC((*eventexec)), SCIP_EVENTHDLRDATA *eventhdlrdata)

SCIP_RETCODE SCIPeventfilterDel(SCIP_EVENTFILTER *eventfilter, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)

SCIP_RETCODE SCIPeventfilterAdd(SCIP_EVENTFILTER *eventfilter, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)

internal methods for managing events

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

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

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 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_Bool SCIPexprIsVar(SCIP_SET *set, SCIP_EXPR *expr)

SCIP_Bool SCIPexprIsValue(SCIP_SET *set, SCIP_EXPR *expr)

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

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)

handler for variable index expressions

SCIP_RETCODE SCIPcreateExprVaridx(SCIP *scip, SCIP_EXPR **expr, int varidx, SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)), void *ownercreatedata)

void SCIPhashmapFree(SCIP_HASHMAP **hashmap)

int SCIPhashmapGetImageInt(SCIP_HASHMAP *hashmap, void *origin)

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

SCIP_Bool SCIPhashmapExists(SCIP_HASHMAP *hashmap, void *origin)

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

SCIP_RETCODE SCIPhashmapRemove(SCIP_HASHMAP *hashmap, void *origin)

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

SCIP_VAR * SCIPcolGetVar(SCIP_COL *col)

SCIP_EVENTTYPE SCIPeventGetType(SCIP_EVENT *event)

SCIP_VAR * SCIPeventGetVar(SCIP_EVENT *event)

const char * SCIPexprcurvGetName(SCIP_EXPRCURV curv)

SCIP_Bool SCIPexpriterIsEnd(SCIP_EXPRITER *iterator)

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

SCIP_Real SCIPgetValueExprValue(SCIP_EXPR *expr)

SCIP_Real SCIPexprGetEvalValue(SCIP_EXPR *expr)

SCIP_EXPR * SCIPexpriterGetNext(SCIP_EXPRITER *iterator)

SCIP_VAR * SCIPgetVarExprVar(SCIP_EXPR *expr)

SCIP_INTERVAL SCIPexprGetActivity(SCIP_EXPR *expr)

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

SCIP_Real SCIPintervalGetInf(SCIP_INTERVAL interval)

SCIP_Bool SCIPintervalIsEntire(SCIP_Real infinity, SCIP_INTERVAL operand)

void SCIPintervalSet(SCIP_INTERVAL *resultant, SCIP_Real value)

void SCIPintervalSetBounds(SCIP_INTERVAL *resultant, SCIP_Real inf, SCIP_Real sup)

void SCIPintervalMulScalar(SCIP_Real infinity, SCIP_INTERVAL *resultant, SCIP_INTERVAL operand1, SCIP_Real operand2)

SCIP_Real SCIPintervalGetSup(SCIP_INTERVAL interval)

void SCIPintervalAdd(SCIP_Real infinity, SCIP_INTERVAL *resultant, SCIP_INTERVAL operand1, SCIP_INTERVAL operand2)

SCIP_RETCODE SCIPnlrowChgRhs(SCIP_NLROW *nlrow, SCIP_SET *set, SCIP_STAT *stat, SCIP_NLP *nlp, SCIP_Real rhs)

SCIP_RETCODE SCIPnlrowCreate(SCIP_NLROW **nlrow, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, const char *name, SCIP_Real constant, int nlinvars, SCIP_VAR **linvars, SCIP_Real *lincoefs, SCIP_EXPR *expr, SCIP_Real lhs, SCIP_Real rhs, SCIP_EXPRCURV curvature)

SCIP_RETCODE SCIPnlrowRelease(SCIP_NLROW **nlrow, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)

SCIP_RETCODE SCIPnlrowEnsureLinearSize(SCIP_NLROW *nlrow, BMS_BLKMEM *blkmem, SCIP_SET *set, int num)

SCIP_RETCODE SCIPnlrowGetNLPFeasibility(SCIP_NLROW *nlrow, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_NLP *nlp, SCIP_Real *feasibility)

SCIP_RETCODE SCIPnlrowIsRedundant(SCIP_NLROW *nlrow, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_Bool *isredundant)

const char * SCIPnlrowGetName(SCIP_NLROW *nlrow)

SCIP_RETCODE SCIPnlrowChgLinearCoef(SCIP_NLROW *nlrow, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_NLP *nlp, SCIP_VAR *var, SCIP_Real coef)

SCIP_Real SCIPnlrowGetRhs(SCIP_NLROW *nlrow)

SCIP_RETCODE SCIPnlrowGetActivityBounds(SCIP_NLROW *nlrow, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_Real *minactivity, SCIP_Real *maxactivity)

SCIP_RETCODE SCIPnlrowGetSolFeasibility(SCIP_NLROW *nlrow, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_SOL *sol, SCIP_Real *feasibility)

SCIP_RETCODE SCIPnlrowAddLinearCoef(SCIP_NLROW *nlrow, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_NLP *nlp, SCIP_VAR *var, SCIP_Real val)

SCIP_RETCODE SCIPnlrowChgLhs(SCIP_NLROW *nlrow, SCIP_SET *set, SCIP_STAT *stat, SCIP_NLP *nlp, SCIP_Real lhs)

SCIP_Real SCIPnlrowGetLhs(SCIP_NLROW *nlrow)

SCIP_EXPRCURV SCIPnlrowGetCurvature(SCIP_NLROW *nlrow)

SCIP_RETCODE SCIPnlrowChgExpr(SCIP_NLROW *nlrow, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_NLP *nlp, SCIP_EXPR *expr)

int SCIPnlrowGetNLPPos(SCIP_NLROW *nlrow)

SCIP_RETCODE SCIPnlrowGetNLPActivity(SCIP_NLROW *nlrow, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_NLP *nlp, SCIP_Real *activity)

int SCIPnlrowGetNLinearVars(SCIP_NLROW *nlrow)

SCIP_VAR ** SCIPnlrowGetLinearVars(SCIP_NLROW *nlrow)

SCIP_RETCODE SCIPnlrowSimplify(SCIP_NLROW *nlrow, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_NLP *nlp)

SCIP_RETCODE SCIPnlrowRecalcNLPActivity(SCIP_NLROW *nlrow, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_NLP *nlp)

SCIP_RETCODE SCIPnlrowGetSolActivity(SCIP_NLROW *nlrow, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_SOL *sol, SCIP_Real *activity)

SCIP_RETCODE SCIPnlrowPrint(SCIP_NLROW *nlrow, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_MESSAGEHDLR *messagehdlr, FILE *file)

SCIP_RETCODE SCIPnlrowChgConstant(SCIP_NLROW *nlrow, SCIP_SET *set, SCIP_STAT *stat, SCIP_NLP *nlp, SCIP_Real constant)

SCIP_Real SCIPnlrowGetDualsol(SCIP_NLROW *nlrow)

SCIP_Real SCIPnlrowGetConstant(SCIP_NLROW *nlrow)

SCIP_EXPR * SCIPnlrowGetExpr(SCIP_NLROW *nlrow)

SCIP_Bool SCIPnlrowIsInNLP(SCIP_NLROW *nlrow)

SCIP_Real * SCIPnlrowGetLinearCoefs(SCIP_NLROW *nlrow)

SCIP_RETCODE SCIPnlrowDelLinearCoef(SCIP_NLROW *nlrow, SCIP_SET *set, SCIP_STAT *stat, SCIP_NLP *nlp, SCIP_VAR *var)

void SCIPnlrowSetCurvature(SCIP_NLP *nlp, SCIP_SET *set, SCIP_NLROW *nlrow, SCIP_EXPRCURV curvature)

SCIP_RETCODE SCIPnlrowCreateCopy(SCIP_NLROW **nlrow, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_NLROW *sourcenlrow)

SCIP_RETCODE SCIPnlrowGetPseudoFeasibility(SCIP_NLROW *nlrow, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_LP *lp, SCIP_Real *pseudofeasibility)

SCIP_RETCODE SCIPnlrowCreateFromRow(SCIP_NLROW **nlrow, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_ROW *row)

SCIP_RETCODE SCIPnlrowRecalcPseudoActivity(SCIP_NLROW *nlrow, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_LP *lp)

SCIP_RETCODE SCIPnlrowGetPseudoActivity(SCIP_NLROW *nlrow, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_LP *lp, SCIP_Real *pseudoactivity)

void SCIPnlrowCapture(SCIP_NLROW *nlrow)

SCIP_Real SCIProwGetLhs(SCIP_ROW *row)

int SCIProwGetNNonz(SCIP_ROW *row)

SCIP_COL ** SCIProwGetCols(SCIP_ROW *row)

SCIP_Real SCIProwGetRhs(SCIP_ROW *row)

const char * SCIProwGetName(SCIP_ROW *row)

SCIP_Real SCIProwGetConstant(SCIP_ROW *row)

SCIP_Real * SCIProwGetVals(SCIP_ROW *row)

SCIP_Real SCIPvarGetMultaggrConstant(SCIP_VAR *var)

SCIP_Bool SCIPvarIsActive(SCIP_VAR *var)

SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)

SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)

SCIP_Bool SCIPvarIsTransformed(SCIP_VAR *var)

SCIP_Real SCIPvarGetObj(SCIP_VAR *var)

SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)

const char * SCIPvarGetName(SCIP_VAR *var)

SCIP_Real SCIPvarGetBestBoundLocal(SCIP_VAR *var)

SCIP_VAR ** SCIPvarGetMultaggrVars(SCIP_VAR *var)

int SCIPvarGetMultaggrNVars(SCIP_VAR *var)

SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)

int SCIPvarGetBranchPriority(SCIP_VAR *var)

int SCIPvarCompare(SCIP_VAR *var1, SCIP_VAR *var2)

SCIP_Real SCIPvarGetNLPSol(SCIP_VAR *var)

SCIP_Real * SCIPvarGetMultaggrScalars(SCIP_VAR *var)

SCIP_Bool SCIPsortedvecFindPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *val, int len, int *pos)

void SCIPsortPtrReal(void **ptrarray, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)

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

#define BMSfreeMemory(ptr)

#define BMSfreeBlockMemory(mem, ptr)

#define BMSallocBlockMemory(mem, ptr)

#define BMSfreeBlockMemoryArrayNull(mem, ptr, num)

#define BMSallocBlockMemoryArray(mem, ptr, num)

#define BMScopyMemoryArray(ptr, source, num)

#define BMSfreeBlockMemoryArray(mem, ptr, num)

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

#define BMSclearMemoryArray(ptr, num)

struct BMS_BlkMem BMS_BLKMEM

#define BMSallocMemory(ptr)

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

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

static SCIP_DECL_EVENTEXEC(eventExecNlp)

SCIP_RETCODE SCIPnlpDelVar(SCIP_NLP *nlp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_VAR *var)

SCIP_Real * SCIPnlpGetVarsUbDualsol(SCIP_NLP *nlp)

SCIP_RETCODE SCIPnlpGetStatistics(SCIP_SET *set, SCIP_NLP *nlp, SCIP_NLPSTATISTICS *statistics)

static SCIP_RETCODE nlrowRemoveFixedLinearCoefPos(SCIP_NLROW *nlrow, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_NLP *nlp, int pos)

SCIP_Bool SCIPnlpIsDivingObjChanged(SCIP_NLP *nlp)

static SCIP_RETCODE nlpFlushVarAdditions(SCIP_NLP *nlp, BMS_BLKMEM *blkmem, SCIP_SET *set)

static SCIP_RETCODE nlrowConstantChanged(SCIP_NLROW *nlrow, SCIP_SET *set, SCIP_STAT *stat, SCIP_NLP *nlp)

SCIP_RETCODE SCIPnlpEndDive(SCIP_NLP *nlp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)

static SCIP_RETCODE nlrowChgLinearCoefPos(SCIP_NLROW *nlrow, SCIP_SET *set, SCIP_STAT *stat, SCIP_NLP *nlp, int pos, SCIP_Real coef)

SCIP_NLPI * SCIPnlpGetNLPI(SCIP_NLP *nlp)

BMS_BLKMEM * SCIPblkmem(SCIP *scip)

static SCIP_RETCODE nlpEnsureVarsSolverSize(SCIP_NLP *nlp, BMS_BLKMEM *blkmem, SCIP_SET *set, int num)

static SCIP_RETCODE nlpCalcFracVars(SCIP_NLP *nlp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)

static void nlrowMoveLinearCoef(SCIP_NLROW *nlrow, int oldpos, int newpos)

SCIP_RETCODE SCIPnlpFree(SCIP_NLP **nlp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)

static SCIP_RETCODE nlrowRemoveFixedLinearCoefs(SCIP_NLROW *nlrow, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_NLP *nlp)

int SCIPnlpGetNNlRows(SCIP_NLP *nlp)

SCIP_RETCODE SCIPnlpWrite(SCIP_NLP *nlp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_MESSAGEHDLR *messagehdlr, const char *fname)

SCIP_RETCODE SCIPnlpReset(SCIP_NLP *nlp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)

SCIP_RETCODE SCIPnlpAddVars(SCIP_NLP *nlp, BMS_BLKMEM *blkmem, SCIP_SET *set, int nvars, SCIP_VAR **vars)

static SCIP_RETCODE nlpRemoveFixedVar(SCIP_NLP *nlp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_VAR *var)

SCIP_RETCODE SCIPnlpCreate(SCIP_NLP **nlp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, const char *name, int nvars_estimate)

static SCIP_RETCODE nlpFlushNlRowDeletions(SCIP_NLP *nlp, BMS_BLKMEM *blkmem, SCIP_SET *set)

SCIP_RETCODE SCIPnlpChgVarBoundsDive(SCIP_SET *set, SCIP_NLP *nlp, SCIP_VAR *var, SCIP_Real lb, SCIP_Real ub)

static SCIP_RETCODE nlpMoveVar(SCIP_NLP *nlp, int oldpos, int newpos)

SCIP_RETCODE SCIPnlpInclude(SCIP_SET *set, BMS_BLKMEM *blkmem)

static SCIP_RETCODE nlpFlushObjective(SCIP_NLP *nlp, BMS_BLKMEM *blkmem, SCIP_SET *set)

SCIP_Bool SCIPnlpHasCurrentNodeNLP(SCIP_NLP *nlp)

SCIP_RETCODE SCIPnlpDelNlRow(SCIP_NLP *nlp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_NLROW *nlrow)

SCIP_RETCODE SCIPnlpChgVarObjDive(SCIP_NLP *nlp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR *var, SCIP_Real coef)

SCIP_RETCODE SCIPnlpEnsureNlRowsSize(SCIP_NLP *nlp, BMS_BLKMEM *blkmem, SCIP_SET *set, int num)

static SCIP_RETCODE nlrowCalcActivityBounds(SCIP_NLROW *nlrow, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)

static SCIP_DECL_EXPR_MAPEXPR(mapvar2varidx)

static void nlrowAddToStat(SCIP_NLP *nlp, SCIP_SET *set, SCIP_NLROW *nlrow, int incr)

static SCIP_RETCODE nlrowRemoveFixedVar(SCIP_NLROW *nlrow, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_NLP *nlp, SCIP_VAR *var)

static SCIP_RETCODE nlpEnsureNlRowsSolverSize(SCIP_NLP *nlp, BMS_BLKMEM *blkmem, SCIP_SET *set, int num)

SCIP_Bool SCIPnlpHasSolution(SCIP_NLP *nlp)

static SCIP_RETCODE nlrowLinearCoefChanged(SCIP_NLROW *nlrow, SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR *var, SCIP_Real coef, SCIP_NLP *nlp)

static void nlrowSortLinear(SCIP_NLROW *nlrow)

static SCIP_RETCODE nlrowSimplifyExpr(SCIP_NLROW *nlrow, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_NLP *nlp)

SCIP_RETCODE SCIPnlpSetInitialGuess(SCIP_SET *set, SCIP_NLP *nlp, BMS_BLKMEM *blkmem, SCIP_Real *initguess)

static SCIP_RETCODE nlpDelNlRowPos(SCIP_NLP *nlp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, int pos)

SCIP_RETCODE SCIPnlpGetVarsNonlinearity(SCIP_NLP *nlp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, int *nlcount)

void SCIPnlpGetNlRowsStat(SCIP_NLP *nlp, int *nlinear, int *nconvexineq, int *nnonconvexineq, int *nnonlineareq)

static SCIP_RETCODE nlpUpdateVarBounds(SCIP_NLP *nlp, SCIP_SET *set, SCIP_VAR *var, SCIP_Bool tightened)

static SCIP_RETCODE nlpFlushVarDeletions(SCIP_NLP *nlp, BMS_BLKMEM *blkmem, SCIP_SET *set)

static SCIP_RETCODE nlpRowChanged(SCIP_NLP *nlp, SCIP_SET *set, SCIP_STAT *stat, SCIP_NLROW *nlrow)

static int nlrowSearchLinearCoef(SCIP_NLROW *nlrow, SCIP_VAR *var)

SCIP_RETCODE SCIPnlpRemoveRedundantNlRows(SCIP_NLP *nlp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)

SCIP_RETCODE SCIPnlpAddNlRows(SCIP_NLP *nlp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, int nnlrows, SCIP_NLROW **nlrows)

SCIP_RETCODE SCIPnlpGetPseudoObjval(SCIP_NLP *nlp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_LP *lp, SCIP_Real *pseudoobjval)

static SCIP_RETCODE nlrowExprChanged(SCIP_NLROW *nlrow, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_NLP *nlp)

static SCIP_RETCODE nlpSolve(SCIP_NLP *nlp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_NLPPARAM *nlpparam)

static SCIP_RETCODE nlpFlushNlRowAdditions(SCIP_NLP *nlp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)

SCIP_RETCODE SCIPnlpChgVarsBoundsDive(SCIP_NLP *nlp, SCIP_SET *set, int nvars, SCIP_VAR **vars, SCIP_Real *lbs, SCIP_Real *ubs)

SCIP_NLPTERMSTAT SCIPnlpGetTermstat(SCIP_NLP *nlp)

static SCIP_RETCODE nlpSetupNlpiIndices(SCIP_NLP *nlp, SCIP_SET *set, SCIP_NLROW *nlrow, int **linidxs)

static SCIP_RETCODE nlrowSideChanged(SCIP_NLROW *nlrow, SCIP_SET *set, SCIP_STAT *stat, SCIP_NLP *nlp)

SCIP_RETCODE SCIPnlpAddNlRow(SCIP_NLP *nlp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_NLROW *nlrow)

static SCIP_RETCODE nlrowAddLinearCoef(SCIP_NLROW *nlrow, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_NLP *nlp, SCIP_VAR *var, SCIP_Real coef)

SCIP_RETCODE SCIPnlpEnsureVarsSize(SCIP_NLP *nlp, BMS_BLKMEM *blkmem, SCIP_SET *set, int num)

SCIP_VAR ** SCIPnlpGetVars(SCIP_NLP *nlp)

SCIP_RETCODE SCIPnlpFlush(SCIP_NLP *nlp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)

SCIP_NLPIPROBLEM * SCIPnlpGetNLPIProblem(SCIP_NLP *nlp)

int SCIPnlpGetNVars(SCIP_NLP *nlp)

static SCIP_RETCODE nlpAddVars(SCIP_NLP *nlp, BMS_BLKMEM *blkmem, SCIP_SET *set, int nvars, SCIP_VAR **vars)

SCIP_RETCODE SCIPnlpGetFracVars(SCIP_NLP *nlp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR ***fracvars, SCIP_Real **fracvarssol, SCIP_Real **fracvarsfrac, int *nfracvars, int *npriofracvars)

static SCIP_RETCODE nlpDelVarPos(SCIP_NLP *nlp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, int pos)

static void nlpMoveNlrow(SCIP_NLP *nlp, int oldpos, int newpos)

SCIP_RETCODE SCIPnlpStartDive(SCIP_NLP *nlp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)

SCIP_Real * SCIPnlpGetVarsLbDualsol(SCIP_NLP *nlp)

SCIP_RETCODE SCIPnlpSolve(SCIP_NLP *nlp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_NLPPARAM *nlpparam)

SCIP_Real SCIPnlpGetObjval(SCIP_NLP *nlp)

static SCIP_RETCODE nlrowDelLinearCoefPos(SCIP_NLROW *nlrow, SCIP_SET *set, SCIP_STAT *stat, SCIP_NLP *nlp, int pos)

static SCIP_RETCODE nlpAddNlRows(SCIP_NLP *nlp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, int nnlrows, SCIP_NLROW **nlrows)

SCIP_NLROW ** SCIPnlpGetNlRows(SCIP_NLP *nlp)

SCIP_RETCODE SCIPnlpHasContinuousNonlinearity(SCIP_NLP *nlp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_Bool *result)

static SCIP_RETCODE nlpUpdateObjCoef(SCIP_SET *set, SCIP_NLP *nlp, SCIP_VAR *var)

SCIP_Bool SCIPnlpIsDiving(SCIP_NLP *nlp)

SCIP_NLPSOLSTAT SCIPnlpGetSolstat(SCIP_NLP *nlp)

SCIP_RETCODE SCIPnlpAddVar(SCIP_NLP *nlp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_VAR *var)

internal methods for NLP management

SCIP_RETCODE SCIPnlpiSetInitialGuess(SCIP_SET *set, SCIP_NLPI *nlpi, SCIP_NLPIPROBLEM *problem, SCIP_Real *primalvalues, SCIP_Real *consdualvalues, SCIP_Real *varlbdualvalues, SCIP_Real *varubdualvalues)

SCIP_RETCODE SCIPnlpiChgVarBounds(SCIP_SET *set, SCIP_NLPI *nlpi, SCIP_NLPIPROBLEM *problem, const int nvars, const int *indices, const SCIP_Real *lbs, const SCIP_Real *ubs)

SCIP_RETCODE SCIPnlpiSetObjective(SCIP_SET *set, SCIP_NLPI *nlpi, SCIP_NLPIPROBLEM *problem, int nlins, const int *lininds, const SCIP_Real *linvals, SCIP_EXPR *expr, const SCIP_Real constant)

SCIP_RETCODE SCIPnlpiGetStatistics(SCIP_SET *set, SCIP_NLPI *nlpi, SCIP_NLPIPROBLEM *problem, SCIP_NLPSTATISTICS *statistics)

SCIP_NLPSOLSTAT SCIPnlpiGetSolstat(SCIP_SET *set, SCIP_NLPI *nlpi, SCIP_NLPIPROBLEM *problem)

SCIP_RETCODE SCIPnlpiFreeProblem(SCIP_SET *set, SCIP_NLPI *nlpi, SCIP_NLPIPROBLEM **problem)

SCIP_RETCODE SCIPnlpiDelVarSet(SCIP_SET *set, SCIP_NLPI *nlpi, SCIP_NLPIPROBLEM *problem, int *dstats, int dstatssize)

SCIP_RETCODE SCIPnlpiAddConstraints(SCIP_SET *set, SCIP_NLPI *nlpi, SCIP_NLPIPROBLEM *problem, int nconss, const SCIP_Real *lhss, const SCIP_Real *rhss, const int *nlininds, int *const *lininds, SCIP_Real *const *linvals, SCIP_EXPR **exprs, const char **names)

SCIP_RETCODE SCIPnlpiSolve(SCIP_SET *set, SCIP_STAT *stat, SCIP_NLPI *nlpi, SCIP_NLPIPROBLEM *problem, SCIP_NLPPARAM *param)

SCIP_RETCODE SCIPnlpiDelConsSet(SCIP_SET *set, SCIP_NLPI *nlpi, SCIP_NLPIPROBLEM *problem, int *dstats, int dstatssize)

SCIP_RETCODE SCIPnlpiAddVars(SCIP_SET *set, SCIP_NLPI *nlpi, SCIP_NLPIPROBLEM *problem, int nvars, const SCIP_Real *lbs, const SCIP_Real *ubs, const char **varnames)

SCIP_RETCODE SCIPnlpiGetSolution(SCIP_SET *set, SCIP_NLPI *nlpi, SCIP_NLPIPROBLEM *problem, SCIP_Real **primalvalues, SCIP_Real **consdualvalues, SCIP_Real **varlbdualvalues, SCIP_Real **varubdualvalues, SCIP_Real *objval)

SCIP_RETCODE SCIPnlpiChgExpr(SCIP_SET *set, SCIP_NLPI *nlpi, SCIP_NLPIPROBLEM *problem, int idxcons, SCIP_EXPR *expr)

SCIP_RETCODE SCIPnlpiChgConsSides(SCIP_SET *set, SCIP_NLPI *nlpi, SCIP_NLPIPROBLEM *problem, int nconss, const int *indices, const SCIP_Real *lhss, const SCIP_Real *rhss)

SCIP_NLPTERMSTAT SCIPnlpiGetTermstat(SCIP_SET *set, SCIP_NLPI *nlpi, SCIP_NLPIPROBLEM *problem)

SCIP_RETCODE SCIPnlpiCreateProblem(SCIP_SET *set, SCIP_NLPI *nlpi, SCIP_NLPIPROBLEM **problem, const char *name)

SCIP_RETCODE SCIPnlpiChgLinearCoefs(SCIP_SET *set, SCIP_NLPI *nlpi, SCIP_NLPIPROBLEM *problem, int idx, int nvals, const int *varidxs, const SCIP_Real *vals)

internal methods for NLP solver interfaces

internal methods for collecting primal CIP solutions and primal informations

public methods for managing events

public functions to work with algebraic expressions

public methods for LP management

public methods for message output

public data structures and miscellaneous methods

methods for sorting joint arrays of various types

public methods for NLP management

public methods for problem variables

SCIP_Bool SCIPsetIsGE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)

SCIP_Bool SCIPsetIsFeasFracIntegral(SCIP_SET *set, SCIP_Real val)

SCIP_Real SCIPsetFeastol(SCIP_SET *set)

SCIP_Bool SCIPsetIsFeasGT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)

SCIP_Bool SCIPsetIsFeasLE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)

SCIP_Bool SCIPsetIsEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)

SCIP_Bool SCIPsetIsFeasLT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)

SCIP_Real SCIPsetInfinity(SCIP_SET *set)

SCIP_RETCODE SCIPsetIncludeEventhdlr(SCIP_SET *set, SCIP_EVENTHDLR *eventhdlr)

SCIP_Bool SCIPsetIsInfinity(SCIP_SET *set, SCIP_Real val)

void SCIPsetSortNlpis(SCIP_SET *set)

SCIP_NLPI * SCIPsetFindNlpi(SCIP_SET *set, const char *name)

SCIP_Bool SCIPsetIsZero(SCIP_SET *set, SCIP_Real val)

SCIP_Real SCIPsetFeasFrac(SCIP_SET *set, SCIP_Real val)

SCIP_Bool SCIPsetIsFeasGE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)

SCIP_EVENTHDLR * SCIPsetFindEventhdlr(SCIP_SET *set, const char *name)

SCIP_Bool SCIPsetIsRelLE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)

int SCIPsetCalcMemGrowSize(SCIP_SET *set, int num)

internal methods for global SCIP settings

#define SCIPsetFreeBufferArray(set, ptr)

#define SCIPsetAllocBufferArray(set, ptr, num)

SCIP_RETCODE SCIPsolCreateNLPSol(SCIP_SOL **sol, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_NLP *nlp, SCIP_HEUR *heur)

SCIP_RETCODE SCIPsolFree(SCIP_SOL **sol, BMS_BLKMEM *blkmem, SCIP_PRIMAL *primal)

SCIP_RETCODE SCIPsolCreatePseudoSol(SCIP_SOL **sol, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_LP *lp, SCIP_HEUR *heur)

SCIP_Real SCIPsolGetVal(SCIP_SOL *sol, SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR *var)

internal methods for storing primal CIP solutions

SCIP_Longint validactivitybdsdomchg

SCIP_Longint validactivitynlp

SCIP_Longint validpsactivitydomchg

SCIP_Real primalsolobjval

SCIP_Longint validfracvars

SCIP_EVENTHDLR * eventhdlr

SCIP_NLPTERMSTAT termstat

SCIP_NLPIPROBLEM * problem

SCIP_Real * varubdualvals

SCIP_Real * varlbdualvals

datastructures for NLP management

SCIP main data structure.

datastructures for global SCIP settings

datastructures for problem statistics

#define SCIP_EVENTTYPE_BOUNDCHANGED

struct SCIP_EventData SCIP_EVENTDATA

#define SCIP_EVENTTYPE_OBJCHANGED

#define SCIP_EVENTTYPE_VARFIXED

#define SCIP_EVENTTYPE_VARDELETED

#define SCIP_EVENTTYPE_FORMAT

#define SCIP_EVENTTYPE_VARADDED

#define SCIP_EVENTTYPE_BOUNDTIGHTENED

enum SCIP_NlpSolStat SCIP_NLPSOLSTAT

@ SCIP_NLPSOLSTAT_UNBOUNDED

@ SCIP_NLPSOLSTAT_GLOBINFEASIBLE

@ SCIP_NLPSOLSTAT_LOCINFEASIBLE

@ SCIP_NLPSOLSTAT_FEASIBLE

@ SCIP_NLPSOLSTAT_GLOBOPT

@ SCIP_NLPSOLSTAT_UNKNOWN

enum SCIP_NlpTermStat SCIP_NLPTERMSTAT

enum SCIP_Retcode SCIP_RETCODE

@ SCIP_VARTYPE_CONTINUOUS

@ SCIP_VARSTATUS_MULTAGGR

SCIP_RETCODE SCIPvarRelease(SCIP_VAR **var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)

SCIP_RETCODE SCIPvarDropEvent(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)

SCIP_RETCODE SCIPvarSetNLPSol(SCIP_VAR *var, SCIP_SET *set, SCIP_Real solval)

SCIP_RETCODE SCIPvarPrint(SCIP_VAR *var, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, FILE *file)

void SCIPvarCapture(SCIP_VAR *var)

SCIP_RETCODE SCIPvarCatchEvent(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)

SCIP_RETCODE SCIPvarGetProbvarSum(SCIP_VAR **var, SCIP_SET *set, SCIP_Real *scalar, SCIP_Real *constant)

internal methods for problem variables

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