/* $Id: AbcDualRowPivot.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 AbcDualRowPivot_H
#define AbcDualRowPivot_H
#include "AbcCommon.hpp"

class AbcSimplex;
class CoinIndexedVector;

//#############################################################################

/** Dual Row Pivot Abstract Base Class
    
    Abstract Base Class for describing an interface to an algorithm
    to choose row pivot in dual simplex algorithm.  For some algorithms
    e.g. Dantzig choice then some functions may be null.
    
*/

class AbcDualRowPivot  {
  
public:
  
  ///@name Algorithmic methods
  //@{
  
  /// Returns pivot row, -1 if none
  virtual int pivotRow() = 0;
  
  /** Does most of work for weights and returns pivot alpha.
      Also does FT update */
  virtual double updateWeights1(CoinIndexedVector & input,CoinIndexedVector & updateColumn) = 0;
  virtual void updateWeightsOnly(CoinIndexedVector & input) = 0;
  virtual double updateWeights(CoinIndexedVector & input,CoinIndexedVector & updateColumn) = 0;
  /// Actually updates weights
  virtual void updateWeights2(CoinIndexedVector & input,CoinIndexedVector & updateColumn) = 0;
  
  /** Updates primal solution (and maybe list of candidates)
      Uses input vector which it deletes
      Would be faster if we kept basic regions, but on other hand it
      means everything is always in sync
  */
  virtual void updatePrimalSolution(CoinIndexedVector & updateColumn,
				    double theta) = 0;
  virtual void updatePrimalSolutionAndWeights(CoinIndexedVector & weightsVector,
				    CoinIndexedVector & updateColumn,
					      double theta);
  /** Saves any weights round factorization as pivot rows may change
      Will be empty unless steepest edge (will save model)
      May also recompute infeasibility stuff
      1) before factorization
      2) after good factorization (if weights empty may initialize)
      3) after something happened but no factorization
      (e.g. check for infeasible)
      4) as 2 but restore weights from previous snapshot
      5) for strong branching - initialize  , infeasibilities
  */
  virtual void saveWeights(AbcSimplex * model, int mode);
  /// Recompute infeasibilities
  virtual void recomputeInfeasibilities();
  /// checks accuracy and may re-initialize (may be empty)
  virtual void checkAccuracy();
  /// Gets rid of all arrays (may be empty)
  virtual void clearArrays();
  /// Returns true if would not find any row
  virtual bool looksOptimal() const {
    return false;
  }
  //@}
  
  
  ///@name Constructors and destructors
  //@{
  /// Default Constructor
  AbcDualRowPivot();
  
  /// Copy constructor
  AbcDualRowPivot(const AbcDualRowPivot &);
  
  /// Assignment operator
  AbcDualRowPivot & operator=(const AbcDualRowPivot& rhs);
  
  /// Destructor
  virtual ~AbcDualRowPivot ();
  
  /// Clone
  virtual AbcDualRowPivot * clone(bool copyData = true) const = 0;
  
  //@}
  
  ///@name Other
  //@{
  /// Returns model
  inline AbcSimplex * model() {
    return model_;
  }
  
  /// Sets model (normally to NULL)
  inline void setModel(AbcSimplex * newmodel) {
    model_ = newmodel;
  }
  
  /// Returns type (above 63 is extra information)
  inline int type() {
    return type_;
  }
  
  //@}
  
  //---------------------------------------------------------------------------
  
protected:
  ///@name Protected member data
  //@{
  /// Pointer to model
  AbcSimplex * model_;
  /// Type of row pivot algorithm
  int type_;
  //@}
};
#ifndef CLP_DUAL_COLUMN_MULTIPLIER
//#define CLP_DUAL_COLUMN_MULTIPLIER 0.99999
#endif
#endif
