/home/coin/SVN-release/CoinAll-1.1.0/Clp/src/ClpGubMatrix.hpp

Go to the documentation of this file.

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


#include "CoinPragma.hpp"

#include "ClpPackedMatrix.hpp"
class ClpSimplex;
class ClpGubMatrix : public ClpPackedMatrix {
  
public:
  virtual ClpMatrixBase * reverseOrderedCopy() const;
  virtual CoinBigIndex countBasis(ClpSimplex * model,
                                 const int * whichColumn, 
                                 int numberRowBasic,
                                  int & numberColumnBasic);
  virtual void fillBasis(ClpSimplex * model,
                                 const int * whichColumn, 
                                 int & numberColumnBasic,
                                 int * row, int * start,
                                 int * rowCount, int * columnCount,
                                 double * element);
  virtual void unpack(const ClpSimplex * model,CoinIndexedVector * rowArray,
                   int column) const ;
  virtual void unpackPacked(ClpSimplex * model,
                            CoinIndexedVector * rowArray,
                            int column) const;
  virtual void add(const ClpSimplex * model,CoinIndexedVector * rowArray,
                   int column, double multiplier) const ;
  virtual void add(const ClpSimplex * model,double * array,
                   int column, double multiplier) const;
  virtual void partialPricing(ClpSimplex * model, double start, double end,
                      int & bestSequence, int & numberWanted);
  virtual int hiddenRows() const;


  using ClpPackedMatrix::transposeTimes ;
  virtual void transposeTimes(const ClpSimplex * model, double scalar,
                              const CoinIndexedVector * x,
                              CoinIndexedVector * y,
                              CoinIndexedVector * z) const;
  virtual void transposeTimesByRow(const ClpSimplex * model, double scalar,
                              const CoinIndexedVector * x,
                              CoinIndexedVector * y,
                              CoinIndexedVector * z) const;
  virtual void subsetTransposeTimes(const ClpSimplex * model,
                                    const CoinIndexedVector * x,
                                    const CoinIndexedVector * y,
                                    CoinIndexedVector * z) const;
  virtual int extendUpdated(ClpSimplex * model,CoinIndexedVector * update,int mode);
  virtual void primalExpanded(ClpSimplex * model,int mode);
  virtual void dualExpanded(ClpSimplex * model,CoinIndexedVector * array,
                            double * other,int mode);
  virtual int generalExpanded(ClpSimplex * model,int mode,int & number);
  virtual int updatePivot(ClpSimplex * model,double oldInValue, double oldOutValue);
  virtual void useEffectiveRhs(ClpSimplex * model,bool cheapest=true);
  virtual double * rhsOffset(ClpSimplex * model,bool forceRefresh=false,
                                bool check=false);
  virtual int synchronize(ClpSimplex * model,int mode);
  virtual void correctSequence(const ClpSimplex * model,int & sequenceIn, int & sequenceOut) ;



   ClpGubMatrix();
   virtual ~ClpGubMatrix();

   ClpGubMatrix(const ClpGubMatrix&);
   ClpGubMatrix(const CoinPackedMatrix&);
  ClpGubMatrix (const ClpGubMatrix & wholeModel,
                    int numberRows, const int * whichRows,
                    int numberColumns, const int * whichColumns);
  ClpGubMatrix (const CoinPackedMatrix & wholeModel,
                    int numberRows, const int * whichRows,
                    int numberColumns, const int * whichColumns);

   ClpGubMatrix(CoinPackedMatrix * matrix);

   ClpGubMatrix(ClpPackedMatrix * matrix, int numberSets,
                const int * start, const int * end,
                const double * lower, const double * upper,
                const unsigned char * status=NULL);

   ClpGubMatrix& operator=(const ClpGubMatrix&);
  virtual ClpMatrixBase * clone() const ;
  virtual ClpMatrixBase * subsetClone (
                    int numberRows, const int * whichRows,
                    int numberColumns, const int * whichColumns) const ;
  void redoSet(ClpSimplex * model,int newKey, int oldKey, int iSet); 


  inline ClpSimplex::Status getStatus(int sequence) const
  {return static_cast<ClpSimplex::Status> (status_[sequence]&7);}
  inline void setStatus(int sequence, ClpSimplex::Status status)
  {
    unsigned char & st_byte = status_[sequence];
    st_byte &= ~7;
    st_byte |= status;
  }
  inline void setFlagged( int sequence)
  {
    status_[sequence] |= 64;
  }
  inline void clearFlagged( int sequence)
  {
    status_[sequence] &= ~64;
  }
  inline bool flagged(int sequence) const
  {return ((status_[sequence]&64)!=0);}
  inline void setAbove( int sequence)
  {
    unsigned char iStat = status_[sequence];
    iStat &= ~24;
    status_[sequence] = iStat|16;
  }
  inline void setFeasible( int sequence)
  {
    unsigned char iStat = status_[sequence];
    iStat &= ~24;
    status_[sequence] = iStat|8;
  }
  inline void setBelow( int sequence)
  {
    unsigned char iStat = status_[sequence];
    iStat &= ~24;
    status_[sequence] = iStat;
  }
  inline double weight( int sequence) const
  {
    int iStat = status_[sequence]&31;
    iStat = iStat>>3;
    return (double) (iStat-1);
  }
  inline int * start() const
  { return start_;}
  inline int * end() const
  { return end_;}
  inline double * lower() const
  { return lower_;}
  inline double * upper() const
  { return upper_;}
  inline int * keyVariable() const
  { return keyVariable_;}
  inline int * backward() const
  { return backward_;}
  inline int numberSets() const
  { return numberSets_;}
  void switchOffCheck();
   
    
protected:

  double sumDualInfeasibilities_;
  double sumPrimalInfeasibilities_;
  double sumOfRelaxedDualInfeasibilities_;
  double sumOfRelaxedPrimalInfeasibilities_;
  double infeasibilityWeight_;
  int * start_;
  int * end_;
  double * lower_;
  double * upper_;
  mutable unsigned char * status_;
  unsigned char * saveStatus_;
  int * savedKeyVariable_;
  int * backward_;
  int * backToPivotRow_;
  double * changeCost_;
  mutable int * keyVariable_;
  mutable int * next_;
  int * toIndex_;
  // Reverse pointer from index to set
  int * fromIndex_; 
  ClpSimplex * model_;
  int numberDualInfeasibilities_;
  int numberPrimalInfeasibilities_;
  int noCheck_;
  int numberSets_;
  int saveNumber_;
  int possiblePivotKey_;
  int gubSlackIn_;
  int firstGub_;
  int lastGub_;
  int gubType_;
};

#endif

---