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

Go to the documentation of this file.

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


#include "CoinPragma.hpp"

#include "ClpMatrixBase.hpp"

class ClpPlusMinusOneMatrix : public ClpMatrixBase {
  
public:

   virtual CoinPackedMatrix * getPackedMatrix() const;
  virtual bool isColOrdered() const ;
  virtual  CoinBigIndex getNumElements() const; 
   virtual int getNumCols() const { return numberColumns_; }
  virtual int getNumRows() const { return numberRows_; }

  virtual const double * getElements() const; 
  virtual const int * getIndices() const
  { return indices_;}
  // and for advanced use
  int * getMutableIndices() const
  { return indices_;}

  virtual const CoinBigIndex * getVectorStarts() const;
  virtual const int * getVectorLengths() const;

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

  virtual int appendMatrix(int number, int type,
                           const CoinBigIndex * starts, const int * index,
                           const double * element, int numberOther=-1);
#endif

  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 CoinBigIndex * dubiousWeights(const ClpSimplex * model,int * inputWeights) const;
  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 void setDimensions(int numrows, int numcols);
  void checkValid(bool detail) const;

  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;
  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);


  inline CoinBigIndex * startPositive() const
  { return startPositive_;}
  inline CoinBigIndex * startNegative() const
  { return startNegative_;}


   ClpPlusMinusOneMatrix();
   virtual ~ClpPlusMinusOneMatrix();

   ClpPlusMinusOneMatrix(const ClpPlusMinusOneMatrix&);
   ClpPlusMinusOneMatrix(const CoinPackedMatrix&);
  ClpPlusMinusOneMatrix(int numberRows, int numberColumns,
                        bool columnOrdered, const int * indices,
                        const CoinBigIndex * startPositive, const CoinBigIndex * startNegative);
  ClpPlusMinusOneMatrix (const ClpPlusMinusOneMatrix & wholeModel,
                    int numberRows, const int * whichRows,
                    int numberColumns, const int * whichColumns);

   ClpPlusMinusOneMatrix& operator=(const ClpPlusMinusOneMatrix&);
  virtual ClpMatrixBase * clone() const ;
  virtual ClpMatrixBase * subsetClone (
                    int numberRows, const int * whichRows,
                    int numberColumns, const int * whichColumns) const ;
  void passInCopy(int numberRows, int numberColumns,
                  bool columnOrdered, int * indices,
                  CoinBigIndex * startPositive, CoinBigIndex * startNegative);
  virtual bool canDoPartialPricing() const;
  virtual void partialPricing(ClpSimplex * model, double start, double end,
                      int & bestSequence, int & numberWanted);
   
    
protected:

  mutable CoinPackedMatrix * matrix_;
  mutable int * lengths_;
  CoinBigIndex * startPositive_;
  CoinBigIndex * startNegative_;
  int * indices_;
  int numberRows_;
  int numberColumns_;
  bool columnOrdered_;
  
};

#endif

---