ClpInterior.hpp

// Copyright (C) 2003, International Business Machines
// Corporation and others.  All Rights Reserved.

/* 
   Authors
   
   John Tomlin (pdco)
   John Forrest (standard predictor-corrector)

 */
#ifndef ClpInterior_H
#define ClpInterior_H

#include <iostream>
#include <cfloat>
#include "ClpModel.hpp"
#include "ClpMatrixBase.hpp"
#include "ClpSolve.hpp"
class ClpLsqr;
class ClpPdcoBase;
// ******** DATA to be moved into protected section of ClpInterior
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);

  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 double sumDualInfeasibilities() const 
          { return sumDualInfeasibilities_;} ;
  inline double sumPrimalInfeasibilities() const 
          { return sumPrimalInfeasibilities_;} ;


  inline double largestPrimalError() const
          { return largestPrimalError_;} ;
  inline double largestDualError() const
          { return largestDualError_;} ;
  inline int maximumBarrierIterations() const
  { return maximumBarrierIterations_;};
  inline void setMaximumBarrierIterations(int value)
  { maximumBarrierIterations_=value;};

  protected:

  void gutsOfDelete();
  void gutsOfCopy(const ClpInterior & rhs);
  bool createWorkingData();
  void deleteWorkingData();
  bool sanityCheck();
  int housekeeping();
  public:

  inline double 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();

  inline void setFixed( int sequence)
  {
    status_[sequence] |= 1;
  };
  inline void clearFixed( int sequence)
  {
    status_[sequence] &= ~1;
  };
  inline bool fixed(int sequence) const
  {return ((status_[sequence]&1)!=0);};

  inline void setFlagged( int sequence)
  {
    status_[sequence] |= 2;
  };
  inline void clearFlagged( int sequence)
  {
    status_[sequence] &= ~2;
  };
  inline bool flagged(int sequence) const
  {return ((status_[sequence]&2)!=0);};

  inline void setFixedOrFree( int sequence)
  {
    status_[sequence] |= 4;
  };
  inline void clearFixedOrFree( int sequence)
  {
    status_[sequence] &= ~4;
  };
  inline bool fixedOrFree(int sequence) const
  {return ((status_[sequence]&4)!=0);};

  inline void setLowerBound( int sequence)
  {
    status_[sequence] |= 8;
  };
  inline void clearLowerBound( int sequence)
  {
    status_[sequence] &= ~8;
  };
  inline bool lowerBound(int sequence) const
  {return ((status_[sequence]&8)!=0);};

  inline void setUpperBound( int sequence)
  {
    status_[sequence] |= 16;
  };
  inline void clearUpperBound( int sequence)
  {
    status_[sequence] &= ~16;
  };
  inline bool upperBound(int sequence) const
  {return ((status_[sequence]&16)!=0);};

  inline void setFakeLower( int sequence)
  {
    status_[sequence] |= 32;
  };
  inline void clearFakeLower( int sequence)
  {
    status_[sequence] &= ~32;
  };
  inline bool fakeLower(int sequence) const
  {return ((status_[sequence]&32)!=0);};

  inline void setFakeUpper( int sequence)
  {
    status_[sequence] |= 64;
  };
  inline void clearFakeUpper( int sequence)
  {
    status_[sequence] &= ~64;
  };
  inline bool fakeUpper(int sequence) const
  {return ((status_[sequence]&64)!=0);};

protected:


  double largestPrimalError_;
  double largestDualError_;
  double sumDualInfeasibilities_;
  double sumPrimalInfeasibilities_;
  double worstComplementarity_;
public:
  double xsize_;
  double zsize_;
protected:
  double * lower_;
  double * rowLowerWork_;
  double * columnLowerWork_;
  double * upper_;
  double * rowUpperWork_;
  double * columnUpperWork_;
  double * cost_;
public:
  double * rhs_;
  double * x_;
  double * y_;
  double * dj_;
protected:
  ClpLsqr * lsqrObject_;
  ClpPdcoBase * pdcoStuff_;
  double mu_;
  double objectiveNorm_;
  double rhsNorm_;
  double solutionNorm_;
  double dualObjective_;
  double primalObjective_;
  double diagonalNorm_;
  double stepLength_;
  double linearPerturbation_;
  double diagonalPerturbation_;
  double targetGap_;
  double projectionTolerance_;
  double maximumRHSError_;
  double maximumBoundInfeasibility_;
  double maximumDualError_;
  double diagonalScaleFactor_;
  double scaleFactor_;
  double actualPrimalStep_;
  double actualDualStep_;
  double smallestInfeasibility_;
#define LENGTH_HISTORY 5
  double historyInfeasibility_[LENGTH_HISTORY];
  double complementarityGap_;
  double baseObjectiveNorm_;
  double worstDirectionAccuracy_;
  double maximumRHSChange_;
  double * errorRegion_;
  double * rhsFixRegion_;
  double * updateRegion_;
  double * upperSlack_;
  double * lowerSlack_;
  double * diagonal_;
  double * weights_;
  double * solution_;
  double * deltaZ_;
  double * deltaW_;
  double * deltaS_;
  double * deltaT_;
  double * zVec_;
  double * wVec_;
  ClpCholeskyBase * cholesky_;
  int numberComplementarityPairs_;
  int maximumBarrierIterations_;
  bool gonePrimalFeasible_;
  bool goneDualFeasible_;
  int algorithm_;
};
//#############################################################################
void
ClpInteriorUnitTest(const std::string & mpsDir,
                   const std::string & netlibDir);


#endif

---