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