ClpDummyMatrix.hpp

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


#include "CoinPragma.hpp"

#include "ClpMatrixBase.hpp"

class ClpDummyMatrix : public ClpMatrixBase {
  
public:

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

  virtual const double * getElements() const; 
  virtual const int * getIndices() const;

  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 ClpMatrixBase * reverseOrderedCopy() const;
  virtual CoinBigIndex numberInBasis(const int * columnIsBasic) const ;
  virtual CoinBigIndex fillBasis(const ClpSimplex * model,
                                const int * columnIsBasic, int & numberBasic,
                                int * row, int * column,
                                double * element) const ;
  virtual CoinBigIndex fillBasis(const ClpSimplex * model,
                                 const int * whichColumn, 
                                 int numberRowBasic,
                                 int numberColumnBasic,
                                 int * row, int * column,
                                 double * element) const ;
  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 releaseDummyMatrix() 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) const;
  virtual void transposeTimes(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;




   ClpDummyMatrix();
  ClpDummyMatrix(int numberColumns, int numberRows,
                   int numberElements);
   virtual ~ClpDummyMatrix();

   ClpDummyMatrix(const ClpDummyMatrix&);
   ClpDummyMatrix(const CoinPackedMatrix&);

   ClpDummyMatrix& operator=(const ClpDummyMatrix&);
  virtual ClpMatrixBase * clone() const ;
   
    
protected:

  int numberRows_;
  int numberColumns_;
  int numberElements_;
  
};

#endif

---