/* $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 ClpFactorization_H
#define ClpFactorization_H

#include "CoinPragma.hpp"

#include "CoinFactorization.hpp"
class ClpMatrixBase;
class ClpSimplex;
class ClpNetworkBasis;
class CoinOtherFactorization;
#ifndef CLP_MULTIPLE_FACTORIZATIONS
#define CLP_MULTIPLE_FACTORIZATIONS 4
#endif
#ifdef CLP_MULTIPLE_FACTORIZATIONS
#include "CoinDenseFactorization.hpp"
#include "ClpSimplex.hpp"
#endif
#ifndef COIN_FAST_CODE
#define COIN_FAST_CODE
#endif
#ifndef CLP_FACTORIZATION_NEW_TIMING
#define CLP_FACTORIZATION_NEW_TIMING 1
#endif

/** This just implements CoinFactorization when an ClpMatrixBase object
    is passed.  If a network then has a dummy CoinFactorization and
    a genuine ClpNetworkBasis object
*/
class ClpFactorization
#ifndef CLP_MULTIPLE_FACTORIZATIONS
  : public CoinFactorization
#endif
{

  //friend class CoinFactorization;

public:
  /**@name factorization */
  //@{
  /** When part of LP - given by basic variables.
     Actually does factorization.
     Arrays passed in have non negative value to say basic.
     If status is okay, basic variables have pivot row - this is only needed
     if increasingRows_ >1.
     Allows scaling
     If status is singular, then basic variables have pivot row
     and ones thrown out have -1
     returns 0 -okay, -1 singular, -2 too many in basis, -99 memory */
  int factorize(ClpSimplex *model, int solveType, bool valuesPass);
  //@}

  /**@name Constructors, destructor */
  //@{
  /** Default constructor. */
  ClpFactorization();
  /** Destructor */
  ~ClpFactorization();
  //@}

  /**@name Copy method */
  //@{
  /** The copy constructor from an CoinFactorization. */
  ClpFactorization(const CoinFactorization &);
  /** The copy constructor. */
  ClpFactorization(const ClpFactorization &, int denseIfSmaller = 0);
#ifdef CLP_MULTIPLE_FACTORIZATIONS
  /** The copy constructor from an CoinOtherFactorization. */
  ClpFactorization(const CoinOtherFactorization &);
#endif
  ClpFactorization &operator=(const ClpFactorization &);
  //@}

  /*  **** below here is so can use networkish basis */
  /**@name rank one updates which do exist */
  //@{

  /** Replaces one Column to basis,
      returns 0=OK, 1=Probably OK, 2=singular, 3=no room
         If checkBeforeModifying is true will do all accuracy checks
         before modifying factorization.  Whether to set this depends on
         speed considerations.  You could just do this on first iteration
         after factorization and thereafter re-factorize
      partial update already in U */
  int replaceColumn(const ClpSimplex *model,
    CoinIndexedVector *regionSparse,
    CoinIndexedVector *tableauColumn,
    int pivotRow,
    double pivotCheck,
    bool checkBeforeModifying = false,
    double acceptablePivot = 1.0e-8);
#if ABOCA_LITE_FACTORIZATION
  /// Does btranU part of replaceColumn (skipping entries)
  void replaceColumn1(CoinIndexedVector *regionSparse, int pivotRow);
  /// Does replaceColumn - having already done btranU
  int replaceColumn2(CoinIndexedVector *regionSparse,
    int pivotRow,
    double pivotCheck);
#endif
  //@}

  /**@name various uses of factorization (return code number elements)
      which user may want to know about */
  //@{
  /** Updates one column (FTRAN) from region2
         Tries to do FT update
         number returned is negative if no room
         region1 starts as zero and is zero at end */
  int updateColumnFT(CoinIndexedVector *regionSparse,
    CoinIndexedVector *regionSparse2);
  /** Updates one column (FTRAN) from region2
         region1 starts as zero and is zero at end */
  int updateColumn(CoinIndexedVector *regionSparse,
    CoinIndexedVector *regionSparse2,
    bool noPermute = false) const;
  /** Updates one column (FTRAN) from region2
         Tries to do FT update
         number returned is negative if no room.
         Also updates region3
         region1 starts as zero and is zero at end */
  int updateTwoColumnsFT(CoinIndexedVector *regionSparse1,
    CoinIndexedVector *regionSparse2,
    CoinIndexedVector *regionSparse3,
    bool noPermuteRegion3 = false);
  /// For debug (no statistics update)
  int updateColumnForDebug(CoinIndexedVector *regionSparse,
    CoinIndexedVector *regionSparse2,
    bool noPermute = false) const;
  /** Updates one column (BTRAN) from region2
         region1 starts as zero and is zero at end */
  int updateColumnTranspose(CoinIndexedVector *regionSparse,
    CoinIndexedVector *regionSparse2) const;
  /** Updates two columns (BTRAN) from regionSparse2 and 3
	 regionSparse starts as zero and is zero at end 
	 Note - if regionSparse2 packed on input - will be packed on output - same for 3
     */
  void updateTwoColumnsTranspose(CoinIndexedVector *regionSparse,
    CoinIndexedVector *regionSparse2,
    CoinIndexedVector *regionSparse3) const;
  //@}
#ifdef CLP_MULTIPLE_FACTORIZATIONS
  /**@name Lifted from CoinFactorization */
  //@{
  /// Total number of elements in factorization
  inline int numberElements() const
  {
    if (coinFactorizationA_)
      return coinFactorizationA_->numberElements();
    else
      return coinFactorizationB_->numberElements();
  }
  /// Returns address of permute region
  inline int *permute() const
  {
    if (coinFactorizationA_)
      return coinFactorizationA_->permute();
    else
      return coinFactorizationB_->permute();
  }
  /// Returns address of pivotColumn region (also used for permuting)
  inline int *pivotColumn() const
  {
    if (coinFactorizationA_)
      return coinFactorizationA_->pivotColumn();
    else
      return coinFactorizationB_->permute();
  }
  /// Maximum number of pivots between factorizations
  inline int maximumPivots() const
  {
    if (coinFactorizationA_)
      return coinFactorizationA_->maximumPivots();
    else
      return coinFactorizationB_->maximumPivots();
  }
  /// Set maximum number of pivots between factorizations
  inline void maximumPivots(int value)
  {
    if (coinFactorizationA_)
      coinFactorizationA_->maximumPivots(value);
    else
      coinFactorizationB_->maximumPivots(value);
  }
  /// Returns number of pivots since factorization
  inline int pivots() const
  {
    if (coinFactorizationA_)
      return coinFactorizationA_->pivots();
    else
      return coinFactorizationB_->pivots();
  }
  /// Whether larger areas needed
  inline double areaFactor() const
  {
    if (coinFactorizationA_)
      return coinFactorizationA_->areaFactor();
    else
      return 0.0;
  }
  /// Set whether larger areas needed
  inline void areaFactor(double value)
  {
    if (coinFactorizationA_)
      coinFactorizationA_->areaFactor(value);
  }
  /// Zero tolerance
  inline double zeroTolerance() const
  {
    if (coinFactorizationA_)
      return coinFactorizationA_->zeroTolerance();
    else
      return coinFactorizationB_->zeroTolerance();
  }
  /// Set zero tolerance
  inline void zeroTolerance(double value)
  {
    if (coinFactorizationA_)
      coinFactorizationA_->zeroTolerance(value);
    else
      coinFactorizationB_->zeroTolerance(value);
  }
  /// Set tolerances to safer of existing and given
  void saferTolerances(double zeroTolerance, double pivotTolerance);
  /**  get sparse threshold */
  inline int sparseThreshold() const
  {
    if (coinFactorizationA_)
      return coinFactorizationA_->sparseThreshold();
    else
      return 0;
  }
  /**  Set sparse threshold */
  inline void sparseThreshold(int value)
  {
    if (coinFactorizationA_)
      coinFactorizationA_->sparseThreshold(value);
  }
  /// Returns status
  inline int status() const
  {
    if (coinFactorizationA_)
      return coinFactorizationA_->status();
    else
      return coinFactorizationB_->status();
  }
  /// Sets status
  inline void setStatus(int value)
  {
    if (coinFactorizationA_)
      coinFactorizationA_->setStatus(value);
    else
      coinFactorizationB_->setStatus(value);
  }
  /// Returns number of dense rows
  inline int numberDense() const
  {
    if (coinFactorizationA_)
      return coinFactorizationA_->numberDense();
    else
      return 0;
  }
#if 1
  /// Returns number in U area
  inline CoinBigIndex numberElementsU() const
  {
    if (coinFactorizationA_)
      return coinFactorizationA_->numberElementsU();
    else
      return -1;
  }
  /// Returns number in L area
  inline CoinBigIndex numberElementsL() const
  {
    if (coinFactorizationA_)
      return coinFactorizationA_->numberElementsL();
    else
      return -1;
  }
  /// Returns number in R area
  inline CoinBigIndex numberElementsR() const
  {
    if (coinFactorizationA_)
      return coinFactorizationA_->numberElementsR();
    else
      return 0;
  }
#endif
  bool timeToRefactorize() const;
#if CLP_FACTORIZATION_NEW_TIMING > 1
  void statsRefactor(char when) const;
#endif
  /// Level of detail of messages
  inline int messageLevel() const
  {
    if (coinFactorizationA_)
      return coinFactorizationA_->messageLevel();
    else
      return 1;
  }
  /// Set level of detail of messages
  inline void messageLevel(int value)
  {
    if (coinFactorizationA_)
      coinFactorizationA_->messageLevel(value);
  }
  /// Get rid of all memory
  inline void clearArrays()
  {
    if (coinFactorizationA_)
      coinFactorizationA_->clearArrays();
    else if (coinFactorizationB_)
      coinFactorizationB_->clearArrays();
  }
  /// Number of Rows after factorization
  inline int numberRows() const
  {
    if (coinFactorizationA_)
      return coinFactorizationA_->numberRows();
    else
      return coinFactorizationB_->numberRows();
  }
  /// Gets dense threshold
  inline int denseThreshold() const
  {
    if (coinFactorizationA_)
      return coinFactorizationA_->denseThreshold();
    else
      return 0;
  }
  /// Sets dense threshold
  inline void setDenseThreshold(int value)
  {
    if (coinFactorizationA_)
      coinFactorizationA_->setDenseThreshold(value);
  }
  /// Pivot tolerance
  inline double pivotTolerance() const
  {
    if (coinFactorizationA_)
      return coinFactorizationA_->pivotTolerance();
    else if (coinFactorizationB_)
      return coinFactorizationB_->pivotTolerance();
    return 1.0e-8;
  }
  /// Set pivot tolerance
  inline void pivotTolerance(double value)
  {
    if (coinFactorizationA_)
      coinFactorizationA_->pivotTolerance(value);
    else if (coinFactorizationB_)
      coinFactorizationB_->pivotTolerance(value);
  }
  /// Allows change of pivot accuracy check 1.0 == none >1.0 relaxed
  inline void relaxAccuracyCheck(double value)
  {
    if (coinFactorizationA_)
      coinFactorizationA_->relaxAccuracyCheck(value);
  }
  /** Array persistence flag
         If 0 then as now (delete/new)
         1 then only do arrays if bigger needed
         2 as 1 but give a bit extra if bigger needed
     */
  inline int persistenceFlag() const
  {
    if (coinFactorizationA_)
      return coinFactorizationA_->persistenceFlag();
    else
      return 0;
  }
  inline void setPersistenceFlag(int value)
  {
    if (coinFactorizationA_)
      coinFactorizationA_->setPersistenceFlag(value);
  }
  /// Delete all stuff (leaves as after CoinFactorization())
  inline void almostDestructor()
  {
    if (coinFactorizationA_)
      coinFactorizationA_->almostDestructor();
    else if (coinFactorizationB_)
      coinFactorizationB_->clearArrays();
  }
  /// Returns areaFactor but adjusted for dense
  inline double adjustedAreaFactor() const
  {
    if (coinFactorizationA_)
      return coinFactorizationA_->adjustedAreaFactor();
    else
      return 0.0;
  }
  inline void setBiasLU(int value)
  {
    if (coinFactorizationA_)
      coinFactorizationA_->setBiasLU(value);
  }
  /// true if Forrest Tomlin update, false if PFI
  inline void setForrestTomlin(bool value)
  {
    if (coinFactorizationA_)
      coinFactorizationA_->setForrestTomlin(value);
  }
  /// Sets default values
  inline void setDefaultValues()
  {
    if (coinFactorizationA_) {
      // row activities have negative sign
#ifndef COIN_FAST_CODE
      coinFactorizationA_->slackValue(-1.0);
#endif
      coinFactorizationA_->zeroTolerance(1.0e-13);
    }
  }
  /// If nonzero force use of 1,dense 2,small 3,osl
  void forceOtherFactorization(int which);
  /// Get switch to osl if number rows <= this
  inline int goOslThreshold() const
  {
    return goOslThreshold_;
  }
  /// Set switch to osl if number rows <= this
  inline void setGoOslThreshold(int value)
  {
    goOslThreshold_ = value;
  }
  /// Get switch to dense if number rows <= this
  inline int goDenseThreshold() const
  {
    return goDenseThreshold_;
  }
  /// Set switch to dense if number rows <= this
  inline void setGoDenseThreshold(int value)
  {
    goDenseThreshold_ = value;
  }
  /// Get switch to small if number rows <= this
  inline int goSmallThreshold() const
  {
    return goSmallThreshold_;
  }
  /// Set switch to small if number rows <= this
  inline void setGoSmallThreshold(int value)
  {
    goSmallThreshold_ = value;
  }
  /// Go over to dense or small code if small enough
  void goDenseOrSmall(int numberRows);
  /// Sets factorization
  void setFactorization(ClpFactorization &factorization);
  /// Return 1 if dense code
  inline int isDenseOrSmall() const
  {
    return coinFactorizationB_ ? 1 : 0;
  }
  /// Return coinFactorizationA_
  inline CoinFactorization *coinFactorization() const
  {
    return coinFactorizationA_;
  }
#else
  inline bool timeToRefactorize() const
  {
    return (pivots() * 3 > maximumPivots() * 2 && numberElementsR() * 3 > (numberElementsL() + numberElementsU()) * 2 + 1000 && !numberDense());
  }
  /// Sets default values
  inline void setDefaultValues()
  {
    // row activities have negative sign
#ifndef COIN_FAST_CODE
    slackValue(-1.0);
#endif
    zeroTolerance(1.0e-13);
  }
  /// Go over to dense code
  inline void goDense() {}
#endif
  //@}

  /**@name other stuff */
  //@{
  /** makes a row copy of L for speed and to allow very sparse problems */
  void goSparse();
  /// Cleans up i.e. gets rid of network basis
  void cleanUp();
  /// Says whether to redo pivot order
  bool needToReorder() const;
  /// To switch statistics on or off
  inline void doStatistics(bool trueFalse) const
  {
    doStatistics_ = trueFalse;
  }
#ifndef SLIM_CLP
  /// Says if a network basis
  inline bool networkBasis() const
  {
    return (networkBasis_ != NULL);
  }
#else
  /// Says if a network basis
  inline bool networkBasis() const
  {
    return false;
  }
#endif
  /// Fills weighted row list
  void getWeights(int *weights) const;
  //@}

  ////////////////// data //////////////////
private:
  /**@name data */
  //@{
  /// Pointer to network basis
#ifndef SLIM_CLP
  ClpNetworkBasis *networkBasis_;
#endif
#ifdef CLP_MULTIPLE_FACTORIZATIONS
  /// Pointer to CoinFactorization
  CoinFactorization *coinFactorizationA_;
  /// Pointer to CoinOtherFactorization
  CoinOtherFactorization *coinFactorizationB_;
#ifdef CLP_REUSE_ETAS
  /// Pointer to model
  ClpSimplex *model_;
#endif
  /// If nonzero force use of 1,dense 2,small 3,osl
  int forceB_;
  /// Switch to osl if number rows <= this
  int goOslThreshold_;
  /// Switch to small if number rows <= this
  int goSmallThreshold_;
  /// Switch to dense if number rows <= this
  int goDenseThreshold_;
#endif
#ifdef CLP_FACTORIZATION_NEW_TIMING
  /// For guessing when to re-factorize
  mutable double shortestAverage_;
  mutable double totalInR_;
  mutable double totalInIncreasingU_;
  mutable int endLengthU_;
  mutable int lastNumberPivots_;
  mutable int effectiveStartNumberU_;
#endif
  /// To switch statistics on or off
  mutable bool doStatistics_;
  //@}
};

#endif

/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/