casadi 3.6.4__cp311-none-manylinux2014_i686.whl → 3.6.6__cp311-none-manylinux2014_i686.whl

casadi/include/coin-or/IpGenTMatrix.hpp

@@ -0,0 +1,290 @@
+// Copyright (C) 2004, 2009 International Business Machines and others.
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13
+
+#ifndef __IPGENTMATRIX_HPP__
+#define __IPGENTMATRIX_HPP__
+
+#include "IpUtils.hpp"
+#include "IpMatrix.hpp"
+
+namespace Ipopt
+{
+
+/* forward declarations */
+class GenTMatrixSpace;
+
+/** Class for general matrices stored in triplet format.
+ *
+ *  In the triplet format, the nonzeros elements of a general matrix
+ *  is stored in three arrays, Irow, Jcol, and Values, all of length
+ *  Nonzeros.  The first two arrays indicate the location of a
+ *  non-zero element (row and column indices), and the last array
+ *  stores the value at that location.  If nonzero elements are
+ *  listed more than once, their values are added.
+ *
+ *  The structure of the nonzeros (i.e. the arrays Irow and Jcol)
+ *  cannot be changed after the matrix can been initialized.  Only
+ *  the values of the nonzero elements can be modified.
+ *
+ *  Note that the first row and column of a matrix has index 1, not 0.
+ */
+class IPOPTLIB_EXPORT GenTMatrix: public Matrix
+{
+public:
+   /**@name Constructors / Destructors */
+   ///@{
+   /** Constructor, taking the owner_space. */
+   GenTMatrix(
+      const GenTMatrixSpace* owner_space
+   );
+
+   /** Destructor */
+   ~GenTMatrix();
+   ///@}
+
+   /**@name Changing the Values.*/
+   ///@{
+   /** Set values of nonzero elements.
+    *
+    *  The values of the nonzero
+    *  elements are copied from the incoming Number array.
+    *  Important: It is assume that the order of the values in Values
+    *  corresponds to the one of Irn and Jcn given to one of the
+    *  constructors above.
+    */
+   void SetValues(
+      const Number* Values
+   );
+   ///@}
+
+   /** @name Accessor Methods */
+   ///@{
+   /** Number of nonzero entries */
+   Index Nonzeros() const;
+
+   /** Array with Row indices (counting starts at 1) */
+   const Index* Irows() const;
+
+   /** Array with Column indices (counting starts at 1) */
+   const Index* Jcols() const;
+
+   /** Array with nonzero values (const version).  */
+   const Number* Values() const
+   {
+      return values_;
+   }
+
+   /** Array with the nonzero values of this matrix (non-const version).
+    *
+    *  Use this method only if you are intending to change
+    *  the values, because the GenTMatrix will be marked as changed.
+    */
+   Number* Values()
+   {
+      ObjectChanged();
+      initialized_ = true;
+      return values_;
+   }
+   ///@}
+
+protected:
+   /**@name Overloaded methods from Matrix base class*/
+   ///@{
+   virtual void MultVectorImpl(
+      Number        alpha,
+      const Vector& x,
+      Number        beta,
+      Vector&       y
+   ) const;
+
+   virtual void TransMultVectorImpl(
+      Number        alpha,
+      const Vector& x,
+      Number        beta,
+      Vector&       y
+   ) const;
+
+   virtual bool HasValidNumbersImpl() const;
+
+   virtual void ComputeRowAMaxImpl(
+      Vector& rows_norms,
+      bool    init
+   ) const;
+
+   virtual void ComputeColAMaxImpl(
+      Vector& cols_norms,
+      bool    init
+   ) const;
+
+   virtual void PrintImpl(
+      const Journalist&  jnlst,
+      EJournalLevel      level,
+      EJournalCategory   category,
+      const std::string& name,
+      Index              indent,
+      const std::string& prefix
+   ) const
+   {
+      PrintImplOffset(jnlst, level, category, name, indent, prefix, 0);
+   }
+   ///@}
+
+   void PrintImplOffset(
+      const Journalist&  jnlst,
+      EJournalLevel      level,
+      EJournalCategory   category,
+      const std::string& name,
+      Index              indent,
+      const std::string& prefix,
+      Index              offset
+   ) const;
+
+   friend class ParGenMatrix;
+
+private:
+   /**@name Default Compiler Generated Methods
+    * (Hidden to avoid implicit creation/calling).
+    * These methods are not implemented and
+    * we do not want the compiler to implement
+    * them for us, so we declare them private
+    * and do not define them. This ensures that
+    * they will not be implicitly created/called.
+    */
+   ///@{
+   /** Default Constructor */
+   GenTMatrix();
+
+   /** Copy Constructor */
+   GenTMatrix(
+      const GenTMatrix&
+   );
+
+   /** Default Assignment Operator */
+   void operator=(
+      const GenTMatrix&
+   );
+   ///@}
+
+   /** Copy of the owner space as a GenTMatrixSpace instead of
+    *  a MatrixSpace
+    */
+   const GenTMatrixSpace* owner_space_;
+
+   /** Values of nonzeros */
+   Number* values_;
+
+   /** Flag for Initialization */
+   bool initialized_;
+
+};
+
+/** This is the matrix space for a GenTMatrix with fixed sparsity structure.
+ *
+ *  The sparsity structure is stored here in the matrix space.
+ */
+class IPOPTLIB_EXPORT GenTMatrixSpace: public MatrixSpace
+{
+public:
+   /** @name Constructors / Destructors */
+   ///@{
+   /** Constructor, given the number of rows and columns, as well as
+    *  the number of nonzeros and the position of the nonzero
+    *  elements.
+    *
+    *  Note that the counting of the nonzeros starts a 1,
+    *  i.e., iRows[i]==1 and jCols[i]==1 refers to the first element
+    *  in the first row.  This is in accordance with the HSL data
+    *  structure.
+    */
+   GenTMatrixSpace(
+      Index        nRows,
+      Index        nCols,
+      Index        nonZeros,
+      const Index* iRows,
+      const Index* jCols
+   );
+
+   /** Destructor */
+   ~GenTMatrixSpace()
+   {
+      delete[] iRows_;
+      delete[] jCols_;
+   }
+   ///@}
+
+   /** Method for creating a new matrix of this specific type. */
+   GenTMatrix* MakeNewGenTMatrix() const
+   {
+      return new GenTMatrix(this);
+   }
+
+   virtual Matrix* MakeNew() const
+   {
+      return MakeNewGenTMatrix();
+   }
+
+   /**@name Methods describing Matrix structure */
+   ///@{
+   /** Number of non-zeros in the sparse matrix */
+   Index Nonzeros() const
+   {
+      return nonZeros_;
+   }
+
+   /** Row index of each non-zero element (counting starts at 1) */
+   const Index* Irows() const
+   {
+      return iRows_;
+   }
+
+   /** Column index of each non-zero element (counting starts at 1) */
+   const Index* Jcols() const
+   {
+      return jCols_;
+   }
+   ///@}
+
+private:
+   /** @name Sparsity structure of matrices generated by this matrix space. */
+   ///@{
+   const Index nonZeros_;
+   Index* jCols_;
+   Index* iRows_;
+   ///@}
+
+   /** This method is only for the GenTMatrix to call in order
+    *  to allocate internal storage
+    */
+   Number* AllocateInternalStorage() const;
+
+   /** This method is only for the GenTMatrix to call in order
+    *  to de-allocate internal storage
+    */
+   void FreeInternalStorage(
+      Number* values
+   ) const;
+
+   friend class GenTMatrix;
+};
+
+/* inline methods */
+inline Index GenTMatrix::Nonzeros() const
+{
+   return owner_space_->Nonzeros();
+}
+
+inline const Index* GenTMatrix::Irows() const
+{
+   return owner_space_->Irows();
+}
+
+inline const Index* GenTMatrix::Jcols() const
+{
+   return owner_space_->Jcols();
+}
+
+} // namespace Ipopt
+#endif

casadi/include/coin-or/IpHessianUpdater.hpp

@@ -0,0 +1,73 @@
+// Copyright (C) 2005, 2006 International Business Machines and others.
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// Authors:  Andreas Waechter            IBM    2005-12-26
+
+#ifndef __IPHESSIANUPDATER_HPP__
+#define __IPHESSIANUPDATER_HPP__
+
+#include "IpAlgStrategy.hpp"
+
+namespace Ipopt
+{
+
+/** Abstract base class for objects responsible for updating the
+ *  Hessian information.
+ *
+ *  This can be done using exact second
+ *  derivatives from the NLP, or by a quasi-Newton Option.  The
+ *  result is put into the W field in IpData.
+ */
+class IPOPTLIB_EXPORT HessianUpdater: public AlgorithmStrategyObject
+{
+public:
+   /**@name Constructors/Destructors */
+   ///@{
+   /** Default Constructor */
+   HessianUpdater()
+   { }
+
+   /** Destructor */
+   virtual ~HessianUpdater()
+   { }
+   ///@}
+
+   /** overloaded from AlgorithmStrategyObject */
+   virtual bool InitializeImpl(
+      const OptionsList& options,
+      const std::string& prefix
+   ) = 0;
+
+   /** Update the Hessian based on the current information in IpData,
+    *  and possibly on information from previous calls.
+    */
+   virtual void UpdateHessian() = 0;
+
+private:
+   /**@name Default Compiler Generated Methods
+    * (Hidden to avoid implicit creation/calling).
+    *
+    * These methods are not implemented and
+    * we do not want the compiler to implement
+    * them for us, so we declare them private
+    * and do not define them. This ensures that
+    * they will not be implicitly created/called.
+    */
+   ///@{
+   /** Copy Constructor */
+   HessianUpdater(
+      const HessianUpdater&
+   );
+
+   /** Default Assignment Operator */
+   void operator=(
+      const HessianUpdater&
+   );
+   ///@}
+
+};
+
+} // namespace Ipopt
+
+#endif

casadi/include/coin-or/IpIdentityMatrix.hpp

@@ -0,0 +1,167 @@
+// Copyright (C) 2004, 2008 International Business Machines and others.
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13
+
+#ifndef __IPIDENTITYMATRIX_HPP__
+#define __IPIDENTITYMATRIX_HPP__
+
+#include "IpUtils.hpp"
+#include "IpSymMatrix.hpp"
+
+namespace Ipopt
+{
+
+/** Class for Matrices which are multiples of the identity matrix. */
+class IPOPTLIB_EXPORT IdentityMatrix: public SymMatrix
+{
+public:
+   /**@name Constructors / Destructors */
+   ///@{
+   /** Constructor, initializing with dimensions of the matrix
+    *  (true identity matrix).
+    */
+   IdentityMatrix(
+      const SymMatrixSpace* owner_space
+   );
+
+   /** Destructor */
+   ~IdentityMatrix();
+   ///@}
+
+   /** Method for setting the factor for the identity matrix. */
+   void SetFactor(
+      Number factor
+   )
+   {
+      factor_ = factor;
+   }
+
+   /** Method for getting the factor for the identity matrix. */
+   Number GetFactor() const
+   {
+      return factor_;
+   }
+
+   /** Method for obtaining the dimension of the matrix. */
+   Index Dim() const;
+
+protected:
+   /**@name Methods overloaded from matrix */
+   ///@{
+   virtual void MultVectorImpl(
+      Number        alpha,
+      const Vector& x,
+      Number        beta,
+      Vector&       y
+   ) const;
+
+   virtual void AddMSinvZImpl(
+      Number        alpha,
+      const Vector& S,
+      const Vector& Z,
+      Vector&       X
+   ) const;
+
+   virtual bool HasValidNumbersImpl() const;
+
+   virtual void ComputeRowAMaxImpl(
+      Vector& rows_norms,
+      bool    init
+   ) const;
+
+   virtual void PrintImpl(
+      const Journalist&  jnlst,
+      EJournalLevel      level,
+      EJournalCategory   category,
+      const std::string& name,
+      Index              indent,
+      const std::string& prefix
+   ) const;
+   ///@}
+
+private:
+   /**@name Default Compiler Generated Methods
+    * (Hidden to avoid implicit creation/calling).
+    * These methods are not implemented and
+    * we do not want the compiler to implement
+    * them for us, so we declare them private
+    * and do not define them. This ensures that
+    * they will not be implicitly created/called.
+    */
+   ///@{
+   /** Default Constructor */
+   IdentityMatrix();
+
+   /** Copy Constructor */
+   IdentityMatrix(
+      const IdentityMatrix&
+   );
+
+   /** Default Assignment Operator */
+   void operator=(
+      const IdentityMatrix&
+   );
+   ///@}
+
+   /** Scaling factor for this identity matrix */
+   Number factor_;
+};
+
+/** This is the matrix space for IdentityMatrix. */
+class IPOPTLIB_EXPORT IdentityMatrixSpace: public SymMatrixSpace
+{
+public:
+   /** @name Constructors / Destructors */
+   ///@{
+   /** Constructor, given the dimension of the matrix. */
+   IdentityMatrixSpace(
+      Index dim
+   )
+      : SymMatrixSpace(dim)
+   { }
+
+   /** Destructor */
+   virtual ~IdentityMatrixSpace()
+   { }
+   ///@}
+
+   virtual SymMatrix* MakeNewSymMatrix() const
+   {
+      return MakeNewIdentityMatrix();
+   }
+
+   /** Method for creating a new matrix of this specific type. */
+   IdentityMatrix* MakeNewIdentityMatrix() const
+   {
+      return new IdentityMatrix(this);
+   }
+
+private:
+   /**@name Default Compiler Generated Methods
+    * (Hidden to avoid implicit creation/calling).
+    * These methods are not implemented and
+    * we do not want the compiler to implement
+    * them for us, so we declare them private
+    * and do not define them. This ensures that
+    * they will not be implicitly created/called.
+    */
+   ///@{
+   /** Default Constructor */
+   IdentityMatrixSpace();
+
+   /** Copy Constructor */
+   IdentityMatrixSpace(
+      const IdentityMatrixSpace&
+   );
+
+   /** Default Assignment Operator */
+   void operator=(
+      const IdentityMatrixSpace&
+   );
+   ///@}
+};
+
+} // namespace Ipopt
+#endif