path: root/build/Bonmin/include/coin/ClpInterior.hpp

/* $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;
/// ******** DATA to be moved into protected section of ClpInterior
typedef struct {
     double  atolmin;
     double  r3norm;
     double  LSdamp;
     double* deltay;
} Info;
/// ******** DATA to be moved into protected section of ClpInterior

typedef struct {
     double  atolold;
     double  atolnew;
     double  r3ratio;
     int   istop;
     int   itncg;
} Outfo;
/// ******** DATA to be moved into protected section of ClpInterior

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
/** This solves LPs using interior point methods

    It inherits from ClpModel and all its arrays are created at
    algorithm time.

*/

class ClpInterior : public ClpModel {
     friend void ClpInteriorUnitTest(const std::string & mpsDir,
                                     const std::string & netlibDir);

public:

     /**@name Constructors and destructor and copy */
     //@{
     /// Default constructor
     ClpInterior (  );

     /// Copy constructor.
     ClpInterior(const ClpInterior &);
     /// Copy constructor from model.
     ClpInterior(const ClpModel &);
     /** Subproblem constructor.  A subset of whole model is created from the
         row and column lists given.  The new order is given by list order and
         duplicates are allowed.  Name and integer information can be dropped
     */
     ClpInterior (const ClpModel * wholeModel,
                  int numberRows, const int * whichRows,
                  int numberColumns, const int * whichColumns,
                  bool dropNames = true, bool dropIntegers = true);
     /// Assignment operator. This copies the data
     ClpInterior & operator=(const ClpInterior & rhs);
     /// Destructor
     ~ClpInterior (  );
     // Ones below are just ClpModel with some changes
     /** Loads a problem (the constraints on the
           rows are given by lower and upper bounds). If a pointer is 0 then the
           following values are the default:
           <ul>
             <li> <code>colub</code>: all columns have upper bound infinity
             <li> <code>collb</code>: all columns have lower bound 0
             <li> <code>rowub</code>: all rows have upper bound infinity
             <li> <code>rowlb</code>: all rows have lower bound -infinity
         <li> <code>obj</code>: all variables have 0 objective coefficient
           </ul>
       */
     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);

     /** Just like the other loadProblem() method except that the matrix is
       given in a standard column major ordered format (without gaps). */
     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);
     /// This one is for after presolve to save memory
     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);
     /// Read an mps file from the given filename
     int readMps(const char *filename,
                 bool keepNames = false,
                 bool ignoreErrors = false);
     /** Borrow model.  This is so we dont have to copy large amounts
         of data around.  It assumes a derived class wants to overwrite
         an empty model with a real one - while it does an algorithm.
         This is same as ClpModel one. */
     void borrowModel(ClpModel & otherModel);
     /** Return model - updates any scalars */
     void returnModel(ClpModel & otherModel);
     //@}

     /**@name Functions most useful to user */
     //@{
     /** Pdco algorithm - see ClpPdco.hpp for method */
     int pdco();
     // ** Temporary version
     int  pdco( ClpPdcoBase * stuff, Options &options, Info &info, Outfo &outfo);
     /// Primal-Dual Predictor-Corrector barrier
     int primalDual();
     //@}

     /**@name most useful gets and sets */
     //@{
     /// If problem is primal feasible
     inline bool primalFeasible() const {
          return (sumPrimalInfeasibilities_ <= 1.0e-5);
     }
     /// If problem is dual feasible
     inline bool dualFeasible() const {
          return (sumDualInfeasibilities_ <= 1.0e-5);
     }
     /// Current (or last) algorithm
     inline int algorithm() const {
          return algorithm_;
     }
     /// Set algorithm
     inline void setAlgorithm(int value) {
          algorithm_ = value;
     }
     /// Sum of dual infeasibilities
     inline CoinWorkDouble sumDualInfeasibilities() const {
          return sumDualInfeasibilities_;
     }
     /// Sum of primal infeasibilities
     inline CoinWorkDouble sumPrimalInfeasibilities() const {
          return sumPrimalInfeasibilities_;
     }
     /// dualObjective.
     inline CoinWorkDouble dualObjective() const {
          return dualObjective_;
     }
     /// primalObjective.
     inline CoinWorkDouble primalObjective() const {
          return primalObjective_;
     }
     /// diagonalNorm
     inline CoinWorkDouble diagonalNorm() const {
          return diagonalNorm_;
     }
     /// linearPerturbation
     inline CoinWorkDouble linearPerturbation() const {
          return linearPerturbation_;
     }
     inline void setLinearPerturbation(CoinWorkDouble value) {
          linearPerturbation_ = value;
     }
     /// projectionTolerance
     inline CoinWorkDouble projectionTolerance() const {
          return projectionTolerance_;
     }
     inline void setProjectionTolerance(CoinWorkDouble value) {
          projectionTolerance_ = value;
     }
     /// diagonalPerturbation
     inline CoinWorkDouble diagonalPerturbation() const {
          return diagonalPerturbation_;
     }
     inline void setDiagonalPerturbation(CoinWorkDouble value) {
          diagonalPerturbation_ = value;
     }
     /// gamma
     inline CoinWorkDouble gamma() const {
          return gamma_;
     }
     inline void setGamma(CoinWorkDouble value) {
          gamma_ = value;
     }
     /// delta
     inline CoinWorkDouble delta() const {
          return delta_;
     }
     inline void setDelta(CoinWorkDouble value) {
          delta_ = value;
     }
     /// ComplementarityGap
     inline CoinWorkDouble complementarityGap() const {
          return complementarityGap_;
     }
     //@}

     /**@name most useful gets and sets */
     //@{
     /// Largest error on Ax-b
     inline CoinWorkDouble largestPrimalError() const {
          return largestPrimalError_;
     }
     /// Largest error on basic duals
     inline CoinWorkDouble largestDualError() const {
          return largestDualError_;
     }
     /// Maximum iterations
     inline int maximumBarrierIterations() const {
          return maximumBarrierIterations_;
     }
     inline void setMaximumBarrierIterations(int value) {
          maximumBarrierIterations_ = value;
     }
     /// Set cholesky (and delete present one)
     void setCholesky(ClpCholeskyBase * cholesky);
     /// Return number fixed to see if worth presolving
     int numberFixed() const;
     /** fix variables interior says should be.  If reallyFix false then just
         set values to exact bounds */
     void fixFixed(bool reallyFix = true);
     /// Primal erturbation vector
     inline CoinWorkDouble * primalR() const {
          return primalR_;
     }
     /// Dual erturbation vector
     inline CoinWorkDouble * dualR() const {
          return dualR_;
     }
     //@}

protected:
     /**@name protected methods */
     //@{
     /// Does most of deletion
     void gutsOfDelete();
     /// Does most of copying
     void gutsOfCopy(const ClpInterior & rhs);
     /// Returns true if data looks okay, false if not
     bool createWorkingData();
     void deleteWorkingData();
     /// Sanity check on input rim data
     bool sanityCheck();
     ///  This does housekeeping
     int housekeeping();
     //@}
public:
     /**@name public methods */
     //@{
     /// Raw objective value (so always minimize)
     inline CoinWorkDouble rawObjectiveValue() const {
          return objectiveValue_;
     }
     /// Returns 1 if sequence indicates column
     inline int isColumn(int sequence) const {
          return sequence < numberColumns_ ? 1 : 0;
     }
     /// Returns sequence number within section
     inline int sequenceWithin(int sequence) const {
          return sequence < numberColumns_ ? sequence : sequence - numberColumns_;
     }
     /// Checks solution
     void checkSolution();
     /** Modifies djs to allow for quadratic.
         returns quadratic offset */
     CoinWorkDouble quadraticDjs(CoinWorkDouble * djRegion, const CoinWorkDouble * solution,
                                 CoinWorkDouble scaleFactor);

     /// To say a variable is fixed
     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);
     }

     /// To flag a variable
     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);
     }

     /// To say a variable is fixed OR free
     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);
     }

     /// To say a variable has lower bound
     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);
     }

     /// To say a variable has upper bound
     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);
     }

     /// To say a variable has fake lower bound
     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);
     }

     /// To say a variable has fake upper bound
     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);
     }
     //@}

////////////////// data //////////////////
protected:

     /**@name data.  Many arrays have a row part and a column part.
      There is a single array with both - columns then rows and
      then normally two arrays pointing to rows and columns.  The
      single array is the owner of memory
     */
     //@{
     /// Largest error on Ax-b
     CoinWorkDouble largestPrimalError_;
     /// Largest error on basic duals
     CoinWorkDouble largestDualError_;
     /// Sum of dual infeasibilities
     CoinWorkDouble sumDualInfeasibilities_;
     /// Sum of primal infeasibilities
     CoinWorkDouble sumPrimalInfeasibilities_;
     /// Worst complementarity
     CoinWorkDouble worstComplementarity_;
     ///
public:
     CoinWorkDouble xsize_;
     CoinWorkDouble zsize_;
protected:
     /// Working copy of lower bounds (Owner of arrays below)
     CoinWorkDouble * lower_;
     /// Row lower bounds - working copy
     CoinWorkDouble * rowLowerWork_;
     /// Column lower bounds - working copy
     CoinWorkDouble * columnLowerWork_;
     /// Working copy of upper bounds (Owner of arrays below)
     CoinWorkDouble * upper_;
     /// Row upper bounds - working copy
     CoinWorkDouble * rowUpperWork_;
     /// Column upper bounds - working copy
     CoinWorkDouble * columnUpperWork_;
     /// Working copy of objective
     CoinWorkDouble * cost_;
public:
     /// Rhs
     CoinWorkDouble * rhs_;
     CoinWorkDouble * x_;
     CoinWorkDouble * y_;
     CoinWorkDouble * dj_;
protected:
     /// Pointer to Lsqr object
     ClpLsqr * lsqrObject_;
     /// Pointer to stuff
     ClpPdcoBase * pdcoStuff_;
     /// Below here is standard barrier stuff
     /// mu.
     CoinWorkDouble mu_;
     /// objectiveNorm.
     CoinWorkDouble objectiveNorm_;
     /// rhsNorm.
     CoinWorkDouble rhsNorm_;
     /// solutionNorm.
     CoinWorkDouble solutionNorm_;
     /// dualObjective.
     CoinWorkDouble dualObjective_;
     /// primalObjective.
     CoinWorkDouble primalObjective_;
     /// diagonalNorm.
     CoinWorkDouble diagonalNorm_;
     /// stepLength
     CoinWorkDouble stepLength_;
     /// linearPerturbation
     CoinWorkDouble linearPerturbation_;
     /// diagonalPerturbation
     CoinWorkDouble diagonalPerturbation_;
     // gamma from Saunders and Tomlin regularized
     CoinWorkDouble gamma_;
     // delta from Saunders and Tomlin regularized
     CoinWorkDouble delta_;
     /// targetGap
     CoinWorkDouble targetGap_;
     /// projectionTolerance
     CoinWorkDouble projectionTolerance_;
     /// maximumRHSError.  maximum Ax
     CoinWorkDouble maximumRHSError_;
     /// maximumBoundInfeasibility.
     CoinWorkDouble maximumBoundInfeasibility_;
     /// maximumDualError.
     CoinWorkDouble maximumDualError_;
     /// diagonalScaleFactor.
     CoinWorkDouble diagonalScaleFactor_;
     /// scaleFactor.  For scaling objective
     CoinWorkDouble scaleFactor_;
     /// actualPrimalStep
     CoinWorkDouble actualPrimalStep_;
     /// actualDualStep
     CoinWorkDouble actualDualStep_;
     /// smallestInfeasibility
     CoinWorkDouble smallestInfeasibility_;
     /// historyInfeasibility.
#define LENGTH_HISTORY 5
     CoinWorkDouble historyInfeasibility_[LENGTH_HISTORY];
     /// complementarityGap.
     CoinWorkDouble complementarityGap_;
     /// baseObjectiveNorm
     CoinWorkDouble baseObjectiveNorm_;
     /// worstDirectionAccuracy
     CoinWorkDouble worstDirectionAccuracy_;
     /// maximumRHSChange
     CoinWorkDouble maximumRHSChange_;
     /// errorRegion. i.e. Ax
     CoinWorkDouble * errorRegion_;
     /// rhsFixRegion.
     CoinWorkDouble * rhsFixRegion_;
     /// upperSlack
     CoinWorkDouble * upperSlack_;
     /// lowerSlack
     CoinWorkDouble * lowerSlack_;
     /// diagonal
     CoinWorkDouble * diagonal_;
     /// solution
     CoinWorkDouble * solution_;
     /// work array
     CoinWorkDouble * workArray_;
     /// delta X
     CoinWorkDouble * deltaX_;
     /// delta Y
     CoinWorkDouble * deltaY_;
     /// deltaZ.
     CoinWorkDouble * deltaZ_;
     /// deltaW.
     CoinWorkDouble * deltaW_;
     /// deltaS.
     CoinWorkDouble * deltaSU_;
     CoinWorkDouble * deltaSL_;
     /// Primal regularization array
     CoinWorkDouble * primalR_;
     /// Dual regularization array
     CoinWorkDouble * dualR_;
     /// rhs B
     CoinWorkDouble * rhsB_;
     /// rhsU.
     CoinWorkDouble * rhsU_;
     /// rhsL.
     CoinWorkDouble * rhsL_;
     /// rhsZ.
     CoinWorkDouble * rhsZ_;
     /// rhsW.
     CoinWorkDouble * rhsW_;
     /// rhs C
     CoinWorkDouble * rhsC_;
     /// zVec
     CoinWorkDouble * zVec_;
     /// wVec
     CoinWorkDouble * wVec_;
     /// cholesky.
     ClpCholeskyBase * cholesky_;
     /// numberComplementarityPairs i.e. ones with lower and/or upper bounds (not fixed)
     int numberComplementarityPairs_;
     /// numberComplementarityItems_ i.e. number of active bounds
     int numberComplementarityItems_;
     /// Maximum iterations
     int maximumBarrierIterations_;
     /// gonePrimalFeasible.
     bool gonePrimalFeasible_;
     /// goneDualFeasible.
     bool goneDualFeasible_;
     /// Which algorithm being used
     int algorithm_;
     //@}
};
//#############################################################################
/** A function that tests the methods in the ClpInterior class. The
    only reason for it not to be a member method is that this way it doesn't
    have to be compiled into the library. And that's a gain, because the
    library should be compiled with optimization on, but this method should be
    compiled with debugging.

    It also does some testing of ClpFactorization class
 */
void
ClpInteriorUnitTest(const std::string & mpsDir,
                    const std::string & netlibDir);


#endif