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