/home/coin/SVN-release/CoinAll-1.1.0/Clp/src/ClpPrimalColumnSteepest.hpp

Go to the documentation of this file.

// 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 numberWanted,
                     int numberLook);
  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);
  void transposeTimes2(const CoinIndexedVector * pi1, CoinIndexedVector * dj1,
                       const CoinIndexedVector * pi2, CoinIndexedVector * dj2,
                       CoinIndexedVector * spare,double scaleFactor);

  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;
  virtual void maximumPivotsChanged();
  

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

  enum Persistence {
    normal = 0x00, // create (if necessary) and destroy
    keep = 0x01 // create (if necessary) and leave
  };
  


  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);
  }
  inline void setPersistence(Persistence life)
  { persistence_ = life;}
  inline Persistence persistence() const
  { return persistence_ ;}
 
  //---------------------------------------------------------------------------
  
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_;
  Persistence persistence_;
  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_;  
  // Iteration when last rectified
  int lastRectified_;
  // Size of factorization at invert (used to decide algorithm)
  int sizeFactorization_;
};

#endif

---