casadi 3.6.7__cp313-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

casadi/include/coin/ClpFactorization.hpp

@@ -0,0 +1,556 @@
+/* $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
+*/