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

Go to the documentation of this file.

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

#include "CoinPragma.hpp"

#include "ClpMatrixBase.hpp"

class ClpPackedMatrix2;
class ClpPackedMatrix3;
class ClpPackedMatrix : public ClpMatrixBase {
  
public:

  virtual CoinPackedMatrix * getPackedMatrix() const { return matrix_;}
    virtual bool isColOrdered() const { return matrix_->isColOrdered(); }
  virtual  CoinBigIndex getNumElements() const 
  { return matrix_->getNumElements(); }
   virtual int getNumCols() const { return matrix_->getNumCols(); }
  virtual int getNumRows() const { return matrix_->getNumRows(); }

   virtual const double * getElements() const 
  { return matrix_->getElements();}
  inline double * getMutableElements() const
  { return matrix_->getMutableElements();}
   virtual const int * getIndices() const 
  { return matrix_->getIndices();}

   virtual const CoinBigIndex * getVectorStarts() const 
  { return matrix_->getVectorStarts();}
   virtual const int * getVectorLengths() const 
  { return matrix_->getVectorLengths();} 
  virtual int getVectorLength(int index) const 
  { return matrix_->getVectorSize(index);}

  virtual void deleteCols(const int numDel, const int * indDel);
  virtual void deleteRows(const int numDel, const int * indDel);
#ifndef CLP_NO_VECTOR
  virtual void appendCols(int number, const CoinPackedVectorBase * const * columns);
  virtual void appendRows(int number, const CoinPackedVectorBase * const * rows);
#endif

  virtual int appendMatrix(int number, int type,
                           const CoinBigIndex * starts, const int * index,
                           const double * element, int numberOther=-1);
  virtual void replaceVector(const int index,
                       const int numReplace, const double * newElements)
      {matrix_->replaceVector(index,numReplace,newElements);}
  virtual void modifyCoefficient(int row, int column, double newElement,
                           bool keepZero=false)
       {matrix_->modifyCoefficient(row, column, newElement, keepZero);}
  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 int scale(ClpModel * model, const ClpSimplex * baseModel=NULL) const ;
  virtual void scaleRowCopy(ClpModel * model) const ;
  void createScaledMatrix(ClpSimplex * model) const;
  virtual ClpMatrixBase * scaledColumnCopy(ClpModel * model) const ;
  virtual bool allElementsInRange(ClpModel * model,
                                  double smallest, double largest,
                                  int check=15);
  virtual void rangeOfElements(double & smallestNegative, double & largestNegative,
                       double & smallestPositive, double & largestPositive);

  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 releasePackedMatrix() const { }
  virtual CoinBigIndex * dubiousWeights(const ClpSimplex * model,int * inputWeights) const;
  virtual bool canDoPartialPricing() const;
  virtual void partialPricing(ClpSimplex * model, double start, double end,
                      int & bestSequence, int & numberWanted);
  virtual int refresh(ClpSimplex * model);
  // Really scale matrix
  virtual void reallyScale(const double * rowScale, const double * columnScale);
  virtual void setDimensions(int numrows, int numcols);

  virtual void times(double scalar,
                       const double * x, double * y) const;
  virtual void times(double scalar,
                     const double * x, double * y,
                     const double * rowScale, 
                     const double * columnScale) const;
    virtual void transposeTimes(double scalar,
                                const double * x, double * y) const;
    virtual void transposeTimes(double scalar,
                                const double * x, double * y,
                                const double * rowScale, 
                                const double * columnScale,
                                double * spare=NULL) const;
  virtual void transposeTimes(const ClpSimplex * model, double scalar,
                              const CoinIndexedVector * x,
                              CoinIndexedVector * y,
                              CoinIndexedVector * z) const;
  void transposeTimesByColumn(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 bool canCombine(const ClpSimplex * model,
                          const CoinIndexedVector * pi) const;
  virtual void transposeTimes2(const ClpSimplex * model,
                               const CoinIndexedVector * pi1, CoinIndexedVector * dj1,
                               const CoinIndexedVector * pi2, CoinIndexedVector * dj2,
                               CoinIndexedVector * spare,
                               double referenceIn, double devex,
                               // Array for exact devex to say what is in reference framework
                               unsigned int * reference,
                               double * weights, double scaleFactor);
  virtual void subsetTimes2(const ClpSimplex * model,
                                CoinIndexedVector * dj1,
                               const CoinIndexedVector * pi2, CoinIndexedVector * dj2,
                               double referenceIn, double devex,
                               // Array for exact devex to say what is in reference framework
                               unsigned int * reference,
                               double * weights, double scaleFactor);
  void useEffectiveRhs(ClpSimplex * model);


  inline CoinPackedMatrix * matrix() const { return matrix_;}
  inline void setMatrixNull()
  { matrix_=NULL;}
  inline void makeSpecialColumnCopy()
  { flags_ |= 8;}
  void releaseSpecialColumnCopy();
  inline bool zeros() const
  { return ((flags_&1)!=0);}
  inline bool wantsSpecialColumnCopy() const
  { return ((flags_&8)!=0);}


   ClpPackedMatrix();
   virtual ~ClpPackedMatrix();

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

   ClpPackedMatrix(CoinPackedMatrix * matrix);

   ClpPackedMatrix& operator=(const ClpPackedMatrix&);
  virtual ClpMatrixBase * clone() const ;
  virtual void copy(const ClpPackedMatrix * from);
  virtual ClpMatrixBase * subsetClone (
                    int numberRows, const int * whichRows,
                    int numberColumns, const int * whichColumns) const ;
  void specialRowCopy(ClpSimplex * model,const ClpMatrixBase * rowCopy); 
  void specialColumnCopy(ClpSimplex * model); 
  virtual void correctSequence(const ClpSimplex * model,int & sequenceIn, int & sequenceOut) ;
private:
  void gutsOfTransposeTimesUnscaled(const double * pi,CoinIndexedVector * output, const double tolerance) const;
  void gutsOfTransposeTimesScaled(const double * pi,const double * columnScale, CoinIndexedVector * output, const double tolerance) const;
  void gutsOfTransposeTimesByRowGE3(const CoinIndexedVector * piVector, CoinIndexedVector * output,
                                   CoinIndexedVector * spareVector, const double tolerance, const double scalar) const;
  void gutsOfTransposeTimesByRowEQ2(const CoinIndexedVector * piVector, CoinIndexedVector * output,
                                   CoinIndexedVector * spareVector, const double tolerance, const double scalar) const;
  void gutsOfTransposeTimesByRowEQ1(const CoinIndexedVector * piVector, CoinIndexedVector * output,
                                   const double tolerance, const double scalar) const;
  void clearCopies();
   
    
protected:
  void checkFlags() const;

  CoinPackedMatrix * matrix_;
  int numberActiveColumns_;
  int flags_;
  ClpPackedMatrix2 * rowCopy_;
  ClpPackedMatrix3 * columnCopy_;
};
#ifdef THREAD
#include <pthread.h>
typedef struct {
  double acceptablePivot;
  const ClpSimplex * model;
  double * spare;
  int * spareIndex;
  double * arrayTemp;
  int * indexTemp;
  int * numberInPtr;
  double * bestPossiblePtr;
  double * upperThetaPtr;
  int * posFreePtr;
  double * freePivotPtr;
  int * numberOutPtr;
  const unsigned short * count;
  const double * pi;
  const CoinBigIndex * rowStart;
  const double * element;
  const unsigned short * column;
  int offset;
  int numberInRowArray;
  int numberLook;
} dualColumn0Struct;
#endif
class ClpPackedMatrix2 {
  
public:
  void transposeTimes(const ClpSimplex * model,
                      const CoinPackedMatrix * rowCopy,
                      const CoinIndexedVector * x,
                      CoinIndexedVector * spareArray,
                      CoinIndexedVector * z) const;
  inline bool usefulInfo() const
  { return rowStart_!=NULL;}


   ClpPackedMatrix2();
   ClpPackedMatrix2(ClpSimplex * model,const CoinPackedMatrix * rowCopy);
   virtual ~ClpPackedMatrix2();

   ClpPackedMatrix2(const ClpPackedMatrix2&);
   ClpPackedMatrix2& operator=(const ClpPackedMatrix2&);
   
    
protected:

  int numberBlocks_;
  int numberRows_;
  int * offset_;
  mutable unsigned short * count_;
  mutable CoinBigIndex * rowStart_;
  unsigned short * column_;
  double * work_;
#ifdef THREAD
  pthread_t * threadId_;
  dualColumn0Struct * info_;
#endif

};
typedef struct {
  CoinBigIndex startElements_; // point to data
  int startIndices_; // point to column_
  int numberInBlock_; 
  int numberPrice_; // at beginning
  int numberElements_; // number elements per column
} blockStruct;
class ClpPackedMatrix3 {
  
public:
  void transposeTimes(const ClpSimplex * model,
                      const double * pi,
                      CoinIndexedVector * output) const;
  void transposeTimes2(const ClpSimplex * model,
                       const double * pi, CoinIndexedVector * dj1,
                       const double * piWeight,
                       double referenceIn, double devex,
                       // Array for exact devex to say what is in reference framework
                       unsigned int * reference,
                       double * weights, double scaleFactor);


   ClpPackedMatrix3();
   ClpPackedMatrix3(ClpSimplex * model,const CoinPackedMatrix * columnCopy);
   virtual ~ClpPackedMatrix3();

   ClpPackedMatrix3(const ClpPackedMatrix3&);
   ClpPackedMatrix3& operator=(const ClpPackedMatrix3&);

  void sortBlocks(const ClpSimplex * model);
  void swapOne(const ClpSimplex * model,const ClpPackedMatrix * matrix,
                int iColumn);
   
    
protected:

  int numberBlocks_;
  int numberColumns_;
  int * column_;
  CoinBigIndex * start_;
  int * row_;
  double * element_;
  blockStruct * block_;
};

#endif

---