CoinWarmStartBasis.hpp

Go to the documentation of this file.

/* $Id: CoinWarmStartBasis.hpp 2083 2019-01-06 19:38:09Z unxusr $ */
#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
*/