ClpGubDynamicMatrix.hpp

Go to the documentation of this file.

/* $Id: ClpGubDynamicMatrix.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 ClpGubDynamicMatrix_H
#define ClpGubDynamicMatrix_H
 
 
#include "CoinPragma.hpp"
 
#include "ClpGubMatrix.hpp"
class ClpGubDynamicMatrix : public ClpGubMatrix {
 
public:
     virtual void partialPricing(ClpSimplex * model, double start, double end,
                                 int & bestSequence, int & numberWanted);
     virtual int synchronize(ClpSimplex * model, int mode);
     virtual void useEffectiveRhs(ClpSimplex * model, bool cheapest = true);
     virtual int updatePivot(ClpSimplex * model, double oldInValue, double oldOutValue);
     void insertNonBasic(int sequence, int iSet);
     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;
     virtual int checkFeasible(ClpSimplex * model, double & sum) const;
     void cleanData(ClpSimplex * model);
 
 
 
     ClpGubDynamicMatrix();
     virtual ~ClpGubDynamicMatrix();
 
     ClpGubDynamicMatrix(const ClpGubDynamicMatrix&);
     ClpGubDynamicMatrix(ClpSimplex * model, int numberSets,
                         int numberColumns, const int * starts,
                         const double * lower, const double * upper,
                         const int * startColumn, const int * row,
                         const double * element, const double * cost,
                         const double * lowerColumn = NULL, const double * upperColumn = NULL,
                         const unsigned char * status = NULL);
 
     ClpGubDynamicMatrix& operator=(const ClpGubDynamicMatrix&);
     virtual ClpMatrixBase * clone() const ;
 
     enum DynamicStatus {
          inSmall = 0x01,
          atUpperBound = 0x02,
          atLowerBound = 0x03
     };
     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 * fullStart() const {
          return fullStart_;
     }
     inline int * id() const {
          return id_;
     }
     inline double * lowerColumn() const {
          return lowerColumn_;
     }
     inline double * upperColumn() const {
          return upperColumn_;
     }
     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 void setFirstAvailable(int value) {
          firstAvailable_ = value;
     }
     inline int firstDynamic() const {
          return firstDynamic_;
     }
     inline int lastDynamic() const {
          return lastDynamic_;
     }
     inline int numberElements() const {
          return numberElements_;
     }
     inline unsigned char * gubRowStatus() const {
          return status_;
     }
     inline unsigned char * dynamicStatus() const {
          return dynamicStatus_;
     }
     int whichSet (int sequence) const;
 
 
protected:
     double objectiveOffset_;
     CoinBigIndex * startColumn_;
     int * row_;
     double * element_;
     double * cost_;
     int * fullStart_;
     int * id_;
     unsigned char * dynamicStatus_;
     double * lowerColumn_;
     double * upperColumn_;
     double * lowerSet_;
     double * upperSet_;
     int numberGubColumns_;
     int firstAvailable_;
     int savedFirstAvailable_;
     int firstDynamic_;
     int lastDynamic_;
     int numberElements_;
};
 
#endif