// Copyright (C) 2003, International Business Machines
// Corporation and others.  All Rights Reserved.
#ifndef ClpGubDynamicMatrix_H
#define ClpGubDynamicMatrix_H


#include "CoinPragma.hpp"

#include "ClpGubMatrix.hpp"
/** This implements Gub rows plus a ClpPackedMatrix.
    This a dynamic version which stores the gub part and dynamically creates matrix.
    All bounds are assumed to be zero and infinity

    This is just a simple example for real column generation
*/

class ClpGubDynamicMatrix : public ClpGubMatrix {
  
public:
  /**@name Main functions provided */
   //@{
  /// Partial pricing 
  virtual void partialPricing(ClpSimplex * model, double start, double end,
			      int & bestSequence, int & numberWanted);
  /** This is local to Gub to allow synchronization:
      mode=0 when status of basis is good 
      mode=1 when variable is flagged
      mode=2 when all variables unflagged (returns number flagged)
      mode=3 just reset costs (primal)
      mode=4 correct number of dual infeasibilities
      mode=5 return 4 if time to re-factorize
      mode=8  - make sure set is clean 
      mode=9  - adjust lower, upper on set by incoming
  */
  virtual int synchronize(ClpSimplex * model,int mode);
  /// Sets up an effective RHS and does gub crash if needed
  virtual void useEffectiveRhs(ClpSimplex * model,bool cheapest=true);
  /** 
     update information for a pivot (and effective rhs)
  */
  virtual int updatePivot(ClpSimplex * model,double oldInValue, double oldOutValue);
  /// Add a new variable to a set
  void insertNonBasic(int sequence, int iSet);
  /** Returns effective RHS offset if it is being used.  This is used for long problems
      or big gub or anywhere where going through full columns is
      expensive.  This may re-compute */
  virtual double * rhsOffset(ClpSimplex * model,bool forceRefresh=false,
				bool check=false);

  using ClpPackedMatrix::times ;
    /** Return <code>y + A * scalar *x</code> in <code>y</code>.
        @pre <code>x</code> must be of size <code>numColumns()</code>
        @pre <code>y</code> must be of size <code>numRows()</code> */
  virtual void times(double scalar,
		       const double * x, double * y) const;
  /** Just for debug 
      Returns sum and number of primal infeasibilities. Recomputes keys
  */
  virtual int checkFeasible(ClpSimplex * model,double & sum) const;
  /// Cleans data after setWarmStart
  void cleanData(ClpSimplex * model);
  //@}

  
  
  /**@name Constructors, destructor */
  //@{
  /** Default constructor. */
  ClpGubDynamicMatrix();
  /** Destructor */
  virtual ~ClpGubDynamicMatrix();
  //@}
  
  /**@name Copy method */
  //@{
  /** The copy constructor. */
  ClpGubDynamicMatrix(const ClpGubDynamicMatrix&);
  /** This is the real constructor.
      It assumes factorization frequency will not be changed.
      This resizes model !!!!
   */
  ClpGubDynamicMatrix(ClpSimplex * model, int numberSets,
		      int numberColumns, const int * starts,
		      const double * lower, const double * upper,
		      const int * startColumn, const int * row,
		      const double * element, const double * cost,
		      const double * lowerColumn=NULL, const double * upperColumn=NULL,
		      const unsigned char * status=NULL);
  
  ClpGubDynamicMatrix& operator=(const ClpGubDynamicMatrix&);
  /// Clone
  virtual ClpMatrixBase * clone() const ;
  //@}
  /**@name gets and sets */
  //@{
  /// enums for status of various sorts
  enum DynamicStatus {
    inSmall = 0x01,
    atUpperBound = 0x02,
    atLowerBound = 0x03
  };
  /// Whether flagged
  inline bool flagged(int i) const {
    return (dynamicStatus_[i]&8)!=0;
  }
  inline void setFlagged(int i) {
    dynamicStatus_[i] |= 8;
  }
  inline void unsetFlagged(int i) {
    dynamicStatus_[i]  &= ~8;;
  }
  inline void setDynamicStatus(int sequence, DynamicStatus status)
  {
    unsigned char & st_byte = dynamicStatus_[sequence];
    st_byte &= ~7;
    st_byte |= status;
  }
  inline DynamicStatus getDynamicStatus(int sequence) const
  {return static_cast<DynamicStatus> (dynamicStatus_[sequence]&7);}
  /// Saved value of objective offset
  inline double objectiveOffset() const
  { return objectiveOffset_;}
  /// Starts of each column
  inline CoinBigIndex * startColumn() const
  { return startColumn_;}
  /// rows
  inline int * row() const
  { return row_;}
  /// elements
  inline double * element() const
  { return element_;}
  /// costs
  inline double * cost() const
  { return cost_;}
  /// full starts
  inline int * fullStart() const
  { return fullStart_;}
  /// ids of active columns (just index here)
  inline int * id() const
  { return id_;}
  /// Optional lower bounds on columns
  inline double * lowerColumn() const
  { return lowerColumn_;}
  /// Optional upper bounds on columns
  inline double * upperColumn() const
  { return upperColumn_;}
  /// Optional true lower bounds on sets
  inline double * lowerSet() const
  { return lowerSet_;}
  /// Optional true upper bounds on sets
  inline double * upperSet() const
  { return upperSet_;}
  /// size
  inline int numberGubColumns() const
  { return numberGubColumns_;}
  /// first free
  inline int firstAvailable() const
  { return firstAvailable_;}
  /// set first free
  inline void setFirstAvailable(int value)
  { firstAvailable_ = value;}
  /// first dynamic
  inline int firstDynamic() const
  { return firstDynamic_;}
  /// number of columns in dynamic model
  inline int lastDynamic() const
  { return lastDynamic_;}
  /// size of working matrix (max)
  inline int numberElements() const
  { return numberElements_;}
  /// Status region for gub slacks
  inline unsigned char * gubRowStatus() const
  { return status_;}
  /// Status region for gub variables
  inline unsigned char * dynamicStatus() const
  { return dynamicStatus_;}
  /// Returns which set a variable is in
  int whichSet (int sequence) const;
  //@}
   
    
protected:
  /**@name Data members
     The data members are protected to allow access for derived classes. */
  //@{
  /// Saved value of objective offset
  double objectiveOffset_;
  /// Starts of each column
  CoinBigIndex * startColumn_;
  /// rows
  int * row_;
  /// elements
  double * element_;
  /// costs
  double * cost_;
  /// full starts
  int * fullStart_;
  /// ids of active columns (just index here)
  int * id_;
  /// for status and which bound
  unsigned char * dynamicStatus_;
  /// Optional lower bounds on columns
  double * lowerColumn_;
  /// Optional upper bounds on columns
  double * upperColumn_;
  /// Optional true lower bounds on sets
  double * lowerSet_;
  /// Optional true upper bounds on sets
  double * upperSet_;
  /// size
  int numberGubColumns_;
  /// first free
  int firstAvailable_;
  /// saved first free
  int savedFirstAvailable_;
  /// first dynamic
  int firstDynamic_;
  /// number of columns in dynamic model
  int lastDynamic_;
  /// size of working matrix (max)
  int numberElements_;
   //@}
};

#endif