AbcPrimalColumnSteepest.hpp

Go to the documentation of this file.

/* $Id$ */
// 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
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/