ClpDynamicMatrix.hpp

Go to the documentation of this file.

/* $Id: ClpDynamicMatrix.hpp 2385 2019-01-06 19:43:06Z unxusr $ */
// Copyright (C) 2004, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).

#ifndef ClpDynamicMatrix_H
#define ClpDynamicMatrix_H

#include "CoinPragma.hpp"

#include "ClpPackedMatrix.hpp"
class ClpSimplex;
class ClpDynamicMatrix : public ClpPackedMatrix {

public:
  enum DynamicStatus {
    soloKey = 0x00,
    inSmall = 0x01,
    atUpperBound = 0x02,
    atLowerBound = 0x03
  };
  virtual void partialPricing(ClpSimplex *model, double start, double end,
    int &bestSequence, int &numberWanted);

  virtual int updatePivot(ClpSimplex *model, double oldInValue, double oldOutValue);
  virtual double *rhsOffset(ClpSimplex *model, bool forceRefresh = false,
    bool check = false);

  using ClpPackedMatrix::times;
  virtual void times(double scalar,
    const double *x, double *y) const;
  void modifyOffset(int sequence, double amount);
  double keyValue(int iSet) const;
  virtual void dualExpanded(ClpSimplex *model, CoinIndexedVector *array,
    double *other, int mode);
  virtual int generalExpanded(ClpSimplex *model, int mode, int &number);
  virtual int refresh(ClpSimplex *model);
  virtual void createVariable(ClpSimplex *model, int &bestSequence);
  virtual double reducedCost(ClpSimplex *model, int sequence) const;
  void gubCrash();
  void writeMps(const char *name);
  void initialProblem();
  int addColumn(CoinBigIndex numberEntries, const int *row, const double *element,
    double cost, double lower, double upper, int iSet,
    DynamicStatus status);
  virtual void packDown(const int *, int) {}
  inline double columnLower(int sequence) const
  {
    if (columnLower_)
      return columnLower_[sequence];
    else
      return 0.0;
  }
  inline double columnUpper(int sequence) const
  {
    if (columnUpper_)
      return columnUpper_[sequence];
    else
      return COIN_DBL_MAX;
  }


  ClpDynamicMatrix();
  ClpDynamicMatrix(ClpSimplex *model, int numberSets,
    int numberColumns, const int *starts,
    const double *lower, const double *upper,
    const CoinBigIndex *startColumn, const int *row,
    const double *element, const double *cost,
    const double *columnLower = NULL, const double *columnUpper = NULL,
    const unsigned char *status = NULL,
    const unsigned char *dynamicStatus = NULL);

  virtual ~ClpDynamicMatrix();

  ClpDynamicMatrix(const ClpDynamicMatrix &);
  ClpDynamicMatrix(const CoinPackedMatrix &);

  ClpDynamicMatrix &operator=(const ClpDynamicMatrix &);
  virtual ClpMatrixBase *clone() const;

  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 bool flaggedSlack(int i) const
  {
    return (status_[i] & 8) != 0;
  }
  inline void setFlaggedSlack(int i)
  {
    status_[i] = static_cast< unsigned char >(status_[i] | 8);
  }
  inline void unsetFlaggedSlack(int i)
  {
    status_[i] = static_cast< unsigned char >(status_[i] & ~8);
  }
  inline int numberSets() const
  {
    return numberSets_;
  }
  inline int numberGubEntries() const
  {
    return startSet_[numberSets_];
  }
  inline int *startSets() const
  {
    return startSet_;
  }
  inline bool flagged(int i) const
  {
    return (dynamicStatus_[i] & 8) != 0;
  }
  inline void setFlagged(int i)
  {
    dynamicStatus_[i] = static_cast< unsigned char >(dynamicStatus_[i] | 8);
  }
  inline void unsetFlagged(int i)
  {
    dynamicStatus_[i] = static_cast< unsigned char >(dynamicStatus_[i] & ~8);
  }
  inline void setDynamicStatus(int sequence, DynamicStatus status)
  {
    unsigned char &st_byte = dynamicStatus_[sequence];
    st_byte = static_cast< unsigned char >(st_byte & ~7);
    st_byte = static_cast< unsigned char >(st_byte | status);
  }
  inline DynamicStatus getDynamicStatus(int sequence) const
  {
    return static_cast< DynamicStatus >(dynamicStatus_[sequence] & 7);
  }
  inline double objectiveOffset() const
  {
    return objectiveOffset_;
  }
  inline CoinBigIndex *startColumn() const
  {
    return startColumn_;
  }
  inline int *row() const
  {
    return row_;
  }
  inline double *element() const
  {
    return element_;
  }
  inline double *cost() const
  {
    return cost_;
  }
  inline int *id() const
  {
    return id_;
  }
  inline double *columnLower() const
  {
    return columnLower_;
  }
  inline double *columnUpper() const
  {
    return columnUpper_;
  }
  inline double *lowerSet() const
  {
    return lowerSet_;
  }
  inline double *upperSet() const
  {
    return upperSet_;
  }
  inline int numberGubColumns() const
  {
    return numberGubColumns_;
  }
  inline int firstAvailable() const
  {
    return firstAvailable_;
  }
  inline int firstDynamic() const
  {
    return firstDynamic_;
  }
  inline int lastDynamic() const
  {
    return lastDynamic_;
  }
  inline int numberStaticRows() const
  {
    return numberStaticRows_;
  }
  inline CoinBigIndex numberElements() const
  {
    return numberElements_;
  }
  inline int *keyVariable() const
  {
    return keyVariable_;
  }
  void switchOffCheck();
  inline unsigned char *gubRowStatus() const
  {
    return status_;
  }
  inline unsigned char *dynamicStatus() const
  {
    return dynamicStatus_;
  }
  int whichSet(int sequence) const;

protected:
  double sumDualInfeasibilities_;
  double sumPrimalInfeasibilities_;
  double sumOfRelaxedDualInfeasibilities_;
  double sumOfRelaxedPrimalInfeasibilities_;
  double savedBestGubDual_;
  int savedBestSet_;
  int *backToPivotRow_;
  mutable int *keyVariable_;
  int *toIndex_;
  // Reverse pointer from index to set
  int *fromIndex_;
  int numberSets_;
  int numberActiveSets_;
  double objectiveOffset_;
  double *lowerSet_;
  double *upperSet_;
  unsigned char *status_;
  ClpSimplex *model_;
  int firstAvailable_;
  int firstAvailableBefore_;
  int firstDynamic_;
  int lastDynamic_;
  int numberStaticRows_;
  CoinBigIndex numberElements_;
  int numberDualInfeasibilities_;
  int numberPrimalInfeasibilities_;
  int noCheck_;
  double infeasibilityWeight_;
  int numberGubColumns_;
  int maximumGubColumns_;
  CoinBigIndex maximumElements_;
  int *startSet_;
  int *next_;
  CoinBigIndex *startColumn_;
  int *row_;
  double *element_;
  double *cost_;
  int *id_;
  unsigned char *dynamicStatus_;
  double *columnLower_;
  double *columnUpper_;
};

#endif

/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/