AbcPrimalColumnSteepest.hpp

Go to the documentation of this file.

/* $Id: AbcPrimalColumnSteepest.hpp 2385 2019-01-06 19:43:06Z unxusr $ */
// 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
*/