path: root/thirdparty/windows/include/coin/ClpFactorization.hpp

/* $Id: ClpFactorization.hpp 2078 2015-01-05 12:39:49Z forrest $ */
// 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);
     //@}

     /**@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;
     //@}
#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;
     }
#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;
#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
     //@}
};
 
#endif