Windows Included

1 files changed, 432 insertions, 0 deletions

diff --git a/thirdparty/windows/include/coin/ClpFactorization.hpp b/thirdparty/windows/include/coin/ClpFactorization.hpp
new file mode 100644
index 0000000..dda8ff7
--- /dev/null
+++ b/thirdparty/windows/include/coin/ClpFactorization.hpp
@@ -0,0 +1,432 @@
+/* $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