ClpDynamicMatrix.hpp

Go to the documentation of this file.

/* $Id: ClpDynamicMatrix.hpp 1755 2011-06-28 18:24:31Z lou $ */
// Copyright (C) 2004, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).

#ifndef ClpDynamicMatrix_H
#define ClpDynamicMatrix_H


#include "CoinPragma.hpp"

#include "ClpPackedMatrix.hpp"
class ClpSimplex;
class ClpDynamicMatrix : public ClpPackedMatrix {

public:
     enum DynamicStatus {
          soloKey = 0x00,
          inSmall = 0x01,
          atUpperBound = 0x02,
          atLowerBound = 0x03
     };
     virtual void partialPricing(ClpSimplex * model, double start, double end,
                                 int & bestSequence, int & numberWanted);

     virtual int updatePivot(ClpSimplex * model, double oldInValue, double oldOutValue);
     virtual double * rhsOffset(ClpSimplex * model, bool forceRefresh = false,
                                bool check = false);

     using ClpPackedMatrix::times ;
     virtual void times(double scalar,
                        const double * x, double * y) const;
     void modifyOffset(int sequence, double amount);
     double keyValue(int iSet) const;
     virtual void dualExpanded(ClpSimplex * model, CoinIndexedVector * array,
                               double * other, int mode);
     virtual int generalExpanded(ClpSimplex * model, int mode, int & number);
     virtual int refresh(ClpSimplex * model);
     virtual void createVariable(ClpSimplex * model, int & bestSequence);
     virtual double reducedCost( ClpSimplex * model, int sequence) const;
     void gubCrash();
     void writeMps(const char * name);
     void initialProblem();
     int addColumn(int numberEntries, const int * row, const double * element,
                   double cost, double lower, double upper, int iSet,
                   DynamicStatus status);
     virtual void packDown(const int * , int ) {}
     inline double columnLower(int sequence) const {
          if (columnLower_) return columnLower_[sequence];
          else return 0.0;
     }
     inline double columnUpper(int sequence) const {
          if (columnUpper_) return columnUpper_[sequence];
          else return COIN_DBL_MAX;
     }




     ClpDynamicMatrix();
     ClpDynamicMatrix(ClpSimplex * model, int numberSets,
                      int numberColumns, const int * starts,
                      const double * lower, const double * upper,
                      const CoinBigIndex * startColumn, const int * row,
                      const double * element, const double * cost,
                      const double * columnLower = NULL, const double * columnUpper = NULL,
                      const unsigned char * status = NULL,
                      const unsigned char * dynamicStatus = NULL);

     virtual ~ClpDynamicMatrix();

     ClpDynamicMatrix(const ClpDynamicMatrix&);
     ClpDynamicMatrix(const CoinPackedMatrix&);

     ClpDynamicMatrix& operator=(const ClpDynamicMatrix&);
     virtual ClpMatrixBase * clone() const ;

     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 bool flaggedSlack(int i) const {
          return (status_[i] & 8) != 0;
     }
     inline void setFlaggedSlack(int i) {
          status_[i] = static_cast<unsigned char>(status_[i] | 8);
     }
     inline void unsetFlaggedSlack(int i) {
          status_[i] = static_cast<unsigned char>(status_[i] & ~8);
     }
     inline int numberSets() const {
          return numberSets_;
     }
     inline int numberGubEntries() const
     { return startSet_[numberSets_];}
     inline int * startSets() const
     { return startSet_;}
     inline bool flagged(int i) const {
          return (dynamicStatus_[i] & 8) != 0;
     }
     inline void setFlagged(int i) {
          dynamicStatus_[i] = static_cast<unsigned char>(dynamicStatus_[i] | 8);
     }
     inline void unsetFlagged(int i) {
          dynamicStatus_[i] = static_cast<unsigned char>(dynamicStatus_[i] & ~8);
     }
     inline void setDynamicStatus(int sequence, DynamicStatus status) {
          unsigned char & st_byte = dynamicStatus_[sequence];
          st_byte = static_cast<unsigned char>(st_byte & ~7);
          st_byte = static_cast<unsigned char>(st_byte | status);
     }
     inline DynamicStatus getDynamicStatus(int sequence) const {
          return static_cast<DynamicStatus> (dynamicStatus_[sequence] & 7);
     }
     inline double objectiveOffset() const {
          return objectiveOffset_;
     }
     inline CoinBigIndex * startColumn() const {
          return startColumn_;
     }
     inline int * row() const {
          return row_;
     }
     inline double * element() const {
          return element_;
     }
     inline double * cost() const {
          return cost_;
     }
     inline int * id() const {
          return id_;
     }
     inline double * columnLower() const {
          return columnLower_;
     }
     inline double * columnUpper() const {
          return columnUpper_;
     }
     inline double * lowerSet() const {
          return lowerSet_;
     }
     inline double * upperSet() const {
          return upperSet_;
     }
     inline int numberGubColumns() const {
          return numberGubColumns_;
     }
     inline int firstAvailable() const {
          return firstAvailable_;
     }
     inline int firstDynamic() const {
          return firstDynamic_;
     }
     inline int lastDynamic() const {
          return lastDynamic_;
     }
     inline int numberStaticRows() const {
          return numberStaticRows_;
     }
     inline int numberElements() const {
          return numberElements_;
     }
     inline int * keyVariable() const {
          return keyVariable_;
     }
     void switchOffCheck();
     inline unsigned char * gubRowStatus() const {
          return status_;
     }
     inline unsigned char * dynamicStatus() const {
          return dynamicStatus_;
     }
     int whichSet (int sequence) const;


protected:
     double sumDualInfeasibilities_;
     double sumPrimalInfeasibilities_;
     double sumOfRelaxedDualInfeasibilities_;
     double sumOfRelaxedPrimalInfeasibilities_;
     double savedBestGubDual_;
     int savedBestSet_;
     int * backToPivotRow_;
     mutable int * keyVariable_;
     int * toIndex_;
     // Reverse pointer from index to set
     int * fromIndex_;
     int numberSets_;
     int numberActiveSets_;
     double objectiveOffset_;
     double * lowerSet_;
     double * upperSet_;
     unsigned char * status_;
     ClpSimplex * model_;
     int firstAvailable_;
     int firstAvailableBefore_;
     int firstDynamic_;
     int lastDynamic_;
     int numberStaticRows_;
     int numberElements_;
     int numberDualInfeasibilities_;
     int numberPrimalInfeasibilities_;
     int noCheck_;
     double infeasibilityWeight_;
     int numberGubColumns_;
     int maximumGubColumns_;
     int maximumElements_;
     int * startSet_;
     int * next_;
     CoinBigIndex * startColumn_;
     int * row_;
     double * element_;
     double * cost_;
     int * id_;
     unsigned char * dynamicStatus_;
     double * columnLower_;
     double * columnUpper_;
};

#endif