AbcPrimalColumnSteepest.hpp

Go to the documentation of this file.

/* $Id: AbcPrimalColumnSteepest.hpp 1910 2013-01-27 02:00:13Z stefan $ */
// Copyright (C) 2002, International Business Machines
// Corporation and others, Copyright (C) 2012, FasterCoin.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).

#ifndef AbcPrimalColumnSteepest_H
#define AbcPrimalColumnSteepest_H

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

//#############################################################################
class CoinIndexedVector;


class AbcPrimalColumnSteepest : public AbcPrimalColumnPivot {

public:



     virtual int pivotColumn(CoinPartitionedVector * updates,
                             CoinPartitionedVector * spareRow2,
                             CoinPartitionedVector * spareColumn1);
     void justDjs(CoinIndexedVector * updates,
                  CoinIndexedVector * spareColumn1);
     int partialPricing(CoinIndexedVector * updates,
                        int numberWanted,
                        int numberLook);
     void djsAndDevex(CoinIndexedVector * updates,
                      CoinIndexedVector * spareRow2,
                      CoinIndexedVector * spareColumn1);
     void djsAndDevex2(CoinIndexedVector * updates,
                       CoinIndexedVector * spareColumn1);
     void justDevex(CoinIndexedVector * updates,
                    CoinIndexedVector * spareColumn1);
     int doSteepestWork(CoinPartitionedVector * updates,
                        CoinPartitionedVector * spareRow2,
                        CoinPartitionedVector * spareColumn1,
                        int type);

     virtual void updateWeights(CoinIndexedVector * input);

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

     void initializeWeights();

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

     inline int mode() const {
          return mode_;
     }

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



     AbcPrimalColumnSteepest(int mode = 3);

     AbcPrimalColumnSteepest(const AbcPrimalColumnSteepest & rhs);

     AbcPrimalColumnSteepest & operator=(const AbcPrimalColumnSteepest& rhs);

     virtual ~AbcPrimalColumnSteepest ();

     virtual AbcPrimalColumnPivot * 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