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

Go to the documentation of this file.

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


#include "CoinPragma.hpp"

#include "ClpPackedMatrix.hpp"
class ClpSimplex;
class ClpDynamicMatrix : public ClpPackedMatrix {
  
public:
  enum DynamicStatus {
    soloKey = 0x00,
    inSmall = 0x01,
    atUpperBound = 0x02,
    atLowerBound = 0x03
  };

  virtual void partialPricing(ClpSimplex * model, double start, double end,
                      int & bestSequence, int & numberWanted);

  virtual int updatePivot(ClpSimplex * model,double oldInValue, double oldOutValue);
  virtual double * rhsOffset(ClpSimplex * model,bool forceRefresh=false,
                                bool check=false);

  using ClpPackedMatrix::times ;
  virtual void times(double scalar,
                       const double * x, double * y) const;
  void modifyOffset(int sequence, double amount);
  double keyValue(int iSet) const;
  virtual void dualExpanded(ClpSimplex * model,CoinIndexedVector * array,
                            double * other,int mode);
  virtual int generalExpanded(ClpSimplex * model,int mode,int & number);
  virtual int refresh(ClpSimplex * model);
  virtual void createVariable(ClpSimplex * model, int & bestSequence);
  virtual double reducedCost( ClpSimplex * model,int sequence) const;
  void gubCrash();
  void initialProblem();
  int addColumn(int numberEntries,const int * row, const double * element,
                 double cost, double lower, double upper, int iSet,
                 DynamicStatus status);
  virtual void packDown(const int * in, int numberToPack) {}
  inline double columnLower(int sequence) const
  { if (columnLower_) return columnLower_[sequence]; else return 0.0;}
  inline double columnUpper(int sequence) const
  { if (columnUpper_) return columnUpper_[sequence]; else return COIN_DBL_MAX;}




   ClpDynamicMatrix();
  ClpDynamicMatrix(ClpSimplex * model, int numberSets,
                   int numberColumns, const int * starts,
                   const double * lower, const double * upper,
                   const int * startColumn, const int * row,
                   const double * element, const double * cost,
                   const double * columnLower=NULL, const double * columnUpper=NULL,
                   const unsigned char * status=NULL,
                   const unsigned char * dynamicStatus=NULL);
  
   virtual ~ClpDynamicMatrix();

   ClpDynamicMatrix(const ClpDynamicMatrix&);
   ClpDynamicMatrix(const CoinPackedMatrix&);

   ClpDynamicMatrix& operator=(const ClpDynamicMatrix&);
  virtual ClpMatrixBase * clone() const ;


  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 int numberSets() const
  { return numberSets_;}
  inline bool flagged(int i) const {
    return (dynamicStatus_[i]&8)!=0;
  }
  inline void setFlagged(int i) {
    dynamicStatus_[i] |= 8;
  }
  inline void unsetFlagged(int i) {
    dynamicStatus_[i]  &= ~8;;
  }
  inline void setDynamicStatus(int sequence, DynamicStatus status)
  {
    unsigned char & st_byte = dynamicStatus_[sequence];
    st_byte &= ~7;
    st_byte |= status;
  }
  inline DynamicStatus getDynamicStatus(int sequence) const
  {return static_cast<DynamicStatus> (dynamicStatus_[sequence]&7);}
  inline double objectiveOffset() const
  { return objectiveOffset_;}
  inline CoinBigIndex * startColumn() const
  { return startColumn_;}
  inline int * row() const
  { return row_;}
  inline double * element() const
  { return element_;}
  inline double * cost() const
  { return cost_;}
  inline int * id() const
  { return id_;}
  inline double * columnLower() const
  { return columnLower_;}
  inline double * columnUpper() const
  { return columnUpper_;}
  inline double * lowerSet() const
  { return lowerSet_;}
  inline double * upperSet() const
  { return upperSet_;}
  inline int numberGubColumns() const
  { return numberGubColumns_;}
  inline int firstAvailable() const
  { return firstAvailable_;}
  inline int firstDynamic() const
  { return firstDynamic_;}
  inline int lastDynamic() const
  { return lastDynamic_;}
  inline int numberStaticRows() const
  { return numberStaticRows_;}
  inline int numberElements() const
  { return numberElements_;}
  inline int * keyVariable() const
  { return keyVariable_;}
  void switchOffCheck();
  inline unsigned char * gubRowStatus() const
  { return status_;}
  inline unsigned char * dynamicStatus() const
  { return dynamicStatus_;}
  int whichSet (int sequence) const;
   
    
protected:

  double sumDualInfeasibilities_;
  double sumPrimalInfeasibilities_;
  double sumOfRelaxedDualInfeasibilities_;
  double sumOfRelaxedPrimalInfeasibilities_;
  double savedBestGubDual_;
  int savedBestSet_;
  int * backToPivotRow_;
  mutable int * keyVariable_;
  int * toIndex_;
  // Reverse pointer from index to set
  int * fromIndex_; 
  int numberSets_;
  int numberActiveSets_;
  double objectiveOffset_;
  double * lowerSet_;
  double * upperSet_;
  unsigned char * status_;
  ClpSimplex * model_;
  int firstAvailable_;
  int firstAvailableBefore_;
  int firstDynamic_;
  int lastDynamic_;
  int numberStaticRows_;
  int numberElements_;
  int numberDualInfeasibilities_;
  int numberPrimalInfeasibilities_;
  int noCheck_;
  double infeasibilityWeight_;
  int numberGubColumns_;
  int maximumGubColumns_;
  int maximumElements_;
  int * startSet_;
  int * next_;
  CoinBigIndex * startColumn_;
  int * row_;
  double * element_;
  double * cost_;
  int * id_;
  unsigned char * dynamicStatus_;
  double * columnLower_;
  double * columnUpper_;
};

#endif

---