ClpGubMatrix.hpp

Go to the documentation of this file.

/* $Id$ */
// 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 ClpGubMatrix_H
#define ClpGubMatrix_H
 
#include "CoinPragma.hpp"
 
#include "ClpPackedMatrix.hpp"
class ClpSimplex;
class ClpGubMatrix : public ClpPackedMatrix {
 
public:
  virtual ClpMatrixBase *reverseOrderedCopy() const;
  virtual int countBasis(const int *whichColumn,
    int &numberColumnBasic);
  virtual void fillBasis(ClpSimplex *model,
    const int *whichColumn,
    int &numberColumnBasic,
    int *row, int *start,
    int *rowCount, int *columnCount,
    CoinFactorizationDouble *element);
  virtual void unpack(const ClpSimplex *model, CoinIndexedVector *rowArray,
    int column) const;
  virtual void unpackPacked(ClpSimplex *model,
    CoinIndexedVector *rowArray,
    int column) const;
  virtual void add(const ClpSimplex *model, CoinIndexedVector *rowArray,
    int column, double multiplier) const;
  virtual void add(const ClpSimplex *model, double *array,
    int column, double multiplier) const;
  virtual void partialPricing(ClpSimplex *model, double start, double end,
    int &bestSequence, int &numberWanted);
  virtual int hiddenRows() const;
 
 
  using ClpPackedMatrix::transposeTimes;
  virtual void transposeTimes(const ClpSimplex *model, double scalar,
    const CoinIndexedVector *x,
    CoinIndexedVector *y,
    CoinIndexedVector *z) const;
  virtual void transposeTimesByRow(const ClpSimplex *model, double scalar,
    const CoinIndexedVector *x,
    CoinIndexedVector *y,
    CoinIndexedVector *z) const;
  virtual void subsetTransposeTimes(const ClpSimplex *model,
    const CoinIndexedVector *x,
    const CoinIndexedVector *y,
    CoinIndexedVector *z) const;
  virtual int extendUpdated(ClpSimplex *model, CoinIndexedVector *update, int mode);
  virtual void primalExpanded(ClpSimplex *model, int mode);
  virtual void dualExpanded(ClpSimplex *model, CoinIndexedVector *array,
    double *other, int mode);
  virtual int generalExpanded(ClpSimplex *model, int mode, int &number);
  virtual int updatePivot(ClpSimplex *model, double oldInValue, double oldOutValue);
  virtual void useEffectiveRhs(ClpSimplex *model, bool cheapest = true);
  virtual double *rhsOffset(ClpSimplex *model, bool forceRefresh = false,
    bool check = false);
  virtual int synchronize(ClpSimplex *model, int mode);
  virtual void correctSequence(const ClpSimplex *model, int &sequenceIn, int &sequenceOut);
 
  ClpGubMatrix();
  virtual ~ClpGubMatrix();
 
  ClpGubMatrix(const ClpGubMatrix &);
  ClpGubMatrix(const CoinPackedMatrix &);
  ClpGubMatrix(const ClpGubMatrix &wholeModel,
    int numberRows, const int *whichRows,
    int numberColumns, const int *whichColumns);
  ClpGubMatrix(const CoinPackedMatrix &wholeModel,
    int numberRows, const int *whichRows,
    int numberColumns, const int *whichColumns);
 
  ClpGubMatrix(CoinPackedMatrix *matrix);
 
  ClpGubMatrix(ClpPackedMatrix *matrix, int numberSets,
    const int *start, const int *end,
    const double *lower, const double *upper,
    const unsigned char *status = NULL);
 
  ClpGubMatrix &operator=(const ClpGubMatrix &);
  virtual ClpMatrixBase *clone() const;
  virtual ClpMatrixBase *subsetClone(
    int numberRows, const int *whichRows,
    int numberColumns, const int *whichColumns) const;
  void redoSet(ClpSimplex *model, int newKey, int oldKey, int iSet);
 
  inline ClpSimplex::Status getStatus(int sequence) const
  {
    return static_cast< ClpSimplex::Status >(status_[sequence] & 7);
  }
  inline void setStatus(int sequence, ClpSimplex::Status status)
  {
    unsigned char &st_byte = status_[sequence];
    st_byte = static_cast< unsigned char >(st_byte & ~7);
    st_byte = static_cast< unsigned char >(st_byte | status);
  }
  inline void setFlagged(int sequence)
  {
    status_[sequence] = static_cast< unsigned char >(status_[sequence] | 64);
  }
  inline void clearFlagged(int sequence)
  {
    status_[sequence] = static_cast< unsigned char >(status_[sequence] & ~64);
  }
  inline bool flagged(int sequence) const
  {
    return ((status_[sequence] & 64) != 0);
  }
  inline void setAbove(int sequence)
  {
    unsigned char iStat = status_[sequence];
    iStat = static_cast< unsigned char >(iStat & ~24);
    status_[sequence] = static_cast< unsigned char >(iStat | 16);
  }
  inline void setFeasible(int sequence)
  {
    unsigned char iStat = status_[sequence];
    iStat = static_cast< unsigned char >(iStat & ~24);
    status_[sequence] = static_cast< unsigned char >(iStat | 8);
  }
  inline void setBelow(int sequence)
  {
    unsigned char iStat = status_[sequence];
    iStat = static_cast< unsigned char >(iStat & ~24);
    status_[sequence] = iStat;
  }
  inline double weight(int sequence) const
  {
    int iStat = status_[sequence] & 31;
    iStat = iStat >> 3;
    return static_cast< double >(iStat - 1);
  }
  inline int *start() const
  {
    return start_;
  }
  inline int *end() const
  {
    return end_;
  }
  inline double *lower() const
  {
    return lower_;
  }
  inline double *upper() const
  {
    return upper_;
  }
  inline int *keyVariable() const
  {
    return keyVariable_;
  }
  inline int *backward() const
  {
    return backward_;
  }
  inline int numberSets() const
  {
    return numberSets_;
  }
  void switchOffCheck();
 
protected:
  double sumDualInfeasibilities_;
  double sumPrimalInfeasibilities_;
  double sumOfRelaxedDualInfeasibilities_;
  double sumOfRelaxedPrimalInfeasibilities_;
  double infeasibilityWeight_;
  int *start_;
  int *end_;
  double *lower_;
  double *upper_;
  mutable unsigned char *status_;
  unsigned char *saveStatus_;
  int *savedKeyVariable_;
  int *backward_;
  int *backToPivotRow_;
  double *changeCost_;
  mutable int *keyVariable_;
  mutable int *next_;
  int *toIndex_;
  // Reverse pointer from index to set
  int *fromIndex_;
  ClpSimplex *model_;
  int numberDualInfeasibilities_;
  int numberPrimalInfeasibilities_;
  int noCheck_;
  int numberSets_;
  int saveNumber_;
  int possiblePivotKey_;
  int gubSlackIn_;
  int firstGub_;
  int lastGub_;
  int gubType_;
};
 
#endif
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/