00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014 #ifndef ClpInterior_H
00015 #define ClpInterior_H
00016
00017 #include <iostream>
00018 #include <cfloat>
00019 #include "ClpModel.hpp"
00020 #include "ClpMatrixBase.hpp"
00021 #include "ClpSolve.hpp"
00022 class ClpLsqr;
00023 class ClpPdcoBase;
00025 typedef struct{
00026 double atolmin;
00027 double r3norm;
00028 double LSdamp;
00029 double* deltay;
00030 } Info;
00032
00033 typedef struct{
00034 double atolold;
00035 double atolnew;
00036 double r3ratio;
00037 int istop;
00038 int itncg;
00039 } Outfo;
00041
00042 typedef struct{
00043 double gamma;
00044 double delta;
00045 int MaxIter;
00046 double FeaTol;
00047 double OptTol;
00048 double StepTol;
00049 double x0min;
00050 double z0min;
00051 double mu0;
00052 int LSmethod;
00053 int LSproblem;
00054 int LSQRMaxIter;
00055 double LSQRatol1;
00056 double LSQRatol2;
00057 double LSQRconlim;
00058 int wait;
00059 } Options;
00060 class Lsqr;
00061 class ClpCholeskyBase;
00062
00070 class ClpInterior : public ClpModel {
00071 friend void ClpInteriorUnitTest(const std::string & mpsDir,
00072 const std::string & netlibDir);
00073
00074 public:
00075
00078
00079 ClpInterior ( );
00080
00082 ClpInterior(const ClpInterior &);
00084 ClpInterior(const ClpModel &);
00089 ClpInterior (const ClpModel * wholeModel,
00090 int numberRows, const int * whichRows,
00091 int numberColumns, const int * whichColumns,
00092 bool dropNames=true, bool dropIntegers=true);
00094 ClpInterior & operator=(const ClpInterior & rhs);
00096 ~ClpInterior ( );
00097
00109 void loadProblem ( const ClpMatrixBase& matrix,
00110 const double* collb, const double* colub,
00111 const double* obj,
00112 const double* rowlb, const double* rowub,
00113 const double * rowObjective=NULL);
00114 void loadProblem ( const CoinPackedMatrix& matrix,
00115 const double* collb, const double* colub,
00116 const double* obj,
00117 const double* rowlb, const double* rowub,
00118 const double * rowObjective=NULL);
00119
00122 void loadProblem ( const int numcols, const int numrows,
00123 const CoinBigIndex* start, const int* index,
00124 const double* value,
00125 const double* collb, const double* colub,
00126 const double* obj,
00127 const double* rowlb, const double* rowub,
00128 const double * rowObjective=NULL);
00130 void loadProblem ( const int numcols, const int numrows,
00131 const CoinBigIndex* start, const int* index,
00132 const double* value,const int * length,
00133 const double* collb, const double* colub,
00134 const double* obj,
00135 const double* rowlb, const double* rowub,
00136 const double * rowObjective=NULL);
00138 int readMps(const char *filename,
00139 bool keepNames=false,
00140 bool ignoreErrors = false);
00145 void borrowModel(ClpModel & otherModel);
00147 void returnModel(ClpModel & otherModel);
00149
00153 int pdco();
00154
00155 int pdco( ClpPdcoBase * stuff, Options &options, Info &info, Outfo &outfo);
00157 int primalDual();
00159
00162
00163 inline bool primalFeasible() const
00164 { return (sumPrimalInfeasibilities_<=1.0e-5);}
00166 inline bool dualFeasible() const
00167 { return (sumDualInfeasibilities_<=1.0e-5);}
00169 inline int algorithm() const
00170 {return algorithm_; }
00172 inline void setAlgorithm(int value)
00173 {algorithm_=value; }
00175 inline double sumDualInfeasibilities() const
00176 { return sumDualInfeasibilities_;}
00178 inline double sumPrimalInfeasibilities() const
00179 { return sumPrimalInfeasibilities_;}
00181 inline double dualObjective() const
00182 { return dualObjective_;}
00184 inline double primalObjective() const
00185 { return primalObjective_;}
00187 inline double diagonalNorm() const
00188 { return diagonalNorm_;}
00190 inline double linearPerturbation() const
00191 { return linearPerturbation_;}
00192 inline void setLinearPerturbation(double value)
00193 { linearPerturbation_=value;}
00195 inline double diagonalPerturbation() const
00196 { return diagonalPerturbation_;}
00197 inline void setDiagonalPerturbation(double value)
00198 { diagonalPerturbation_=value;}
00200 inline double gamma() const
00201 { return gamma_;}
00202 inline void setGamma(double value)
00203 { gamma_=value;}
00205 inline double delta() const
00206 { return delta_;}
00207 inline void setDelta(double value)
00208 { delta_=value;}
00210 inline double complementarityGap() const
00211 { return complementarityGap_;}
00213
00216
00217 inline double largestPrimalError() const
00218 { return largestPrimalError_;}
00220 inline double largestDualError() const
00221 { return largestDualError_;}
00223 inline int maximumBarrierIterations() const
00224 { return maximumBarrierIterations_;}
00225 inline void setMaximumBarrierIterations(int value)
00226 { maximumBarrierIterations_=value;}
00228 void setCholesky(ClpCholeskyBase * cholesky);
00230 int numberFixed() const;
00233 void fixFixed(bool reallyFix=true);
00235 inline double * primalR() const
00236 { return primalR_;}
00238 inline double * dualR() const
00239 { return dualR_;}
00241
00242 protected:
00245
00246 void gutsOfDelete();
00248 void gutsOfCopy(const ClpInterior & rhs);
00250 bool createWorkingData();
00251 void deleteWorkingData();
00253 bool sanityCheck();
00255 int housekeeping();
00257 public:
00260
00261 inline double rawObjectiveValue() const
00262 { return objectiveValue_;}
00264 inline int isColumn(int sequence) const
00265 { return sequence<numberColumns_ ? 1 : 0;}
00267 inline int sequenceWithin(int sequence) const
00268 { return sequence<numberColumns_ ? sequence : sequence-numberColumns_;}
00270 void checkSolution();
00273 double quadraticDjs(double * djRegion, const double * solution,
00274 double scaleFactor);
00275
00277 inline void setFixed( int sequence)
00278 {
00279 status_[sequence] |= 1;
00280 }
00281 inline void clearFixed( int sequence)
00282 {
00283 status_[sequence] &= ~1;
00284 }
00285 inline bool fixed(int sequence) const
00286 {return ((status_[sequence]&1)!=0);}
00287
00289 inline void setFlagged( int sequence)
00290 {
00291 status_[sequence] |= 2;
00292 }
00293 inline void clearFlagged( int sequence)
00294 {
00295 status_[sequence] &= ~2;
00296 }
00297 inline bool flagged(int sequence) const
00298 {return ((status_[sequence]&2)!=0);}
00299
00301 inline void setFixedOrFree( int sequence)
00302 {
00303 status_[sequence] |= 4;
00304 }
00305 inline void clearFixedOrFree( int sequence)
00306 {
00307 status_[sequence] &= ~4;
00308 }
00309 inline bool fixedOrFree(int sequence) const
00310 {return ((status_[sequence]&4)!=0);}
00311
00313 inline void setLowerBound( int sequence)
00314 {
00315 status_[sequence] |= 8;
00316 }
00317 inline void clearLowerBound( int sequence)
00318 {
00319 status_[sequence] &= ~8;
00320 }
00321 inline bool lowerBound(int sequence) const
00322 {return ((status_[sequence]&8)!=0);}
00323
00325 inline void setUpperBound( int sequence)
00326 {
00327 status_[sequence] |= 16;
00328 }
00329 inline void clearUpperBound( int sequence)
00330 {
00331 status_[sequence] &= ~16;
00332 }
00333 inline bool upperBound(int sequence) const
00334 {return ((status_[sequence]&16)!=0);}
00335
00337 inline void setFakeLower( int sequence)
00338 {
00339 status_[sequence] |= 32;
00340 }
00341 inline void clearFakeLower( int sequence)
00342 {
00343 status_[sequence] &= ~32;
00344 }
00345 inline bool fakeLower(int sequence) const
00346 {return ((status_[sequence]&32)!=0);}
00347
00349 inline void setFakeUpper( int sequence)
00350 {
00351 status_[sequence] |= 64;
00352 }
00353 inline void clearFakeUpper( int sequence)
00354 {
00355 status_[sequence] &= ~64;
00356 }
00357 inline bool fakeUpper(int sequence) const
00358 {return ((status_[sequence]&64)!=0);}
00360
00362 protected:
00363
00370
00371 double largestPrimalError_;
00373 double largestDualError_;
00375 double sumDualInfeasibilities_;
00377 double sumPrimalInfeasibilities_;
00379 double worstComplementarity_;
00381 public:
00382 double xsize_;
00383 double zsize_;
00384 protected:
00386 double * lower_;
00388 double * rowLowerWork_;
00390 double * columnLowerWork_;
00392 double * upper_;
00394 double * rowUpperWork_;
00396 double * columnUpperWork_;
00398 double * cost_;
00399 public:
00401 double * rhs_;
00402 double * x_;
00403 double * y_;
00404 double * dj_;
00405 protected:
00407 ClpLsqr * lsqrObject_;
00409 ClpPdcoBase * pdcoStuff_;
00412 double mu_;
00414 double objectiveNorm_;
00416 double rhsNorm_;
00418 double solutionNorm_;
00420 double dualObjective_;
00422 double primalObjective_;
00424 double diagonalNorm_;
00426 double stepLength_;
00428 double linearPerturbation_;
00430 double diagonalPerturbation_;
00431
00432 double gamma_;
00433
00434 double delta_;
00436 double targetGap_;
00438 double projectionTolerance_;
00440 double maximumRHSError_;
00442 double maximumBoundInfeasibility_;
00444 double maximumDualError_;
00446 double diagonalScaleFactor_;
00448 double scaleFactor_;
00450 double actualPrimalStep_;
00452 double actualDualStep_;
00454 double smallestInfeasibility_;
00456 #define LENGTH_HISTORY 5
00457 double historyInfeasibility_[LENGTH_HISTORY];
00459 double complementarityGap_;
00461 double baseObjectiveNorm_;
00463 double worstDirectionAccuracy_;
00465 double maximumRHSChange_;
00467 double * errorRegion_;
00469 double * rhsFixRegion_;
00471 double * upperSlack_;
00473 double * lowerSlack_;
00475 double * diagonal_;
00477 double * solution_;
00479 double * workArray_;
00481 double * deltaX_;
00483 double * deltaY_;
00485 double * deltaZ_;
00487 double * deltaW_;
00489 double * deltaSU_;
00490 double * deltaSL_;
00492 double * primalR_;
00494 double * dualR_;
00496 double * rhsB_;
00498 double * rhsU_;
00500 double * rhsL_;
00502 double * rhsZ_;
00504 double * rhsW_;
00506 double * rhsC_;
00508 double * zVec_;
00510 double * wVec_;
00512 ClpCholeskyBase * cholesky_;
00514 int numberComplementarityPairs_;
00516 int numberComplementarityItems_;
00518 int maximumBarrierIterations_;
00520 bool gonePrimalFeasible_;
00522 bool goneDualFeasible_;
00524 int algorithm_;
00526 };
00527
00536 void
00537 ClpInteriorUnitTest(const std::string & mpsDir,
00538 const std::string & netlibDir);
00539
00540
00541 #endif