casadi 3.6.7__cp313-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

casadi/include/coin/CoinShallowPackedVector.hpp

@@ -0,0 +1,149 @@
+/* $Id$ */
+// Copyright (C) 2000, International Business Machines
+// Corporation and others.  All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef CoinShallowPackedVector_H
+#define CoinShallowPackedVector_H
+
+#if defined(_MSC_VER)
+// Turn off compiler warning about long names
+#pragma warning(disable : 4786)
+#endif
+
+#include "CoinError.hpp"
+#include "CoinPackedVectorBase.hpp"
+
+/** Shallow Sparse Vector
+ 
+This class is for sparse vectors where the indices and 
+elements are stored elsewhere.  This class only maintains
+pointers to the indices and elements.  Since this class
+does not own the index and element data it provides
+read only access to to the data.  An CoinSparsePackedVector
+must be used when the sparse vector's data will be altered.
+
+This class stores pointers to the vectors.
+It does not actually contain the vectors.
+
+Here is a sample usage:
+@verbatim
+   const int ne = 4; 
+   int inx[ne] =   {  1,   4,  0,   2 }; 
+   double el[ne] = { 10., 40., 1., 50. }; 
+ 
+   // Create vector and set its value 
+   CoinShallowPackedVector r(ne,inx,el); 
+ 
+   // access each index and element 
+   assert( r.indices ()[0]== 1  ); 
+   assert( r.elements()[0]==10. ); 
+   assert( r.indices ()[1]== 4  ); 
+   assert( r.elements()[1]==40. ); 
+   assert( r.indices ()[2]== 0  ); 
+   assert( r.elements()[2]== 1. ); 
+   assert( r.indices ()[3]== 2  ); 
+   assert( r.elements()[3]==50. ); 
+ 
+   // access as a full storage vector 
+   assert( r[ 0]==1. ); 
+   assert( r[ 1]==10.); 
+   assert( r[ 2]==50.); 
+   assert( r[ 3]==0. ); 
+   assert( r[ 4]==40.); 
+ 
+   // Tests for equality and equivalence
+   CoinShallowPackedVector r1; 
+   r1=r; 
+   assert( r==r1 ); 
+   r.sort(CoinIncrElementOrdered()); 
+   assert( r!=r1 ); 
+ 
+   // Add packed vectors. 
+   // Similarly for subtraction, multiplication, 
+   // and division. 
+   CoinPackedVector add = r + r1; 
+   assert( add[0] ==  1.+ 1. ); 
+   assert( add[1] == 10.+10. ); 
+   assert( add[2] == 50.+50. ); 
+   assert( add[3] ==  0.+ 0. ); 
+   assert( add[4] == 40.+40. ); 
+   assert( r.sum() == 10.+40.+1.+50. ); 
+@endverbatim
+*/
+class CoinShallowPackedVector : public CoinPackedVectorBase {
+  friend void CoinShallowPackedVectorUnitTest();
+
+public:
+  /**@name Get methods */
+  //@{
+  /// Get length of indices and elements vectors
+  virtual int getNumElements() const { return nElements_; }
+  /// Get indices of elements
+  virtual const int *getIndices() const { return indices_; }
+  /// Get element values
+  virtual const double *getElements() const { return elements_; }
+  //@}
+
+  /**@name Set methods */
+  //@{
+  /// Reset the vector (as if were just created an empty vector)
+  void clear();
+  /** Assignment operator. */
+  CoinShallowPackedVector &operator=(const CoinShallowPackedVector &x);
+  /** Assignment operator from a CoinPackedVectorBase. */
+  CoinShallowPackedVector &operator=(const CoinPackedVectorBase &x);
+  /** just like the explicit constructor */
+  void setVector(int size, const int *indices, const double *elements,
+    bool testForDuplicateIndex = true);
+  //@}
+
+  /**@name Methods to create, set and destroy */
+  //@{
+  /** Default constructor. */
+  CoinShallowPackedVector(bool testForDuplicateIndex = true);
+  /** Explicit Constructor.
+       Set vector size, indices, and elements. Size is the length of both the
+       indices and elements vectors. The indices and elements vectors are not
+       copied into this class instance. The ShallowPackedVector only maintains
+       the pointers to the indices and elements vectors. <br>
+       The last argument specifies whether the creator of the object knows in
+       advance that there are no duplicate indices.
+   */
+  CoinShallowPackedVector(int size,
+    const int *indices, const double *elements,
+    bool testForDuplicateIndex = true);
+  /** Copy constructor from the base class. */
+  CoinShallowPackedVector(const CoinPackedVectorBase &);
+  /** Copy constructor. */
+  CoinShallowPackedVector(const CoinShallowPackedVector &);
+  /** Destructor. */
+  virtual ~CoinShallowPackedVector() {}
+  /// Print vector information.
+  void print();
+  //@}
+
+private:
+  /**@name Private member data */
+  //@{
+  /// Vector indices
+  const int *indices_;
+  ///Vector elements
+  const double *elements_;
+  /// Size of indices and elements vectors
+  int nElements_;
+  //@}
+};
+
+//#############################################################################
+/** A function that tests the methods in the CoinShallowPackedVector class. The
+    only reason for it not to be a member method is that this way it doesn't
+    have to be compiled into the library. And that's a gain, because the
+    library should be compiled with optimization on, but this method should be
+    compiled with debugging. */
+void CoinShallowPackedVectorUnitTest();
+
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/CoinSignal.hpp

@@ -0,0 +1,127 @@
+/* $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 _CoinSignal_hpp
+#define _CoinSignal_hpp
+
+// This file is fully docified.
+// There's nothing to docify...
+
+//#############################################################################
+
+#include <csignal>
+
+//#############################################################################
+
+#if defined(_MSC_VER)
+typedef void(__cdecl *CoinSighandler_t)(int);
+#define CoinSighandler_t_defined
+#endif
+
+//-----------------------------------------------------------------------------
+
+#if (defined(__GNUC__) && defined(__linux__))
+typedef sighandler_t CoinSighandler_t;
+#define CoinSighandler_t_defined
+#endif
+
+//-----------------------------------------------------------------------------
+
+#if defined(__CYGWIN__) && defined(__GNUC__)
+typedef __decltype(SIG_DFL) CoinSighandler_t;
+#define CoinSighandler_t_defined
+#endif
+
+//-----------------------------------------------------------------------------
+
+#if defined(__MINGW32__) && defined(__GNUC__)
+typedef __decltype(SIG_DFL) CoinSighandler_t;
+#define CoinSighandler_t_defined
+#endif
+
+//-----------------------------------------------------------------------------
+
+#if defined(__OpenBSD__) && defined(__GNUC__)
+typedef __decltype(SIG_DFL) CoinSighandler_t;
+#define CoinSighandler_t_defined
+#endif
+
+//-----------------------------------------------------------------------------
+
+#if defined(__FreeBSD__) && defined(__GNUC__)
+typedef __decltype(SIG_DFL) CoinSighandler_t;
+#define CoinSighandler_t_defined
+#endif
+
+//-----------------------------------------------------------------------------
+
+#if defined(__NetBSD__) && defined(__GNUC__)
+typedef __decltype(SIG_DFL) CoinSighandler_t;
+#define CoinSighandler_t_defined
+#endif
+
+//-----------------------------------------------------------------------------
+
+#if defined(_AIX)
+#if defined(__GNUC__)
+typedef __decltype(SIG_DFL) CoinSighandler_t;
+#define CoinSighandler_t_defined
+#endif
+#endif
+
+//-----------------------------------------------------------------------------
+
+#if defined(__hpux)
+#define CoinSighandler_t_defined
+#if defined(__GNUC__)
+typedef __decltype(SIG_DFL) CoinSighandler_t;
+#else
+extern "C" {
+typedef void (*CoinSighandler_t)(int);
+}
+#endif
+#endif
+
+//-----------------------------------------------------------------------------
+
+#if defined(__sun)
+#if defined(__SUNPRO_CC)
+#include <signal.h>
+extern "C" {
+typedef void (*CoinSighandler_t)(int);
+}
+#define CoinSighandler_t_defined
+#endif
+#if defined(__GNUC__)
+typedef __decltype(SIG_DFL) CoinSighandler_t;
+#define CoinSighandler_t_defined
+#endif
+#endif
+
+//-----------------------------------------------------------------------------
+
+#if defined(__MACH__) && defined(__GNUC__)
+typedef __decltype(SIG_DFL) CoinSighandler_t;
+#define CoinSighandler_t_defined
+#endif
+
+//#############################################################################
+
+#ifndef CoinSighandler_t_defined
+#warning("OS and/or compiler is not recognized. Defaulting to:");
+#warning("extern 'C' {")
+#warning("   typedef void (*CoinSighandler_t) (int);")
+#warning("}")
+extern "C" {
+typedef void (*CoinSighandler_t)(int);
+}
+#endif
+
+//#############################################################################
+
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/CoinSimpFactorization.hpp

@@ -0,0 +1,432 @@
+/* $Id$ */
+// Copyright (C) 2008, International Business Machines
+// Corporation and others.  All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+/* 
+   This is a simple factorization of the LP Basis
+ */
+#ifndef CoinSimpFactorization_H
+#define CoinSimpFactorization_H
+
+#include <iostream>
+#include <string>
+#include <cassert>
+#include "CoinTypes.hpp"
+#include "CoinIndexedVector.hpp"
+#include "CoinDenseFactorization.hpp"
+class CoinPackedMatrix;
+
+/// pointers used during factorization
+class FactorPointers {
+public:
+  double *rowMax;
+  int *firstRowKnonzeros;
+  int *prevRow;
+  int *nextRow;
+  int *firstColKnonzeros;
+  int *prevColumn;
+  int *nextColumn;
+  int *newCols;
+  //constructor
+  FactorPointers(int numRows, int numCols, int *UrowLengths_, int *UcolLengths_);
+  // destructor
+  ~FactorPointers();
+};
+
+class CoinSimpFactorization : public CoinOtherFactorization {
+  friend void CoinSimpFactorizationUnitTest(const std::string &mpsDir);
+
+public:
+  /**@name Constructors and destructor and copy */
+  //@{
+  /// Default constructor
+  CoinSimpFactorization();
+  /// Copy constructor
+  CoinSimpFactorization(const CoinSimpFactorization &other);
+
+  /// Destructor
+  virtual ~CoinSimpFactorization();
+  /// = copy
+  CoinSimpFactorization &operator=(const CoinSimpFactorization &other);
+  /// Clone
+  virtual CoinOtherFactorization *clone() const;
+  //@}
+
+  /**@name Do factorization - public */
+  //@{
+  /// Gets space for a factorization
+  virtual void getAreas(int numberRows,
+    int numberColumns,
+    int maximumL,
+    int maximumU);
+
+  /// PreProcesses column ordered copy of basis
+  virtual void preProcess();
+  /** Does most of factorization returning status
+      0 - OK
+      -99 - needs more memory
+      -1 - singular - use numberGoodColumns and redo
+  */
+  virtual int factor();
+  /// Does post processing on valid factorization - putting variables on correct rows
+  virtual void postProcess(const int *sequence, int *pivotVariable);
+  /// Makes a non-singular basis by replacing variables
+  virtual void makeNonSingular(int *sequence, int numberColumns);
+  //@}
+
+  /**@name general stuff such as status */
+  //@{
+  /// Total number of elements in factorization
+  virtual inline int numberElements() const
+  {
+    return numberRows_ * (numberColumns_ + numberPivots_);
+  }
+  /// Returns maximum absolute value in factorization
+  double maximumCoefficient() const;
+  //@}
+
+  /**@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 */
+  virtual int replaceColumn(CoinIndexedVector *regionSparse,
+    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 regionSparse2
+      Tries to do FT update
+      number returned is negative if no room
+      regionSparse starts as zero and is zero at end.
+      Note - if regionSparse2 packed on input - will be packed on output
+  */
+
+  virtual int updateColumnFT(CoinIndexedVector *regionSparse,
+    CoinIndexedVector *regionSparse2,
+    bool noPermute = false);
+
+  /** This version has same effect as above with FTUpdate==false
+	so number returned is always >=0 */
+  virtual int updateColumn(CoinIndexedVector *regionSparse,
+    CoinIndexedVector *regionSparse2,
+    bool noPermute = false) const;
+  /// does FTRAN on two columns
+  virtual int updateTwoColumnsFT(CoinIndexedVector *regionSparse1,
+    CoinIndexedVector *regionSparse2,
+    CoinIndexedVector *regionSparse3,
+    bool noPermute = false);
+  /// does updatecolumn if save==true keeps column for replace column
+  int upColumn(CoinIndexedVector *regionSparse,
+    CoinIndexedVector *regionSparse2,
+    bool noPermute = false, bool save = false) const;
+  /** Updates one column (BTRAN) from regionSparse2
+	regionSparse starts as zero and is zero at end 
+	Note - if regionSparse2 packed on input - will be packed on output
+    */
+  virtual int updateColumnTranspose(CoinIndexedVector *regionSparse,
+    CoinIndexedVector *regionSparse2) const;
+  /// does updateColumnTranspose, the other is a wrapper
+  int upColumnTranspose(CoinIndexedVector *regionSparse,
+    CoinIndexedVector *regionSparse2) const;
+  //@}
+  /// *** Below this user may not want to know about
+
+  /**@name various uses of factorization
+   which user may not want to know about (left over from my LP code) */
+  //@{
+  /// Get rid of all memory
+  inline void clearArrays()
+  {
+    gutsOfDestructor();
+  }
+  /// Returns array to put basis indices in
+  inline int *indices() const
+  {
+    return reinterpret_cast< int * >(elements_ + numberRows_ * numberRows_);
+  }
+  /// Returns permute in
+  virtual inline int *permute() const
+  {
+    return pivotRow_;
+  }
+  //@}
+
+  /// The real work of destructor
+  void gutsOfDestructor();
+  /// The real work of constructor
+  void gutsOfInitialize();
+  /// The real work of copy
+  void gutsOfCopy(const CoinSimpFactorization &other);
+
+  /// calls factorization
+  void factorize(int numberOfRows,
+    int numberOfColumns,
+    const int colStarts[],
+    const int indicesRow[],
+    const double elements[]);
+  /// main loop of factorization
+  int mainLoopFactor(FactorPointers &pointers);
+  /// copies L by rows
+  void copyLbyRows();
+  /// copies U by columns
+  void copyUbyColumns();
+  /// finds a pivot element using Markowitz count
+  int findPivot(FactorPointers &pointers, int &r, int &s, bool &ifSlack);
+  /// finds a pivot in a shortest column
+  int findPivotShCol(FactorPointers &pointers, int &r, int &s);
+  /// finds a pivot in the first column available
+  int findPivotSimp(FactorPointers &pointers, int &r, int &s);
+  /// does Gauss elimination
+  void GaussEliminate(FactorPointers &pointers, int &r, int &s);
+  /// finds short row that intersects a given column
+  int findShortRow(const int column, const int length, int &minRow,
+    int &minRowLength, FactorPointers &pointers);
+  /// finds short column that intersects a given row
+  int findShortColumn(const int row, const int length, int &minCol,
+    int &minColLength, FactorPointers &pointers);
+  /// finds maximum absolute value in a row
+  double findMaxInRrow(const int row, FactorPointers &pointers);
+  /// does pivoting
+  void pivoting(const int pivotRow, const int pivotColumn,
+    const double invPivot, FactorPointers &pointers);
+  /// part of pivoting
+  void updateCurrentRow(const int pivotRow, const int row,
+    const double multiplier, FactorPointers &pointers,
+    int &newNonZeros);
+  /// allocates more space for L
+  void increaseLsize();
+  /// allocates more space for a row of U
+  void increaseRowSize(const int row, const int newSize);
+  /// allocates more space for a column of U
+  void increaseColSize(const int column, const int newSize, const bool b);
+  /// allocates more space for rows of U
+  void enlargeUrow(const int numNewElements);
+  /// allocates more space for columns of U
+  void enlargeUcol(const int numNewElements, const bool b);
+  /// finds a given row in a column
+  int findInRow(const int row, const int column);
+  /// finds a given column in a row
+  int findInColumn(const int column, const int row);
+  /// declares a row inactive
+  void removeRowFromActSet(const int row, FactorPointers &pointers);
+  /// declares a column inactive
+  void removeColumnFromActSet(const int column, FactorPointers &pointers);
+  /// allocates space for U
+  void allocateSpaceForU();
+  /// allocates several working arrays
+  void allocateSomeArrays();
+  /// initializes some numbers
+  void initialSomeNumbers();
+  /// solves L x = b
+  void Lxeqb(double *b) const;
+  /// same as above but with two rhs
+  void Lxeqb2(double *b1, double *b2) const;
+  /// solves U x = b
+  void Uxeqb(double *b, double *sol) const;
+  /// same as above but with two rhs
+  void Uxeqb2(double *b1, double *sol1, double *sol2, double *b2) const;
+  /// solves x L = b
+  void xLeqb(double *b) const;
+  /// solves x U = b
+  void xUeqb(double *b, double *sol) const;
+  /// updates factorization after a Simplex iteration
+  int LUupdate(int newBasicCol);
+  /// creates a new eta vector
+  void newEta(int row, int numNewElements);
+  /// makes a copy of row permutations
+  void copyRowPermutations();
+  /// solves H x = b, where H is a product of eta matrices
+  void Hxeqb(double *b) const;
+  /// same as above but with two rhs
+  void Hxeqb2(double *b1, double *b2) const;
+  /// solves x H = b
+  void xHeqb(double *b) const;
+  /// does FTRAN
+  void ftran(double *b, double *sol, bool save) const;
+  /// same as above but with two columns
+  void ftran2(double *b1, double *sol1, double *b2, double *sol2) const;
+  /// does BTRAN
+  void btran(double *b, double *sol) const;
+  ///---------------------------------------
+
+  //@}
+protected:
+  /** Returns accuracy status of replaceColumn
+      returns 0=OK, 1=Probably OK, 2=singular */
+  int checkPivot(double saveFromU, double oldPivot) const;
+  ////////////////// data //////////////////
+protected:
+  /**@name data */
+  //@{
+  /// work array (should be initialized to zero)
+  double *denseVector_;
+  /// work array
+  double *workArea2_;
+  /// work array
+  double *workArea3_;
+  /// array of labels (should be initialized to zero)
+  int *vecLabels_;
+  /// array of indices
+  int *indVector_;
+
+  /// auxiliary vector
+  double *auxVector_;
+  /// auxiliary vector
+  int *auxInd_;
+
+  /// vector to keep for LUupdate
+  double *vecKeep_;
+  /// indices of this vector
+  int *indKeep_;
+  /// number of nonzeros
+  mutable int keepSize_;
+
+  /// Starts of the rows of L
+  int *LrowStarts_;
+  /// Lengths of the rows of L
+  int *LrowLengths_;
+  /// L by rows
+  double *Lrows_;
+  /// indices in the rows of L
+  int *LrowInd_;
+  /// Size of Lrows_;
+  int LrowSize_;
+  /// Capacity of Lrows_
+  int LrowCap_;
+
+  /// Starts of the columns of L
+  int *LcolStarts_;
+  /// Lengths of the columns of L
+  int *LcolLengths_;
+  /// L by columns
+  double *Lcolumns_;
+  /// indices in the columns of L
+  int *LcolInd_;
+  /// numbers of elements in L
+  int LcolSize_;
+  /// maximum capacity of L
+  int LcolCap_;
+
+  /// Starts of the rows of U
+  int *UrowStarts_;
+  /// Lengths of the rows of U
+  int *UrowLengths_;
+#ifdef COIN_SIMP_CAPACITY
+  /// Capacities of the rows of U
+  int *UrowCapacities_;
+#endif
+  /// U by rows
+  double *Urows_;
+  /// Indices in the rows of U
+  int *UrowInd_;
+  /// maximum capacity of Urows
+  int UrowMaxCap_;
+  /// number of used places in Urows
+  int UrowEnd_;
+  /// first row in U
+  int firstRowInU_;
+  /// last row in U
+  int lastRowInU_;
+  /// previous row in U
+  int *prevRowInU_;
+  /// next row in U
+  int *nextRowInU_;
+
+  /// Starts of the columns of U
+  int *UcolStarts_;
+  /// Lengths of the columns of U
+  int *UcolLengths_;
+#ifdef COIN_SIMP_CAPACITY
+  /// Capacities of the columns of U
+  int *UcolCapacities_;
+#endif
+  /// U by columns
+  double *Ucolumns_;
+  /// Indices in the columns of U
+  int *UcolInd_;
+  /// previous column in U
+  int *prevColInU_;
+  /// next column in U
+  int *nextColInU_;
+  /// first column in U
+  int firstColInU_;
+  /// last column in U
+  int lastColInU_;
+  /// maximum capacity of Ucolumns_
+  int UcolMaxCap_;
+  /// last used position in Ucolumns_
+  int UcolEnd_;
+  /// indicator of slack variables
+  int *colSlack_;
+
+  /// inverse values of the elements of diagonal of U
+  double *invOfPivots_;
+
+  /// permutation of columns
+  int *colOfU_;
+  /// position of column after permutation
+  int *colPosition_;
+  /// permutations of rows
+  int *rowOfU_;
+  /// position of row after permutation
+  int *rowPosition_;
+  /// permutations of rows during LUupdate
+  int *secRowOfU_;
+  /// position of row after permutation during LUupdate
+  int *secRowPosition_;
+
+  /// position of Eta vector
+  int *EtaPosition_;
+  /// Starts of eta vectors
+  int *EtaStarts_;
+  /// Lengths of eta vectors
+  int *EtaLengths_;
+  /// columns of eta vectors
+  int *EtaInd_;
+  /// elements of eta vectors
+  double *Eta_;
+  /// number of elements in Eta_
+  int EtaSize_;
+  /// last eta row
+  int lastEtaRow_;
+  /// maximum number of eta vectors
+  int maxEtaRows_;
+  /// Capacity of Eta_
+  int EtaMaxCap_;
+
+  /// minimum storage increase
+  int minIncrease_;
+  /// maximum size for the diagonal of U after update
+  double updateTol_;
+  /// do Shul heuristic
+  bool doSuhlHeuristic_;
+  /// maximum of U
+  double maxU_;
+  /// bound on the growth rate
+  double maxGrowth_;
+  /// maximum of A
+  double maxA_;
+  /// maximum number of candidates for pivot
+  int pivotCandLimit_;
+  /// number of slacks in basis
+  int numberSlacks_;
+  /// number of slacks in irst basis
+  int firstNumberSlacks_;
+  //@}
+};
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/