CoinWarmStartBasis.hpp

Go to the documentation of this file.

/* $Id$ */
#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, 
    superBasic = 0x04 
  };
 
  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);
char statusToChar(CoinWarmStartBasis::Status status);
CoinWarmStartBasis::Status charToStatus(char 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
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/