ClpInterior.hpp

Go to the documentation of this file.

/* $Id: ClpInterior.hpp 1665 2011-01-04 17:55:54Z lou $ */
// Copyright (C) 2003, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).
/*
   Authors
 
   John Tomlin (pdco)
   John Forrest (standard predictor-corrector)
 
   Note JJF has added arrays - this takes more memory but makes
   flow easier to understand and hopefully easier to extend
 
 */
#ifndef ClpInterior_H
#define ClpInterior_H
 
#include <iostream>
#include <cfloat>
#include "ClpModel.hpp"
#include "ClpMatrixBase.hpp"
#include "ClpSolve.hpp"
#include "CoinDenseVector.hpp"
class ClpLsqr;
class ClpPdcoBase;
typedef struct {
     double  atolmin;
     double  r3norm;
     double  LSdamp;
     double* deltay;
} Info;
 
typedef struct {
     double  atolold;
     double  atolnew;
     double  r3ratio;
     int   istop;
     int   itncg;
} Outfo;
 
typedef struct {
     double  gamma;
     double  delta;
     int MaxIter;
     double  FeaTol;
     double  OptTol;
     double  StepTol;
     double  x0min;
     double  z0min;
     double  mu0;
     int   LSmethod;   // 1=Cholesky    2=QR    3=LSQR
     int   LSproblem;  // See below
     int LSQRMaxIter;
     double  LSQRatol1; // Initial  atol
     double  LSQRatol2; // Smallest atol (unless atol1 is smaller)
     double  LSQRconlim;
     int  wait;
} Options;
class Lsqr;
class ClpCholeskyBase;
// ***** END
class ClpInterior : public ClpModel {
     friend void ClpInteriorUnitTest(const std::string & mpsDir,
                                     const std::string & netlibDir);
 
public:
 
     ClpInterior (  );
 
     ClpInterior(const ClpInterior &);
     ClpInterior(const ClpModel &);
     ClpInterior (const ClpModel * wholeModel,
                  int numberRows, const int * whichRows,
                  int numberColumns, const int * whichColumns,
                  bool dropNames = true, bool dropIntegers = true);
     ClpInterior & operator=(const ClpInterior & rhs);
     ~ClpInterior (  );
     // Ones below are just ClpModel with some changes
     void loadProblem (  const ClpMatrixBase& matrix,
                         const double* collb, const double* colub,
                         const double* obj,
                         const double* rowlb, const double* rowub,
                         const double * rowObjective = NULL);
     void loadProblem (  const CoinPackedMatrix& matrix,
                         const double* collb, const double* colub,
                         const double* obj,
                         const double* rowlb, const double* rowub,
                         const double * rowObjective = NULL);
 
     void loadProblem (  const int numcols, const int numrows,
                         const CoinBigIndex* start, const int* index,
                         const double* value,
                         const double* collb, const double* colub,
                         const double* obj,
                         const double* rowlb, const double* rowub,
                         const double * rowObjective = NULL);
     void loadProblem (  const int numcols, const int numrows,
                         const CoinBigIndex* start, const int* index,
                         const double* value, const int * length,
                         const double* collb, const double* colub,
                         const double* obj,
                         const double* rowlb, const double* rowub,
                         const double * rowObjective = NULL);
     int readMps(const char *filename,
                 bool keepNames = false,
                 bool ignoreErrors = false);
     void borrowModel(ClpModel & otherModel);
     void returnModel(ClpModel & otherModel);
 
     int pdco();
     // ** Temporary version
     int  pdco( ClpPdcoBase * stuff, Options &options, Info &info, Outfo &outfo);
     int primalDual();
 
     inline bool primalFeasible() const {
          return (sumPrimalInfeasibilities_ <= 1.0e-5);
     }
     inline bool dualFeasible() const {
          return (sumDualInfeasibilities_ <= 1.0e-5);
     }
     inline int algorithm() const {
          return algorithm_;
     }
     inline void setAlgorithm(int value) {
          algorithm_ = value;
     }
     inline CoinWorkDouble sumDualInfeasibilities() const {
          return sumDualInfeasibilities_;
     }
     inline CoinWorkDouble sumPrimalInfeasibilities() const {
          return sumPrimalInfeasibilities_;
     }
     inline CoinWorkDouble dualObjective() const {
          return dualObjective_;
     }
     inline CoinWorkDouble primalObjective() const {
          return primalObjective_;
     }
     inline CoinWorkDouble diagonalNorm() const {
          return diagonalNorm_;
     }
     inline CoinWorkDouble linearPerturbation() const {
          return linearPerturbation_;
     }
     inline void setLinearPerturbation(CoinWorkDouble value) {
          linearPerturbation_ = value;
     }
     inline CoinWorkDouble projectionTolerance() const {
          return projectionTolerance_;
     }
     inline void setProjectionTolerance(CoinWorkDouble value) {
          projectionTolerance_ = value;
     }
     inline CoinWorkDouble diagonalPerturbation() const {
          return diagonalPerturbation_;
     }
     inline void setDiagonalPerturbation(CoinWorkDouble value) {
          diagonalPerturbation_ = value;
     }
     inline CoinWorkDouble gamma() const {
          return gamma_;
     }
     inline void setGamma(CoinWorkDouble value) {
          gamma_ = value;
     }
     inline CoinWorkDouble delta() const {
          return delta_;
     }
     inline void setDelta(CoinWorkDouble value) {
          delta_ = value;
     }
     inline CoinWorkDouble complementarityGap() const {
          return complementarityGap_;
     }
 
     inline CoinWorkDouble largestPrimalError() const {
          return largestPrimalError_;
     }
     inline CoinWorkDouble largestDualError() const {
          return largestDualError_;
     }
     inline int maximumBarrierIterations() const {
          return maximumBarrierIterations_;
     }
     inline void setMaximumBarrierIterations(int value) {
          maximumBarrierIterations_ = value;
     }
     void setCholesky(ClpCholeskyBase * cholesky);
     int numberFixed() const;
     void fixFixed(bool reallyFix = true);
     inline CoinWorkDouble * primalR() const {
          return primalR_;
     }
     inline CoinWorkDouble * dualR() const {
          return dualR_;
     }
 
protected:
     void gutsOfDelete();
     void gutsOfCopy(const ClpInterior & rhs);
     bool createWorkingData();
     void deleteWorkingData();
     bool sanityCheck();
     int housekeeping();
public:
     inline CoinWorkDouble rawObjectiveValue() const {
          return objectiveValue_;
     }
     inline int isColumn(int sequence) const {
          return sequence < numberColumns_ ? 1 : 0;
     }
     inline int sequenceWithin(int sequence) const {
          return sequence < numberColumns_ ? sequence : sequence - numberColumns_;
     }
     void checkSolution();
     CoinWorkDouble quadraticDjs(CoinWorkDouble * djRegion, const CoinWorkDouble * solution,
                                 CoinWorkDouble scaleFactor);
 
     inline void setFixed( int sequence) {
          status_[sequence] = static_cast<unsigned char>(status_[sequence] | 1) ;
     }
     inline void clearFixed( int sequence) {
          status_[sequence] = static_cast<unsigned char>(status_[sequence] & ~1) ;
     }
     inline bool fixed(int sequence) const {
          return ((status_[sequence] & 1) != 0);
     }
 
     inline void setFlagged( int sequence) {
          status_[sequence] = static_cast<unsigned char>(status_[sequence] | 2) ;
     }
     inline void clearFlagged( int sequence) {
          status_[sequence] = static_cast<unsigned char>(status_[sequence] & ~2) ;
     }
     inline bool flagged(int sequence) const {
          return ((status_[sequence] & 2) != 0);
     }
 
     inline void setFixedOrFree( int sequence) {
          status_[sequence] = static_cast<unsigned char>(status_[sequence] | 4) ;
     }
     inline void clearFixedOrFree( int sequence) {
          status_[sequence] = static_cast<unsigned char>(status_[sequence] & ~4) ;
     }
     inline bool fixedOrFree(int sequence) const {
          return ((status_[sequence] & 4) != 0);
     }
 
     inline void setLowerBound( int sequence) {
          status_[sequence] = static_cast<unsigned char>(status_[sequence] | 8) ;
     }
     inline void clearLowerBound( int sequence) {
          status_[sequence] = static_cast<unsigned char>(status_[sequence] & ~8) ;
     }
     inline bool lowerBound(int sequence) const {
          return ((status_[sequence] & 8) != 0);
     }
 
     inline void setUpperBound( int sequence) {
          status_[sequence] = static_cast<unsigned char>(status_[sequence] | 16) ;
     }
     inline void clearUpperBound( int sequence) {
          status_[sequence] = static_cast<unsigned char>(status_[sequence] & ~16) ;
     }
     inline bool upperBound(int sequence) const {
          return ((status_[sequence] & 16) != 0);
     }
 
     inline void setFakeLower( int sequence) {
          status_[sequence] = static_cast<unsigned char>(status_[sequence] | 32) ;
     }
     inline void clearFakeLower( int sequence) {
          status_[sequence] = static_cast<unsigned char>(status_[sequence] & ~32) ;
     }
     inline bool fakeLower(int sequence) const {
          return ((status_[sequence] & 32) != 0);
     }
 
     inline void setFakeUpper( int sequence) {
          status_[sequence] = static_cast<unsigned char>(status_[sequence] | 64) ;
     }
     inline void clearFakeUpper( int sequence) {
          status_[sequence] = static_cast<unsigned char>(status_[sequence] & ~64) ;
     }
     inline bool fakeUpper(int sequence) const {
          return ((status_[sequence] & 64) != 0);
     }
 
protected:
 
     CoinWorkDouble largestPrimalError_;
     CoinWorkDouble largestDualError_;
     CoinWorkDouble sumDualInfeasibilities_;
     CoinWorkDouble sumPrimalInfeasibilities_;
     CoinWorkDouble worstComplementarity_;
public:
     CoinWorkDouble xsize_;
     CoinWorkDouble zsize_;
protected:
     CoinWorkDouble * lower_;
     CoinWorkDouble * rowLowerWork_;
     CoinWorkDouble * columnLowerWork_;
     CoinWorkDouble * upper_;
     CoinWorkDouble * rowUpperWork_;
     CoinWorkDouble * columnUpperWork_;
     CoinWorkDouble * cost_;
public:
     CoinWorkDouble * rhs_;
     CoinWorkDouble * x_;
     CoinWorkDouble * y_;
     CoinWorkDouble * dj_;
protected:
     ClpLsqr * lsqrObject_;
     ClpPdcoBase * pdcoStuff_;
     CoinWorkDouble mu_;
     CoinWorkDouble objectiveNorm_;
     CoinWorkDouble rhsNorm_;
     CoinWorkDouble solutionNorm_;
     CoinWorkDouble dualObjective_;
     CoinWorkDouble primalObjective_;
     CoinWorkDouble diagonalNorm_;
     CoinWorkDouble stepLength_;
     CoinWorkDouble linearPerturbation_;
     CoinWorkDouble diagonalPerturbation_;
     // gamma from Saunders and Tomlin regularized
     CoinWorkDouble gamma_;
     // delta from Saunders and Tomlin regularized
     CoinWorkDouble delta_;
     CoinWorkDouble targetGap_;
     CoinWorkDouble projectionTolerance_;
     CoinWorkDouble maximumRHSError_;
     CoinWorkDouble maximumBoundInfeasibility_;
     CoinWorkDouble maximumDualError_;
     CoinWorkDouble diagonalScaleFactor_;
     CoinWorkDouble scaleFactor_;
     CoinWorkDouble actualPrimalStep_;
     CoinWorkDouble actualDualStep_;
     CoinWorkDouble smallestInfeasibility_;
#define LENGTH_HISTORY 5
     CoinWorkDouble historyInfeasibility_[LENGTH_HISTORY];
     CoinWorkDouble complementarityGap_;
     CoinWorkDouble baseObjectiveNorm_;
     CoinWorkDouble worstDirectionAccuracy_;
     CoinWorkDouble maximumRHSChange_;
     CoinWorkDouble * errorRegion_;
     CoinWorkDouble * rhsFixRegion_;
     CoinWorkDouble * upperSlack_;
     CoinWorkDouble * lowerSlack_;
     CoinWorkDouble * diagonal_;
     CoinWorkDouble * solution_;
     CoinWorkDouble * workArray_;
     CoinWorkDouble * deltaX_;
     CoinWorkDouble * deltaY_;
     CoinWorkDouble * deltaZ_;
     CoinWorkDouble * deltaW_;
     CoinWorkDouble * deltaSU_;
     CoinWorkDouble * deltaSL_;
     CoinWorkDouble * primalR_;
     CoinWorkDouble * dualR_;
     CoinWorkDouble * rhsB_;
     CoinWorkDouble * rhsU_;
     CoinWorkDouble * rhsL_;
     CoinWorkDouble * rhsZ_;
     CoinWorkDouble * rhsW_;
     CoinWorkDouble * rhsC_;
     CoinWorkDouble * zVec_;
     CoinWorkDouble * wVec_;
     ClpCholeskyBase * cholesky_;
     int numberComplementarityPairs_;
     int numberComplementarityItems_;
     int maximumBarrierIterations_;
     bool gonePrimalFeasible_;
     bool goneDualFeasible_;
     int algorithm_;
};
//#############################################################################
void
ClpInteriorUnitTest(const std::string & mpsDir,
                    const std::string & netlibDir);
 
 
#endif