casadi 3.6.7__cp313-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

casadi/include/coin/ClpAmplObjective.hpp

@@ -0,0 +1,113 @@
+/* $Id$ */
+// Copyright (C) 2007, International Business Machines
+// Corporation and others.  All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef ClpAmplObjective_H
+#define ClpAmplObjective_H
+
+#include "ClpObjective.hpp"
+#include "CoinPackedMatrix.hpp"
+
+//#############################################################################
+
+/** Ampl Objective Class
+
+*/
+
+class ClpAmplObjective : public ClpObjective {
+
+public:
+  ///@name Stuff
+  //@{
+
+  /** Returns gradient.  If Ampl then solution may be NULL,
+        also returns an offset (to be added to current one)
+        If refresh is false then uses last solution
+        Uses model for scaling
+        includeLinear 0 - no, 1 as is, 2 as feasible
+    */
+  virtual double *gradient(const ClpSimplex *model,
+    const double *solution, double &offset, bool refresh,
+    int includeLinear = 2);
+  /// Resize objective
+  /** Returns reduced gradient.Returns an offset (to be added to current one).
+    */
+  virtual double reducedGradient(ClpSimplex *model, double *region,
+    bool useFeasibleCosts);
+  /** Returns step length which gives minimum of objective for
+        solution + theta * change vector up to maximum theta.
+
+        arrays are numberColumns+numberRows
+        Also sets current objective, predicted and at maximumTheta
+    */
+  virtual double stepLength(ClpSimplex *model,
+    const double *solution,
+    const double *change,
+    double maximumTheta,
+    double &currentObj,
+    double &predictedObj,
+    double &thetaObj);
+  /// Return objective value (without any ClpModel offset) (model may be NULL)
+  virtual double objectiveValue(const ClpSimplex *model, const double *solution) const;
+  virtual void resize(int newNumberColumns);
+  /// Delete columns in  objective
+  virtual void deleteSome(int numberToDelete, const int *which);
+  /// Scale objective
+  virtual void reallyScale(const double *columnScale);
+  /** Given a zeroed array sets nonlinear columns to 1.
+        Returns number of nonlinear columns
+     */
+  virtual int markNonlinear(char *which);
+
+  /// Say we have new primal solution - so may need to recompute
+  virtual void newXValues();
+  //@}
+
+  ///@name Constructors and destructors
+  //@{
+  /// Default Constructor
+  ClpAmplObjective();
+
+  /// Constructor from ampl info
+  ClpAmplObjective(void *amplInfo);
+
+  /** Copy constructor .
+    */
+  ClpAmplObjective(const ClpAmplObjective &rhs);
+
+  /// Assignment operator
+  ClpAmplObjective &operator=(const ClpAmplObjective &rhs);
+
+  /// Destructor
+  virtual ~ClpAmplObjective();
+
+  /// Clone
+  virtual ClpObjective *clone() const;
+
+  //@}
+  ///@name Gets and sets
+  //@{
+  /// Linear objective
+  double *linearObjective() const;
+  //@}
+
+  //---------------------------------------------------------------------------
+
+private:
+  ///@name Private member data
+  /// Saved offset
+  double offset_;
+  /// Ampl info
+  void *amplObjective_;
+  /// Objective
+  double *objective_;
+  /// Gradient
+  double *gradient_;
+  //@}
+};
+
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/ClpCholeskyBase.hpp

@@ -0,0 +1,321 @@
+/* $Id$ */
+// Copyright (C) 2003, International Business Machines
+// Corporation and others.  All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef ClpCholeskyBase_H
+#define ClpCholeskyBase_H
+
+#include "CoinPragma.hpp"
+#include "CoinTypes.hpp"
+//#define CLP_LONG_CHOLESKY 0
+#ifndef CLP_LONG_CHOLESKY
+#define CLP_LONG_CHOLESKY 0
+#endif
+/* valid combinations are
+   CLP_LONG_CHOLESKY 0 and COIN_LONG_WORK 0
+   CLP_LONG_CHOLESKY 1 and COIN_LONG_WORK 1
+   CLP_LONG_CHOLESKY 2 and COIN_LONG_WORK 1
+*/
+#if COIN_LONG_WORK == 0
+#if CLP_LONG_CHOLESKY > 0
+#define CHOLESKY_BAD_COMBINATION
+#endif
+#else
+#if CLP_LONG_CHOLESKY == 0
+#define CHOLESKY_BAD_COMBINATION
+#endif
+#endif
+#ifdef CHOLESKY_BAD_COMBINATION
+#warning("Bad combination of CLP_LONG_CHOLESKY and COIN_BIG_DOUBLE/COIN_LONG_WORK");
+"Bad combination of CLP_LONG_CHOLESKY and COIN_LONG_WORK"
+#endif
+#if CLP_LONG_CHOLESKY > 1
+  typedef long double longDouble;
+#define CHOL_SMALL_VALUE 1.0e-15
+#elif CLP_LONG_CHOLESKY == 1
+typedef double longDouble;
+#define CHOL_SMALL_VALUE 1.0e-11
+#else
+typedef double longDouble;
+#define CHOL_SMALL_VALUE 1.0e-11
+#endif
+class ClpInterior;
+class ClpCholeskyDense;
+class ClpMatrixBase;
+
+/** Base class for Clp Cholesky factorization
+    Will do better factorization.  very crude ordering
+
+    Derived classes may be using more sophisticated methods
+*/
+
+class ClpCholeskyBase {
+
+public:
+  /**@name Virtual methods that the derived classes may provide  */
+  //@{
+  /** Orders rows and saves pointer to matrix.and model.
+      returns non-zero if not enough memory.
+      You can use preOrder to set up ADAT
+      If using default symbolic etc then must set sizeFactor_ to
+      size of input matrix to order (and to symbolic).
+      Also just permute_ and permuteInverse_ should be created */
+  virtual int order(ClpInterior *model);
+  /** Does Symbolic factorization given permutation.
+         This is called immediately after order.  If user provides this then
+         user must provide factorize and solve.  Otherwise the default factorization is used
+         returns non-zero if not enough memory */
+  virtual int symbolic();
+  /** Factorize - filling in rowsDropped and returning number dropped.
+         If return code negative then out of memory */
+  virtual int factorize(const CoinWorkDouble *diagonal, int *rowsDropped);
+  /** Uses factorization to solve. */
+  virtual void solve(CoinWorkDouble *region);
+  /** Uses factorization to solve. - given as if KKT.
+      region1 is rows+columns, region2 is rows */
+  virtual void solveKKT(CoinWorkDouble *region1, CoinWorkDouble *region2, const CoinWorkDouble *diagonal,
+    CoinWorkDouble diagonalScaleFactor);
+
+private:
+  /// AMD ordering
+  int orderAMD();
+
+public:
+  //@}
+
+  /**@name Gets */
+  //@{
+  /// status.  Returns status
+  inline int status() const
+  {
+    return status_;
+  }
+  /// numberRowsDropped.  Number of rows gone
+  inline int numberRowsDropped() const
+  {
+    return numberRowsDropped_;
+  }
+  /// reset numberRowsDropped and rowsDropped.
+  void resetRowsDropped();
+  /// rowsDropped - which rows are gone
+  inline char *rowsDropped() const
+  {
+    return rowsDropped_;
+  }
+  /// choleskyCondition.
+  inline double choleskyCondition() const
+  {
+    return choleskyCondition_;
+  }
+  /// goDense i.e. use dense factoriaztion if > this (default 0.7).
+  inline double goDense() const
+  {
+    return goDense_;
+  }
+  /// goDense i.e. use dense factoriaztion if > this (default 0.7).
+  inline void setGoDense(double value)
+  {
+    goDense_ = value;
+  }
+  /// rank.  Returns rank
+  inline int rank() const
+  {
+    return numberRows_ - numberRowsDropped_;
+  }
+  /// Return number of rows
+  inline int numberRows() const
+  {
+    return numberRows_;
+  }
+  /// Return size
+  inline int size() const
+  {
+    return sizeFactor_;
+  }
+  /// Return sparseFactor
+  inline longDouble *sparseFactor() const
+  {
+    return sparseFactor_;
+  }
+  /// Return diagonal
+  inline longDouble *diagonal() const
+  {
+    return diagonal_;
+  }
+  /// Return workDouble
+  inline longDouble *workDouble() const
+  {
+    return workDouble_;
+  }
+  /// If KKT on
+  inline bool kkt() const
+  {
+    return doKKT_;
+  }
+  /// Set KKT
+  inline void setKKT(bool yesNo)
+  {
+    doKKT_ = yesNo;
+  }
+  /// Set integer parameter
+  inline void setIntegerParameter(int i, int value)
+  {
+    integerParameters_[i] = value;
+  }
+  /// get integer parameter
+  inline int getIntegerParameter(int i)
+  {
+    return integerParameters_[i];
+  }
+  /// Set double parameter
+  inline void setDoubleParameter(int i, double value)
+  {
+    doubleParameters_[i] = value;
+  }
+  /// get double parameter
+  inline double getDoubleParameter(int i)
+  {
+    return doubleParameters_[i];
+  }
+  //@}
+
+public:
+  /**@name Constructors, destructor
+      */
+  //@{
+  /** Constructor which has dense columns activated.
+         Default is off. */
+  ClpCholeskyBase(int denseThreshold = -1);
+  /** Destructor (has to be public) */
+  virtual ~ClpCholeskyBase();
+  /// Copy
+  ClpCholeskyBase(const ClpCholeskyBase &);
+  /// Assignment
+  ClpCholeskyBase &operator=(const ClpCholeskyBase &);
+  //@}
+  //@{
+  ///@name Other
+  /// Clone
+  virtual ClpCholeskyBase *clone() const;
+
+  /// Returns type
+  inline int type() const
+  {
+    if (doKKT_)
+      return 100;
+    else
+      return type_;
+  }
+
+protected:
+  /// Sets type
+  inline void setType(int type)
+  {
+    type_ = type;
+  }
+  /// model.
+  inline void setModel(ClpInterior *model)
+  {
+    model_ = model;
+  }
+  //@}
+
+  /**@name Symbolic, factor and solve */
+  //@{
+  /** Symbolic1  - works out size without clever stuff.
+         Uses upper triangular as much easier.
+         Returns size
+      */
+  int symbolic1(const int *Astart, const int *Arow);
+  /** Symbolic2  - Fills in indices
+         Uses lower triangular so can do cliques etc
+      */
+  void symbolic2(const int *Astart, const int *Arow);
+  /** Factorize - filling in rowsDropped and returning number dropped
+         in integerParam.
+      */
+  void factorizePart2(int *rowsDropped);
+  /** solve - 1 just first half, 2 just second half - 3 both.
+     If 1 and 2 then diagonal has sqrt of inverse otherwise inverse
+     */
+  void solve(CoinWorkDouble *region, int type);
+  /// Forms ADAT - returns nonzero if not enough memory
+  int preOrder(bool lowerTriangular, bool includeDiagonal, bool doKKT);
+  /// Updates dense part (broken out for profiling)
+  void updateDense(longDouble *d, /*longDouble * work,*/ int *first);
+  //@}
+
+protected:
+  /**@name Data members
+        The data members are protected to allow access for derived classes. */
+  //@{
+  /// type (may be useful) if > 20 do KKT
+  int type_;
+  /// Doing full KKT (only used if default symbolic and factorization)
+  bool doKKT_;
+  /// Go dense at this fraction
+  double goDense_;
+  /// choleskyCondition.
+  double choleskyCondition_;
+  /// model.
+  ClpInterior *model_;
+  /// numberTrials.  Number of trials before rejection
+  int numberTrials_;
+  /// numberRows.  Number of Rows in factorization
+  int numberRows_;
+  /// status.  Status of factorization
+  int status_;
+  /// rowsDropped
+  char *rowsDropped_;
+  /// permute inverse.
+  int *permuteInverse_;
+  /// main permute.
+  int *permute_;
+  /// numberRowsDropped.  Number of rows gone
+  int numberRowsDropped_;
+  /// sparseFactor.
+  longDouble *sparseFactor_;
+  /// choleskyStart - element starts
+  int *choleskyStart_;
+  /// choleskyRow (can be shorter than sparsefactor)
+  int *choleskyRow_;
+  /// Index starts
+  int *indexStart_;
+  /// Diagonal
+  longDouble *diagonal_;
+  /// double work array
+  longDouble *workDouble_;
+  /// link array
+  int *link_;
+  // Integer work array
+  int *workInteger_;
+  // Clique information
+  int *clique_;
+  /// sizeFactor.
+  int sizeFactor_;
+  /// Size of index array
+  int sizeIndex_;
+  /// First dense row
+  int firstDense_;
+  /// integerParameters
+  int integerParameters_[64];
+  /// doubleParameters;
+  double doubleParameters_[64];
+  /// Row copy of matrix
+  ClpMatrixBase *rowCopy_;
+  /// Dense indicators
+  char *whichDense_;
+  /// Dense columns (updated)
+  longDouble *denseColumn_;
+  /// Dense cholesky
+  ClpCholeskyDense *dense_;
+  /// Dense threshold (for taking out of Cholesky)
+  int denseThreshold_;
+  //@}
+};
+
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/ClpCholeskyDense.hpp

@@ -0,0 +1,157 @@
+/* $Id$ */
+/*
+  Copyright (C) 2003, International Business Machines Corporation
+  and others.  All Rights Reserved.
+
+  This code is licensed under the terms of the Eclipse Public License (EPL).
+*/
+#ifndef ClpCholeskyDense_H
+#define ClpCholeskyDense_H
+
+#include "ClpCholeskyBase.hpp"
+class ClpMatrixBase;
+
+class ClpCholeskyDense : public ClpCholeskyBase {
+
+public:
+  /**@name Virtual methods that the derived classes provides  */
+  /**@{*/
+  /** Orders rows and saves pointer to matrix.and model.
+      Returns non-zero if not enough memory */
+  virtual int order(ClpInterior *model);
+  /** Does Symbolic factorization given permutation.
+         This is called immediately after order.  If user provides this then
+         user must provide factorize and solve.  Otherwise the default factorization is used
+         returns non-zero if not enough memory */
+  virtual int symbolic();
+  /** Factorize - filling in rowsDropped and returning number dropped.
+         If return code negative then out of memory */
+  virtual int factorize(const CoinWorkDouble *diagonal, int *rowsDropped);
+  /** Uses factorization to solve. */
+  virtual void solve(CoinWorkDouble *region);
+  /**@}*/
+
+  /**@name Non virtual methods for ClpCholeskyDense  */
+  /**@{*/
+  /** Reserves space.
+         If factor not NULL then just uses passed space
+      Returns non-zero if not enough memory */
+  int reserveSpace(const ClpCholeskyBase *factor, int numberRows);
+  /** Returns space needed */
+  int space(int numberRows) const;
+  /** part 2 of Factorize - filling in rowsDropped */
+  void factorizePart2(int *rowsDropped);
+  /** part 2 of Factorize - filling in rowsDropped - blocked */
+  void factorizePart3(int *rowsDropped);
+  /** Forward part of solve */
+  void solveF1(longDouble *a, int n, CoinWorkDouble *region);
+  void solveF2(longDouble *a, int n, CoinWorkDouble *region, CoinWorkDouble *region2);
+  /** Backward part of solve */
+  void solveB1(longDouble *a, int n, CoinWorkDouble *region);
+  void solveB2(longDouble *a, int n, CoinWorkDouble *region, CoinWorkDouble *region2);
+  int bNumber(const longDouble *array, int &, int &);
+  /** A */
+  inline longDouble *aMatrix() const
+  {
+    return sparseFactor_;
+  }
+  /** Diagonal */
+  inline longDouble *diagonal() const
+  {
+    return diagonal_;
+  }
+  /**@}*/
+
+  /**@name Constructors, destructor */
+  /**@{*/
+  /** Default constructor. */
+  ClpCholeskyDense();
+  /** Destructor  */
+  virtual ~ClpCholeskyDense();
+  /** Copy */
+  ClpCholeskyDense(const ClpCholeskyDense &);
+  /** Assignment */
+  ClpCholeskyDense &operator=(const ClpCholeskyDense &);
+  /** Clone */
+  virtual ClpCholeskyBase *clone() const;
+  /**@}*/
+
+private:
+  /**@name Data members */
+  /**@{*/
+  /** Just borrowing space */
+  bool borrowSpace_;
+  /**@}*/
+};
+
+/* structure for C */
+typedef struct {
+  longDouble *diagonal_;
+  longDouble *a;
+  longDouble *work;
+  int *rowsDropped;
+  double doubleParameters_[1]; /* corresponds to 10 */
+  int integerParameters_[2]; /* corresponds to 34, nThreads */
+  int n;
+  int numberBlocks;
+} ClpCholeskyDenseC;
+
+extern "C" {
+void ClpCholeskySpawn(void *);
+}
+/**Non leaf recursive factor */
+void ClpCholeskyCfactor(ClpCholeskyDenseC *thisStruct,
+  longDouble *a, int n, int numberBlocks,
+  longDouble *diagonal, longDouble *work, int *rowsDropped);
+
+/**Non leaf recursive triangle rectangle update */
+void ClpCholeskyCtriRec(ClpCholeskyDenseC *thisStruct,
+  longDouble *aTri, int nThis,
+  longDouble *aUnder, longDouble *diagonal,
+  longDouble *work,
+  int nLeft, int iBlock, int jBlock,
+  int numberBlocks);
+/**Non leaf recursive rectangle triangle update */
+void ClpCholeskyCrecTri(ClpCholeskyDenseC *thisStruct,
+  longDouble *aUnder, int nTri, int nDo,
+  int iBlock, int jBlock, longDouble *aTri,
+  longDouble *diagonal, longDouble *work,
+  int numberBlocks);
+/** Non leaf recursive rectangle rectangle update,
+    nUnder is number of rows in iBlock,
+    nUnderK is number of rows in kBlock
+*/
+void ClpCholeskyCrecRec(ClpCholeskyDenseC *thisStruct,
+  longDouble *above, int nUnder, int nUnderK,
+  int nDo, longDouble *aUnder, longDouble *aOther,
+  longDouble *work,
+  int iBlock, int jBlock,
+  int numberBlocks);
+/**Leaf recursive factor */
+void ClpCholeskyCfactorLeaf(ClpCholeskyDenseC *thisStruct,
+  longDouble *a, int n,
+  longDouble *diagonal, longDouble *work,
+  int *rowsDropped);
+/**Leaf recursive triangle rectangle update */
+void ClpCholeskyCtriRecLeaf(/*ClpCholeskyDenseC * thisStruct,*/
+  longDouble *aTri, longDouble *aUnder,
+  longDouble *diagonal, longDouble *work,
+  int nUnder);
+/**Leaf recursive rectangle triangle update */
+void ClpCholeskyCrecTriLeaf(/*ClpCholeskyDenseC * thisStruct, */
+  longDouble *aUnder, longDouble *aTri,
+  /*longDouble * diagonal,*/ longDouble *work, int nUnder);
+/** Leaf recursive rectangle rectangle update,
+    nUnder is number of rows in iBlock,
+    nUnderK is number of rows in kBlock
+*/
+void ClpCholeskyCrecRecLeaf(/*ClpCholeskyDenseC * thisStruct, */
+  const longDouble *COIN_RESTRICT above,
+  const longDouble *COIN_RESTRICT aUnder,
+  longDouble *COIN_RESTRICT aOther,
+  const longDouble *COIN_RESTRICT work,
+  int nUnder);
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/ClpCholeskyMumps.hpp

@@ -0,0 +1,65 @@
+/* $Id$ */
+// Copyright (C) 2009, International Business Machines
+// Corporation and others.  All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef ClpCholeskyMumps_H
+#define ClpCholeskyMumps_H
+#include "ClpCholeskyBase.hpp"
+class ClpMatrixBase;
+class ClpCholeskyDense;
+
+// unfortunately, DMUMPS_STRUC_C is an anonymous struct in MUMPS, so we define it to void for everyone outside ClpCholeskyMumps
+// if this file is included by ClpCholeskyMumps.cpp, then after dmumps_c.h has been included, which defines MUMPS_VERSION
+#ifndef MUMPS_VERSION
+typedef void DMUMPS_STRUC_C;
+#endif
+
+/** Mumps class for Clp Cholesky factorization
+
+*/
+class ClpCholeskyMumps : public ClpCholeskyBase {
+
+public:
+  /**@name Virtual methods that the derived classes provides  */
+  //@{
+  /** Orders rows and saves pointer to matrix.and model.
+      Returns non-zero if not enough memory */
+  virtual int order(ClpInterior *model);
+  /** Does Symbolic factorization given permutation.
+         This is called immediately after order.  If user provides this then
+         user must provide factorize and solve.  Otherwise the default factorization is used
+         returns non-zero if not enough memory */
+  virtual int symbolic();
+  /** Factorize - filling in rowsDropped and returning number dropped.
+         If return code negative then out of memory */
+  virtual int factorize(const double *diagonal, int *rowsDropped);
+  /** Uses factorization to solve. */
+  virtual void solve(double *region);
+  //@}
+
+  /**@name Constructors, destructor */
+  //@{
+  /** Constructor which has dense columns activated.
+         Default is off. */
+  ClpCholeskyMumps(int denseThreshold = -1, int logLevel = 0);
+  /** Destructor  */
+  virtual ~ClpCholeskyMumps();
+  /// Clone
+  virtual ClpCholeskyBase *clone() const;
+  //@}
+
+private:
+  // Mumps structure
+  DMUMPS_STRUC_C *mumps_;
+
+  // Copy
+  ClpCholeskyMumps(const ClpCholeskyMumps &);
+  // Assignment
+  ClpCholeskyMumps &operator=(const ClpCholeskyMumps &);
+};
+
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/