ClpGubMatrix.hpp

Go to the documentation of this file.

/* $Id: ClpGubMatrix.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 ClpGubMatrix_H
#define ClpGubMatrix_H
 
 
#include "CoinPragma.hpp"
 
#include "ClpPackedMatrix.hpp"
class ClpSimplex;
class ClpGubMatrix : public ClpPackedMatrix {
 
public:
     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 partialPricing(ClpSimplex * model, double start, double end,
                                 int & bestSequence, int & numberWanted);
     virtual int hiddenRows() const;
 
 
     using ClpPackedMatrix::transposeTimes ;
     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 int extendUpdated(ClpSimplex * model, CoinIndexedVector * update, int mode);
     virtual void primalExpanded(ClpSimplex * model, int mode);
     virtual void dualExpanded(ClpSimplex * model, CoinIndexedVector * array,
                               double * other, int mode);
     virtual int generalExpanded(ClpSimplex * model, int mode, int & number);
     virtual int updatePivot(ClpSimplex * model, double oldInValue, double oldOutValue);
     virtual void useEffectiveRhs(ClpSimplex * model, bool cheapest = true);
     virtual double * rhsOffset(ClpSimplex * model, bool forceRefresh = false,
                                bool check = false);
     virtual int synchronize(ClpSimplex * model, int mode);
     virtual void correctSequence(const ClpSimplex * model, int & sequenceIn, int & sequenceOut) ;
 
 
 
     ClpGubMatrix();
     virtual ~ClpGubMatrix();
 
     ClpGubMatrix(const ClpGubMatrix&);
     ClpGubMatrix(const CoinPackedMatrix&);
     ClpGubMatrix (const ClpGubMatrix & wholeModel,
                   int numberRows, const int * whichRows,
                   int numberColumns, const int * whichColumns);
     ClpGubMatrix (const CoinPackedMatrix & wholeModel,
                   int numberRows, const int * whichRows,
                   int numberColumns, const int * whichColumns);
 
     ClpGubMatrix(CoinPackedMatrix * matrix);
 
     ClpGubMatrix(ClpPackedMatrix * matrix, int numberSets,
                  const int * start, const int * end,
                  const double * lower, const double * upper,
                  const unsigned char * status = NULL);
 
     ClpGubMatrix& operator=(const ClpGubMatrix&);
     virtual ClpMatrixBase * clone() const ;
     virtual ClpMatrixBase * subsetClone (
          int numberRows, const int * whichRows,
          int numberColumns, const int * whichColumns) const ;
     void redoSet(ClpSimplex * model, int newKey, int oldKey, int iSet);
 
     inline ClpSimplex::Status getStatus(int sequence) const {
          return static_cast<ClpSimplex::Status> (status_[sequence] & 7);
     }
     inline void setStatus(int sequence, ClpSimplex::Status status) {
          unsigned char & st_byte = status_[sequence];
          st_byte = static_cast<unsigned char>(st_byte & ~7);
          st_byte = static_cast<unsigned char>(st_byte | status);
     }
     inline void setFlagged( int sequence) {
          status_[sequence] = static_cast<unsigned char>(status_[sequence] | 64);
     }
     inline void clearFlagged( int sequence) {
          status_[sequence] = static_cast<unsigned char>(status_[sequence] & ~64);
     }
     inline bool flagged(int sequence) const {
          return ((status_[sequence] & 64) != 0);
     }
     inline void setAbove( int sequence) {
          unsigned char iStat = status_[sequence];
          iStat = static_cast<unsigned char>(iStat & ~24);
          status_[sequence] = static_cast<unsigned char>(iStat | 16);
     }
     inline void setFeasible( int sequence) {
          unsigned char iStat = status_[sequence];
          iStat = static_cast<unsigned char>(iStat & ~24);
          status_[sequence] = static_cast<unsigned char>(iStat | 8);
     }
     inline void setBelow( int sequence) {
          unsigned char iStat = status_[sequence];
          iStat = static_cast<unsigned char>(iStat & ~24);
          status_[sequence] = iStat;
     }
     inline double weight( int sequence) const {
          int iStat = status_[sequence] & 31;
          iStat = iStat >> 3;
          return static_cast<double> (iStat - 1);
     }
     inline int * start() const {
          return start_;
     }
     inline int * end() const {
          return end_;
     }
     inline double * lower() const {
          return lower_;
     }
     inline double * upper() const {
          return upper_;
     }
     inline int * keyVariable() const {
          return keyVariable_;
     }
     inline int * backward() const {
          return backward_;
     }
     inline int numberSets() const {
          return numberSets_;
     }
     void switchOffCheck();
 
 
protected:
     double sumDualInfeasibilities_;
     double sumPrimalInfeasibilities_;
     double sumOfRelaxedDualInfeasibilities_;
     double sumOfRelaxedPrimalInfeasibilities_;
     double infeasibilityWeight_;
     int * start_;
     int * end_;
     double * lower_;
     double * upper_;
     mutable unsigned char * status_;
     unsigned char * saveStatus_;
     int * savedKeyVariable_;
     int * backward_;
     int * backToPivotRow_;
     double * changeCost_;
     mutable int * keyVariable_;
     mutable int * next_;
     int * toIndex_;
     // Reverse pointer from index to set
     int * fromIndex_;
     ClpSimplex * model_;
     int numberDualInfeasibilities_;
     int numberPrimalInfeasibilities_;
     int noCheck_;
     int numberSets_;
     int saveNumber_;
     int possiblePivotKey_;
     int gubSlackIn_;
     int firstGub_;
     int lastGub_;
     int gubType_;
};
 
#endif