ClpPrimalColumnSteepest.hpp

Go to the documentation of this file.

/* $Id: ClpPrimalColumnSteepest.hpp 1665 2011-01-04 17:55:54Z lou $ */
// Copyright (C) 2002, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).
 
#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 * spareRow2,
                  CoinIndexedVector * spareColumn1,
                  CoinIndexedVector * spareColumn2);
     int partialPricing(CoinIndexedVector * updates,
                        CoinIndexedVector * spareRow2,
                        int numberWanted,
                        int numberLook);
     void djsAndDevex(CoinIndexedVector * updates,
                      CoinIndexedVector * spareRow2,
                      CoinIndexedVector * spareColumn1,
                      CoinIndexedVector * spareColumn2);
     void djsAndSteepest(CoinIndexedVector * updates,
                         CoinIndexedVector * spareRow2,
                         CoinIndexedVector * spareColumn1,
                         CoinIndexedVector * spareColumn2);
     void djsAndDevex2(CoinIndexedVector * updates,
                       CoinIndexedVector * spareRow2,
                       CoinIndexedVector * spareColumn1,
                       CoinIndexedVector * spareColumn2);
     void djsAndSteepest2(CoinIndexedVector * updates,
                          CoinIndexedVector * spareRow2,
                          CoinIndexedVector * spareColumn1,
                          CoinIndexedVector * spareColumn2);
     void justDevex(CoinIndexedVector * updates,
                    CoinIndexedVector * spareRow2,
                    CoinIndexedVector * spareColumn1,
                    CoinIndexedVector * spareColumn2);
     void justSteepest(CoinIndexedVector * updates,
                       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 & rhs);
 
     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