ClpDummyMatrix.hpp

Go to the documentation of this file.

/* $Id: ClpDummyMatrix.hpp 1665 2011-01-04 17:55:54Z lou $ */
// Copyright (C) 2003, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).
 
#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 countBasis(const int * whichColumn,
                                     int & numberColumnBasic);
     virtual void fillBasis(ClpSimplex * model,
                            const int * whichColumn,
                            int & numberColumnBasic,
                            int * row, int * start,
                            int * rowCount, int * columnCount,
                            CoinFactorizationDouble * 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 releasePackedMatrix() 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;
 
     using ClpMatrixBase::transposeTimes ;
     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