CoinWarmStartBasis.hpp

#ifndef CoinWarmStartBasis_H
#define CoinWarmStartBasis_H

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

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

class CoinWarmStartBasis : public CoinWarmStart {
public:

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

public:


  inline int getNumStructural() const { return numStructural_; }

  inline int getNumArtificial() const { return numArtificial_; }

  int numberBasicStructurals();

  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 &= ~(3 << ((i&3)<<1));
    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 &= ~(3 << ((i&3)<<1));
    st_byte |= (st << ((i&3)<<1));
  }

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



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

  virtual void
  CoinWarmStartBasis::applyDiff (const CoinWarmStartDiff *const cwsdDiff) ;




  virtual void setSize(int ns, int na) ;

  virtual void resize (int newNumberRows, int newNumberColumns);

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

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



  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;


private:

    int numStructural_;
    int numArtificial_;
    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 &= ~(3 << ((i&3)<<1));
  st_byte |= (st << ((i&3)<<1));
}



class CoinWarmStartBasisDiff : public CoinWarmStartDiff
{ public:

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

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

  virtual ~CoinWarmStartBasisDiff()
  { delete[] diffNdxs_ ;
    delete[] diffVals_ ; }

  protected:

  CoinWarmStartBasisDiff () : sze_(0), diffNdxs_(0), diffVals_(0) { } ;

  CoinWarmStartBasisDiff (const CoinWarmStartBasisDiff &cwsbd) ;

  private:

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

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

  unsigned int *diffNdxs_ ;

  unsigned int *diffVals_ ;
} ;


#endif

---