ClpPrimalColumnSteepest.hpp

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

#include "ClpPrimalColumnPivot.hpp"
#include <bitset>

//#############################################################################


class CoinIndexedVector;

class ClpPrimalColumnSteepest : public ClpPrimalColumnPivot {
  
public:
  

  
  virtual int pivotColumn(CoinIndexedVector * updates,
                          CoinIndexedVector * spareRow1,
                          CoinIndexedVector * spareRow2,
                          CoinIndexedVector * spareColumn1,
                          CoinIndexedVector * spareColumn2);
  int pivotColumnOldMethod(CoinIndexedVector * updates,
                          CoinIndexedVector * spareRow1,
                          CoinIndexedVector * spareRow2,
                          CoinIndexedVector * spareColumn1,
                          CoinIndexedVector * spareColumn2);
  void justDjs(CoinIndexedVector * updates,
               CoinIndexedVector * spareRow1,
               CoinIndexedVector * spareRow2,
               CoinIndexedVector * spareColumn1,
               CoinIndexedVector * spareColumn2);
  int partialPricing(CoinIndexedVector * updates,
                     CoinIndexedVector * spareRow2,
                     int numberToDo);
  void djsAndDevex(CoinIndexedVector * updates,
               CoinIndexedVector * spareRow1,
               CoinIndexedVector * spareRow2,
               CoinIndexedVector * spareColumn1,
               CoinIndexedVector * spareColumn2);
  void djsAndSteepest(CoinIndexedVector * updates,
               CoinIndexedVector * spareRow1,
               CoinIndexedVector * spareRow2,
               CoinIndexedVector * spareColumn1,
               CoinIndexedVector * spareColumn2);
  void djsAndDevex2(CoinIndexedVector * updates,
               CoinIndexedVector * spareRow1,
               CoinIndexedVector * spareRow2,
               CoinIndexedVector * spareColumn1,
               CoinIndexedVector * spareColumn2);
  void djsAndSteepest2(CoinIndexedVector * updates,
               CoinIndexedVector * spareRow1,
               CoinIndexedVector * spareRow2,
               CoinIndexedVector * spareColumn1,
               CoinIndexedVector * spareColumn2);
  void justDevex(CoinIndexedVector * updates,
               CoinIndexedVector * spareRow1,
               CoinIndexedVector * spareRow2,
               CoinIndexedVector * spareColumn1,
               CoinIndexedVector * spareColumn2);
  void justSteepest(CoinIndexedVector * updates,
               CoinIndexedVector * spareRow1,
               CoinIndexedVector * spareRow2,
               CoinIndexedVector * spareColumn1,
               CoinIndexedVector * spareColumn2);

  virtual void updateWeights(CoinIndexedVector * input);

  void checkAccuracy(int sequence,double relativeTolerance,
                     CoinIndexedVector * rowArray1,
                     CoinIndexedVector * rowArray2);

  void initializeWeights();

  virtual void saveWeights(ClpSimplex * model,int mode);
  virtual void unrollWeights();
  virtual void clearArrays();
  virtual bool looksOptimal() const;
  

  inline int mode() const
    { return mode_;};
  virtual int numberSprintColumns(int & numberIterations) const;
  virtual void switchOffSprint();
  

  


  ClpPrimalColumnSteepest(int mode=3); 
  
  ClpPrimalColumnSteepest(const ClpPrimalColumnSteepest &);
  
  ClpPrimalColumnSteepest & operator=(const ClpPrimalColumnSteepest& rhs);
  
  virtual ~ClpPrimalColumnSteepest ();

  virtual ClpPrimalColumnPivot * clone(bool copyData = true) const;
 


  inline bool reference(int i) const {
    return ((reference_[i>>5]>>(i&31))&1)!=0;
  }
  inline void setReference(int i,bool trueFalse) {
    unsigned int & value = reference_[i>>5];
    int bit = i&31;
    if (trueFalse)
      value |= (1<<bit);
    else
      value &= ~(1<<bit);
  }
  //---------------------------------------------------------------------------
  
private:
  // Update weight
  double devex_;
  double * weights_;
  CoinIndexedVector * infeasible_;
  CoinIndexedVector * alternateWeights_;
  double * savedWeights_;
  // Array for exact devex to say what is in reference framework
  unsigned int * reference_;
  int state_;
  int mode_;
  int numberSwitched_;
  // This is pivot row (or pivot sequence round re-factorization)
  int pivotSequence_;  
  // This is saved pivot sequence
  int savedPivotSequence_;  
  // This is saved outgoing variable
  int savedSequenceOut_;  
  // Size of factorization at invert (used to decide algorithm)
  int sizeFactorization_;
};

#endif

---