ClpPlusMinusOneMatrix.hpp

Go to the documentation of this file.

/* $Id: ClpPlusMinusOneMatrix.hpp 2078 2015-01-05 12:39:49Z forrest $ */
// 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 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(
          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 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 * 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 * COIN_RESTRICT startPositive_;
     CoinBigIndex * COIN_RESTRICT startNegative_;
     int * COIN_RESTRICT indices_;
     int numberRows_;
     int numberColumns_;
#ifdef CLP_PLUS_ONE_MATRIX

     mutable int otherFlags_;
#endif
     bool columnOrdered_;

};

#endif