Main Page
Classes
Files
File List
File Members
opt
build
clp
clp-1.12.0
Clp
src
ClpInterior.hpp
Go to the documentation of this file.
1
/* $Id: ClpInterior.hpp 1525 2010-02-26 17:27:59Z mjs $ */
2
// Copyright (C) 2003, International Business Machines
3
// Corporation and others. All Rights Reserved.
4
5
/*
6
Authors
7
8
John Tomlin (pdco)
9
John Forrest (standard predictor-corrector)
10
11
Note JJF has added arrays - this takes more memory but makes
12
flow easier to understand and hopefully easier to extend
13
14
*/
15
#ifndef ClpInterior_H
16
#define ClpInterior_H
17
18
#include <iostream>
19
#include <cfloat>
20
#include "
ClpModel.hpp
"
21
#include "
ClpMatrixBase.hpp
"
22
#include "
ClpSolve.hpp
"
23
#include "CoinDenseVector.hpp"
24
class
ClpLsqr
;
25
class
ClpPdcoBase
;
27
typedef
struct
{
28
double
atolmin
;
29
double
r3norm
;
30
double
LSdamp
;
31
double
*
deltay
;
32
}
Info
;
34
35
typedef
struct
{
36
double
atolold
;
37
double
atolnew
;
38
double
r3ratio
;
39
int
istop
;
40
int
itncg
;
41
}
Outfo
;
43
44
typedef
struct
{
45
double
gamma
;
46
double
delta
;
47
int
MaxIter
;
48
double
FeaTol
;
49
double
OptTol
;
50
double
StepTol
;
51
double
x0min
;
52
double
z0min
;
53
double
mu0
;
54
int
LSmethod
;
// 1=Cholesky 2=QR 3=LSQR
55
int
LSproblem
;
// See below
56
int
LSQRMaxIter
;
57
double
LSQRatol1
;
// Initial atol
58
double
LSQRatol2
;
// Smallest atol (unless atol1 is smaller)
59
double
LSQRconlim
;
60
int
wait
;
61
}
Options
;
62
class
Lsqr;
63
class
ClpCholeskyBase
;
64
// ***** END
72
class
ClpInterior
:
public
ClpModel
{
73
friend
void
ClpInteriorUnitTest
(
const
std::string & mpsDir,
74
const
std::string & netlibDir);
75
76
public
:
77
80
ClpInterior
( );
82
84
ClpInterior
(
const
ClpInterior
&);
86
ClpInterior
(
const
ClpModel
&);
91
ClpInterior
(
const
ClpModel
* wholeModel,
92
int
numberRows
,
const
int
* whichRows,
93
int
numberColumns
,
const
int
* whichColumns,
94
bool
dropNames
=
true
,
bool
dropIntegers =
true
);
96
ClpInterior
&
operator=
(
const
ClpInterior
& rhs);
98
~ClpInterior
( );
99
// Ones below are just ClpModel with some changes
111
void
loadProblem
(
const
ClpMatrixBase
&
matrix
,
112
const
double
* collb,
const
double
* colub,
113
const
double
* obj,
114
const
double
* rowlb,
const
double
* rowub,
115
const
double
*
rowObjective
= NULL);
116
void
loadProblem
(
const
CoinPackedMatrix& matrix,
117
const
double
* collb,
const
double
* colub,
118
const
double
* obj,
119
const
double
* rowlb,
const
double
* rowub,
120
const
double
*
rowObjective
= NULL);
121
124
void
loadProblem
(
const
int
numcols,
const
int
numrows,
125
const
CoinBigIndex* start,
const
int
* index,
126
const
double
* value,
127
const
double
* collb,
const
double
* colub,
128
const
double
* obj,
129
const
double
* rowlb,
const
double
* rowub,
130
const
double
*
rowObjective
= NULL);
132
void
loadProblem
(
const
int
numcols,
const
int
numrows,
133
const
CoinBigIndex* start,
const
int
* index,
134
const
double
* value,
const
int
* length,
135
const
double
* collb,
const
double
* colub,
136
const
double
* obj,
137
const
double
* rowlb,
const
double
* rowub,
138
const
double
*
rowObjective
= NULL);
140
int
readMps
(
const
char
*filename,
141
bool
keepNames =
false
,
142
bool
ignoreErrors =
false
);
147
void
borrowModel
(
ClpModel
& otherModel);
149
void
returnModel
(
ClpModel
& otherModel);
151
155
int
pdco
();
156
// ** Temporary version
157
int
pdco
(
ClpPdcoBase
* stuff,
Options
&options,
Info
&info,
Outfo
&outfo);
159
int
primalDual
();
161
164
inline
bool
primalFeasible
()
const
{
166
return
(
sumPrimalInfeasibilities_
<= 1.0e-5);
167
}
169
inline
bool
dualFeasible
()
const
{
170
return
(
sumDualInfeasibilities_
<= 1.0e-5);
171
}
173
inline
int
algorithm
()
const
{
174
return
algorithm_
;
175
}
177
inline
void
setAlgorithm
(
int
value) {
178
algorithm_
= value;
179
}
181
inline
CoinWorkDouble
sumDualInfeasibilities
()
const
{
182
return
sumDualInfeasibilities_
;
183
}
185
inline
CoinWorkDouble
sumPrimalInfeasibilities
()
const
{
186
return
sumPrimalInfeasibilities_
;
187
}
189
inline
CoinWorkDouble
dualObjective
()
const
{
190
return
dualObjective_
;
191
}
193
inline
CoinWorkDouble
primalObjective
()
const
{
194
return
primalObjective_
;
195
}
197
inline
CoinWorkDouble
diagonalNorm
()
const
{
198
return
diagonalNorm_
;
199
}
201
inline
CoinWorkDouble
linearPerturbation
()
const
{
202
return
linearPerturbation_
;
203
}
204
inline
void
setLinearPerturbation
(CoinWorkDouble value) {
205
linearPerturbation_
= value;
206
}
208
inline
CoinWorkDouble
projectionTolerance
()
const
{
209
return
projectionTolerance_
;
210
}
211
inline
void
setProjectionTolerance
(CoinWorkDouble value) {
212
projectionTolerance_
= value;
213
}
215
inline
CoinWorkDouble
diagonalPerturbation
()
const
{
216
return
diagonalPerturbation_
;
217
}
218
inline
void
setDiagonalPerturbation
(CoinWorkDouble value) {
219
diagonalPerturbation_
= value;
220
}
222
inline
CoinWorkDouble
gamma
()
const
{
223
return
gamma_
;
224
}
225
inline
void
setGamma
(CoinWorkDouble value) {
226
gamma_
= value;
227
}
229
inline
CoinWorkDouble
delta
()
const
{
230
return
delta_
;
231
}
232
inline
void
setDelta
(CoinWorkDouble value) {
233
delta_
= value;
234
}
236
inline
CoinWorkDouble
complementarityGap
()
const
{
237
return
complementarityGap_
;
238
}
240
243
inline
CoinWorkDouble
largestPrimalError
()
const
{
245
return
largestPrimalError_
;
246
}
248
inline
CoinWorkDouble
largestDualError
()
const
{
249
return
largestDualError_
;
250
}
252
inline
int
maximumBarrierIterations
()
const
{
253
return
maximumBarrierIterations_
;
254
}
255
inline
void
setMaximumBarrierIterations
(
int
value) {
256
maximumBarrierIterations_
= value;
257
}
259
void
setCholesky
(
ClpCholeskyBase
* cholesky);
261
int
numberFixed
()
const
;
264
void
fixFixed
(
bool
reallyFix =
true
);
266
inline
CoinWorkDouble *
primalR
()
const
{
267
return
primalR_
;
268
}
270
inline
CoinWorkDouble *
dualR
()
const
{
271
return
dualR_
;
272
}
274
275
protected
:
278
void
gutsOfDelete
();
281
void
gutsOfCopy
(
const
ClpInterior
& rhs);
283
bool
createWorkingData
();
284
void
deleteWorkingData
();
286
bool
sanityCheck
();
288
int
housekeeping
();
290
public
:
293
inline
CoinWorkDouble
rawObjectiveValue
()
const
{
295
return
objectiveValue_
;
296
}
298
inline
int
isColumn
(
int
sequence)
const
{
299
return
sequence <
numberColumns_
? 1 : 0;
300
}
302
inline
int
sequenceWithin
(
int
sequence)
const
{
303
return
sequence <
numberColumns_
? sequence : sequence -
numberColumns_
;
304
}
306
void
checkSolution
();
309
CoinWorkDouble
quadraticDjs
(CoinWorkDouble * djRegion,
const
CoinWorkDouble * solution,
310
CoinWorkDouble scaleFactor);
311
313
inline
void
setFixed
(
int
sequence) {
314
status_
[sequence] =
static_cast<
unsigned
char
>
(
status_
[sequence] | 1) ;
315
}
316
inline
void
clearFixed
(
int
sequence) {
317
status_
[sequence] =
static_cast<
unsigned
char
>
(
status_
[sequence] & ~1) ;
318
}
319
inline
bool
fixed
(
int
sequence)
const
{
320
return
((
status_
[sequence] & 1) != 0);
321
}
322
324
inline
void
setFlagged
(
int
sequence) {
325
status_
[sequence] =
static_cast<
unsigned
char
>
(
status_
[sequence] | 2) ;
326
}
327
inline
void
clearFlagged
(
int
sequence) {
328
status_
[sequence] =
static_cast<
unsigned
char
>
(
status_
[sequence] & ~2) ;
329
}
330
inline
bool
flagged
(
int
sequence)
const
{
331
return
((
status_
[sequence] & 2) != 0);
332
}
333
335
inline
void
setFixedOrFree
(
int
sequence) {
336
status_
[sequence] =
static_cast<
unsigned
char
>
(
status_
[sequence] | 4) ;
337
}
338
inline
void
clearFixedOrFree
(
int
sequence) {
339
status_
[sequence] =
static_cast<
unsigned
char
>
(
status_
[sequence] & ~4) ;
340
}
341
inline
bool
fixedOrFree
(
int
sequence)
const
{
342
return
((
status_
[sequence] & 4) != 0);
343
}
344
346
inline
void
setLowerBound
(
int
sequence) {
347
status_
[sequence] =
static_cast<
unsigned
char
>
(
status_
[sequence] | 8) ;
348
}
349
inline
void
clearLowerBound
(
int
sequence) {
350
status_
[sequence] =
static_cast<
unsigned
char
>
(
status_
[sequence] & ~8) ;
351
}
352
inline
bool
lowerBound
(
int
sequence)
const
{
353
return
((
status_
[sequence] & 8) != 0);
354
}
355
357
inline
void
setUpperBound
(
int
sequence) {
358
status_
[sequence] =
static_cast<
unsigned
char
>
(
status_
[sequence] | 16) ;
359
}
360
inline
void
clearUpperBound
(
int
sequence) {
361
status_
[sequence] =
static_cast<
unsigned
char
>
(
status_
[sequence] & ~16) ;
362
}
363
inline
bool
upperBound
(
int
sequence)
const
{
364
return
((
status_
[sequence] & 16) != 0);
365
}
366
368
inline
void
setFakeLower
(
int
sequence) {
369
status_
[sequence] =
static_cast<
unsigned
char
>
(
status_
[sequence] | 32) ;
370
}
371
inline
void
clearFakeLower
(
int
sequence) {
372
status_
[sequence] =
static_cast<
unsigned
char
>
(
status_
[sequence] & ~32) ;
373
}
374
inline
bool
fakeLower
(
int
sequence)
const
{
375
return
((
status_
[sequence] & 32) != 0);
376
}
377
379
inline
void
setFakeUpper
(
int
sequence) {
380
status_
[sequence] =
static_cast<
unsigned
char
>
(
status_
[sequence] | 64) ;
381
}
382
inline
void
clearFakeUpper
(
int
sequence) {
383
status_
[sequence] =
static_cast<
unsigned
char
>
(
status_
[sequence] & ~64) ;
384
}
385
inline
bool
fakeUpper
(
int
sequence)
const
{
386
return
((
status_
[sequence] & 64) != 0);
387
}
389
391
protected
:
392
399
CoinWorkDouble
largestPrimalError_
;
402
CoinWorkDouble
largestDualError_
;
404
CoinWorkDouble
sumDualInfeasibilities_
;
406
CoinWorkDouble
sumPrimalInfeasibilities_
;
408
CoinWorkDouble
worstComplementarity_
;
410
public
:
411
CoinWorkDouble
xsize_
;
412
CoinWorkDouble
zsize_
;
413
protected
:
415
CoinWorkDouble *
lower_
;
417
CoinWorkDouble *
rowLowerWork_
;
419
CoinWorkDouble *
columnLowerWork_
;
421
CoinWorkDouble *
upper_
;
423
CoinWorkDouble *
rowUpperWork_
;
425
CoinWorkDouble *
columnUpperWork_
;
427
CoinWorkDouble *
cost_
;
428
public
:
430
CoinWorkDouble *
rhs_
;
431
CoinWorkDouble *
x_
;
432
CoinWorkDouble *
y_
;
433
CoinWorkDouble *
dj_
;
434
protected
:
436
ClpLsqr
*
lsqrObject_
;
438
ClpPdcoBase
*
pdcoStuff_
;
441
CoinWorkDouble
mu_
;
443
CoinWorkDouble
objectiveNorm_
;
445
CoinWorkDouble
rhsNorm_
;
447
CoinWorkDouble
solutionNorm_
;
449
CoinWorkDouble
dualObjective_
;
451
CoinWorkDouble
primalObjective_
;
453
CoinWorkDouble
diagonalNorm_
;
455
CoinWorkDouble
stepLength_
;
457
CoinWorkDouble
linearPerturbation_
;
459
CoinWorkDouble
diagonalPerturbation_
;
460
// gamma from Saunders and Tomlin regularized
461
CoinWorkDouble
gamma_
;
462
// delta from Saunders and Tomlin regularized
463
CoinWorkDouble
delta_
;
465
CoinWorkDouble
targetGap_
;
467
CoinWorkDouble
projectionTolerance_
;
469
CoinWorkDouble
maximumRHSError_
;
471
CoinWorkDouble
maximumBoundInfeasibility_
;
473
CoinWorkDouble
maximumDualError_
;
475
CoinWorkDouble
diagonalScaleFactor_
;
477
CoinWorkDouble
scaleFactor_
;
479
CoinWorkDouble
actualPrimalStep_
;
481
CoinWorkDouble
actualDualStep_
;
483
CoinWorkDouble
smallestInfeasibility_
;
485
#define LENGTH_HISTORY 5
486
CoinWorkDouble
historyInfeasibility_
[
LENGTH_HISTORY
];
488
CoinWorkDouble
complementarityGap_
;
490
CoinWorkDouble
baseObjectiveNorm_
;
492
CoinWorkDouble
worstDirectionAccuracy_
;
494
CoinWorkDouble
maximumRHSChange_
;
496
CoinWorkDouble *
errorRegion_
;
498
CoinWorkDouble *
rhsFixRegion_
;
500
CoinWorkDouble *
upperSlack_
;
502
CoinWorkDouble *
lowerSlack_
;
504
CoinWorkDouble *
diagonal_
;
506
CoinWorkDouble *
solution_
;
508
CoinWorkDouble *
workArray_
;
510
CoinWorkDouble *
deltaX_
;
512
CoinWorkDouble *
deltaY_
;
514
CoinWorkDouble *
deltaZ_
;
516
CoinWorkDouble *
deltaW_
;
518
CoinWorkDouble *
deltaSU_
;
519
CoinWorkDouble *
deltaSL_
;
521
CoinWorkDouble *
primalR_
;
523
CoinWorkDouble *
dualR_
;
525
CoinWorkDouble *
rhsB_
;
527
CoinWorkDouble *
rhsU_
;
529
CoinWorkDouble *
rhsL_
;
531
CoinWorkDouble *
rhsZ_
;
533
CoinWorkDouble *
rhsW_
;
535
CoinWorkDouble *
rhsC_
;
537
CoinWorkDouble *
zVec_
;
539
CoinWorkDouble *
wVec_
;
541
ClpCholeskyBase
*
cholesky_
;
543
int
numberComplementarityPairs_
;
545
int
numberComplementarityItems_
;
547
int
maximumBarrierIterations_
;
549
bool
gonePrimalFeasible_
;
551
bool
goneDualFeasible_
;
553
int
algorithm_
;
555
};
556
//#############################################################################
565
void
566
ClpInteriorUnitTest
(
const
std::string & mpsDir,
567
const
std::string & netlibDir);
568
569
570
#endif
Generated on Tue Mar 1 2016 22:38:52 by
1.8.4