/build/buildd/clp-1.12.0/Clp/src/ClpInterior.hpp
Go to the documentation of this file.
00001 /* $Id: ClpInterior.hpp 1525 2010-02-26 17:27:59Z mjs $ */
00002 // Copyright (C) 2003, International Business Machines
00003 // Corporation and others.  All Rights Reserved.
00004 
00005 /*
00006    Authors
00007 
00008    John Tomlin (pdco)
00009    John Forrest (standard predictor-corrector)
00010 
00011    Note JJF has added arrays - this takes more memory but makes
00012    flow easier to understand and hopefully easier to extend
00013 
00014  */
00015 #ifndef ClpInterior_H
00016 #define ClpInterior_H
00017 
00018 #include <iostream>
00019 #include <cfloat>
00020 #include "ClpModel.hpp"
00021 #include "ClpMatrixBase.hpp"
00022 #include "ClpSolve.hpp"
00023 #include "CoinDenseVector.hpp"
00024 class ClpLsqr;
00025 class ClpPdcoBase;
00027 typedef struct {
00028      double  atolmin;
00029      double  r3norm;
00030      double  LSdamp;
00031      double* deltay;
00032 } Info;
00034 
00035 typedef struct {
00036      double  atolold;
00037      double  atolnew;
00038      double  r3ratio;
00039      int   istop;
00040      int   itncg;
00041 } Outfo;
00043 
00044 typedef struct {
00045      double  gamma;
00046      double  delta;
00047      int MaxIter;
00048      double  FeaTol;
00049      double  OptTol;
00050      double  StepTol;
00051      double  x0min;
00052      double  z0min;
00053      double  mu0;
00054      int   LSmethod;   // 1=Cholesky    2=QR    3=LSQR
00055      int   LSproblem;  // See below
00056      int LSQRMaxIter;
00057      double  LSQRatol1; // Initial  atol
00058      double  LSQRatol2; // Smallest atol (unless atol1 is smaller)
00059      double  LSQRconlim;
00060      int  wait;
00061 } Options;
00062 class Lsqr;
00063 class ClpCholeskyBase;
00064 // ***** END
00072 class ClpInterior : public ClpModel {
00073      friend void ClpInteriorUnitTest(const std::string & mpsDir,
00074                                      const std::string & netlibDir);
00075 
00076 public:
00077 
00080 
00081      ClpInterior (  );
00082 
00084      ClpInterior(const ClpInterior &);
00086      ClpInterior(const ClpModel &);
00091      ClpInterior (const ClpModel * wholeModel,
00092                   int numberRows, const int * whichRows,
00093                   int numberColumns, const int * whichColumns,
00094                   bool dropNames = true, bool dropIntegers = true);
00096      ClpInterior & operator=(const ClpInterior & rhs);
00098      ~ClpInterior (  );
00099      // Ones below are just ClpModel with some changes
00111      void loadProblem (  const ClpMatrixBase& matrix,
00112                          const double* collb, const double* colub,
00113                          const double* obj,
00114                          const double* rowlb, const double* rowub,
00115                          const double * rowObjective = NULL);
00116      void loadProblem (  const CoinPackedMatrix& matrix,
00117                          const double* collb, const double* colub,
00118                          const double* obj,
00119                          const double* rowlb, const double* rowub,
00120                          const double * rowObjective = NULL);
00121 
00124      void loadProblem (  const int numcols, const int numrows,
00125                          const CoinBigIndex* start, const int* index,
00126                          const double* value,
00127                          const double* collb, const double* colub,
00128                          const double* obj,
00129                          const double* rowlb, const double* rowub,
00130                          const double * rowObjective = NULL);
00132      void loadProblem (  const int numcols, const int numrows,
00133                          const CoinBigIndex* start, const int* index,
00134                          const double* value, const int * length,
00135                          const double* collb, const double* colub,
00136                          const double* obj,
00137                          const double* rowlb, const double* rowub,
00138                          const double * rowObjective = NULL);
00140      int readMps(const char *filename,
00141                  bool keepNames = false,
00142                  bool ignoreErrors = false);
00147      void borrowModel(ClpModel & otherModel);
00149      void returnModel(ClpModel & otherModel);
00151 
00155      int pdco();
00156      // ** Temporary version
00157      int  pdco( ClpPdcoBase * stuff, Options &options, Info &info, Outfo &outfo);
00159      int primalDual();
00161 
00164 
00165      inline bool primalFeasible() const {
00166           return (sumPrimalInfeasibilities_ <= 1.0e-5);
00167      }
00169      inline bool dualFeasible() const {
00170           return (sumDualInfeasibilities_ <= 1.0e-5);
00171      }
00173      inline int algorithm() const {
00174           return algorithm_;
00175      }
00177      inline void setAlgorithm(int value) {
00178           algorithm_ = value;
00179      }
00181      inline CoinWorkDouble sumDualInfeasibilities() const {
00182           return sumDualInfeasibilities_;
00183      }
00185      inline CoinWorkDouble sumPrimalInfeasibilities() const {
00186           return sumPrimalInfeasibilities_;
00187      }
00189      inline CoinWorkDouble dualObjective() const {
00190           return dualObjective_;
00191      }
00193      inline CoinWorkDouble primalObjective() const {
00194           return primalObjective_;
00195      }
00197      inline CoinWorkDouble diagonalNorm() const {
00198           return diagonalNorm_;
00199      }
00201      inline CoinWorkDouble linearPerturbation() const {
00202           return linearPerturbation_;
00203      }
00204      inline void setLinearPerturbation(CoinWorkDouble value) {
00205           linearPerturbation_ = value;
00206      }
00208      inline CoinWorkDouble projectionTolerance() const {
00209           return projectionTolerance_;
00210      }
00211      inline void setProjectionTolerance(CoinWorkDouble value) {
00212           projectionTolerance_ = value;
00213      }
00215      inline CoinWorkDouble diagonalPerturbation() const {
00216           return diagonalPerturbation_;
00217      }
00218      inline void setDiagonalPerturbation(CoinWorkDouble value) {
00219           diagonalPerturbation_ = value;
00220      }
00222      inline CoinWorkDouble gamma() const {
00223           return gamma_;
00224      }
00225      inline void setGamma(CoinWorkDouble value) {
00226           gamma_ = value;
00227      }
00229      inline CoinWorkDouble delta() const {
00230           return delta_;
00231      }
00232      inline void setDelta(CoinWorkDouble value) {
00233           delta_ = value;
00234      }
00236      inline CoinWorkDouble complementarityGap() const {
00237           return complementarityGap_;
00238      }
00240 
00243 
00244      inline CoinWorkDouble largestPrimalError() const {
00245           return largestPrimalError_;
00246      }
00248      inline CoinWorkDouble largestDualError() const {
00249           return largestDualError_;
00250      }
00252      inline int maximumBarrierIterations() const {
00253           return maximumBarrierIterations_;
00254      }
00255      inline void setMaximumBarrierIterations(int value) {
00256           maximumBarrierIterations_ = value;
00257      }
00259      void setCholesky(ClpCholeskyBase * cholesky);
00261      int numberFixed() const;
00264      void fixFixed(bool reallyFix = true);
00266      inline CoinWorkDouble * primalR() const {
00267           return primalR_;
00268      }
00270      inline CoinWorkDouble * dualR() const {
00271           return dualR_;
00272      }
00274 
00275 protected:
00278 
00279      void gutsOfDelete();
00281      void gutsOfCopy(const ClpInterior & rhs);
00283      bool createWorkingData();
00284      void deleteWorkingData();
00286      bool sanityCheck();
00288      int housekeeping();
00290 public:
00293 
00294      inline CoinWorkDouble rawObjectiveValue() const {
00295           return objectiveValue_;
00296      }
00298      inline int isColumn(int sequence) const {
00299           return sequence < numberColumns_ ? 1 : 0;
00300      }
00302      inline int sequenceWithin(int sequence) const {
00303           return sequence < numberColumns_ ? sequence : sequence - numberColumns_;
00304      }
00306      void checkSolution();
00309      CoinWorkDouble quadraticDjs(CoinWorkDouble * djRegion, const CoinWorkDouble * solution,
00310                                  CoinWorkDouble scaleFactor);
00311 
00313      inline void setFixed( int sequence) {
00314           status_[sequence] = static_cast<unsigned char>(status_[sequence] | 1) ;
00315      }
00316      inline void clearFixed( int sequence) {
00317           status_[sequence] = static_cast<unsigned char>(status_[sequence] & ~1) ;
00318      }
00319      inline bool fixed(int sequence) const {
00320           return ((status_[sequence] & 1) != 0);
00321      }
00322 
00324      inline void setFlagged( int sequence) {
00325           status_[sequence] = static_cast<unsigned char>(status_[sequence] | 2) ;
00326      }
00327      inline void clearFlagged( int sequence) {
00328           status_[sequence] = static_cast<unsigned char>(status_[sequence] & ~2) ;
00329      }
00330      inline bool flagged(int sequence) const {
00331           return ((status_[sequence] & 2) != 0);
00332      }
00333 
00335      inline void setFixedOrFree( int sequence) {
00336           status_[sequence] = static_cast<unsigned char>(status_[sequence] | 4) ;
00337      }
00338      inline void clearFixedOrFree( int sequence) {
00339           status_[sequence] = static_cast<unsigned char>(status_[sequence] & ~4) ;
00340      }
00341      inline bool fixedOrFree(int sequence) const {
00342           return ((status_[sequence] & 4) != 0);
00343      }
00344 
00346      inline void setLowerBound( int sequence) {
00347           status_[sequence] = static_cast<unsigned char>(status_[sequence] | 8) ;
00348      }
00349      inline void clearLowerBound( int sequence) {
00350           status_[sequence] = static_cast<unsigned char>(status_[sequence] & ~8) ;
00351      }
00352      inline bool lowerBound(int sequence) const {
00353           return ((status_[sequence] & 8) != 0);
00354      }
00355 
00357      inline void setUpperBound( int sequence) {
00358           status_[sequence] = static_cast<unsigned char>(status_[sequence] | 16) ;
00359      }
00360      inline void clearUpperBound( int sequence) {
00361           status_[sequence] = static_cast<unsigned char>(status_[sequence] & ~16) ;
00362      }
00363      inline bool upperBound(int sequence) const {
00364           return ((status_[sequence] & 16) != 0);
00365      }
00366 
00368      inline void setFakeLower( int sequence) {
00369           status_[sequence] = static_cast<unsigned char>(status_[sequence] | 32) ;
00370      }
00371      inline void clearFakeLower( int sequence) {
00372           status_[sequence] = static_cast<unsigned char>(status_[sequence] & ~32) ;
00373      }
00374      inline bool fakeLower(int sequence) const {
00375           return ((status_[sequence] & 32) != 0);
00376      }
00377 
00379      inline void setFakeUpper( int sequence) {
00380           status_[sequence] = static_cast<unsigned char>(status_[sequence] | 64) ;
00381      }
00382      inline void clearFakeUpper( int sequence) {
00383           status_[sequence] = static_cast<unsigned char>(status_[sequence] & ~64) ;
00384      }
00385      inline bool fakeUpper(int sequence) const {
00386           return ((status_[sequence] & 64) != 0);
00387      }
00389 
00391 protected:
00392 
00399 
00400      CoinWorkDouble largestPrimalError_;
00402      CoinWorkDouble largestDualError_;
00404      CoinWorkDouble sumDualInfeasibilities_;
00406      CoinWorkDouble sumPrimalInfeasibilities_;
00408      CoinWorkDouble worstComplementarity_;
00410 public:
00411      CoinWorkDouble xsize_;
00412      CoinWorkDouble zsize_;
00413 protected:
00415      CoinWorkDouble * lower_;
00417      CoinWorkDouble * rowLowerWork_;
00419      CoinWorkDouble * columnLowerWork_;
00421      CoinWorkDouble * upper_;
00423      CoinWorkDouble * rowUpperWork_;
00425      CoinWorkDouble * columnUpperWork_;
00427      CoinWorkDouble * cost_;
00428 public:
00430      CoinWorkDouble * rhs_;
00431      CoinWorkDouble * x_;
00432      CoinWorkDouble * y_;
00433      CoinWorkDouble * dj_;
00434 protected:
00436      ClpLsqr * lsqrObject_;
00438      ClpPdcoBase * pdcoStuff_;
00441      CoinWorkDouble mu_;
00443      CoinWorkDouble objectiveNorm_;
00445      CoinWorkDouble rhsNorm_;
00447      CoinWorkDouble solutionNorm_;
00449      CoinWorkDouble dualObjective_;
00451      CoinWorkDouble primalObjective_;
00453      CoinWorkDouble diagonalNorm_;
00455      CoinWorkDouble stepLength_;
00457      CoinWorkDouble linearPerturbation_;
00459      CoinWorkDouble diagonalPerturbation_;
00460      // gamma from Saunders and Tomlin regularized
00461      CoinWorkDouble gamma_;
00462      // delta from Saunders and Tomlin regularized
00463      CoinWorkDouble delta_;
00465      CoinWorkDouble targetGap_;
00467      CoinWorkDouble projectionTolerance_;
00469      CoinWorkDouble maximumRHSError_;
00471      CoinWorkDouble maximumBoundInfeasibility_;
00473      CoinWorkDouble maximumDualError_;
00475      CoinWorkDouble diagonalScaleFactor_;
00477      CoinWorkDouble scaleFactor_;
00479      CoinWorkDouble actualPrimalStep_;
00481      CoinWorkDouble actualDualStep_;
00483      CoinWorkDouble smallestInfeasibility_;
00485 #define LENGTH_HISTORY 5
00486      CoinWorkDouble historyInfeasibility_[LENGTH_HISTORY];
00488      CoinWorkDouble complementarityGap_;
00490      CoinWorkDouble baseObjectiveNorm_;
00492      CoinWorkDouble worstDirectionAccuracy_;
00494      CoinWorkDouble maximumRHSChange_;
00496      CoinWorkDouble * errorRegion_;
00498      CoinWorkDouble * rhsFixRegion_;
00500      CoinWorkDouble * upperSlack_;
00502      CoinWorkDouble * lowerSlack_;
00504      CoinWorkDouble * diagonal_;
00506      CoinWorkDouble * solution_;
00508      CoinWorkDouble * workArray_;
00510      CoinWorkDouble * deltaX_;
00512      CoinWorkDouble * deltaY_;
00514      CoinWorkDouble * deltaZ_;
00516      CoinWorkDouble * deltaW_;
00518      CoinWorkDouble * deltaSU_;
00519      CoinWorkDouble * deltaSL_;
00521      CoinWorkDouble * primalR_;
00523      CoinWorkDouble * dualR_;
00525      CoinWorkDouble * rhsB_;
00527      CoinWorkDouble * rhsU_;
00529      CoinWorkDouble * rhsL_;
00531      CoinWorkDouble * rhsZ_;
00533      CoinWorkDouble * rhsW_;
00535      CoinWorkDouble * rhsC_;
00537      CoinWorkDouble * zVec_;
00539      CoinWorkDouble * wVec_;
00541      ClpCholeskyBase * cholesky_;
00543      int numberComplementarityPairs_;
00545      int numberComplementarityItems_;
00547      int maximumBarrierIterations_;
00549      bool gonePrimalFeasible_;
00551      bool goneDualFeasible_;
00553      int algorithm_;
00555 };
00556 //#############################################################################
00565 void
00566 ClpInteriorUnitTest(const std::string & mpsDir,
00567                     const std::string & netlibDir);
00568 
00569 
00570 #endif