Cbc  2.9.9
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
ClpInterior.hpp
Go to the documentation of this file.
1 /* $Id: ClpInterior.hpp 1665 2011-01-04 17:55:54Z lou $ */
2 // Copyright (C) 2003, International Business Machines
3 // Corporation and others. All Rights Reserved.
4 // This code is licensed under the terms of the Eclipse Public License (EPL).
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
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  }
183  }
187  }
189  inline CoinWorkDouble dualObjective() const {
190  return dualObjective_;
191  }
194  return primalObjective_;
195  }
197  inline CoinWorkDouble diagonalNorm() const {
198  return diagonalNorm_;
199  }
202  return linearPerturbation_;
203  }
205  linearPerturbation_ = value;
206  }
209  return projectionTolerance_;
210  }
212  projectionTolerance_ = value;
213  }
216  return diagonalPerturbation_;
217  }
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  }
237  return complementarityGap_;
238  }
240 
243  inline CoinWorkDouble largestPrimalError() const {
245  return largestPrimalError_;
246  }
249  return largestDualError_;
250  }
252  inline int maximumBarrierIterations() const {
254  }
255  inline void setMaximumBarrierIterations(int 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 
410 public:
413 protected:
428 public:
434 protected:
460  // gamma from Saunders and Tomlin regularized
462  // delta from Saunders and Tomlin regularized
485 #define LENGTH_HISTORY 5
555 };
556 //#############################################################################
565 void
566 ClpInteriorUnitTest(const std::string & mpsDir,
567  const std::string & netlibDir);
568 
569 
570 #endif
CoinWorkDouble zsize_
int algorithm() const
Current (or last) algorithm.
bool goneDualFeasible_
goneDualFeasible.
void clearUpperBound(int sequence)
bool flagged(int sequence) const
CoinWorkDouble diagonalNorm_
diagonalNorm.
CoinWorkDouble maximumBoundInfeasibility_
maximumBoundInfeasibility.
friend void ClpInteriorUnitTest(const std::string &mpsDir, const std::string &netlibDir)
A function that tests the methods in the ClpInterior class.
CoinWorkDouble complementarityGap() const
ComplementarityGap.
double atolmin
Definition: ClpInterior.hpp:28
CoinWorkDouble gamma() const
gamma
CoinWorkDouble smallestInfeasibility_
smallestInfeasibility
int itncg
Definition: ClpInterior.hpp:40
void ClpInteriorUnitTest(const std::string &mpsDir, const std::string &netlibDir)
A function that tests the methods in the ClpInterior class.
void setDelta(CoinWorkDouble value)
CoinWorkDouble * columnLowerWork_
Column lower bounds - working copy.
CoinWorkDouble worstComplementarity_
Worst complementarity.
void setFixedOrFree(int sequence)
To say a variable is fixed OR free.
int numberComplementarityItems_
numberComplementarityItems_ i.e. number of active bounds
Abstract base class for Clp Matrices.
CoinWorkDouble * rhsL_
rhsL.
CoinWorkDouble * solution_
solution
This solves LPs using interior point methods.
Definition: ClpInterior.hpp:72
CoinWorkDouble rawObjectiveValue() const
Raw objective value (so always minimize)
void setUpperBound(int sequence)
To say a variable has upper bound.
CoinWorkDouble primalObjective() const
primalObjective.
CoinWorkDouble historyInfeasibility_[LENGTH_HISTORY]
CoinWorkDouble * lower_
Working copy of lower bounds (Owner of arrays below)
CoinWorkDouble solutionNorm_
solutionNorm.
bool fakeLower(int sequence) const
void deleteWorkingData()
This class implements LSQR.
Definition: ClpLsqr.hpp:76
double LSdamp
Definition: ClpInterior.hpp:30
CoinWorkDouble linearPerturbation() const
linearPerturbation
CoinWorkDouble * primalR() const
Primal erturbation vector.
CoinWorkDouble diagonalPerturbation_
diagonalPerturbation
double r3norm
Definition: ClpInterior.hpp:29
void clearFixedOrFree(int sequence)
CoinWorkDouble * deltaSU_
deltaS.
CoinWorkDouble sumPrimalInfeasibilities() const
Sum of primal infeasibilities.
bool lowerBound(int sequence) const
******** DATA to be moved into protected section of ClpInterior
Definition: ClpInterior.hpp:35
CoinWorkDouble * rhsC_
rhs C
CoinWorkDouble largestPrimalError() const
Largest error on Ax-b.
bool gonePrimalFeasible_
gonePrimalFeasible.
~ClpInterior()
Destructor.
double * deltay
Definition: ClpInterior.hpp:31
CoinWorkDouble targetGap_
targetGap
void setFixed(int sequence)
To say a variable is fixed.
CoinWorkDouble * errorRegion_
errorRegion. i.e. Ax
CoinWorkDouble objectiveNorm_
objectiveNorm.
CoinWorkDouble delta_
int algorithm_
Which algorithm being used.
bool fakeUpper(int sequence) const
CoinWorkDouble xsize_
CoinWorkDouble * deltaY_
delta Y
int maximumBarrierIterations_
Maximum iterations.
double LSQRconlim
Definition: ClpInterior.hpp:59
void setGamma(CoinWorkDouble value)
CoinWorkDouble * upperSlack_
upperSlack
int isColumn(int sequence) const
Returns 1 if sequence indicates column.
int numberColumns() const
Definition: ClpModel.hpp:325
void clearFakeUpper(int sequence)
Base class for Clp Cholesky factorization Will do better factorization.
CoinWorkDouble baseObjectiveNorm_
baseObjectiveNorm
double mu0
Definition: ClpInterior.hpp:53
CoinWorkDouble * rhsFixRegion_
rhsFixRegion.
void clearLowerBound(int sequence)
CoinWorkDouble * rhsZ_
rhsZ.
#define LENGTH_HISTORY
historyInfeasibility.
CoinWorkDouble delta() const
delta
void setFakeLower(int sequence)
To say a variable has fake lower bound.
void clearFixed(int sequence)
int LSQRMaxIter
Definition: ClpInterior.hpp:56
void setLinearPerturbation(CoinWorkDouble value)
******** DATA to be moved into protected section of ClpInterior
Definition: ClpInterior.hpp:27
CoinWorkDouble * rhsW_
rhsW.
CoinWorkDouble projectionTolerance_
projectionTolerance
CoinWorkDouble * zVec_
zVec
int numberComplementarityPairs_
numberComplementarityPairs i.e. ones with lower and/or upper bounds (not fixed)
int sequenceWithin(int sequence) const
Returns sequence number within section.
int primalDual()
Primal-Dual Predictor-Corrector barrier.
CoinWorkDouble * deltaSL_
CoinWorkDouble * workArray_
work array
CoinWorkDouble * x_
CoinWorkDouble sumPrimalInfeasibilities_
Sum of primal infeasibilities.
CoinWorkDouble diagonalNorm() const
diagonalNorm
void gutsOfCopy(const ClpInterior &rhs)
Does most of copying.
ClpInterior()
Default constructor.
double z0min
Definition: ClpInterior.hpp:52
CoinWorkDouble complementarityGap_
complementarityGap.
void setFakeUpper(int sequence)
To say a variable has fake upper bound.
int istop
Definition: ClpInterior.hpp:39
CoinWorkDouble maximumRHSError_
maximumRHSError. maximum Ax
CoinWorkDouble maximumDualError_
maximumDualError.
CoinWorkDouble * diagonal_
diagonal
double gamma
Definition: ClpInterior.hpp:45
CoinWorkDouble primalObjective_
primalObjective.
Abstract base class for tailoring everything for Pcdo.
Definition: ClpPdcoBase.hpp:25
CoinWorkDouble * dualR() const
Dual erturbation vector.
int numberColumns_
Number of columns.
Definition: ClpModel.hpp:1126
ClpInterior & operator=(const ClpInterior &rhs)
Assignment operator. This copies the data.
void setAlgorithm(int value)
Set algorithm.
void checkSolution()
Checks solution.
double LSQRatol2
Definition: ClpInterior.hpp:58
CoinWorkDouble * columnUpperWork_
Column upper bounds - working copy.
CoinWorkDouble quadraticDjs(CoinWorkDouble *djRegion, const CoinWorkDouble *solution, CoinWorkDouble scaleFactor)
Modifies djs to allow for quadratic.
double atolnew
Definition: ClpInterior.hpp:37
int readMps(const char *filename, bool keepNames=false, bool ignoreErrors=false)
Read an mps file from the given filename.
double * rowObjective() const
Row Objective.
Definition: ClpModel.hpp:676
CoinWorkDouble largestDualError() const
Largest error on basic duals.
CoinWorkDouble * upper_
Working copy of upper bounds (Owner of arrays below)
void setMaximumBarrierIterations(int value)
void setProjectionTolerance(CoinWorkDouble value)
CoinWorkDouble * rowUpperWork_
Row upper bounds - working copy.
CoinWorkDouble * deltaW_
deltaW.
double delta
Definition: ClpInterior.hpp:46
void clearFlagged(int sequence)
CoinWorkDouble actualPrimalStep_
actualPrimalStep
CoinWorkDouble sumDualInfeasibilities() const
Sum of dual infeasibilities.
ClpLsqr * lsqrObject_
Pointer to Lsqr object.
int pdco()
Pdco algorithm - see ClpPdco.hpp for method.
int MaxIter
Definition: ClpInterior.hpp:47
Sparse Matrix Base Class.
CoinWorkDouble * dualR_
Dual regularization array.
CoinWorkDouble dualObjective() const
dualObjective.
double r3ratio
Definition: ClpInterior.hpp:38
ClpPdcoBase * pdcoStuff_
Pointer to stuff.
bool dualFeasible() const
If problem is dual feasible.
CoinWorkDouble maximumRHSChange_
maximumRHSChange
CoinWorkDouble rhsNorm_
rhsNorm.
CoinWorkDouble sumDualInfeasibilities_
Sum of dual infeasibilities.
bool fixed(int sequence) const
bool fixedOrFree(int sequence) const
int numberRows() const
Number of rows.
Definition: ClpModel.hpp:315
void setLowerBound(int sequence)
To say a variable has lower bound.
int housekeeping()
This does housekeeping.
CoinWorkDouble * y_
bool upperBound(int sequence) const
CoinWorkDouble scaleFactor_
scaleFactor. For scaling objective
CoinWorkDouble * deltaX_
delta X
int CoinBigIndex
CoinWorkDouble stepLength_
stepLength
double StepTol
Definition: ClpInterior.hpp:50
double LSQRatol1
Definition: ClpInterior.hpp:57
bool sanityCheck()
Sanity check on input rim data.
double FeaTol
Definition: ClpInterior.hpp:48
CoinWorkDouble * lowerSlack_
lowerSlack
unsigned char * status_
Status (i.e.
Definition: ClpModel.hpp:1173
double x0min
Definition: ClpInterior.hpp:51
double atolold
Definition: ClpInterior.hpp:36
bool primalFeasible() const
If problem is primal feasible.
void fixFixed(bool reallyFix=true)
fix variables interior says should be.
CoinWorkDouble diagonalPerturbation() const
diagonalPerturbation
void setCholesky(ClpCholeskyBase *cholesky)
Set cholesky (and delete present one)
int LSmethod
Definition: ClpInterior.hpp:54
CoinWorkDouble * cost_
Working copy of objective.
CoinWorkDouble * wVec_
wVec
void returnModel(ClpModel &otherModel)
Return model - updates any scalars.
int maximumBarrierIterations() const
Maximum iterations.
CoinWorkDouble largestPrimalError_
Largest error on Ax-b.
int numberFixed() const
Return number fixed to see if worth presolving.
CoinWorkDouble * rhs_
Rhs.
bool createWorkingData()
Returns true if data looks okay, false if not.
double CoinWorkDouble
Definition: CoinTypes.hpp:53
CoinWorkDouble * rowLowerWork_
Row lower bounds - working copy.
CoinWorkDouble * dj_
CoinWorkDouble actualDualStep_
actualDualStep
CoinWorkDouble * rhsU_
rhsU.
void borrowModel(ClpModel &otherModel)
Borrow model.
CoinWorkDouble linearPerturbation_
linearPerturbation
CoinWorkDouble worstDirectionAccuracy_
worstDirectionAccuracy
ClpCholeskyBase * cholesky_
cholesky.
double OptTol
Definition: ClpInterior.hpp:49
CoinWorkDouble dualObjective_
dualObjective.
void dropNames()
Drops names - makes lengthnames 0 and names empty.
CoinWorkDouble * primalR_
Primal regularization array.
double objectiveValue_
Objective value.
Definition: ClpModel.hpp:1116
CoinWorkDouble projectionTolerance() const
projectionTolerance
CoinWorkDouble * rhsB_
rhs B
void setFlagged(int sequence)
To flag a variable.
CoinWorkDouble * deltaZ_
deltaZ.
CoinPackedMatrix * matrix() const
Matrix (if not ClpPackedmatrix be careful about memory leak.
Definition: ClpModel.hpp:697
CoinWorkDouble diagonalScaleFactor_
diagonalScaleFactor.
CoinWorkDouble gamma_
void loadProblem(const ClpMatrixBase &matrix, const double *collb, const double *colub, const double *obj, const double *rowlb, const double *rowub, const double *rowObjective=NULL)
Loads a problem (the constraints on the rows are given by lower and upper bounds).
******** DATA to be moved into protected section of ClpInterior
Definition: ClpInterior.hpp:44
int LSproblem
Definition: ClpInterior.hpp:55
CoinWorkDouble mu_
Below here is standard barrier stuff mu.
void gutsOfDelete()
Does most of deletion.
CoinWorkDouble largestDualError_
Largest error on basic duals.
void clearFakeLower(int sequence)
void setDiagonalPerturbation(CoinWorkDouble value)