CoinWarmStartBasis.hpp

Go to the documentation of this file.

/* $Id: CoinWarmStartBasis.hpp 1515 2011-12-10 23:38:04Z lou $ */
#ifndef CoinWarmStartBasis_H
#define CoinWarmStartBasis_H

#include <vector>

#include "CoinSort.hpp"
#include "CoinHelperFunctions.hpp"
#include "CoinWarmStart.hpp"

//#############################################################################

class CoinWarmStartBasis : public virtual CoinWarmStart {
public:

  enum Status {
    isFree = 0x00,              
    basic = 0x01,               
    atUpperBound = 0x02,        
    atLowerBound = 0x03         
  };

  typedef CoinTriple<int,int,int> XferEntry ;

  typedef std::vector<XferEntry> XferVec ;

public:

  inline int getNumStructural() const { return numStructural_; }

  inline int getNumArtificial() const { return numArtificial_; }

  int numberBasicStructurals() const ;

  inline Status getStructStatus(int i) const {
    const int st = (structuralStatus_[i>>2] >> ((i&3)<<1)) & 3;
    return static_cast<CoinWarmStartBasis::Status>(st);
  }

  inline void setStructStatus(int i, Status st) {
    char& st_byte = structuralStatus_[i>>2];
    st_byte = static_cast<char>(st_byte & ~(3 << ((i&3)<<1))) ;
    st_byte = static_cast<char>(st_byte | (st << ((i&3)<<1))) ;
  }

  inline char * getStructuralStatus() { return structuralStatus_; }

  inline const char * getStructuralStatus() const { return structuralStatus_; }

  inline char * getArtificialStatus() { return artificialStatus_; }

  inline Status getArtifStatus(int i) const {
    const int st = (artificialStatus_[i>>2] >> ((i&3)<<1)) & 3;
    return static_cast<CoinWarmStartBasis::Status>(st);
  }

  inline void setArtifStatus(int i, Status st) {
    char& st_byte = artificialStatus_[i>>2];
    st_byte = static_cast<char>(st_byte & ~(3 << ((i&3)<<1))) ;
    st_byte = static_cast<char>(st_byte | (st << ((i&3)<<1))) ;
  }

  inline const char * getArtificialStatus() const { return artificialStatus_; }



  virtual CoinWarmStartDiff*
  generateDiff (const CoinWarmStart *const oldCWS) const ;

  virtual void
  applyDiff (const CoinWarmStartDiff *const cwsdDiff) ;




  virtual void setSize(int ns, int na) ;

  virtual void resize (int newNumberRows, int newNumberColumns);

  virtual void compressRows (int tgtCnt, const int *tgts) ;

  virtual void deleteRows(int rawTgtCnt, const int *rawTgts) ;

  virtual void deleteColumns(int number, const int * which);

  virtual void mergeBasis(const CoinWarmStartBasis *src,
                          const XferVec *xferRows,
                          const XferVec *xferCols) ;



  CoinWarmStartBasis();

  CoinWarmStartBasis(int ns, int na, const char* sStat, const char* aStat) ;

  CoinWarmStartBasis(const CoinWarmStartBasis& ws) ;

  virtual CoinWarmStart *clone() const
  {
     return new CoinWarmStartBasis(*this);
  }

  virtual ~CoinWarmStartBasis();

  virtual CoinWarmStartBasis& operator=(const CoinWarmStartBasis& rhs) ;

  virtual void assignBasisStatus(int ns, int na, char*& sStat, char*& aStat) ;


  virtual void print() const;
  bool fullBasis() const;
  bool fixFullBasis();


protected:
    int numStructural_;
    int numArtificial_;
    int maxSize_;
    char * structuralStatus_;
    char * artificialStatus_;
};


inline CoinWarmStartBasis::Status getStatus(const char *array, int i)  {
  const int st = (array[i>>2] >> ((i&3)<<1)) & 3;
  return static_cast<CoinWarmStartBasis::Status>(st);
}

inline void setStatus(char * array, int i, CoinWarmStartBasis::Status st) {
  char& st_byte = array[i>>2];
  st_byte = static_cast<char>(st_byte & ~(3 << ((i&3)<<1))) ;
  st_byte = static_cast<char>(st_byte | (st << ((i&3)<<1))) ;
}

const char *statusName(CoinWarmStartBasis::Status status) ;


class CoinWarmStartBasisDiff : public virtual CoinWarmStartDiff
{ public:

  virtual CoinWarmStartDiff *clone() const
  { CoinWarmStartBasisDiff *cwsbd =  new CoinWarmStartBasisDiff(*this) ;
    return (dynamic_cast<CoinWarmStartDiff *>(cwsbd)) ; }

  virtual
    CoinWarmStartBasisDiff &operator= (const CoinWarmStartBasisDiff &rhs) ;

  virtual ~CoinWarmStartBasisDiff();

  protected:

  CoinWarmStartBasisDiff () : sze_(0), difference_(0) { } 

  CoinWarmStartBasisDiff (const CoinWarmStartBasisDiff &cwsbd) ;

  CoinWarmStartBasisDiff (int sze, const unsigned int *const diffNdxs,
                          const unsigned int *const diffVals) ;

  CoinWarmStartBasisDiff (const CoinWarmStartBasis * rhs);
  
  private:

  friend CoinWarmStartDiff*
    CoinWarmStartBasis::generateDiff(const CoinWarmStart *const oldCWS) const ;
  friend void
    CoinWarmStartBasis::applyDiff(const CoinWarmStartDiff *const diff) ;

  int sze_ ;

  unsigned int *difference_ ;

} ;


#endif