RetroSearch Browse

== 0 )

108 for

( i = 0; i < row->

; ++i )

127#define debugRowPrint(x,y) 140

assert(col !=

);

147 if

( col->

== 0 )

151 for

(

= 0;

< col->

; ++

)

160#define debugColPrint(x,y) 185

assert(num <= lp->chgcolssize);

208

assert(num <= lp->chgrowssize);

231

assert(num <= lp->lpicolssize);

254

assert(num <= lp->lpirowssize);

277

assert(num <= lp->colssize);

297

assert(num <= lp->soldirectionsize);

320

assert(num <= lp->lazycolssize);

343

assert(num <= lp->rowssize);

357

assert(col !=

);

358

assert(col->

<= col->

);

360 if

( num > col->

)

368

col->

= newsize;

370

assert(num <= col->size);

386

assert(stat !=

);

387

assert(blkmem !=

);

420

assert(blkmem !=

);

424 if

( storedsolvals !=

)

478

assert(col !=

);

479

assert(blkmem !=

);

507

assert(col !=

);

508

assert(blkmem !=

);

512 if

( storedsolvals !=

)

553

assert(row !=

);

554

assert(blkmem !=

);

592

assert(row !=

);

593

assert(blkmem !=

);

597 if

( storedsolvals !=

)

637

assert(row !=

);

638

assert(row->

<= row->

);

640 if

( num > row->

)

649

row->

= newsize;

651

assert(num <= row->size);

657#ifdef SCIP_MORE_DEBUG 667 if

( !msgdisp_checkrow )

669

printf(

"LP ROW CHECKING ACTIVATED! THIS IS VERY SLOW!\n"

);

670

msgdisp_checkrow =

;

677 for

( i = 1; i < row->

; ++i )

688 for

( i = row->

+ 1; i < row->len; ++i )

699#ifdef SCIP_MORE_DEBUG 710

assert(cols !=

|| row->

== 0);

714 for

( c = row->

- 1; c >= 0; --c )

716 if

( cols[c]->lppos >= 0 )

717

sqrnorm +=

SQR

(row->

[c]);

720

assert(

(sqrnorm - row->

sqrnorm

) < 1e-06 *

(1.0,sqrnorm));

733

assert(cols !=

|| row->

== 0);

737 for

( c = row->

- 1; c >= 0; --c )

739 if

( cols[c]->lppos >= 0 )

743

assert(

(sumnorm - row->

sumnorm

) < 1e-06 *

(1.0,sumnorm));

756

assert(cols !=

|| row->

== 0);

760 for

( c = row->

- 1; c >= 0; --c )

762 if

( cols[c]->lppos >= 0 )

766

assert(

(objprod - row->

objprod

) < 1e-06 *

(1.0,objprod));

769#define checkRowSqrnorm(row) 770#define checkRowSumnorm(row) 771#define checkRowObjprod(row) 793

assert(prob !=

);

797

nvars = prob->

;

801 for

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

834

assert(prob !=

);

838

nvars = prob->

;

842 for

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

876

assert(prob !=

);

880

nvars = prob->

;

884 for

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

914

assert(prob !=

);

936

assert(prob !=

);

953

assert(elem1 !=

);

954

assert(elem2 !=

);

976

assert(col !=

);

986 for

( i = 0; i < col->

; ++i )

1009

assert(col !=

);

1019 for

( i = col->

; i < col->len; ++i )

1040

assert(row !=

);

1050 for

( i = 0; i < row->

; ++i )

1073

assert(row !=

);

1085 for

( i = row->

; i < row->len; ++i )

1113

assert(col !=

);

1114

assert(row !=

);

1117

searchidx = row->

;

1118 while

(minpos <= maxpos)

1120

pos = (minpos + maxpos)/2;

1121

assert(0 <= pos && pos < col->len);

1123

assert((pos < col->nlprows) == (col->

[pos]->

>= 0 && col->

[pos] >= 0));

1125 if

( searchidx == idx )

1127 else if

( searchidx < idx )

1145

assert(col !=

);

1146

assert(row !=

);

1151 if

( row->

>= 0 )

1188

assert(row !=

);

1189

assert(col !=

);

1192

searchidx = col->

;

1193 while

(minpos <= maxpos)

1195

pos = (minpos + maxpos)/2;

1196

assert(0 <= pos && pos < row->len);

1198

assert((pos < row->nlpcols) == (row->

[pos]->

>= 0 && row->

[pos] >= 0));

1201 if

( searchidx == idx )

1203 else if

( searchidx < idx )

1223

assert(row !=

);

1224

assert(col !=

);

1232 if

( col->

>= 0 )

1253

assert(-1 <= pos && pos < row->len);

1255

assert(row->

[pos] == col);

1259 for

( i = 0; i < row->

; ++i )

1260

assert(row->

[i] != col);

1275

assert(col !=

);

1276

assert(0 <= oldpos && oldpos < col->len);

1277

assert(0 <= newpos && newpos < col->len);

1278

assert(col->

[oldpos] !=

);

1280 if

( oldpos == newpos )

1283

col->

[newpos] = col->

[oldpos];

1284

col->

[newpos] = col->

[oldpos];

1288 if

( col->

[newpos] >= 0 )

1315

assert(col !=

);

1316

assert(0 <= pos1 && pos1 < col->len);

1317

assert(0 <= pos2 && pos2 < col->len);

1318

assert(col->

[pos1] !=

);

1324

tmprow = col->

[pos2];

1325

tmpval = col->

[pos2];

1326

tmplinkpos = col->

[pos2];

1328

col->

[pos2] = col->

[pos1];

1329

col->

[pos2] = col->

[pos1];

1332

col->

[pos1] = tmprow;

1333

col->

[pos1] = tmpval;

1334

col->

[pos1] = tmplinkpos;

1337 if

( col->

[pos1] >= 0 )

1344 if

( col->

[pos2] >= 0 )

1371

assert(row !=

);

1372

assert(0 <= oldpos && oldpos < row->len);

1373

assert(0 <= newpos && newpos < row->len);

1374

assert(row->

[oldpos] !=

);

1376 if

( oldpos == newpos )

1379

row->

[newpos] = row->

[oldpos];

1381

row->

[newpos] = row->

[oldpos];

1385 if

( row->

[newpos] >= 0 )

1413

assert(row !=

);

1414

assert(0 <= pos1 && pos1 < row->len);

1415

assert(0 <= pos2 && pos2 < row->len);

1416

assert(row->

[pos1] !=

);

1423

tmpcol = row->

[pos2];

1425

tmpval = row->

[pos2];

1426

tmplinkpos = row->

[pos2];

1428

row->

[pos2] = row->

[pos1];

1430

row->

[pos2] = row->

[pos1];

1433

row->

[pos1] = tmpcol;

1435

row->

[pos1] = tmpval;

1436

row->

[pos1] = tmplinkpos;

1439 if

( row->

[pos1] >= 0 )

1446 if

( row->

[pos2] >= 0 )

1477

assert(row !=

);

1479

assert(col !=

);

1506

assert(row !=

);

1535

assert(row !=

);

1552#ifdef SCIP_MORE_DEBUG 1555#define ASSERT(x) do { if( !(x) ) abort(); } while( FALSE ) 1557#define ASSERT(x) assert(x) 1573

ASSERT(lp !=

);

1575 if

( !msgdisp_checklinks )

1577

printf(

"LP LINK CHECKING ACTIVATED! THIS IS VERY SLOW!\n"

);

1578

msgdisp_checklinks =

;

1581 for

( i = 0; i < lp->

; ++i )

1583

col = lp->

[i];

1584

ASSERT(col !=

);

1590 for

( j = 0; j < col->

; ++j )

1592

row = col->

[j];

1593

ASSERT(row !=

);

1597

ASSERT((j < col->nlprows) == (col->

[j] >= 0 && row->

>= 0));

1601 for

( i = 0; i < lp->

; ++i )

1603

row = lp->

[i];

1604

ASSERT(row !=

);

1610 for

( j = 0; j < row->

; ++j )

1612

col = row->

[j];

1613

ASSERT(col !=

);

1617

ASSERT((j < row->nlpcols) == (row->

[j] >= 0 && col->

>= 0));

1625#define checkLinks(lp) 1640

assert(row !=

);

1641

assert(col !=

);

1642

assert(lp !=

);

1712

assert(blkmem !=

);

1713

assert(col !=

);

1716

assert(row !=

);

1731 if

( row->

>= 0 && linkpos >= 0 )

1746

col->

[pos] = row;

1747

col->

[pos] = val;

1748

col->

[pos] = linkpos;

1749 if

( linkpos == -1 )

1756 if

( col->

>= 0 )

1762 if

( row->

>= 0 )

1764

linkpos = col->

[pos];

1766

assert(0 <= linkpos && linkpos < row->len);

1767

assert(row->

[linkpos] == col);

1768

assert(col->

[pos] == row);

1775

assert(row->

[linkpos] == -1);

1777

row->

[linkpos] = pos;

1783 if

( col->

>= 0 )

1789 if

( linkpos == row->

-1 )

1795 if

( row->

>= 0 && linkpos >= 0 )

1805

assert(col->

[col->

-1] == row);

1812 SCIPsetDebugMsg

(

"added coefficient %g * <%s> at position %d (%d/%d) to column <%s> (nunlinked=%d)\n"

1829

assert(col !=

);

1832

assert(0 <= pos && pos < col->len);

1835

assert((pos < col->nlprows) == (col->

[pos] >= 0 && col->

[pos]->

>= 0));

1837

row = col->

[pos];

1838

assert((row->

>= 0) == (pos < col->nlprows));

1843 if

( col->

[pos] == -1 )

1847 if

( pos < col->nlprows )

1873

assert(col !=

);

1875

assert(0 <= pos && pos < col->len);

1893

col->

[pos] = val;

1919

assert(row !=

);

1923

assert(col !=

);

1929 if

( col->

>= 0 )

1939 if

( updateidxvals )

1980

assert(row->

nummaxval

<= 0 || absval <= row->maxval);

1998

assert(row !=

);

2002

assert(col !=

);

2014 if

( forcenormupdate || col->

>= 0 )

2057

assert(row !=

);

2059

assert(blkmem !=

);

2060

assert(col !=

);

2068 SCIPerrorMessage

(

"cannot add a coefficient to the locked unmodifiable row <%s>\n"

, row->

);

2082 if

( col->

>= 0 && linkpos >= 0 )

2097

row->

[pos] = col;

2099

row->

[pos] = val;

2100

row->

[pos] = linkpos;

2102 if

( linkpos == -1 )

2109 if

( row->

>= 0 )

2115 if

( col->

>= 0 )

2117

linkpos = row->

[pos];

2119

assert(0 <= linkpos && linkpos < col->len);

2120

assert(col->

[linkpos] == row);

2121

assert(row->

[pos] == col);

2128

assert(col->

[linkpos] == -1);

2130

col->

[linkpos] = pos;

2136 if

( row->

>= 0 )

2142 if

( linkpos == col->

-1 )

2148 if

( col->

>= 0 && linkpos >= 0 )

2161

assert(row->

[row->

-1] == col);

2174 SCIPsetDebugMsg

(

"added coefficient %g * <%s> at position %d (%d/%d) to row <%s> (nunlinked=%d)\n"

2197

assert(row !=

);

2199

assert(0 <= pos && pos < row->len);

2201

assert((pos < row->nlpcols) == (row->

[pos] >= 0 && row->

[pos]->

>= 0));

2203

col = row->

[pos];

2204

val = row->

[pos];

2205

assert((pos < row->nlpcols) == (col->

>= 0 && row->

[pos] >= 0));

2212 SCIPerrorMessage

(

"cannot delete a coefficient from the locked unmodifiable row <%s>\n"

, row->

);

2216 if

( row->

[pos] == -1 )

2220 if

( pos < row->nlpcols )

2257

assert(row !=

);

2258

assert(0 <= pos && pos < row->len);

2265 SCIPerrorMessage

(

"cannot change a coefficient of the locked unmodifiable row <%s>\n"

, row->

);

2271

col = row->

[pos];

2283

oldval = row->

[pos];

2287

row->

[pos] = val;

2308

assert(row !=

);

2309

assert(lp !=

);

2363

assert(col !=

);

2365

assert(blkmem !=

);

2367

assert(lp !=

);

2374 for

( i = col->

; i < col->len; ++i )

2377 if

( col->

[i] == -1 )

2406

assert(col !=

);

2408

assert(blkmem !=

);

2410

assert(lp !=

);

2415 for

( i = 0; i < col->

; ++i )

2444

assert(row !=

);

2445

assert(blkmem !=

);

2447

assert(lp !=

);

2454 for

( i = row->

; i < row->len; ++i )

2457 if

( row->

[i] == -1 )

2484

assert(row !=

);

2486

assert(lp !=

);

2491 for

( i = 0; i < row->

; ++i )

2524

assert(lp !=

);

2525

assert(success !=

);

2549 return lpSetIntpar

(lp, lpparam, (

int

)value, success);

2563

assert(lp !=

);

2564

assert(success !=

);

2591

assert(lp !=

);

2600

assert(lpivalue == value);

2627

assert(lp !=

);

2636

assert(lpivalue == value);

2641#define lpCheckIntpar(lp, lpparam, value) SCIP_OKAY 2642#define lpCheckBoolpar(lp, lpparam, value) SCIP_OKAY 2643#define lpCheckRealpar(lp, lpparam, value) SCIP_OKAY 2647#define lpCutoffDisabled(set, prob, lp) (set->lp_disablecutoff == 1 || (set->lp_disablecutoff == 2 && !SCIPprobAllColsInLP(prob, set, lp)) || set->misc_exactsolve) 2662

assert(lp !=

);

2664

assert(success !=

);

2709

assert(lp !=

);

2710

assert(feastol >= 0.0);

2711

assert(success !=

);

2724 if

( lp->

> 0 && actualfeastol < lp->lpifeastol )

2752

assert(lp !=

);

2753

assert(dualfeastol >= 0.0);

2754

assert(success !=

);

2767 if

( lp->

> 0 && actualdualfeastol < lp->lpidualfeastol )

2795

assert(lp !=

);

2796

assert(barrierconvtol >= 0.0);

2797

assert(success !=

);

2810 if

( lp->

> 0 && actualbarrierconvtol < lp->lpibarrierconvtol

2839

assert(lp !=

);

2840

assert(success !=

);

2864

assert(lp !=

);

2865

assert(success !=

);

2866

assert(0 <= fastmip && fastmip <= 1);

2895

assert(lp !=

);

2896

assert(success !=

);

2920

assert(lp !=

);

2921

assert(success !=

);

2945

assert(lp !=

);

2946

assert(success !=

);

2970

assert(lp !=

);

2971

assert(success !=

);

2996

assert(lp !=

);

2997

assert(itlim >= -1);

3032

assert(lp !=

);

3055 switch

( pricingchar )

3097

assert(lp !=

);

3119

assert(lp !=

);

3120

assert(success !=

);

3144

assert(lp !=

);

3145

assert(success !=

);

3172

assert(lp !=

);

3173

assert(success !=

);

3181

lptiming = (int) timing;

3203

assert(lp !=

);

3204

assert(success !=

);

3208 if

( randomseed == 0 )

3233

assert(lp !=

);

3234

assert(success !=

);

3256

assert(lp !=

);

3257

assert(success !=

);

3291

assert(col !=

);

3292

assert(blkmem !=

);

3294

assert(stat !=

);

3295

assert(var !=

);

3297

assert(len == 0 || (rows !=

&& vals !=

));

3307 for

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

3309

assert(rows[i] !=

);

3311

(*col)->linkpos[i] = -1;

3316

(*col)->rows =

;

3317

(*col)->vals =

;

3318

(*col)->linkpos =

;

3326

(*col)->flushedobj = 0.0;

3327

(*col)->flushedlb = 0.0;

3328

(*col)->flushedub = 0.0;

3329

(*col)->index = stat->

ncolidx

;

3333

(*col)->nlprows = 0;

3334

(*col)->nunlinked = len;

3336

(*col)->lpipos = -1;

3337

(*col)->lpdepth = -1;

3338

(*col)->primsol = 0.0;

3341

(*col)->minprimsol = (*col)->ub;

3342

(*col)->maxprimsol = (*col)->lb;

3347

(*col)->sbnode = -1;

3348

(*col)->validredcostlp = -1;

3349

(*col)->validfarkaslp = -1;

3350

(*col)->validsblp = -1;

3351

(*col)->sbitlim = -1;

3352

(*col)->nsbcalls = 0;

3354

(*col)->obsoletenode = -1;

3357

(*col)->lprowssorted =

;

3358

(*col)->nonlprowssorted = (len <= 1);

3359

(*col)->objchanged =

;

3360

(*col)->lbchanged =

;

3361

(*col)->ubchanged =

;

3362

(*col)->coefchanged =

;

3364

(*col)->removable = removable;

3365

(*col)->sbdownvalid =

;

3366

(*col)->sbupvalid =

;

3369

(*col)->storedsolvals =

;

3383

assert(blkmem !=

);

3384

assert(col !=

);

3385

assert(*col !=

);

3386

assert((*col)->var !=

);

3388

assert(&(*col)->var->data.col == col);

3389

assert((*col)->lppos == -1);

3390

assert((*col)->lpipos == -1);

3413

assert(col !=

);

3420 if

( col->

== 0 )

3422 for

(

= 0;

< col->

; ++

)

3455

assert(lp !=

);

3477

assert(col !=

);

3479

assert(lp !=

);

3481

assert(row !=

);

3490

assert(0 <= pos && pos < col->len);

3491

assert(col->

[pos] == row);

3494 if

( col->

[pos] >= 0 )

3523

assert(col !=

);

3524

assert(lp !=

);

3526

assert(row !=

);

3540

assert(0 <= pos && pos < col->len);

3541

assert(col->

[pos] == row);

3544 if

( col->

[pos] >= 0 )

3574

assert(col !=

);

3575

assert(lp !=

);

3577

assert(row !=

);

3594

assert(0 <= pos && pos < col->len);

3595

assert(col->

[pos] == row);

3598 if

( col->

[pos] >= 0 )

3653

quotient = (

REALABS

(newvalue)+1.0) / (

REALABS

(oldvalue) + 1.0);

3703

assert(col !=

);

3707

assert(lp !=

);

3762

assert(col !=

);

3766

assert(lp !=

);

3807

assert(col !=

);

3811

assert(lp !=

);

3854

assert(col !=

);

3857

assert(dualsol !=

);

3859

redcost = col->

;

3860 for

( i = 0; i < col->

; ++i )

3862

row = col->

[i];

3863

assert(row !=

);

3864

assert(row->

>= 0);

3865

redcost -= col->

[i] * dualsol[row->

];

3870 for

( i = col->

; i < col->len; ++i )

3872

row = col->

[i];

3873

assert(row !=

);

3875 if

( row->

>= 0 )

3876

redcost -= col->

[i] * dualsol[row->

];

3882 for

( i = col->

; i < col->len; ++i )

3884

row = col->

[i];

3885

assert(row !=

);

3886

assert(row->

== -1);

3887

assert(col->

[i] >= 0);

3905

assert(col !=

);

3909

redcost = col->

;

3910 for

( i = 0; i < col->

; ++i )

3912

row = col->

[i];

3913

assert(row !=

);

3915

assert(row->

>= 0);

3916

assert(col->

[i] >= 0);

3922 for

( i = col->

; i < col->len; ++i )

3924

row = col->

[i];

3925

assert(row !=

);

3928 if

( row->

>= 0 )

3935 for

( i = col->

; i < col->len; ++i )

3937

row = col->

[i];

3938

assert(row !=

);

3940

assert(row->

== -1);

3941

assert(col->

[i] >= 0);

3956

assert(col !=

);

3957

assert(stat !=

);

3958

assert(lp !=

);

3981

assert(col !=

);

3983

assert(stat !=

);

3984

assert(lp !=

);

4037

assert(col !=

);

4040

assert(dualfarkas !=

);

4043 for

( i = 0; i < col->

; ++i )

4045

row = col->

[i];

4046

assert(row !=

);

4047

assert(row->

>= 0);

4048

farkas += col->

[i] * dualfarkas[row->

];

4053 for

( i = col->

; i < col->len; ++i )

4055

row = col->

[i];

4056

assert(row !=

);

4058 if

( row->

>= 0 )

4059

farkas += col->

[i] * dualfarkas[row->

];

4065 for

( i = col->

; i < col->len; ++i )

4067

row = col->

[i];

4068

assert(row !=

);

4069

assert(row->

== -1);

4070

assert(col->

[i] >= 0);

4088

assert(col !=

);

4093 for

( i = 0; i < col->

; ++i )

4095

row = col->

[i];

4096

assert(row !=

);

4098

assert(row->

>= 0);

4099

assert(col->

[i] >= 0);

4105 for

( i = col->

; i < col->len; ++i )

4107

row = col->

[i];

4108

assert(row !=

);

4111 if

( row->

>= 0 )

4118 for

( i = col->

; i < col->len; ++i )

4120

row = col->

[i];

4121

assert(row !=

);

4123

assert(row->

== -1);

4124

assert(col->

[i] >= 0);

4139

assert(col !=

);

4140

assert(stat !=

);

4141

assert(lp !=

);

4167

assert(col !=

);

4171 if

( farkascoef > 0.0 )

4172 return

col->

* farkascoef;

4174 return

col->

* farkascoef;

4182

assert(lp !=

);

4197

assert(lp !=

);

4223

assert(col !=

);

4229

assert(col->

>= 0);

4230

assert(col->

>= 0);

4232

assert(stat !=

);

4233

assert(lp !=

);

4236

assert(lp->

[col->

] == col);

4254 if

( stat->

== 1 )

4269

assert(col !=

);

4275

assert(col->

>= 0);

4276

assert(col->

>= 0);

4278

assert(stat !=

);

4279

assert(lp !=

);

4282

assert(lp->

[col->

] == col);

4327

assert(col !=

);

4334

assert(col->

>= 0);

4335

assert(col->

>= 0);

4337

assert(stat !=

);

4338

assert(lp !=

);

4345

assert(lp->

[col->

] == col);

4350

assert(lperror !=

);

4361

validsblp = stat->

;

4372

sbdownvalid =

;

4380 SCIPsetDebugMsg

(

"performing strong branching on variable <%s>(%g) with %d iterations\n"

4407

sbdownvalid =

;

4436 if

( iter/2 >= itlim )

4441 if

( stat->

== 1 )

4459 if

( downvalid !=

)

4460

*downvalid = sbdownvalid;

4461 if

( upvalid !=

)

4462

*upvalid = sbupvalid;

4513

assert(cols !=

);

4515

assert(stat !=

);

4516

assert(lp !=

);

4522

assert(down !=

);

4523

assert(up !=

);

4524

assert(lperror !=

);

4545 for

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

4551

assert(lp->

[col->

] == col);

4557

assert(col->

>= 0);

4558

assert(col->

>= 0);

4575

up[j] = col->

sbup

;

4576 if

( downvalid !=

)

4578 if

( upvalid !=

)

4586

lpipos[nsubcols] = col->

;

4587

primsols[nsubcols] = col->

;

4589

subidx[nsubcols] = j;

4590

subcols[nsubcols++] = col;

4594 SCIPsetDebugMsg

(

"performing strong branching on %d variables with %d iterations\n"

, ncols, itlim);

4607 for

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

4624

down[idx] = col->

sbdown

;

4625

up[idx] = col->

sbup

;

4626 if

( downvalid !=

)

4628 if

( upvalid !=

)

4641 for

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

4657

down[idx] = col->

sbdown

;

4658

up[idx] = col->

sbup

;

4659 if

( downvalid !=

)

4661 if

( upvalid !=

)

4674 if

( iter/2 >= itlim )

4679 if

( stat->

== 1 )

4717

assert(col !=

);

4723 if

( downvalid !=

)

4725 if

( upvalid !=

)

4727 if

( solval !=

)

4729 if

( lpobjval !=

)

4742

assert(col !=

);

4743

assert(stat !=

);

4754

assert(col !=

);

4755

assert(stat !=

);

4756

assert(stat->

> 0);

4776

assert(row !=

);

4795 for

( i = 0; i < row->

; ++i )

4800

assert(row->

[i] >= 0);

4810 for

( i = row->

; i < row->len; ++i )

4837

assert(row !=

);

4850 for

( i = 0; i < row->

; ++i )

4852

col = row->

[i];

4853

assert(col !=

);

4910

assert(mindelta <= 0.0);

4911

assert(maxdelta >= 0.0);

4913

sval = val * scalar;

4914

downval = floor(sval);

4919 if

( intval !=

)

4925 if

( intval !=

)

4967

assert(row !=

);

4971

assert(-1.0 < minrounddelta && minrounddelta <= 0.0);

4972

assert(0.0 <= maxrounddelta && maxrounddelta < 1.0);

4974 SCIPsetDebugMsg

(

"scale row <%s> with %g (tolerance=[%g,%g])\n"

, row->

, scaleval, minrounddelta, maxrounddelta);

4978

mindeltainf =

;

4979

maxdeltainf =

;

4980

oldlen = row->

;

4989 while

( c < row->len )

4991

col = row->

[c];

4992

val = row->

[c];

5008

newval = val * scaleval;

5010

isIntegralScalar

(val, scaleval, minrounddelta, maxrounddelta, &intval) )

5014 if

( intval < newval )

5016

mindelta += (intval - newval)*ub;

5017

maxdelta += (intval - newval)*lb;

5023

mindelta += (intval - newval)*lb;

5024

maxdelta += (intval - newval)*ub;

5046 if

( oldlen != row->

)

5048

assert(row->

== oldlen - 1);

5050

oldlen = row->

;

5069

newval = (row->

- row->

) * scaleval + mindelta;

5081

newval = (row->

- row->

) * scaleval + maxdelta;

5126

assert(row !=

);

5127

assert(blkmem !=

);

5128

assert(stat !=

);

5130

assert(len == 0 || (cols !=

&& vals !=

));

5139

(*row)->integral =

;

5150 for

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

5152

assert(cols[i] !=

);

5155

var = cols[i]->

var

;

5156

(*row)->cols_index[i] = cols[i]->

;

5157

(*row)->linkpos[i] = -1;

5165

(*row)->integral =

;

5171

(*row)->cols =

;

5172

(*row)->cols_index =

;

5173

(*row)->vals =

;

5174

(*row)->linkpos =

;

5178

(*row)->constant = 0.0;

5183

(*row)->sqrnorm = 0.0;

5184

(*row)->sumnorm = 0.0;

5185

(*row)->objprod = 0.0;

5186

(*row)->maxval = 0.0;

5188

(*row)->dualsol = 0.0;

5190

(*row)->dualfarkas = 0.0;

5194

(*row)->origin = origin;

5195

(*row)->eventfilter =

;

5196

(*row)->index = stat->

nrowidx

;

5200

(*row)->nlpcols = 0;

5201

(*row)->nunlinked = len;

5204

(*row)->lpipos = -1;

5205

(*row)->lpdepth = -1;

5206

(*row)->minidx = INT_MAX;

5207

(*row)->maxidx = INT_MIN;

5208

(*row)->nummaxval = 0;

5209

(*row)->numminval = 0;

5210

(*row)->numintcols = -1;

5211

(*row)->validactivitylp = -1;

5212

(*row)->validpsactivitydomchg = -1;

5213

(*row)->validactivitybdsdomchg = -1;

5214

(*row)->nlpsaftercreation = 0L;

5215

(*row)->activeinlpcounter = 0L;

5218

(*row)->obsoletenode = -1;

5219

(*row)->fromcutpool =

;

5221

(*row)->lpcolssorted =

;

5222

(*row)->nonlpcolssorted = (len <= 1);

5223

(*row)->delaysort =

;

5224

(*row)->validminmaxidx =

;

5225

(*row)->lhschanged =

;

5226

(*row)->rhschanged =

;

5227

(*row)->coefchanged =

;

5228

(*row)->local = local;

5229

(*row)->modifiable = modifiable;

5231

(*row)->origintype = origintype;

5232

(*row)->removable = removable;

5233

(*row)->inglobalcutpool =

;

5234

(*row)->storedsolvals =

;

5249

assert(cons !=

);

5264

assert(blkmem !=

);

5265

assert(row !=

);

5266

assert(*row !=

);

5267

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

5268

assert((*row)->lppos == -1);

5269

assert((*row)->eventfilter !=

);

5275

assert(cons !=

);

5305

assert(row !=

);

5317 if

( row->

== 0 )

5319 for

( i = 0; i < row->

; ++i )

5341

assert(row !=

);

5342

assert(row->

nuses

>= 0);

5343

assert(row->

nlocks

<= (

unsigned int

)(row->

nuses

));

5357

assert(blkmem !=

);

5358

assert(row !=

);

5359

assert(*row !=

);

5360

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

5361

assert((*row)->nlocks < (

unsigned int

)((*row)->nuses));

5363 SCIPsetDebugMsg

(

"release row <%s> with nuses=%d and nlocks=%u\n"

, (*row)->name, (*row)->nuses, (*row)->nlocks);

5365 if

( (*row)->nuses == 0 )

5380

assert(row !=

);

5395

assert(row !=

);

5401

assert(row->

nlocks

> 0);

5417

assert(lp !=

);

5439

assert(row !=

);

5441

assert(lp !=

);

5443

assert(col !=

);

5453

assert(0 <= pos && pos < row->len);

5454

assert(row->

[pos] == col);

5458 if

( row->

[pos] >= 0 )

5486

assert(row !=

);

5488

assert(lp !=

);

5490

assert(col !=

);

5504

assert(0 <= pos && pos < row->len);

5505

assert(row->

[pos] == col);

5509 if

( row->

[pos] >= 0 )

5538

assert(row !=

);

5539

assert(lp !=

);

5541

assert(col !=

);

5558

assert(0 <= pos && pos < row->len);

5559

assert(row->

[pos] == col);

5563 if

( row->

[pos] >= 0 )

5593

assert(row !=

);

5594

assert(row->

<= row->

);

5596

assert(stat !=

);

5597

assert(lp !=

);

5648

assert(row !=

);

5649

assert(row->

<= row->

);

5651

assert(stat !=

);

5652

assert(lp !=

);

5673

assert(row !=

);

5674

assert(lp !=

);

5680

oldlhs = row->

;

5705

assert(row !=

);

5706

assert(lp !=

);

5712

oldrhs = row->

;

5733

assert(row !=

);

5735

row->

local

= local;

5776

assert(row !=

);

5780

assert(maxdnom >= 1);

5781

assert(mindelta < 0.0);

5782

assert(maxdelta > 0.0);

5783

assert(success !=

);

5788 if

( intscalar !=

)

5794 for

( c = 0; c < row->

; ++c )

5797

col = row->

[c];

5798

assert(col !=

);

5803

val = row->

[c];

5806 if

( val < mindelta || val > maxdelta )

5809

minval =

(minval, absval);

5815 if

( intscalar !=

)

5822

assert(minval >

(-mindelta, maxdelta));

5829

scaleval = 1.0/minval;

5830

scalable = (scaleval <= maxscale);

5831 for

( c = 0; c < row->

&& scalable; ++c )

5838

val = row->

[c];

5840 while

( scaleval <= maxscale

5841

&& (absval * scaleval < 0.5 || !

isIntegralScalar

(val, scaleval, mindelta, maxdelta,

)) )

5854

scalable = (scaleval <= maxscale);

5855 SCIPsetDebugMsg

(

" -> val=%g, scaleval=%g, val*scaleval=%g, scalable=%u\n"

, val, scaleval, val*scaleval, scalable);

5862

assert(scaleval <= maxscale);

5863 if

( intscalar !=

)

5864

*intscalar = scaleval;

5866 SCIPsetDebugMsg

(

" -> integrality can be achieved by scaling with %g (minval=%g)\n"

, scaleval, minval);

5873

twomult = (twomultval <= maxscale);

5874 for

( c = 0; c < row->

&& twomult; ++c )

5881

val = row->

[c];

5883 while

( twomultval <= maxscale

5884

&& (absval * twomultval < 0.5 || !

isIntegralScalar

(val, twomultval, mindelta, maxdelta,

)) )

5897

twomult = (twomultval <= maxscale);

5899

val, twomultval, val*twomultval, twomult);

5904

assert(twomultval <= maxscale);

5905 if

( intscalar !=

)

5906

*intscalar = twomultval;

5908 SCIPsetDebugMsg

(

" -> integrality can be achieved by scaling with %g (power of 2)\n"

, twomultval);

5918

rational = (maxdnom > 1);

5921 for

( c = 0; c < row->

&& rational; ++c )

5925

val = row->

[c];

5926

rational =

SCIPrealToRational

(val, mindelta, maxdelta, maxdnom, &numerator, &denominator);

5927 if

( rational && numerator != 0 )

5929

assert(denominator > 0);

5930

gcd =

(numerator);

5934

val, numerator, denominator, gcd, scm, rational);

5941 for

( ++c; c < row->

&& rational; ++c )

5945

val = row->

[c];

5946

rational =

SCIPrealToRational

(val, mindelta, maxdelta, maxdnom, &numerator, &denominator);

5947 if

( rational && numerator != 0 )

5949

assert(denominator > 0);

5954

val, numerator, denominator, gcd, scm, rational);

5963 if

( intscalar !=

)

5971

assert(!(*success));

5996

assert(success !=

);

6000

&intscalar, success) );

6005 SCIP_CALL

(

rowScale

(row, blkmem,

, eventqueue, stat, lp, intscalar, usecontvars, mindelta, maxdelta) );

6018

assert(row !=

);

6026#ifdef SCIP_MORE_DEBUG 6032 for

( c = 1; c < row->

; ++c )

6034 for

( c = row->

+ 1; c < row->len; ++c )

6052

assert(row !=

);

6077

assert(cols !=

);

6078

assert(cols_index !=

);

6079

assert(vals !=

);

6084

assert(row->

[0] == -1);

6086 for

( s = 1; s < row->

; ++s )

6089

assert(row->

[s] == -1);

6091 if

( cols[s] == cols[t] )

6108

cols_index[t] = cols_index[s];

6117

assert(s == row->

);

6118

assert(t <= row->len);

6134 for

( i = 0; i < row->

; ++i )

6138 for

( j = i+1; j < row->

; ++j )

6139

assert(row->

[i] != row->

[j]);

6150

assert(row !=

);

6162

assert(row !=

);

6178

assert(row !=

);

6179

assert(stat !=

);

6182 for

( c = 0; c < row->

; ++c )

6184

col = row->

[c];

6185

assert(col !=

);

6187

assert(col->

>= 0);

6188

assert(row->

[c] >= 0);

6194 for

( c = row->

; c < row->len; ++c )

6196

col = row->

[c];

6197

assert(col !=

);

6200 if

( col->

>= 0 )

6207 for

( c = row->

; c < row->len; ++c )

6209

col = row->

[c];

6210

assert(col !=

);

6212

assert(col->

== -1);

6213

assert(row->

[c] >= 0);

6232

assert(row !=

);

6233

assert(stat !=

);

6234

assert(lp !=

);

6245

activity =

(activity, -inf);

6246

activity =

(activity, +inf);

6261

assert(row !=

);

6265 return MIN

(row->

- activity, activity - row->

);

6283

assert( row !=

);

6284

assert( stat !=

);

6287 for

(c = 0; c < row->

; ++c)

6289

col = row->

[c];

6290

assert( col !=

);

6291

assert( col->

>= 0 );

6293

assert( row->

[c] >= 0 );

6299 for

(c = row->

; c < row->len; ++c)

6301

col = row->

[c];

6302

assert( col !=

);

6303

assert( col->

== -1 || row->

[c] == -1 );

6304 if

( col->

>= 0 )

6314 for

(c = row->

; c < row->len; ++c)

6316

col = row->

[c];

6317

assert( col !=

);

6318

assert( col->

== -1 );

6319

assert( row->

[c] >= 0 );

6324

activity =

(activity, -inf);

6325

activity =

(activity, +inf);

6327 return MIN

(row->

- activity, activity - row->

);

6345

assert( row !=

);

6346

assert( stat !=

);

6349 for

(c = 0; c < row->

; ++c)

6351

col = row->

[c];

6352

assert( col !=

);

6353

assert( col->

>= 0 );

6355

assert( row->

[c] >= 0 );

6361 for

(c = row->

; c < row->len; ++c)

6363

col = row->

[c];

6364

assert( col !=

);

6365

assert( col->

== -1 || row->

[c] == -1 );

6366 if

( col->

>= 0 )

6376 for

(c = row->

; c < row->len; ++c)

6378

col = row->

[c];

6379

assert( col !=

);

6380

assert( col->

== -1 );

6381

assert( row->

[c] >= 0 );

6386

activity =

(activity, -inf);

6387

activity =

(activity, +inf);

6389 return MIN

(row->

- activity, activity - row->

);

6401

assert(row !=

);

6402

assert(stat !=

);

6405 for

( i = 0; i < row->

; ++i )

6407

col = row->

[i];

6408

assert(col !=

);

6409

assert((i < row->nlpcols) == (row->

[i] >= 0 && col->

>= 0));

6429

assert(row !=

);

6430

assert(stat !=

);

6441

activity =

(activity, -inf);

6442

activity =

(activity, +inf);

6456

assert(row !=

);

6460 return MIN

(row->

- pseudoactivity, pseudoactivity - row->

);

6477

assert(row !=

);

6480 for

( i = 0; i < row->

; ++i )

6482

col = row->

[i];

6483

assert(col !=

);

6484

assert((i < row->nlpcols) == (row->

[i] >= 0 && col->

>= 0));

6489

solval = (row->

[i] >= 0.0 ? col->

: col->

);

6491

solval = (row->

[i] >= 0.0 ? col->

: col->

);

6493

solval = (col->

+ col->

)/2.0;

6495

activity += row->

[i] * solval;

6499

activity =

(activity, -inf);

6500

activity =

(activity, +inf);

6515

assert(row !=

);

6519 return MIN

(row->

- activity, activity - row->

);

6536

assert(row !=

);

6538

assert(stat !=

);

6541

mininfinite =

;

6542

maxinfinite =

;

6545 for

( i = 0; i < row->

&& (!mininfinite || !maxinfinite); ++i )

6547

col = row->

[i];

6548

assert(col !=

);

6549

assert((i < row->nlpcols) == (row->

[i] >= 0 && col->

>= 0));

6550

val = row->

[i];

6602

assert(row !=

);

6603

assert(stat !=

);

6623

assert(row !=

);

6624

assert(stat !=

);

6644

assert(row !=

);

6674

assert(row !=

);

6679

assert(row->

maxval

>= 0.0 || row->

== 0);

6690

assert(row !=

);

6695

assert(row->

minval

>= 0.0 || row->

== 0);

6706

assert(row !=

);

6710

assert(row->

maxidx

>= 0 || row->

== 0);

6722

assert(row !=

);

6726

assert(row->

minidx

>= 0 || row->

== 0);

6738

assert(row !=

);

6760

assert(sol !=

);

6771 for

( k = 0; k < lp->

; ++k )

6780

scale = 1.0 / sqrt(scale);

6782 for

( k = 0; k < lp->

; ++k )

6787

solcutoffdist = 0.0;

6788 for

( k = 0; k < row->

; ++k )

6791 for

( k = row->

; k < row->len; ++k )

6798

solcutoffdist =

->num_sumepsilon;

6802 return

solcutoffdist;

6819 switch

(

->sepa_efficacynorm )

6831

norm = (row->

== 0 ? 0.0 : 1.0);

6843 return

-feasibility / norm;

6876 switch

(

->sepa_efficacynorm )

6888

norm = (row->

== 0 ? 0.0 : 1.0);

6900 return

-feasibility / norm;

6934 switch

(

->sepa_efficacynorm )

6946

norm = (row->

== 0 ? 0.0 : 1.0);

6958 return

-feasibility / norm;

6974 switch

(

->sepa_efficacynorm )

6986

norm = (row->

== 0 ? 0.0 : 1.0);

6998 return

-feasibility / norm;

7017

assert(row1 !=

);

7018

assert(row2 !=

);

7072 while

( i1 < row1->nlpcols && i2 < row2->len )

7074

assert(row1->

[i1] != row2->

[i2]);

7083

assert(i1 == row1->

|| i2 == row2->

);

7087 while

( i1 < row1->len && i2 < row2->nlpcols )

7089

assert(row1->

[i1] != row2->

[i2]);

7098

assert(i1 == row1->

|| i2 == row2->

);

7119 while

( i1 >= 0 && i2 >= 0 )

7121

assert(row1->

[i1]->

== row1colsidx[i1]);

7122

assert(row2->

[i2]->

== row2colsidx[i2]);

7123

assert((row1->

[i1] == row2->

[i2]) == (row1colsidx[i1] == row2colsidx[i2]));

7124 if

( row1colsidx[i1] < row2colsidx[i2] )

7126 else if

( row1colsidx[i1] > row2colsidx[i2] )

7130

scalarprod += row1->

[i1] * row2->

[i2];

7158 while

( ilp1 < row1->nlpcols && inlp1 < row1->len && ilp2 < row2->nlpcols && inlp2 < row2->len )

7160

assert(row1->

[ilp1]->

== row1colsidx[ilp1]);

7161

assert(row1->

[inlp1]->

== row1colsidx[inlp1]);

7162

assert(row2->

[ilp2]->

== row2colsidx[ilp2]);

7163

assert(row2->

[inlp2]->

== row2colsidx[inlp2]);

7164

assert((row1->

[ilp1] == row2->

[ilp2]) == (row1colsidx[ilp1] == row2colsidx[ilp2]));

7165

assert((row1->

[ilp1] == row2->

[inlp2]) == (row1colsidx[ilp1] == row2colsidx[inlp2]));

7166

assert((row1->

[inlp1] == row2->

[ilp2]) == (row1colsidx[inlp1] == row2colsidx[ilp2]));

7167

assert((row1->

[inlp1] == row2->

[inlp2]) == (row1colsidx[inlp1] == row2colsidx[inlp2]));

7170 if

( row1colsidx[ilp1] == row2colsidx[ilp2] )

7172

scalarprod += row1->

[ilp1] * row2->

[ilp2];

7177 else if

( row1colsidx[ilp1] == row2colsidx[inlp2] )

7179

scalarprod += row1->

[ilp1] * row2->

[inlp2];

7184 else if

( row1colsidx[inlp1] == row2colsidx[ilp2] )

7186

scalarprod += row1->

[inlp1] * row2->

[ilp2];

7191 else if

( row1colsidx[inlp1] == row2colsidx[inlp2] && row1->

[inlp1]->

>= 0 )

7193

scalarprod += row1->

[inlp1] * row2->

[inlp2];

7198 else if

( row1colsidx[ilp1] < row1colsidx[inlp1] )

7200 if

( row2colsidx[ilp2] < row2colsidx[inlp2] )

7202 if

( row1colsidx[ilp1] < row2colsidx[ilp2] )

7209 if

( row1colsidx[ilp1] < row2colsidx[inlp2] )

7217 if

( row2colsidx[ilp2] < row2colsidx[inlp2] )

7219 if

( row1colsidx[inlp1] < row2colsidx[ilp2] )

7226 if

( row1colsidx[inlp1] < row2colsidx[inlp2] )

7238 if

( ilp1 != row1->

&& inlp1 != row1->

)

7243

assert(ilp2 == row2->

|| inlp2 == row2->

);

7266

assert(inlp1 == row1->

);

7276 while

( i1 < end1 && ilp2 < row2->nlpcols && inlp2 < row2->len )

7278

assert(row1->

[i1]->

== row1colsidx[i1]);

7279

assert(row2->

[ilp2]->

== row2colsidx[ilp2]);

7280

assert(row2->

[inlp2]->

== row2colsidx[inlp2]);

7281

assert((row1->

[i1] == row2->

[ilp2]) == (row1colsidx[i1] == row2colsidx[ilp2]));

7282

assert((row1->

[i1] == row2->

[inlp2]) == (row1colsidx[i1] == row2colsidx[inlp2]));

7285 if

( row1colsidx[i1] == row2colsidx[ilp2] )

7287

scalarprod += row1->

[i1] * row2->

[ilp2];

7292 else if

( row1colsidx[i1] == row2colsidx[inlp2] && (lpcols || row1->

[i1]->

>= 0) )

7294

scalarprod += row1->

[i1] * row2->

[inlp2];

7299 else if

( row2colsidx[ilp2] < row2colsidx[inlp2] )

7301 if

( row1colsidx[i1] < row2colsidx[ilp2] )

7308 if

( row1colsidx[i1] < row2colsidx[inlp2] )

7329

assert(inlp2 == row2->

);

7336 while

( i1 < end1 && i2 < end2 )

7338

assert(row1->

[i1]->

== row1colsidx[i1]);

7339

assert(row2->

[i2]->

== row2colsidx[i2]);

7340

assert((row1->

[i1] == row2->

[i2]) == (row1colsidx[i1] == row2colsidx[i2]));

7343 if

( row1colsidx[i1] == row2colsidx[i2] && (lpcols || row1->

[i1]->

>= 0) )

7345

scalarprod += row1->

[i1] * row2->

[i2];

7350 else if

( row1colsidx[i1] < row2colsidx[i2] )

7374

assert(row1 !=

);

7375

assert(row2 !=

);

7429 while

( i1 < row1->nlpcols && i2 < row2->len )

7431

assert(row1->

[i1] != row2->

[i2]);

7440

assert(i1 == row1->

|| i2 == row2->

);

7444 while

( i1 < row1->len && i2 < row2->nlpcols )

7446

assert(row1->

[i1] != row2->

[i2]);

7455

assert(i1 == row1->

|| i2 == row2->

);

7476 while

( i1 >= 0 && i2 >= 0 )

7478

assert(row1->

[i1]->

== row1colsidx[i1]);

7479

assert(row2->

[i2]->

== row2colsidx[i2]);

7480

assert((row1->

[i1] == row2->

[i2]) == (row1colsidx[i1] == row2colsidx[i2]));

7481 if

( row1colsidx[i1] < row2colsidx[i2] )

7483 else if

( row1colsidx[i1] > row2colsidx[i2] )

7515 while

( ilp1 < row1->nlpcols && inlp1 < row1->len && ilp2 < row2->nlpcols && inlp2 < row2->len )

7517

assert(row1->

[ilp1]->

== row1colsidx[ilp1]);

7518

assert(row1->

[inlp1]->

== row1colsidx[inlp1]);

7519

assert(row2->

[ilp2]->

== row2colsidx[ilp2]);

7520

assert(row2->

[inlp2]->

== row2colsidx[inlp2]);

7521

assert((row1->

[ilp1] == row2->

[ilp2]) == (row1colsidx[ilp1] == row2colsidx[ilp2]));

7522

assert((row1->

[ilp1] == row2->

[inlp2]) == (row1colsidx[ilp1] == row2colsidx[inlp2]));

7523

assert((row1->

[inlp1] == row2->

[ilp2]) == (row1colsidx[inlp1] == row2colsidx[ilp2]));

7524

assert((row1->

[inlp1] == row2->

[inlp2]) == (row1colsidx[inlp1] == row2colsidx[inlp2]));

7527 if

( row1colsidx[ilp1] == row2colsidx[ilp2] )

7534 else if

( row1colsidx[ilp1] == row2colsidx[inlp2] )

7541 else if

( row1colsidx[inlp1] == row2colsidx[ilp2] )

7548 else if

( row1colsidx[inlp1] == row2colsidx[inlp2] && row1->

[inlp1]->

>= 0 )

7555 else if

( row1colsidx[ilp1] < row1colsidx[inlp1] )

7557 if

( row2colsidx[ilp2] < row2colsidx[inlp2] )

7559 if

( row1colsidx[ilp1] < row2colsidx[ilp2] )

7566 if

( row1colsidx[ilp1] < row2colsidx[inlp2] )

7574 if

( row2colsidx[ilp2] < row2colsidx[inlp2] )

7576 if

( row1colsidx[inlp1] < row2colsidx[ilp2] )

7583 if

( row1colsidx[inlp1] < row2colsidx[inlp2] )

7595 if

( ilp1 != row1->

&& inlp1 != row1->

)

7600

assert(ilp2 == row2->

|| inlp2 == row2->

);

7623

assert(inlp1 == row1->

);

7633 while

( i1 < end1 && ilp2 < row2->nlpcols && inlp2 < row2->len )

7635

assert(row1->

[i1]->

== row1colsidx[i1]);

7636

assert(row2->

[ilp2]->

== row2colsidx[ilp2]);

7637

assert(row2->

[inlp2]->

== row2colsidx[inlp2]);

7638

assert((row1->

[i1] == row2->

[ilp2]) == (row1colsidx[i1] == row2colsidx[ilp2]));

7639

assert((row1->

[i1] == row2->

[inlp2]) == (row1colsidx[i1] == row2colsidx[inlp2]));

7642 if

( row1colsidx[i1] == row2colsidx[ilp2] )

7649 else if

( row1colsidx[i1] == row2colsidx[inlp2] && (lpcols || row1->

[i1]->

>= 0) )

7656 else if

( row2colsidx[ilp2] < row2colsidx[inlp2] )

7658 if

( row1colsidx[i1] < row2colsidx[ilp2] )

7665 if

( row1colsidx[i1] < row2colsidx[inlp2] )

7686

assert(inlp2 == row2->

);

7693 while

( i1 < end1 && i2 < end2 )

7695

assert(row1->

[i1]->

== row1colsidx[i1]);

7696

assert(row2->

[i2]->

== row2colsidx[i2]);

7697

assert((row1->

[i1] == row2->

[i2]) == (row1colsidx[i1] == row2colsidx[i2]));

7700 if

( row1colsidx[i1] == row2colsidx[i2] && (lpcols || row1->

[i1]->

>= 0) )

7707 else if

( row1colsidx[i1] < row2colsidx[i2] )

7731 switch

( orthofunc )

7735 if

( scalarprod == 0.0 )

7749 for

( i = 0; i < row1->

; ++i )

7759 for

( i = 0; i < row2->

; ++i )

7774 SCIPerrorMessage

(

"invalid orthogonality function parameter '%c'\n"

, orthofunc);

7807

assert(row !=

);

7808

assert(lp !=

);

7824

parallelism =

(parallelism, 1.0);

7825

parallelism =

(parallelism, 0.0);

7841

assert(row !=

);

7847

eventtype, row->

, (

void

*)eventhdlr, (

void

*)eventdata);

7865

assert(row !=

);

7868 SCIPsetDebugMsg

(

"drop event of row <%s> with handler %p and data %p\n"

, row->

, (

void

*)eventhdlr, (

void

*)eventdata);

7881

assert(row !=

);

7882

assert(stat !=

);

7883

assert(stat->

> 0);

7899

assert(col !=

);

7921

assert(lp !=

);

7977

assert(lp !=

);

7979

assert(col !=

);

7980

assert(lb !=

);

7981

assert(ub !=

);

8027

assert(lp !=

);

8029

assert(blkmem !=

);

8047 for

( c = lp->

; c < lp->ncols; ++c )

8048

naddcoefs += lp->

[c]->

;

8049

assert(naddcols > 0);

8062 for

( pos = 0, c = lp->

; c < lp->ncols; ++pos, ++c )

8064

col = lp->

[c];

8065

assert(col !=

);

8069

assert(col->

== c);

8070

assert(nnonz + col->

<= naddcoefs);

8097

obj[pos] = col->

;

8109 for

( i = 0; i < col->

; ++i )

8115

assert(lpipos < lp->nrows);

8116

assert(nnonz < naddcoefs);

8117

ind[nnonz] = lpipos;

8118

val[nnonz] = col->

[i];

8123 for

( i = col->

; i < col->len; ++i )

8165

assert(row !=

);

8183

assert(lp !=

);

8249

assert(lp !=

);

8251

assert(blkmem !=

);

8267 for

(

= lp->

nlpirows

; r < lp->nrows; ++

)

8268

naddcoefs += lp->

[

]->

;

8269

assert(naddrows > 0);

8281 for

( pos = 0,

= lp->

nlpirows

; r < lp->nrows; ++pos, ++

)

8283

row = lp->

[

];

8284

assert(row !=

);

8285

assert(row->

);

8286

assert(nnonz + row->

<= naddcoefs);

8316

name[pos] = row->

;

8322 for

( i = 0; i < row->

; ++i )

8328

assert(lpipos < lp->ncols);

8329

assert(nnonz < naddcoefs);

8331

ind[nnonz] = lpipos;

8332

val[nnonz] = row->

[i];

8338 for

( i = row->

; i < row->len; ++i )

8393

assert(lp !=

);

8411 for

( i = 0; i < lp->

nchgcols

; ++i )

8414

assert(col !=

);

8443

newobj = col->

;

8446

assert(nobjchg < lp->ncols);

8447

objind[nobjchg] = col->

;

8448

obj[nobjchg] = newobj;

8465

assert(nbdchg < lp->ncols);

8466

bdind[nbdchg] = col->

;

8483 SCIPsetDebugMsg

(

"flushing objective changes: change %d objective values of %d changed columns\n"

, nobjchg, lp->

nchgcols

);

8538

assert(lp !=

);

8553 for

( i = 0; i < lp->

nchgrows

; ++i )

8556

assert(row !=

);

8581

assert(nchg < lp->nrows);

8582

ind[nchg] = row->

;

8631

assert(lp !=

);

8638 for

( i = 0; i < lp->

; ++i )

8651 if

( nintegers > 0 )

8677

assert(lp !=

);

8678

assert(blkmem !=

);

8680 SCIPsetDebugMsg

(

"flushing LP changes: old (%d cols, %d rows), nchgcols=%d, nchgrows=%d, firstchgcol=%d, firstchgrow=%d, new (%d cols, %d rows), flushed=%u\n"

8724

assert(ncols == lp->

);

8725

assert(nrows == lp->

);

8743

assert(lp !=

);

8776 for

( i = 0; i < lp->

nchgcols

; ++i )

8781

assert(col !=

);

8815 for

( i = 0; i < lp->

nchgrows

; ++i )

8820

assert(row !=

);

8870

assert(col !=

);

8871

assert(col->

>= 0);

8874 for

( i = 0; i < col->

; ++i )

8879

row = col->

[i];

8880

assert(row !=

);

8881

assert(row->

[pos] == i);

8882

assert(row->

[pos] == col);

8883

assert(row->

<= pos && pos < row->len);

8890 if

( pos == row->

-1 )

8909

assert(row !=

);

8910

assert(row->

>= 0);

8913 for

( i = 0; i < row->

; ++i )

8918

col = row->

[i];

8919

assert(col !=

);

8920

assert(col->

[pos] == i);

8921

assert(col->

[pos] == row);

8922

assert(col->

<= pos && pos < col->len);

8928 if

( pos == col->

-1 )

8945

assert(col !=

);

8946

assert(col->

== -1);

8949 for

( i = 0; i < col->

; ++i )

8954

row = col->

[i];

8955

assert(row !=

);

8956

assert(row->

[pos] == i);

8957

assert(row->

[pos] == col);

8958

assert(0 <= pos && pos < row->nlpcols);

8983

assert(row !=

);

8984

assert(row->

== -1);

8987 for

( i = 0; i < row->

; ++i )

8992

col = row->

[i];

8993

assert(col !=

);

8994

assert(0 <= pos && pos < col->nlprows);

8995

assert(col->

[pos] == i);

8996

assert(col->

[pos] == row);

9014

assert(lp !=

);

9020

assert(initsize > 0);

9037

assert(lp !=

);

9043

assert(minsize > 0);

9045 if

( minsize <= lp->divechgsidessize )

9061

assert(lp !=

);

9074#define DIVESTACKINITSIZE 100 9087

assert(lp !=

);

9089

assert(stat !=

);

9090

assert(name !=

);

9097

(*lp)->lpicols =

;

9098

(*lp)->lpirows =

;

9099

(*lp)->chgcols =

;

9100

(*lp)->chgrows =

;

9101

(*lp)->cols =

;

9102

(*lp)->soldirection =

;

9103

(*lp)->lazycols =

;

9104

(*lp)->rows =

;

9105

(*lp)->lpobjval = 0.0;

9106

(*lp)->glbpseudoobjval = 0.0;

9107

(*lp)->relglbpseudoobjval = 0.0;

9108

(*lp)->glbpseudoobjvalid =

;

9109

(*lp)->glbpseudoobjvalinf = 0;

9110

(*lp)->pseudoobjval = 0.0;

9111

(*lp)->relpseudoobjval = 0.0;

9112

(*lp)->pseudoobjvalid =

;

9113

(*lp)->pseudoobjvalinf = 0;

9114

(*lp)->looseobjval = 0.0;

9115

(*lp)->rellooseobjval = 0.0;

9116

(*lp)->looseobjvalid =

;

9117

(*lp)->looseobjvalinf = 0;

9118

(*lp)->nloosevars = 0;

9124

(*lp)->validdegeneracylp = -1;

9125

(*lp)->objsqrnorm = 0.0;

9126

(*lp)->objsumnorm = 0.0;

9127

(*lp)->lpicolssize = 0;

9128

(*lp)->nlpicols = 0;

9129

(*lp)->lpirowssize = 0;

9130

(*lp)->nlpirows = 0;

9131

(*lp)->lpifirstchgcol = 0;

9132

(*lp)->lpifirstchgrow = 0;

9133

(*lp)->colssize = 0;

9134

(*lp)->soldirectionsize = 0;

9136

(*lp)->lazycolssize = 0;

9137

(*lp)->nlazycols = 0;

9138

(*lp)->rowssize = 0;

9140

(*lp)->chgcolssize = 0;

9141

(*lp)->nchgcols = 0;

9142

(*lp)->chgrowssize = 0;

9143

(*lp)->nchgrows = 0;

9144

(*lp)->firstnewcol = 0;

9145

(*lp)->firstnewrow = 0;

9146

(*lp)->nremovablecols = 0;

9147

(*lp)->nremovablerows = 0;

9148

(*lp)->validsollp = stat->

lpcount

;

9149

(*lp)->validfarkaslp = -1;

9150

(*lp)->validsoldirlp = -1;

9151

(*lp)->validsoldirsol =

;

9152

(*lp)->objsqrnormunreliable =

;

9153

(*lp)->flushdeletedcols =

;

9154

(*lp)->flushaddedcols =

;

9155

(*lp)->flushdeletedrows =

;

9156

(*lp)->flushaddedrows =

;

9157

(*lp)->updateintegrality =

;

9158

(*lp)->flushed =

;

9160

(*lp)->solved =

;

9161

(*lp)->primalfeasible =

;

9162

(*lp)->primalchecked =

;

9163

(*lp)->dualfeasible =

;

9164

(*lp)->dualchecked =

;

9165

(*lp)->solisbasic =

;

9166

(*lp)->rootlpisrelax =

;

9167

(*lp)->isrelax =

;

9168

(*lp)->installing =

;

9169

(*lp)->strongbranching =

;

9170

(*lp)->strongbranchprobing =

;

9171

(*lp)->probing =

;

9172

(*lp)->diving =

;

9173

(*lp)->divingobjchg =

;

9174

(*lp)->divinglazyapplied =

;

9175

(*lp)->divelpistate =

;

9176

(*lp)->divelpwasprimfeas =

;

9177

(*lp)->divelpwasprimchecked =

;

9178

(*lp)->divelpwasdualfeas =

;

9179

(*lp)->divelpwasdualchecked =

;

9180

(*lp)->divechgsides =

;

9181

(*lp)->divechgsidetypes =

;

9182

(*lp)->divechgrows =

;

9183

(*lp)->ndivechgsides = 0;

9184

(*lp)->divechgsidessize = 0;

9185

(*lp)->ndivingrows = 0;

9186

(*lp)->divinglpiitlim = INT_MAX;

9187

(*lp)->resolvelperror =

;

9188

(*lp)->divenolddomchgs = 0;

9189

(*lp)->adjustlpval =

;

9191

(*lp)->lpifeastol = (*lp)->feastol;

9194

(*lp)->lpifromscratch =

;

9195

(*lp)->lpifastmip =

->lp_fastmip;

9196

(*lp)->lpiscaling =

->lp_scaling;

9197

(*lp)->lpipresolving =

->lp_presolving;

9198

(*lp)->lpilpinfo =

->disp_lpinfo;

9199

(*lp)->lpirowrepswitch =

->lp_rowrepswitch;

9200

(*lp)->lpisolutionpolishing = (

->lp_solutionpolishing > 0);

9201

(*lp)->lpirefactorinterval =

->lp_refactorinterval;

9202

(*lp)->lpiconditionlimit =

->lp_conditionlimit;

9203

(*lp)->lpimarkowitz =

->lp_markowitz;

9204

(*lp)->lpiitlim = INT_MAX;

9207

(*lp)->lpithreads =

->lp_threads;

9208

(*lp)->lpitiming = (int)

->time_clocktype;

9209

(*lp)->lpirandomseed =

->random_randomseed;

9210

(*lp)->storedsolvals =

;

9220 "LP Solver <%s>: objective limit cannot be set -- can lead to unnecessary simplex iterations\n"

9224

(*lp)->lpihasfeastol = success;

9228 "LP Solver <%s>: primal feasibility tolerance cannot be set -- tolerance of SCIP and LP solver may differ\n"

9232

(*lp)->lpihasdualfeastol = success;

9236 "LP Solver <%s>: dual feasibility tolerance cannot be set -- tolerance of SCIP and LP solver may differ\n"

9240

(*lp)->lpihasbarrierconvtol = success;

9244 "LP Solver <%s>: barrier convergence tolerance cannot be set -- tolerance of SCIP and LP solver may differ\n"

9249

(*lp)->lpihasfastmip = success;

9253 "LP Solver <%s>: fastmip setting not available -- SCIP parameter has no effect\n"

9257

(*lp)->lpihasscaling = success;

9261 "LP Solver <%s>: scaling not available -- SCIP parameter has no effect\n"

9265

(*lp)->lpihaspresolving = success;

9269 "LP Solver <%s>: presolving not available -- SCIP parameter has no effect\n"

9276 "LP Solver <%s>: clock type cannot be set\n"

9283 "LP Solver <%s>: iteration limit cannot be set -- can lead to unnecessary simplex iterations\n"

9290 "LP Solver <%s>: pricing strategy cannot be set -- SCIP parameter has no effect\n"

9297 "LP Solver <%s>: lpinfo setting not available -- SCIP parameter has no effect\n"

9301

(*lp)->lpihasrowrep = success;

9305 "LP Solver <%s>: row representation of the basis not available -- SCIP parameter lp/rowrepswitch has no effect\n"

9309

(*lp)->lpihaspolishing = success;

9313 "LP Solver <%s>: solution polishing not available -- SCIP parameter lp/solutionpolishing has no effect\n"

9317

(*lp)->lpihasrefactor = success;

9321 "LP Solver <%s>: refactorization interval not available -- SCIP parameter lp/refactorinterval has no effect\n"

9328 "LP Solver <%s>: condition number limit for the basis not available -- SCIP parameter lp/conditionlimit has no effect\n"

9335 "LP Solver <%s>: markowitz threshhold not available -- SCIP parameter lp/minmarkowitz has no effect\n"

9342 "LP Solver <%s>: number of threads settings not available -- SCIP parameter has no effect\n"

9346 if

( (*lp)->lpirandomseed != 0 )

9352 "LP Solver <%s>: random seed parameter not available -- SCIP parameter has no effect\n"

9361 SCIPerrorMessage

(

"The infinity value of the LP solver has to be at least as large as the one of SCIP.\n"

);

9379

assert(lp !=

);

9380

assert(*lp !=

);

9387 for

( i = 0; i < (*lp)->nlpirows; ++i )

9392 if

( (*lp)->lpi !=

)

9424

assert(stat !=

);

9456

assert(lp !=

);

9458

assert(col !=

);

9460

assert(col->

== -1);

9471 for

( i = 0; i < col->

; ++i )

9518

assert(lp !=

);

9519

assert(row !=

);

9521

assert(row->

== -1);

9531 for

( i = 0; i < row->

; ++i )

9588

assert(lp !=

);

9598 for

( c = 0; c < lp->

; ++c )

9611 for

( c = 0; c < lp->

; ++c )

9628#define checkLazyColArray(lp, set) 9641

assert(lp !=

);

9644

assert(0 <= newncols);

9645

assert(newncols <= lp->ncols);

9647 if

( newncols < lp->ncols )

9651 for

( c = lp->

-1; c >= newncols; --c )

9653

col = lp->

[c];

9654

assert(col !=

);

9659

assert(col->

== c);

9676

assert(lp->

== newncols);

9681 while

( c < lp->nlazycols )

9716

assert(lp !=

);

9717

assert(0 <= newnrows && newnrows <= lp->nrows);

9720 if

( newnrows < lp->nrows )

9722 for

(

= lp->

-1;

>= newnrows; --

)

9724

row = lp->

[

];

9725

assert(row !=

);

9727

assert(row->

);

9756

assert(lp->

== newnrows);

9778

assert(lp !=

);

9793

assert(lp !=

);

9807

assert(lp !=

);

9820

assert(lp !=

);

9824

assert(basisind !=

);

9838

assert(lp !=

);

9858

assert(lp !=

);

9862

assert(0 <=

&& r < lp->nrows);

9863

assert(coef !=

);

9884

assert(lp !=

);

9888

assert(0 <= c && c < lp->nrows);

9889

assert(coef !=

);

9907

assert(lp !=

);

9911

assert(0 <=

&& r < lp->nrows);

9912

assert(coef !=

);

9931

assert(lp !=

);

9935

assert(0 <= c && c < lp->ncols);

9936

assert(coef !=

);

9963

assert(lp !=

);

9964

assert(prob !=

);

9965

assert(weights !=

);

9966

assert(sumcoef !=

);

9967

assert(sumlhs !=

);

9968

assert(sumrhs !=

);

9976

lhsinfinite =

;

9977

rhsinfinite =

;

9978 for

(

= 0;

< lp->

; ++

)

9982

row = lp->

[

];

9983

assert(row !=

);

9989 for

( i = 0; i < row->

; ++i )

9997

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

10002 if

( weights[

] > 0.0 )

10005 if

( !lhsinfinite )

10006

(*sumlhs) += weights[

] * (row->

- row->

);

10008 if

( !rhsinfinite )

10009

(*sumrhs) += weights[

] * (row->

- row->

);

10014 if

( !lhsinfinite )

10015

(*sumlhs) += weights[

] * (row->

- row->

);

10017 if

( !rhsinfinite )

10018

(*sumrhs) += weights[

] * (row->

- row->

);

10038

assert(lp !=

);

10041

assert(blkmem !=

);

10042

assert(lpistate !=

);

10069

assert(lp !=

);

10070

assert(blkmem !=

);

10080 if

( lpistate ==

)

10105

assert(lp !=

);

10107 if

( *lpistate !=

)

10121

assert(lp !=

);

10138

assert(lp !=

);

10141

assert(blkmem !=

);

10142

assert(lpinorms !=

);

10162

assert(lp !=

);

10163

assert(blkmem !=

);

10167 if

( lpinorms !=

)

10182

assert(lp !=

);

10194

assert(lp !=

);

10207

assert(lp !=

);

10249

assert(lp !=

);

10261

assert(lp !=

);

10262

assert(newfeastol > 0.0);

10267 if

( newfeastol < lp->feastol )

10285

assert(lp !=

);

10304 return "primal simplex"

;

10306 return "dual simplex"

;

10310 return "barrier/crossover"

;

10334

assert(lp !=

);

10337

assert(stat !=

);

10338

assert(lperror !=

);

10345#ifdef SCIP_MORE_DEBUG 10351 SCIPsetDebugMsg

(

"wrote LP to file <%s> (primal simplex, objlim=%.15g, feastol=%.15g/%.15g, fromscratch=%d, fastmip=%d, scaling=%d, presolving=%d)\n"

10415 if

( iterations > 0 )

10425 SCIPstatAdd

(stat,

, nprimalresolvelpiterations, iterations);

10460 if

( keepsol && !(*lperror) )

10492

assert(lp !=

);

10495

assert(stat !=

);

10496

assert(lperror !=

);

10503#ifdef SCIP_MORE_DEBUG 10509 SCIPsetDebugMsg

(

"wrote LP to file <%s> (dual simplex, objlim=%.15g, feastol=%.15g/%.15g, fromscratch=%d, fastmip=%d, scaling=%d, presolving=%d)\n"

10573 if

( iterations > 0 )

10618 if

( keepsol && !(*lperror) )

10680 int

totalIterations;

10685

assert(lp !=

);

10688

assert(stat !=

);

10689

assert(lperror !=

);

10724

totalIterations = iterations;

10742 if

( iterations > 0 )

10816

chooseBasic =

->lp_lexdualbasic;

10862 for

( c = 0; c < lp->

; ++c )

10869

fixedc[c] =

;

10875

indallrow[

] =

;

10877

fixedr[

] =

;

10882#ifdef DEBUG_LEXDUAL 10886 if

( !chooseBasic )

10888

assert(primsol ==

);

10891

assert(primsol !=

);

10895 for

( j = 0; j < lp->

; ++j )

10928 if

( !chooseBasic )

10931

assert(primsol ==

);

10955

assert(primsol ==

);

10966 for

( c = 0; c < lp->

; ++c )

10974 if

( pos == -1 && c > oldpos )

10987 if

( pos == -1 && c > oldpos )

10992

newlb[cntcol] = oldlb[c];

10993

newub[cntcol] = oldlb[c];

10994

indcol[cntcol++] = c;

10999 if

( !chooseBasic )

11009

newlb[cntcol] = oldlb[c];

11010

newub[cntcol] = oldlb[c];

11016

newlb[cntcol] = oldub[c];

11017

newub[cntcol] = oldub[c];

11022

newlb[cntcol] = 0.0;

11023

newub[cntcol] = 0.0;

11026

indcol[cntcol++] = c;

11037 if

( !fixedr[

] )

11050

newlhs[cntrow] = oldlhs[

];

11051

newrhs[cntrow] = oldlhs[

];

11056

newlhs[cntrow] = oldrhs[

];

11057

newrhs[cntrow] = oldrhs[

];

11059

indrow[cntrow++] =

;

11060

fixedr[

] =

;

11066 if

( nDualDeg > 0 && pos >= 0 )

11068

assert(0 <= pos && pos < lp->nlpicols && pos > oldpos);

11100

lexIterations += iterations;

11102#ifdef DEBUG_LEXDUAL 11103 if

( iterations > 0 )

11107 if

( !chooseBasic )

11109

assert(primsol ==

);

11112

assert(primsol !=

);

11115 for

( j = 0; j < lp->

; ++j )

11123 char

cstart =

'['

;

11157 if

( !chooseBasic )

11160

assert(primsol ==

);

11166 if

( iterations > 0 )

11171 while

( pos >= 0 && nDualDeg > 0 && (

->lp_lexdualmaxrounds == -1 || rounds < set->lp_lexdualmaxrounds) );

11197

lexIterations += iterations;

11205 if

( lexIterations > 0 )

11211 SCIPstatAdd

(stat,

, nlexdualresolvelpiterations, lexIterations);

11216

totalIterations += lexIterations;

11263 if

( keepsol && !(*lperror) )

11291

assert(lp !=

);

11294

assert(stat !=

);

11295

assert(lperror !=

);

11303#ifdef SCIP_MORE_DEBUG 11309 SCIPsetDebugMsg

(

"wrote LP to file <%s> (barrier, objlim=%.15g, feastol=%.15g/%.15g, convtol=%.15g, fromscratch=%d, fastmip=%d, scaling=%d, presolving=%d)\n"

11362 if

( iterations > 0 )

11397 if

( keepsol && !(*lperror) )

11430

assert(lp !=

);

11432

assert(lperror !=

);

11436 if

(

->istimelimitfinite )

11440 if

( lptimelimit > 0.0 )

11443 if

( lptimelimit <= 0.0 || !success )

11445 SCIPsetDebugMsg

(

"time limit of %f seconds could not be set\n"

, lptimelimit);

11446

*lperror = ((lptimelimit > 0.0) ?

);

11447

*timelimit =

;

11461 if

(

->lp_lexdualalgo && (!

->lp_lexdualrootonly || stat->

maxdepth

== 0) && (!

->lp_lexdualstalling || lp->

installing

) )

11498#define MAXNUMTROUBLELPMSGS 10 11512 const char

* formatstr,

11535 if

( verblevel >

->disp_verblevel )

11545

va_start(ap, formatstr);

11552 SCIPmessagePrintInfo

(messagehdlr,

" -- further messages will be suppressed (use display/verblevel=5 to see all)"

);

11569

assert(lp !=

);

11577 if

( !

->lp_checkdualfeas )

11579 if

( !

->lp_checkprimfeas )

11586#define FEASTOLTIGHTFAC 0.001 11616

assert(lp !=

);

11619

assert(stat !=

);

11620

assert(lperror !=

);

11621

assert(timelimit !=

);

11632 SCIPerrorMessage

(

"cannot solve LP when loose variable with infinite best bound is present\n"

);

11640

itlimishard = (itlim == harditlim);

11646

usepolishing =

;

11653

usepolishing =

;

11695 if

( !

->lp_checkstability )

11722 if

( !

->lp_checkstability )

11742 lpalgoName

(lpalgo), (scaling == 0) ?

"with"

"without"

);

11749 if

( !

->lp_checkstability )

11772 lpalgoName

(lpalgo), !

->lp_presolving ?

"with"

"without"

);

11779 if

( !

->lp_checkstability )

11796 if

( ((simplex && (!tightprimfeastol || !tightdualfeastol)) || (!tightprimfeastol && !tightdualfeastol)) &&

11800 if

( !tightprimfeastol )

11806 if

( !tightdualfeastol )

11812 if

( !simplex && !tightprimfeastol && !tightdualfeastol )

11818 if

( success || success2 || success3 )

11828 if

( !

->lp_checkstability )

11837 if

( !tightprimfeastol )

11841 if

( !tightdualfeastol )

11845 if

( !simplex && !tightprimfeastol && !tightdualfeastol )

11857 if

( !fromscratch && simplex )

11869 if

( !

->lp_checkstability )

11890 if

( !

->lp_checkstability )

11903 lpalgoName

(lpalgo), (scaling == 0) ?

"with"

"without"

);

11910 if

( !

->lp_checkstability )

11928 lpalgoName

(lpalgo), !

->lp_presolving ?

"with"

"without"

);

11935 if

( !

->lp_checkstability )

11949 if

( !tightprimfeastol || !tightdualfeastol )

11952 if

( !tightprimfeastol )

11958 if

( !tightdualfeastol )

11964 if

( success || success2 )

11974 if

( !

->lp_checkstability )

11983 if

( !tightprimfeastol )

11987 if

( !tightdualfeastol )

12011

assert(lp !=

);

12062

assert(lp !=

);

12065

assert(stat !=

);

12066

assert(lperror !=

);

12070

solvedprimal =

;

12071

solveddual =

;

12072

timelimit =

;

12075

itlim = ( resolve ? resolveitlim : harditlim );

12079 SCIP_CALL

(

lpSolveStable

(lp,

, messagehdlr, stat, prob, lpalgo, itlim, harditlim, resolve, fastmip, tightprimfeastol, tightdualfeastol, fromscratch,

12080

scaling, keepsol, &timelimit, lperror) );

12216 SCIPsetDebugMsg

(

"solving LP with %s returned solstat=%d (internal status: %d, primalfeasible=%u, dualfeasible=%u)\n"

12249

assert(lp !=

);

12251

assert(lperror !=

);

12259

algo = resolve ?

->lp_resolvealgorithm :

->lp_initalgorithm;

12269

needdualray, resolve, fastmip, tightprimfeastol, tightdualfeastol, fromscratch, scaling, keepsol, lperror) );

12275

needdualray, resolve, fastmip, tightprimfeastol, tightdualfeastol, fromscratch, scaling, keepsol, lperror) );

12282

needdualray, resolve, fastmip, tightprimfeastol, tightdualfeastol, fromscratch, scaling, keepsol, lperror) );

12288

needdualray, resolve, fastmip, tightprimfeastol, tightdualfeastol, fromscratch, scaling, keepsol, lperror) );

12294

needdualray, resolve, fastmip, tightprimfeastol, tightdualfeastol, fromscratch, scaling, keepsol, lperror) );

12300

needdualray, resolve, fastmip, tightprimfeastol, tightdualfeastol, fromscratch, scaling, keepsol, lperror) );

12304 SCIPerrorMessage

(

"invalid parameter setting <%c> for LP algorithm\n"

, algo);

12307

assert(!(*lperror) || !lp->

);

12325 for

( c = 0; c < lp->

nlazycols

; ++c )

12335#define checkLazyBounds(lp, set) 12358 SCIPsetDebugMsg

(

"mark all lazy columns as changed in order to reload bounds (diving=%u, applied=%u)\n"

12361 for

( c = 0; c < lp->

nlazycols

; ++c )

12411 if

( (

->lp_resolveiterfac == -1) || stat->

- stat->

nrootlps

< 5 )

12417 return

(

int

)

(itlim,

(

->lp_resolveitermin, \

12448

assert(lp !=

);

12449

assert(prob !=

);

12451

assert(lperror !=

);

12462 SCIPsetDebugMsg

(

"solving LP: %d rows, %d cols, primalfeasible=%u, dualfeasible=%u, solved=%u, diving=%u, probing=%u, cutoffbnd=%g\n"

12466

needprimalray =

;

12468

|| (

->conf_enable &&

->conf_useinflp !=

'o'

));

12471

harditlim = (int)

(itlim, INT_MAX);

12472

resolveitlim = ( limitresolveiters ?

lpGetResolveItlim

(

, stat, harditlim) : harditlim );

12473

assert(harditlim == -1 || (resolveitlim <= harditlim));

12512

tightprimfeastol =

;

12513

tightdualfeastol =

;

12514

fromscratch =

;

12515

primalfeasible =

;

12516

dualfeasible =

;

12517

wasfromscratch = (stat->

== 0);

12518

scaling =

->lp_scaling;

12522

oldnlps = stat->

;

12523 SCIP_CALL

(

lpFlushAndSolve

(lp, blkmem,

, messagehdlr, stat, prob, eventqueue, resolveitlim, harditlim, needprimalray,

12524

needdualray, fastmip, tightprimfeastol, tightdualfeastol, fromscratch, scaling, keepsol, lperror) );

12526

assert(!(*lperror) || !lp->

);

12540 if

(

->lp_checkprimfeas )

12542

primalfeaspointer = &primalfeasible;

12548

primalfeasible =

;

12549

primalfeaspointer =

;

12552 if

(

->lp_checkdualfeas )

12554

dualfeaspointer = &dualfeasible;

12560

dualfeasible =

;

12561

dualfeaspointer =

;

12570 if

( primalfeasible && dualfeasible && aging && !lp->

diving

&& stat->

> oldnlps )

12574 if

( stat->

% ((

->lp_rowagelimit+1)/2 + 1) == 0 )

12587 if

( !primalfeasible || !dualfeasible )

12591 if

( (fastmip > 0) && simplex )

12596

stat->

, stat->

, primalfeasible, dualfeasible);

12600 else if

( (!primalfeasible && !tightprimfeastol) || (!dualfeasible && !tightdualfeastol) )

12607

stat->

, stat->

, primalfeasible, dualfeasible);

12608

tightprimfeastol = tightprimfeastol || !primalfeasible;

12609

tightdualfeastol = tightdualfeastol || !dualfeasible;

12612 else if

( !fromscratch && !wasfromscratch && simplex )

12617

stat->

, stat->

, primalfeasible, dualfeasible);

12618

fromscratch =

;

12629 SCIPsetDebugMsg

(

" -> LP objective value: %g + %g = %g (solstat=%d, cutoff=%g)\n"

12651

farkasvalid =

;

12656

farkasvalid =

;

12659 if

( !farkasvalid && !(*lperror) )

12663 if

( (fastmip > 0) && simplex )

12674 else if

( !tightdualfeastol )

12682

tightdualfeastol =

;

12685 else if

( !fromscratch && simplex )

12693

fromscratch =

;

12711 if

(

->lp_checkprimfeas )

12723

primalfeasible =

;

12724

rayfeasible =

;

12731 SCIPsetDebugMsg

(

" -> LP has unbounded primal ray (primalfeas=%u, rayfeas=%u)\n"

12732

primalfeasible, rayfeasible);

12734 if

( !primalfeasible || !rayfeasible )

12738 if

( (fastmip > 0) && simplex )

12743

stat->

, stat->

, primalfeasible, rayfeasible);

12747 else if

( !tightprimfeastol )

12754

stat->

, stat->

, primalfeasible, rayfeasible);

12755

tightprimfeastol =

;

12758 else if

( !fromscratch && simplex )

12763

stat->

, stat->

, primalfeasible, rayfeasible);

12764

fromscratch =

;

12767 else if

( scaling > 0 )

12772

stat->

, stat->

, primalfeasible, rayfeasible);

12806

assert(lpi !=

);

12818 char

tmppricingchar;

12824

fromscratch =

;

12836 FALSE

, fastmip, tightprimfeastol, tightdualfeastol, fromscratch, scaling, keepsol, lperror) );

12849 SCIPsetDebugMsg

(

" ---> new objval = %f (solstat: %d, 1 add. step)\n"

, objval, solstat);

12858 if

( !(*lperror) && (fastmip > 0) && simplex )

12862 FALSE

, fastmip, tightprimfeastol, tightdualfeastol, fromscratch, scaling, keepsol, lperror) );

12870 SCIPsetDebugMsg

(

" ---> new objval = %f (solstat: %d, without fastmip)\n"

, objval, solstat);

12877 SCIPsetDebugMsg

(

"unresolved error while resolving LP in order to exceed the objlimit\n"

);

12893 if

(

->lp_checkprimfeas )

12895

primalfeaspointer = &primalfeasible;

12901

primalfeasible =

;

12902

primalfeaspointer =

;

12905 if

(

->lp_checkdualfeas )

12907

dualfeaspointer = &dualfeasible;

12913

dualfeasible =

;

12914

dualfeaspointer =

;

12939 if

( !primalfeasible || !dualfeasible

12949 SCIPsetDebugMsg

(

" -> LP objective value: %g + %g = %g (solstat=%d, cutoff=%g)\n"

12973

farkasvalid =

;

12978

farkasvalid =

;

12980 if

( !farkasvalid )

12984 if

( !tightprimfeastol )

12992

tightprimfeastol =

;

12995 else if

( simplex )

13003

fromscratch =

;

13021 if

(

->lp_checkprimfeas )

13033

primalfeasible =

;

13034

rayfeasible =

;

13043 if

( !primalfeasible || !rayfeasible )

13081 SCIPmessagePrintWarning

(messagehdlr,

"LP solver reached time limit, but SCIP time limit is not exceeded yet; " 13082 "you might consider switching the clock type of SCIP\n"

);

13099

assert(!(*lperror) || !lp->

);

13108 SCIPsetDebugMsg

(

"resetting parameter SCIP_LPPARAM_FROMSCRATCH to FALSE %s\n"

, success ?

""

"failed"

);

13120

assert(lp !=

);

13138

assert(lp !=

);

13164

assert(lp !=

);

13177

assert(lp !=

);

13197

assert(lp !=

);

13208

assert(lp !=

);

13225

assert(lp !=

);

13227

assert(prob !=

);

13229

vars = prob->

vars

;

13230

nvars = prob->

;

13238 for

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

13289

assert(lp !=

);

13321

assert(lp !=

);

13356 int

pseudoobjvalinf;

13367

pseudoobjval -= oldbound * obj;

13368

assert(pseudoobjvalinf >= 0);

13372

pseudoobjval += newbound * obj;

13374

assert(pseudoobjvalinf >= 0);

13376 if

( pseudoobjvalinf > 0 ||

->nactivepricers > 0 )

13379 return

pseudoobjval;

13395 int

pseudoobjvalinf;

13421

assert(pseudoobjvalinf >= 0);

13433

assert(pseudoobjvalinf >= 0);

13435 if

( pseudoobjvalinf > 0 ||

->nactivepricers > 0 )

13438 return

pseudoobjval;

13469

(*deltaval) = lb * (newobj - oldobj);

13480

(*deltaval) = ub * newobj;

13489

(*deltaval) = -lb * oldobj;

13494

(*deltaval) = (ub * newobj) - (lb * oldobj);

13504

(*deltaval) = -lb * oldobj;

13514

(*deltaval) = ub * (newobj - oldobj);

13525

(*deltaval) = lb * newobj;

13534

(*deltaval) = -ub * oldobj;

13539

(*deltaval) = (lb * newobj) - (ub * oldobj);

13549

(*deltaval) = -ub * oldobj;

13560

(*deltaval) = ub * newobj;

13567

(*deltaval) = lb * newobj;

13587

assert(newlb != oldlb);

13594

*deltaval = -obj * oldlb;

13601

*deltaval = obj * newlb;

13606

*deltaval = obj * (newlb - oldlb);

13625

assert(newub != oldub);

13632

*deltaval = -obj * oldub;

13639

*deltaval = obj * newub;

13644

*deltaval = obj * (newub - oldub);

13661

assert(lp !=

);

13751

assert(lp !=

);

13760

assert(var !=

);

13764 SCIPerrorMessage

(

"LP was informed of an objective change of a non-active variable\n"

);

13774 if

( oldobj > 0.0 )

13786 else if

( oldobj < 0.0 )

13800 if

( newobj > 0.0 )

13812 else if

( newobj < 0.0 )

13854

assert(var !=

);

13856 if

(

->misc_exactsolve )

13858 if

( oldobj != newobj )

13908

assert(var !=

);

13935

assert(var !=

);

13937 if

(

->misc_exactsolve )

13976

assert(var !=

);

14003

assert(var !=

);

14005 if

(

->misc_exactsolve )

14041

assert(lp !=

);

14062

assert(lp !=

);

14090

assert(lp !=

);

14141

assert(lp !=

);

14200 if

(

->misc_exactsolve )

14224

assert(lp !=

);

14273

assert(lp !=

);

14324 if

(

->misc_exactsolve )

14341

assert(lp !=

);

14381

assert(lp !=

);

14385

assert(stat !=

);

14393 if

( primalfeasible ==

)

14394

stillprimalfeasible =

;

14397

*primalfeasible =

;

14398

stillprimalfeasible =

;

14400 if

( dualfeasible ==

)

14401

stilldualfeasible =

;

14404

*dualfeasible =

;

14405

stilldualfeasible =

;

14425#ifdef SCIP_USE_LPSOLVER_ACTIVITY 14447 for

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

14449

assert( 0 <= cstat[c] && cstat[c] < 4 );

14450

lpicols[c]->

= primsol[c];

14457

stillprimalfeasible =

;

14458

stilldualfeasible =

;

14462

lpicols[c]->

minprimsol

(lpicols[c]->minprimsol, primsol[c]);

14463

lpicols[c]->

maxprimsol

(lpicols[c]->maxprimsol, primsol[c]);

14464

lpicols[c]->

= redcost[c];

14465

lpicols[c]->

basisstatus

= (

unsigned

int) cstat[c];

14467 if

( stillprimalfeasible )

14469

stillprimalfeasible =

14472

primalbound += (lpicols[c]->

* lpicols[c]->

);

14482 if

( stilldualfeasible )

14484

compslack =

((lpicols[c]->primsol - lpicols[c]->lb), 1.0) * lpicols[c]->

;

14487 if

( stilldualfeasible )

14489

compslack =

((lpicols[c]->ub - lpicols[c]->primsol), 1.0) * lpicols[c]->

;

14493 SCIPsetDebugMsg

(

" col <%s> [%.9g,%.9g]: primsol=%.9f, redcost=%.9f, pfeas=%u/%u(%u), dfeas=%d/%d(%u)\n"

14494 SCIPvarGetName

(lpicols[c]->var), lpicols[c]->lb, lpicols[c]->ub, lpicols[c]->primsol, lpicols[c]->redcost,

14497

primalfeasible !=

? stillprimalfeasible :

14500

dualfeasible !=

? stilldualfeasible :

);

14514 if

( stilldualfeasible

14517 if

( stilldualfeasible

14521 SCIPsetDebugMsg

(

" col <%s> [%.9g,%.9g]: primsol=%.9f, redcost=%.9f, pfeas=%u/%u(%u), dfeas=%d/%d(%u)\n"

14522 SCIPvarGetName

(lpicols[c]->var), lpicols[c]->lb, lpicols[c]->ub, lpicols[c]->primsol, lpicols[c]->redcost,

14525

primalfeasible !=

? stillprimalfeasible :

14528

dualfeasible !=

? stilldualfeasible :

);

14535 if

( stilldualfeasible )

14538

dualbound += (lpicols[c]->

* lpicols[c]->

);

14540

dualbound += (lpicols[c]->redcost * lpicols[c]->ub);

14545 for

(

= 0;

< nlpirows; ++

)

14547

assert( 0 <= rstat[

] && rstat[

] < 4 );

14549#ifdef SCIP_USE_LPSOLVER_ACTIVITY 14553 if

( lpirows[

]->validactivitylp != stat->

lpcount

)

14558 if

( stillprimalfeasible )

14560

stillprimalfeasible =

14572 if

( stilldualfeasible )

14574

compslack =

((lpirows[

]->activity - lpirows[

]->lhs), 1.0) * lpirows[

]->

dualsol

;

14577 if

( stilldualfeasible )

14579

compslack =

((lpirows[

]->rhs - lpirows[

]->activity), 1.0) * lpirows[

]->

dualsol

;

14583 SCIPsetDebugMsg

(

" row <%s> [%.9g,%.9g]: activity=%.9f, dualsol=%.9f, pfeas=%u/%u(%u), dfeas=%d/%d(%u)\n"

14584

lpirows[

]->name, lpirows[

]->lhs, lpirows[

]->rhs, lpirows[

]->activity, lpirows[

]->dualsol,

14587

primalfeasible !=

? stillprimalfeasible :

14590

dualfeasible !=

? stilldualfeasible :

);

14598 if

( stilldualfeasible &&

14601 if

( stilldualfeasible &&

14605 SCIPsetDebugMsg

(

" row <%s> [%.9g,%.9g] + %.9g: activity=%.9f, dualsol=%.9f, pfeas=%u/%u(%u), dfeas=%d/%d(%u)\n"

14606

lpirows[

]->name, lpirows[

]->lhs, lpirows[

]->rhs, lpirows[

]->constant, lpirows[

]->activity, lpirows[

]->dualsol,

14609

primalfeasible !=

? stillprimalfeasible :

14612

dualfeasible !=

? stilldualfeasible :

);

14619 if

( stilldualfeasible )

14624

dualbound += (lpirows[

]->dualsol * (lpirows[

]->rhs - lpirows[

]->constant));

14653 if

( primalfeasible !=

)

14654

*primalfeasible = stillprimalfeasible;

14655 if

( dualfeasible !=

)

14656

*dualfeasible = stilldualfeasible;

14662#ifdef SCIP_USE_LPSOLVER_ACTIVITY 14694

assert(lp !=

);

14700

assert(stat !=

);

14703 if

( primalfeasible !=

)

14704

*primalfeasible =

;

14705 if

( rayfeasible !=

)

14706

*rayfeasible =

;

14716 SCIPerrorMessage

(

"LP solver has no primal ray to prove unboundedness.\n"

);

14738 for

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

14740

assert(lpicols[c] !=

);

14741

assert(lpicols[c]->var !=

);

14746 if

( rayfeasible !=

)

14748

*rayfeasible = *rayfeasible

14754

rayobjval += ray[c] * col->

;

14764

primsol[c] = col->

;

14766

primsol[c] = col->

;

14770

primsol[c] =

(primsol[c], col->

);

14771

primsol[c] =

(primsol[c], col->

);

14777 for

(

= 0;

< nlpirows; ++

)

14782

row = lpirows[

];

14783

assert( row !=

);

14786 for

( c = 0; c < row->

; ++c )

14788

col = row->

[c];

14790

assert( col !=

);

14791

assert( col->

>= 0 );

14792

assert( row->

[c] >= 0 );

14795

act += row->

[c] * primsol[col->

];

14800 for

( c = row->

; c < row->len; ++c )

14802

col = row->

[c];

14803

assert( col !=

);

14805 if

( col->

>= 0 )

14806

act += row->

[c] * primsol[col->

];

14817 if

(

< nlpirows )

14823 if

( primalfeasible !=

)

14825

assert( *primalfeasible );

14826 for

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

14828

assert( lpicols[c] !=

);

14829

assert( lpicols[c]->var !=

);

14836

*primalfeasible =

;

14844 for

(

= 0;

< nlpirows; ++

)

14850

row = lpirows[

];

14851

assert( row !=

);

14855 for

( c = 0; c < row->

; ++c )

14857

col = row->

[c];

14859

assert( col !=

);

14860

assert( col->

>= 0 );

14861

assert( row->

[c] >= 0 );

14864

primact += row->

[c] * primsol[col->

];

14865

rayact += row->

[c] * ray[col->

];

14870 for

( c = row->

; c < row->len; ++c )

14872

col = row->

[c];

14873

assert( col !=

);

14875 if

( col->

>= 0 )

14877

primact += row->

[c] * primsol[col->

];

14878

rayact += row->

[c] * ray[col->

];

14884 if

( primalfeasible !=

&& *primalfeasible )

14888

*primalfeasible =

;

14892 if

( rayfeasible !=

&& *rayfeasible )

14896

*rayfeasible =

;

14900

activity[

] = primact;

14903 if

( primalfeasible !=

&& !(*primalfeasible) )

14908 else if

( rayfeasible !=

&& !(*rayfeasible) )

14919 if

( rayfeasible !=

)

14920

*rayfeasible =

;

14926

assert(rayobjval != 0.0);

14933 for

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

14938

rayscale =

(rayscale, (lpicols[c]->ub - primsol[c]) / ray[c]);

14943

rayscale =

(rayscale, 1.0 / ray[c]);

14949

rayscale =

(rayscale, (lpicols[c]->lb - primsol[c]) / ray[c]);

14954

rayscale =

(rayscale, -1.0 / ray[c]);

14962 SCIPsetDebugMsg

(

"unbounded LP solution: rayobjval=%f, rayscale=%f\n"

, rayobjval, rayscale);

14967 for

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

14970

lpicols[c]->

= primsol[c];

14974

primsolval = primsol[c] + rayscale * ray[c];

14982 for

(

= 0;

< nlpirows; ++

)

15012

assert(lp !=

);

15014

assert(ray !=

);

15039 for

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

15041

assert(lpicols[c] !=

);

15043

var = lpicols[c]->

var

;

15044

assert(var !=

);

15079

assert(lp !=

);

15084

assert(stat !=

);

15087 if

( valid !=

)

15095

farkascoefs =

;

15098

checkfarkas =

->lp_checkfarkas && valid !=

;

15119 for

(

= 0;

< nlpirows; ++

)

15128 if

( checkfarkas && dualfarkas[

] != 0.0 )

15130

assert(valid !=

);

15131

assert(farkascoefs !=

);

15141 SCIPsetDebugMsg

(

"farkas proof is invalid: row <%s>[lhs=%g,rhs=%g,c=%g] has multiplier %g\n"

15142 SCIProwGetName

(lpirows[

]), lpirows[

]->lhs, lpirows[

]->rhs, lpirows[

]->constant, dualfarkas[

]);

15156 for

( c = 0; c < lpirows[

]->

; c++ )

15163

assert(pos >= 0 && pos < nlpicols);

15165

farkascoefs[pos] += dualfarkas[

] * lpirows[

]->

[c];

15169 if

( dualfarkas[

] > 0.0 )

15173

farkaslhs += dualfarkas[

] * lpirows[

]->

;

15176 else if

( dualfarkas[

] < 0.0 )

15180

farkaslhs += dualfarkas[

] * lpirows[

]->

;

15183

maxactivity += dualfarkas[

] * lpirows[

]->

;

15188 for

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

15197

assert(valid !=

);

15198

assert(farkascoefs !=

);

15206 if

( farkascoefs[c] > 0.0 )

15208

maxactivity += farkascoefs[c] * lpicols[c]->

;

15212 SCIPsetDebugMsg

(

"farkas proof is invalid: col <%s>[lb=%g,ub=%g] has coefficient %g\n"

15221

maxactivity += farkascoefs[c] * lpicols[c]->

;

15225 SCIPsetDebugMsg

(

"farkas proof is invalid: col <%s>[lb=%g,ub=%g] has coefficient %g\n"

15239

assert(valid !=

);

15241 SCIPsetDebugMsg

(

"farkas proof is invalid: maxactivity=%.12f, lhs=%.12f\n"

, maxactivity, farkaslhs);

15243 if

( forcedlpsolve &&

SCIPsetIsLT

(

, maxactivity, farkaslhs) )

15244 SCIPmessagePrintWarning

(

->scip->messagehdlr,

"Unreliable farkas proof forced valid, result might not be optimal.\n"

);

15265

assert(lp !=

);

15287

assert(lp !=

);

15292

assert(stat !=

);

15302 for

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

15304

assert(lpicols[c] == lp->

[c]);

15305 if

( lpicols[c]->primsol == 0.0 )

15306

lpicols[c]->

++;

15308

lpicols[c]->

= 0;

15313 for

(

= 0;

< nlpirows; ++

)

15316

assert(lpirows[

] == lp->

[

]);

15318 if

( lpirows[

]->dualsol == 0.0 )

15320

lpirows[

]->

++;

15325

lpirows[

]->

= 0;

15345

assert(lp !=

);

15349

assert(coldstat !=

);

15352

ncols = lp->

;

15358 for

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

15360

col = lp->

[c];

15361

assert(col !=

);

15362

assert(col == lp->

lpicols

[c]);

15363

assert(coldstat[c] <= c);

15364

col->

= coldstat[c];

15365 if

( coldstat[c] == -1 )

15383 else if

( coldstat[c] < c )

15385

assert(lp->

[coldstat[c]] ==

);

15387

lp->

[coldstat[c]] = col;

15388

lp->

lpicols

[coldstat[c]] = col;

15389

lp->

[coldstat[c]]->

= coldstat[c];

15390

lp->

[coldstat[c]]->

= coldstat[c];

15398 while

( c < lp->nlazycols )

15410 if

( lp->

< ncols )

15447

assert(lp !=

);

15451

assert(rowdstat !=

);

15453

nrows = lp->

;

15459 for

(

= 0;

< nrows; ++

)

15461

row = lp->

[

];

15462

assert(row == lp->

lpirows

[

]);

15463

assert(rowdstat[

] <=

);

15464

assert(row !=

);

15465

row->

= rowdstat[

];

15466 if

( rowdstat[

] == -1 )

15495 else if

( rowdstat[

] <

)

15497

assert(lp->

[rowdstat[

]] ==

);

15499

lp->

[rowdstat[

]] = row;

15500

lp->

lpirows

[rowdstat[

]] = row;

15501

lp->

[rowdstat[

]]->

= rowdstat[

];

15509 if

( lp->

< nrows )

15548

assert(lp !=

);

15554

assert(stat !=

);

15559

ncols = lp->

;

15571 for

( c = firstcol; c < ncols; ++c )

15573

assert(cols[c] == lpicols[c]);

15574

assert(cols[c]->lppos == c);

15575

assert(cols[c]->lpipos == c);

15576 if

( cols[c]->removable

15577

&& cols[c]->obsoletenode != stat->

nnodes 15578

&& cols[c]->

->lp_colagelimit

15582

assert(cols[c]->primsol == 0.0);

15586 SCIPsetDebugMsg

(

"removing obsolete col <%s>: primsol=%f, bounds=[%g,%g]\n"

15587 SCIPvarGetName

(cols[c]->var), cols[c]->primsol, cols[c]->lb, cols[c]->ub);

15591 SCIPsetDebugMsg

(

"removing %d/%d obsolete columns from LP\n"

, ndelcols, ncols);

15594 if

( ndelcols > 0 )

15598

assert(lp->

== ncols - ndelcols);

15627

assert(lp !=

);

15633

assert(stat !=

);

15638

nrows = lp->

;

15650 for

(

= firstrow;

< nrows; ++

)

15652

assert(rows[

] == lpirows[

]);

15653

assert(rows[

]->lppos ==

);

15654

assert(rows[

]->lpipos ==

);

15655 if

( rows[

]->removable

15656

&& rows[

]->obsoletenode != stat->

nnodes 15657

&& rows[

]->

->lp_rowagelimit

15663 SCIPsetDebugMsg

(

"removing obsolete row <%s>: activity=%f, sides=[%g,%g]\n"

15664

rows[

]->name, rows[

]->activity, rows[

]->lhs, rows[

]->rhs);

15668 SCIPsetDebugMsg

(

"removing %d/%d obsolete rows from LP\n"

, ndelrows, nrows);

15671 if

( ndelrows > 0 )

15675

assert(lp->

== nrows - ndelrows);

15693

assert(lp !=

);

15699 SCIPsetDebugMsg

(

"removing obsolete columns starting with %d/%d, obsolete rows starting with %d/%d\n"

15724

assert(lp !=

);

15732 if

( 0 < lp->

)

15736 if

( 0 < lp->

)

15760

assert(lp !=

);

15764

assert(stat !=

);

15766

assert(0 <= firstcol && firstcol < lp->ncols);

15771

ncols = lp->

;

15781 for

( c = firstcol; c < ncols; ++c )

15783

assert(cols[c] == lpicols[c]);

15784

assert(cols[c]->lppos == c);

15785

assert(cols[c]->lpipos == c);

15786 if

( lpicols[c]->removable

15788

&& lpicols[c]->primsol == 0.0

15796 SCIPsetDebugMsg

(

"removing %d/%d unused columns from LP\n"

, ndelcols, ncols);

15799 if

( ndelcols > 0 )

15803

assert(lp->

== ncols - ndelcols);

15832

assert(lp !=

);

15837

assert(stat !=

);

15839

assert(0 <= firstrow && firstrow < lp->nrows);

15847

nrows = lp->

;

15856 for

(

= firstrow;

< nrows; ++

)

15858

assert(rows[

] == lpirows[

]);

15859

assert(rows[

]->lppos ==

);

15860

assert(rows[

]->lpipos ==

);

15871 if

( ndelrows > 0 )

15875

assert(lp->

== nrows - ndelrows);

15897

assert(lp !=

);

15904

cleanupcols = (root ?

->lp_cleanupcolsroot :

->lp_cleanupcols);

15905

cleanuprows = (root ?

->lp_cleanuprowsroot :

->lp_cleanuprows);

15907 SCIPsetDebugMsg

(

"removing unused columns starting with %d/%d (%u), unused rows starting with %d/%d (%u), LP algo: %d, basic sol: %u\n"

15936

assert(lp !=

);

15943

cleanupcols = (root ?

->lp_cleanupcolsroot :

->lp_cleanupcols);

15944

cleanuprows = (root ?

->lp_cleanuprowsroot :

->lp_cleanuprows);

15946 SCIPsetDebugMsg

(

"removing all unused columns (%u) and rows (%u), LP algo: %d, basic sol: %u\n"

15949 if

( cleanupcols && 0 < lp->

)

15953 if

( cleanuprows && 0 < lp->

)

15980

assert(lp !=

);

15985

assert(stat !=

);

15995

nrows = lp->

;

16006

assert(rows[

] == lpirows[

]);

16007

assert(rows[

]->lppos ==

);

16008

assert(rows[

]->lpipos ==

);

16012 SCIPsetDebugMsg

(

"basic row <%s> is redundant: sides=[%g,%g], act=[%g,%g]\n"

16020 SCIPsetDebugMsg

(

"removing %d/%d redundant basic rows from LP\n"

, ndelrows, nrows);

16023 if

( ndelrows > 0 )

16027

assert(lp->

== nrows - ndelrows);

16046

assert(lp !=

);

16054

assert(blkmem !=

);

16058 SCIPsetDebugMsg

(

"diving started (LP flushed: %u, LP solved: %u, solstat: %d)\n"

16062 for

( c = 0; c < lp->

; ++c )

16084 if

( !

->lp_resolverestore && lp->

)

16115 for

( c = 0; c < lp->

; ++c )

16119 for

(

= 0;

< lp->

; ++

)

16158

assert(lp !=

);

16160

assert(blkmem !=

);

16161

assert(nvars == 0 || vars !=

);

16166 for

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

16169

assert(var !=

);

16234 SCIP_CALL

(

SCIPlpSolveAndEval

(lp,

, messagehdlr, blkmem, stat, eventqueue, eventfilter, prob, -1LL,

, &lperror) );

16246 "LP was not resolved to a sufficient status after diving\n"

);

16287 for

( c = 0; c < lp->

; ++c )

16291 for

(

= 0;

< lp->

; ++

)

16305 for

( c = 0; c < lp->

; ++c )

16321#define DIVESTACKGROWFACT 1.5 16330

assert(lp !=

);

16331

assert(row !=

);

16352

assert(lp !=

);

16367

assert(lp !=

);

16382

assert(lp !=

);

16395

assert(lp !=

);

16436

assert(lp !=

);

16446 for

( j = 0; j < lp->

; ++j )

16448

row = lp->

[j];

16449

assert(row !=

);

16475 for

( j = 0; j < lp->

; ++j )

16477

col = lp->

[j];

16478

assert(col !=

);

16483

c = usefarkas ? 0.0 : col->

;

16486 for

( i = 0; i < col->

; ++i )

16490

assert(col->

[i] >= 0);

16497 for

( i = col->

; i < col->len; ++i )

16503

assert(col->

[i] >= 0);

16546

assert(proved !=

);

16550

*proved = (

bound

> 0.0);

16552 SCIPsetDebugMsg

(

"proved Farkas value of LP: %g -> infeasibility %sproved\n"

bound

, *proved ?

""

"not "

);

16565

assert(lp !=

);

16567

assert(fname !=

);

16579 const char

* fname,

16595

assert(lp !=

);

16597

assert(fname !=

);

16600

file = fopen(fname,

"w"

);

16601 if

( file ==

)

16609 if

( genericnames )

16610 SCIPmessageFPrintInfo

(messagehdlr, file,

"\\ Original Variable and Constraint Names have been replaced by generic names.\n"

);

16613 SCIPmessageFPrintInfo

(messagehdlr, file,

"\\ Warning: Variable and Constraint Names should not contain special characters like '+', '=' etc.\n"

);

16614 SCIPmessageFPrintInfo

(messagehdlr, file,

"\\ If this is the case, the model may be corrupted!\n"

);

16617 if

( origobj && objoffset != 0.0 )

16619 SCIPmessageFPrintInfo

(messagehdlr, file,

"\\ An artificial variable 'objoffset' has been added and fixed to 1.\n"

);

16620 SCIPmessageFPrintInfo

(messagehdlr, file,

"\\ Switching this variable to 0 will disable the offset in the objective.\n\n"

);

16633 for

( i = 0; i < lp->

; ++i )

16635 if

( lp->

[i]->

!= 0.0 )

16637

coeff = lp->

[i]->

;

16644 if

( genericnames )

16655 if

( origobj && objoffset != 0.0 )

16660 for

( i = 0; i < lp->

; i++ )

16682 if

( genericnames )

16693 if

( strlen(rowname) > 0 )

16698 SCIPmessageFPrintInfo

(messagehdlr, file,

"are not in a valid range. The following two constraints may be corrupted!\n"

);

16706

assert(type ==

'B'

);

16714 if

( genericnames )

16719 if

( (j+1) % 10 == 0 )

16751 for

( i = 0; i < lp->

; i++ )

16773 if

( genericnames )

16784 if

( strlen(rowname) > 0 )

16789 SCIPmessageFPrintInfo

(messagehdlr, file,

"are not in a valid range. The following two constraints may be corrupted!\n"

);

16797

assert(type ==

'B'

);

16805 if

( genericnames )

16810 if

( (j+1) % 10 == 0 )

16841 for

( i = 0; i < lp->

; ++i )

16850 if

( genericnames )

16861 if

( origobj && objoffset != 0.0 )

16867 for

( i = 0; i < lp->

; ++i )

16872 if

( genericnames )

16899#undef SCIPcolGetObj 16902#undef SCIPcolGetBestBound 16903#undef SCIPcolGetPrimsol 16904#undef SCIPcolGetMinPrimsol 16905#undef SCIPcolGetMaxPrimsol 16906#undef SCIPcolGetBasisStatus 16907#undef SCIPcolGetVar 16908#undef SCIPcolGetIndex 16909#undef SCIPcolGetVarProbindex 16910#undef SCIPcolIsIntegral 16911#undef SCIPcolIsRemovable 16912#undef SCIPcolGetLPPos 16913#undef SCIPcolGetLPDepth 16914#undef SCIPcolIsInLP 16915#undef SCIPcolGetNNonz 16916#undef SCIPcolGetNLPNonz 16917#undef SCIPcolGetRows 16918#undef SCIPcolGetVals 16919#undef SCIPcolGetStrongbranchNode 16920#undef SCIPcolGetNStrongbranchs 16921#undef SCIPcolGetAge 16922#undef SCIPboundtypeOpposite 16923#undef SCIProwGetNNonz 16924#undef SCIProwGetNLPNonz 16925#undef SCIProwGetCols 16926#undef SCIProwGetVals 16927#undef SCIProwGetConstant 16928#undef SCIProwGetNorm 16929#undef SCIProwGetSumNorm 16930#undef SCIProwGetLhs 16931#undef SCIProwGetRhs 16932#undef SCIProwGetDualsol 16933#undef SCIProwGetDualfarkas 16934#undef SCIProwGetBasisStatus 16935#undef SCIProwGetName 16936#undef SCIProwGetIndex 16937#undef SCIProwGetAge 16938#undef SCIProwGetRank 16939#undef SCIProwIsIntegral 16940#undef SCIProwIsLocal 16941#undef SCIProwIsModifiable 16942#undef SCIProwIsRemovable 16943#undef SCIProwGetOrigintype 16944#undef SCIProwGetOriginCons 16945#undef SCIProwGetOriginConshdlr 16946#undef SCIProwGetOriginSepa 16947#undef SCIProwIsInGlobalCutpool 16948#undef SCIProwGetLPPos 16949#undef SCIProwGetLPDepth 16950#undef SCIProwIsInLP 16951#undef SCIProwGetActiveLPCount 16952#undef SCIProwGetNLPsAfterCreation 16953#undef SCIProwChgRank 16954#undef SCIPlpGetCols 16955#undef SCIPlpGetNCols 16956#undef SCIPlpGetRows 16957#undef SCIPlpGetNRows 16958#undef SCIPlpGetNewcols 16959#undef SCIPlpGetNNewcols 16960#undef SCIPlpGetNewrows 16961#undef SCIPlpGetNNewrows 16962#undef SCIPlpGetObjNorm 16963#undef SCIPlpGetRootObjval 16964#undef SCIPlpGetRootColumnObjval 16965#undef SCIPlpGetRootLooseObjval 16967#undef SCIPlpSetIsRelax 16968#undef SCIPlpIsRelax 16969#undef SCIPlpIsSolved 16970#undef SCIPlpIsSolBasic 16972#undef SCIPlpDivingObjChanged 16973#undef SCIPlpMarkDivingObjChanged 16974#undef SCIPlpUnmarkDivingObjChanged 16975#undef SCIPlpDivingRowsChanged 16976#undef SCIPlpIsFeasEQ 16977#undef SCIPlpIsFeasLT 16978#undef SCIPlpIsFeasLE 16979#undef SCIPlpIsFeasGT 16980#undef SCIPlpIsFeasGE 16981#undef SCIPlpIsFeasZero 16982#undef SCIPlpIsFeasPositive 16983#undef SCIPlpIsFeasNegative 16990

assert(col !=

);

17000

assert(col !=

);

17010

assert(col !=

);

17020

assert(col !=

);

17022 if

( col->

>= 0.0 )

17033

assert(col !=

);

17035 if

( col->

>= 0 )

17046

assert(col !=

);

17056

assert(col !=

);

17068

assert(col !=

);

17079

assert(col !=

);

17089

assert(col !=

);

17091 return

col->

;

17099

assert(col !=

);

17109

assert(col !=

);

17120

assert(col !=

);

17130

assert(col !=

);

17133 return

col->

;

17141

assert(col !=

);

17152

assert(col !=

);

17155 return

(col->

>= 0);

17163

assert(col !=

);

17177

assert(col !=

);

17188

assert(col !=

);

17190 return

col->

;

17198

assert(col !=

);

17200 return

col->

;

17210

assert(col !=

);

17220

assert(col !=

);

17230

assert(col !=

);

17250

assert(row !=

);

17264

assert(row !=

);

17275

assert(row !=

);

17277 return

row->

;

17285

assert(row !=

);

17287 return

row->

;

17295

assert(row !=

);

17305

assert(row !=

);

17317

assert(row !=

);

17329

assert(row !=

);

17339

assert(row !=

);

17349

assert(row !=

);

17351 if

( row->

>= 0 )

17362

assert(row !=

);

17364 if

( row->

>= 0 )

17377

assert(row !=

);

17388

assert(row !=

);

17390 return

row->

;

17398

assert(row !=

);

17400 return

row->

;

17408

assert(row !=

);

17418

assert(row !=

);

17420 return

row->

rank

;

17428

assert(row !=

);

17438

assert(row !=

);

17440 return

row->

local

;

17448

assert(row !=

);

17458

assert(row !=

);

17468

assert( row !=

);

17478

assert( row !=

);

17493

assert( row !=

);

17513

assert( row !=

);

17528

assert(row !=

);

17538

assert(row !=

);

17541 return

row->

;

17549

assert(row !=

);

17560

assert(row !=

);

17563 return

(row->

>= 0);

17572

assert(row !=

);

17582

assert(row !=

);

17592

assert(row !=

);

17602

assert(lp !=

);

17612

assert(lp !=

);

17614 return

lp->

;

17628

assert(lp !=

);

17629

assert(

eps

> 0.0);

17631

lpcols = lp->

;

17632

nlpcols = lp->

;

17635 for

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

17637 if

( lpcols[c]->ub - lpcols[c]->lb >

eps

)

17641 return

nunfixedcols;

17649

assert(lp !=

);

17659

assert(lp !=

);

17661 return

lp->

;

17669

assert(lp !=

);

17680

assert(lp !=

);

17691

assert(lp !=

);

17702

assert(lp !=

);

17720

assert(cols !=

|| lp->

== 0);

17724 for

( c = lp->

- 1; c >= 0; --c )

17744

assert(lp !=

);

17757

assert(lp !=

);

17767

assert(lp !=

);

17777

assert(lp !=

);

17789

assert(lp !=

);

17801

assert(lp !=

);

17811

assert(lp !=

);

17822

assert(lp !=

);

17834

assert(lp !=

);

17844

assert(lp !=

);

17854

assert(lp !=

);

17864

assert(lp !=

);

17874

assert(lp !=

);

17884

assert(lp !=

);

17894

assert(lp !=

);

17904

assert(lp !=

);

17915

assert(lp !=

);

17926

assert(lp !=

);

17972

assert(lpi !=

);

17978 SCIPmessagePrintWarning

(messagehdlr,

"Could not set feasibility tolerance of LP solver for relative interior point computation.\n"

);

17986 SCIPmessagePrintWarning

(messagehdlr,

"Could not set dual feasibility tolerance of LP solver for relative interior point computation.\n"

);

17991

nnewcols = 3*lp->

+ 2*lp->

+ (inclobjcutoff ? 1 : 0) + 1;

17997 for

( j = 0; j < lp->

; ++j )

18007

nnewcols = lp->

;

18008

obj[nnewcols] = 0.0;

18009

lb[nnewcols] = 1.0;

18014 for

( i = 0; i < lp->

; ++i )

18018

row = lp->

[i];

18019

assert( row !=

);

18033

ntotnonz += row->

+ 1;

18043

lb[nnewcols] = 0.0;

18044

ub[nnewcols] = 1.0;

18045

obj[nnewcols++] = 1.0;

18046

ntotnonz += row->

+ 2;

18049

ntotnonz += row->

+ 1;

18056

lb[nnewcols] = 0.0;

18057

ub[nnewcols] = 1.0;

18058

obj[nnewcols++] = 1.0;

18059

ntotnonz += row->

+ 2;

18062

ntotnonz += row->

+ 1;

18069 if

( inclobjcutoff && relaxrows )

18072

lb[nnewcols] = 0.0;

18073

ub[nnewcols] = 1.0;

18074

obj[nnewcols++] = 1.0;

18075

ntotnonz += lp->

+ 2;

18080 for

( j = 0; j < lp->

; ++j )

18084

col = lp->

[j];

18085

assert( col !=

);

18098

lb[nnewcols] = 0.0;

18099

ub[nnewcols] = 1.0;

18100

obj[nnewcols++] = 1.0;

18106

lb[nnewcols] = 0.0;

18107

ub[nnewcols] = 1.0;

18108

obj[nnewcols++] = 1.0;

18115

nslacks = nnewcols - lp->

- 1;

18116

assert( nslacks >= 0 );

18117

assert( nnewcols <= 3*lp->ncols + 2*lp->

+ (inclobjcutoff ? 1 : 0) + 1 );

18139 for

( i = 0; i < lp->

; ++i )

18148

row = lp->

[i];

18149

assert( row !=

);

18159

assert( nnonz <= lp->ncols );

18160

rowcols = row->

;

18161

rowvals = row->

;

18167

matbeg[matrowidx] = matidx;

18168 for

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

18170

assert( rowcols[j] !=

);

18171

assert( 0 <= rowcols[j]->lppos && rowcols[j]->lppos < lp->ncols );

18172

assert( lp->

[rowcols[j]->

] == rowcols[j] );

18174

matinds[matidx] = rowcols[j]->

;

18175

matvals[matidx++] = rowvals[j];

18176

assert( matidx <= ntotnonz );

18182

matinds[matidx] = lp->

;

18183

matvals[matidx++] = -rhs;

18184

assert( matidx <= ntotnonz );

18187

matlhs[matrowidx] = 0.0;

18188

matrhs[matrowidx++] = 0.0;

18189

assert( matrowidx <= ntotrows );

18202

matbeg[matrowidx] = matidx;

18203 for

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

18205

assert( rowcols[j] !=

);

18206

assert( 0 <= rowcols[j]->lppos && rowcols[j]->lppos < lp->ncols );

18207

assert( lp->

[rowcols[j]->

] == rowcols[j] );

18209

matinds[matidx] = rowcols[j]->

;

18210

matvals[matidx++] = rowvals[j];

18211

assert( matidx <= ntotnonz );

18217

matinds[matidx] = lp->

;

18218

matvals[matidx++] = -lhs;

18219

assert( matidx <= ntotnonz );

18225

matvals[matidx] = -

(1.0, lhs);

18226

matinds[matidx++] = lp->

+ 1 + cnt;

18227

assert( matidx <= ntotnonz );

18231

matlhs[matrowidx] = 0.0;

18233

assert( matrowidx <= ntotrows );

18240

matbeg[matrowidx] = matidx;

18241 for

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

18243

assert( rowcols[j] !=

);

18244

assert( 0 <= rowcols[j]->lppos && rowcols[j]->lppos < lp->ncols );

18245

assert( lp->

[rowcols[j]->

] == rowcols[j] );

18247

matinds[matidx] = rowcols[j]->

;

18248

matvals[matidx++] = rowvals[j];

18249

assert( matidx <= ntotnonz );

18255

matinds[matidx] = lp->

;

18256

matvals[matidx++] = -rhs;

18257

assert( matidx <= ntotnonz );

18263

matvals[matidx] =

(1.0, absrhs);

18264

matinds[matidx++] = lp->

+ 1 + cnt;

18269

matrhs[matrowidx++] = 0.0;

18270

assert( matrowidx <= ntotrows );

18276 if

( inclobjcutoff )

18285

matbeg[matrowidx] = matidx;

18286 for

( j = 0; j < lp->

; ++j )

18294

matinds[matidx] = lp->

[j]->

;

18295

matvals[matidx++] = lp->

[j]->

;

18296

assert( matidx <= ntotnonz );

18305

matinds[matidx] = lp->

;

18306

matvals[matidx++] = -rhs;

18307

assert( matidx <= ntotnonz );

18315

matvals[matidx] =

(1.0, absrhs);

18316

matinds[matidx++] = lp->

+ 1 + cnt;

18317

assert( matidx <= ntotnonz );

18321

matrhs[matrowidx++] = 0.0;

18322

assert( matrowidx <= ntotrows );

18326 for

( j = 0; j < lp->

; ++j )

18332

col = lp->

[j];

18333

assert( col !=

);

18334

assert( col->

== j );

18340

matbeg[matrowidx] = matidx;

18342

matinds[matidx] = j;

18343

matvals[matidx++] = 1.0;

18344

assert( matidx <= ntotnonz );

18349

matinds[matidx] = lp->

;

18350

matvals[matidx++] = -col->

;

18351

assert( matidx <= ntotnonz );

18354

matlhs[matrowidx] = 0.0;

18355

matrhs[matrowidx++] = 0.0;

18356

assert( matrowidx <= ntotrows );

18368

matbeg[matrowidx] = matidx;

18370

matinds[matidx] = j;

18371

matvals[matidx++] = 1.0;

18372

assert( matidx <= ntotnonz );

18377

matinds[matidx] = lp->

;

18378

matvals[matidx++] = -col->

;

18379

assert( matidx <= ntotnonz );

18383

matvals[matidx] = -

(1.0, abscollb);

18384

matinds[matidx++] = lp->

+ 1 + cnt;

18385

assert( matidx <= ntotnonz );

18388

matlhs[matrowidx] = 0.0;

18390

assert( matrowidx <= ntotrows );

18397

matbeg[matrowidx] = matidx;

18399

matinds[matidx] = j;

18400

matvals[matidx++] = 1.0;

18401

assert( matidx <= ntotnonz );

18406

matinds[matidx] = lp->

;

18407

matvals[matidx++] = -col->

;

18408

assert( matidx <= ntotnonz );

18412

matvals[matidx] =

(1.0, abscolub);

18413

matinds[matidx++] = lp->

+ 1 + cnt;

18414

assert( matidx <= ntotnonz );

18418

matrhs[matrowidx++] = 0.0;

18419

assert( matrowidx <= ntotrows );

18422

assert( cnt == nslacks );

18423

assert( matrowidx == ntotrows );

18442

assert( ncols == nnewcols );

18453 SCIPmessagePrintWarning

(messagehdlr,

"Could not set time limit of LP solver for relative interior point computation.\n"

);

18462 SCIPmessagePrintWarning

(messagehdlr,

"Could not set iteration limit of LP solver for relative interior point computation.\n"

);

18472 SCIPmessagePrintWarning

(messagehdlr,

"Iteration limit exceeded in relative interior point computation.\n"

);

18482

alpha = primal[lp->

];

18485 SCIPsetDebugMsg

(

"Solved relative interior lp with objective %g.\n"

, objval);

18488 for

( j = 0; j < lp->

; ++j )

18489

point[j] = primal[j]/alpha;

18496 for

( i = 0; i < lp->

; ++i )

18506

row = lp->

[i];

18507

assert( row !=

);

18513

assert( nnonz <= lp->ncols );

18514

rowcols = row->

;

18515

rowvals = row->

;

18518 for

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

18519

sum += rowvals[j] * primal[rowcols[j]->lppos];

18543 if

( inclobjcutoff )

18552 for

( j = 0; j < lp->

; ++j )

18561 for

( j = 0; j < lp->

; ++j )

18568

col = lp->

[j];

18569

assert( col !=

);

18571

val = primal[col->

] / alpha;

18653

assert(lp !=

);

18654

assert(point !=

);

18655

assert(success !=

);

18660 if

( timelimit <= 0.0 || iterlimit <= 0 )

18664

assert(lp->

>= 0);

18665

assert(lp->

>= 0);

18666 if

( lp->

== 0 )

18671

inclobjcutoff =

;

18676 if

( lp->

== 0 && !inclobjcutoff )

18689

retcode =

computeRelIntPoint

(lpi,

, messagehdlr, lp, prob, relaxrows, inclobjcutoff, timelimit, iterlimit, point, success);

18716

assert(lp !=

);

18732 int

nfixedcols = 0;

18733 int

nalreadyfixedcols = 0;

18734 int

nfixedrows = 0;

18736 int

nimplicitfixedrows = 0;

18741 int

nbasicequalities = 0;

18745

ncols = lp->

;

18746

nrows = lp->

;

18749 for

( c = ncols - 1 ; c >= 0; --c )

18762

++nalreadyfixedcols;

18767 for

(

= nrows - 1;

>= 0; --

)

18800

++nimplicitfixedrows;

18806

++nbasicequalities;

18808

assert(nfixedcols + nfixedrows <= ncols + nineq + nbasicequalities - nrows - nalreadyfixedcols - nimplicitfixedrows);

18810 if

( ncols + nineq - nrows + nbasicequalities - nalreadyfixedcols > 0 )

18811

lp->

degeneracy

= 1.0 - 1.0 * (nfixedcols + nfixedrows) / (ncols + nineq - nrows + nbasicequalities - nalreadyfixedcols);

18816

lp->

varconsratio

= 1.0 * (ncols + nineq + nbasicequalities - nfixedcols - nfixedrows - nalreadyfixedcols) / nrows;

18845

assert(lp !=

);

18865

assert(lp !=

);

18885

assert(lp !=

);

18905

assert(lp !=

);

18925

assert(lp !=

);

18942

assert(lp !=

);

18953

assert(lp !=

);

18964

assert(lp !=