ClpPrimalColumnSteepest.hpp

Go to the documentation of this file.

/* $Id$ */
// 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);
  int 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);
  void redoInfeasibilities();
  virtual void unrollWeights();
  virtual void clearArrays();
  virtual bool looksOptimal() const;
  virtual void maximumPivotsChanged();
 
  inline int mode() const
  {
    return mode_;
  }
  inline void setMode(int mode)
  {
    mode_ = mode;
  }
  inline CoinIndexedVector *infeasible() const
  {
    return infeasible_;
  }
  inline const double *weights() const
  {
    return weights_;
  }
  inline CoinIndexedVector *alternateWeights() const
  {
    return alternateWeights_;
  }
  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_;
  }
 
  //---------------------------------------------------------------------------
 
protected:
  // 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_;
  /* Infeasibility state i.e. array of infeasibilities and sequenceIn-
        0 - correct
        1 - needs correcting
        2 - not known but column sequence has been chosen
     */
  int infeasibilitiesState_;
  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
*/