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

casadi/include/coin-or/IpDiagMatrix.hpp

@@ -0,0 +1,158 @@
+// 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 __IPDIAGMATRIX_HPP__
+#define __IPDIAGMATRIX_HPP__
+
+#include "IpUtils.hpp"
+#include "IpSymMatrix.hpp"
+
+namespace Ipopt
+{
+
+/** Class for diagonal matrices.
+ *
+ *  The diagonal is stored as a Vector.
+ */
+class IPOPTLIB_EXPORT DiagMatrix: public SymMatrix
+{
+public:
+
+   /**@name Constructors / Destructors */
+   ///@{
+   /** Constructor, given the corresponding matrix space. */
+   DiagMatrix(
+      const SymMatrixSpace* owner_space
+   );
+
+   /** Destructor */
+   ~DiagMatrix();
+   ///@}
+
+   /** Set the diagonal elements (as a Vector). */
+   void SetDiag(
+      const Vector& diag
+   )
+   {
+      diag_ = &diag;
+   }
+
+   /** Get the diagonal elements. */
+   SmartPtr<const Vector> GetDiag() const
+   {
+      return diag_;
+   }
+
+protected:
+   /**@name Methods overloaded from matrix */
+   ///@{
+   virtual void MultVectorImpl(
+      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 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 */
+   DiagMatrix();
+
+   /** Copy Constructor */
+   DiagMatrix(
+      const DiagMatrix&
+   );
+
+   /** Default Assignment Operator */
+   void operator=(
+      const DiagMatrix&
+   );
+   ///@}
+
+   /** Vector storing the diagonal elements */
+   SmartPtr<const Vector> diag_;
+};
+
+/** This is the matrix space for DiagMatrix. */
+class IPOPTLIB_EXPORT DiagMatrixSpace: public SymMatrixSpace
+{
+public:
+   /** @name Constructors / Destructors */
+   ///@{
+   /** Constructor, given the dimension of the matrix. */
+   DiagMatrixSpace(
+      Index dim
+   )
+      : SymMatrixSpace(dim)
+   { }
+
+   /** Destructor */
+   virtual ~DiagMatrixSpace()
+   { }
+   ///@}
+
+   virtual SymMatrix* MakeNewSymMatrix() const
+   {
+      return MakeNewDiagMatrix();
+   }
+
+   /** Method for creating a new matrix of this specific type. */
+   DiagMatrix* MakeNewDiagMatrix() const
+   {
+      return new DiagMatrix(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 */
+   DiagMatrixSpace();
+
+   /** Copy Constructor */
+   DiagMatrixSpace(
+      const DiagMatrixSpace&
+   );
+
+   /** Default Assignment Operator */
+   void operator=(
+      const DiagMatrixSpace&
+   );
+   ///@}
+
+};
+
+} // namespace Ipopt
+#endif

casadi/include/coin-or/IpEqMultCalculator.hpp

@@ -0,0 +1,76 @@
+// Copyright (C) 2004, 2006 International Business Machines and others.
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// Authors:  Carl Laird, Andreas Waechter              IBM    2004-09-23
+
+#ifndef __IPEQMULTCALCULATOR_HPP__
+#define __IPEQMULTCALCULATOR_HPP__
+
+#include "IpUtils.hpp"
+#include "IpAlgStrategy.hpp"
+
+namespace Ipopt
+{
+/** Base Class for objects that compute estimates for the equality
+ *  constraint multipliers y_c and y_d.
+ *
+ *  For example, this is the base class for objects for computing
+ *  least square multipliers or coordinate multipliers.
+ */
+class EqMultiplierCalculator: public AlgorithmStrategyObject
+{
+public:
+   /**@name Constructors/Destructors */
+   ///@{
+   /** Default Constructor. */
+   EqMultiplierCalculator()
+   { }
+   /** Destructor */
+   virtual ~EqMultiplierCalculator()
+   { }
+   ///@}
+
+   /** overloaded from AlgorithmStrategyObject */
+   virtual bool InitializeImpl(
+      const OptionsList& options,
+      const std::string& prefix
+   ) = 0;
+
+   /** This method computes the estimates for y_c and y_d at the
+    *  current point.
+    *
+    *  If the estimates cannot be computed (e.g. some linear system
+    *  is singular), the return value of this method is false.
+    */
+   virtual bool CalculateMultipliers(
+      Vector& y_c,
+      Vector& y_d
+   ) = 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 */
+   EqMultiplierCalculator(
+      const EqMultiplierCalculator&
+   );
+
+   /** Default Assignment Operator */
+   void operator=(
+      const EqMultiplierCalculator&
+   );
+   ///@}
+};
+
+} // namespace Ipopt
+
+#endif

casadi/include/coin-or/IpException.hpp

@@ -0,0 +1,156 @@
+// Copyright (C) 2004, 2006 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
+
+/**  This file contains a base class for all exceptions
+ *  and a set of macros to help with exceptions.
+ */
+
+#ifndef __IPEXCEPTION_HPP__
+#define __IPEXCEPTION_HPP__
+
+#include "IpUtils.hpp"
+#include "IpJournalist.hpp"
+
+namespace Ipopt
+{
+
+/** This is the base class for all exceptions.
+ *
+ * The easiest way to
+ * use this class is by means of the following macros:
+ *
+ * \verbatim
+
+ DECLARE_STD_EXCEPTION(ExceptionType);
+ \endverbatim
+ *
+ * This macro defines a new class with the name ExceptionType,
+ * inherited from the base class IpoptException.  After this,
+ * exceptions of this type can be thrown using
+ *
+ * \verbatim
+
+ THROW_EXCEPTION(ExceptionType, Message);
+ \endverbatim
+ *
+ * where Message is a std::string with a message that gives an
+ * indication of what caused the exception.  Exceptions can also be
+ * thrown using the macro
+ *
+ * \verbatim
+
+ ASSERT_EXCEPTION(Condition, ExceptionType, Message);
+ \endverbatim
+ *
+ * where Conditions is an expression.  If Condition evaluates to
+ * false, then the exception of the type ExceptionType is thrown
+ * with Message.
+ *
+ * When an exception is caught, the method ReportException can be
+ * used to write the information about the exception to the
+ * Journalist, using the level J_ERROR and the category J_MAIN.
+ *
+ */
+class IPOPTLIB_EXPORT IpoptException
+{
+public:
+   /**@name Constructors/Destructors */
+   ///@{
+   /** Constructor */
+   IpoptException(
+      const std::string& msg,
+      const std::string& file_name,
+      Index              line_number,
+      const std::string& type = "IpoptException"
+   )
+      : msg_(msg),
+        file_name_(file_name),
+        line_number_(line_number),
+        type_(type)
+   { }
+
+   /** Copy Constructor */
+   IpoptException(
+      const IpoptException& copy
+   )
+      : msg_(copy.msg_),
+        file_name_(copy.file_name_),
+        line_number_(copy.line_number_),
+        type_(copy.type_)
+   { }
+
+   /** Default destructor */
+   virtual ~IpoptException()
+   { }
+   ///@}
+
+   /** Method to report the exception to a journalist */
+   void ReportException(
+      const Journalist& jnlst,
+      EJournalLevel     level = J_ERROR
+   ) const
+   {
+      jnlst.Printf(level, J_MAIN,
+                   "Exception of type: %s in file \"%s\" at line %" IPOPT_INDEX_FORMAT ":\n Exception message: %s\n", type_.c_str(), file_name_.c_str(), line_number_, msg_.c_str());
+   }
+
+   const std::string& Message() const
+   {
+      return msg_;
+   }
+
+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 */
+   IpoptException();
+
+   /** Default Assignment Operator */
+   void operator=(
+      const IpoptException&
+   );
+   ///@}
+
+   std::string msg_;
+   std::string file_name_;
+   Index       line_number_;
+   std::string type_;
+};
+
+} // namespace Ipopt
+
+#define THROW_EXCEPTION(__except_type, __msg) \
+  throw __except_type( (__msg), (__FILE__), (__LINE__) );
+
+#define ASSERT_EXCEPTION(__condition, __except_type, __msg) \
+  if (! (__condition) ) { \
+    std::string newmsg = #__condition; \
+    newmsg += " evaluated false: "; \
+    newmsg += __msg; \
+    throw __except_type( (newmsg), (__FILE__), (__LINE__) ); \
+  }
+
+#define DECLARE_STD_EXCEPTION(__except_type) \
+    class IPOPTLIB_EXPORT  __except_type : public Ipopt::IpoptException \
+    { \
+    public: \
+      __except_type(const std::string& msg, const std::string& fname, Ipopt::Index line) \
+      : Ipopt::IpoptException(msg,fname,line, #__except_type) {} \
+      __except_type(const __except_type& copy) \
+      : Ipopt::IpoptException(copy) {} \
+    private: \
+       __except_type(); \
+       void operator=(const __except_type&); \
+    }
+
+#endif

casadi/include/coin-or/IpExpansionMatrix.hpp

@@ -0,0 +1,245 @@
+// 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 __IPEXPANSIONMATRIX_HPP__
+#define __IPEXPANSIONMATRIX_HPP__
+
+#include "IpUtils.hpp"
+#include "IpMatrix.hpp"
+
+namespace Ipopt
+{
+
+/** forward declarations */
+class ExpansionMatrixSpace;
+
+/** Class for expansion/projection matrices.
+ *
+ *  These matrices allow
+ *  to lift a vector to a vector with larger dimension, keeping
+ *  some elements of the larger vector zero.  This operation is achieved
+ *  by the MultVector operation.  The transpose operation then
+ *  filters some elements from a large vector into a smaller vector.
+ */
+class IPOPTLIB_EXPORT ExpansionMatrix: public Matrix
+{
+public:
+   /**@name Constructors / Destructors */
+   ///@{
+   /** Constructor, taking the owner_space.
+    */
+   ExpansionMatrix(
+      const ExpansionMatrixSpace* owner_space
+   );
+
+   /** Destructor */
+   ~ExpansionMatrix();
+   ///@}
+
+   /** Return the vector of indices marking the expanded position.
+    *
+    *  The result is the Index array (of length NSmallVec=NCols())
+    *  that stores the mapping from the small vector to the large
+    *  vector.  For each element i=0,..,NSmallVec in the small
+    *  vector, ExpandedPosIndices()[i] give the corresponding index
+    *  in the large vector.
+    */
+   const Index* ExpandedPosIndices() const;
+
+   /** Return the vector of indices marking the compressed position.
+    *
+    *  The result is the Index array (of length NLargeVec=NRows())
+    *  that stores the mapping from the large vector to the small
+    *  vector.  For each element i=0,..,NLargeVec in the large
+    *  vector, CompressedPosIndices()[i] gives the corresponding
+    *  index in the small vector, unless CompressedPosIndices()[i] is
+    *  negative.
+    */
+   const Index* CompressedPosIndices() const;
+
+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 void AddMSinvZImpl(
+      Number        alpha,
+      const Vector& S,
+      const Vector& Z,
+      Vector&       X
+   ) const;
+
+   virtual void SinvBlrmZMTdBrImpl(
+      Number        alpha,
+      const Vector& S,
+      const Vector& R,
+      const Vector& Z,
+      const Vector& D,
+      Vector&       X
+   ) 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, 1, 1);
+   }
+   ///@}
+
+   void PrintImplOffset(
+      const Journalist&  jnlst,
+      EJournalLevel      level,
+      EJournalCategory   category,
+      const std::string& name,
+      Index              indent,
+      const std::string& prefix,
+      Index              row_offset,
+      Index              col_offset
+   ) const;
+
+   friend class ParExpansionMatrix;
+
+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 */
+   ExpansionMatrix();
+
+   /** Copy Constructor */
+   ExpansionMatrix(
+      const ExpansionMatrix&
+   );
+
+   /** Default Assignment Operator */
+   void operator=(
+      const ExpansionMatrix&
+   );
+   ///@}
+
+   const ExpansionMatrixSpace* owner_space_;
+
+};
+
+/** This is the matrix space for ExpansionMatrix. */
+class IPOPTLIB_EXPORT ExpansionMatrixSpace: public MatrixSpace
+{
+public:
+   /** @name Constructors / Destructors */
+   ///@{
+   /** Constructor, given the list of elements of the large vector
+    *  (of size NLargeVec) to be filtered into the small vector (of
+    *  size NSmallVec).
+    *
+    *  For each i=0..NSmallVec-1 the i-th element
+    *  of the small vector will be put into the ExpPos[i] position of
+    *  the large vector.  The position counting in the vector is
+    *  assumed to start at 0 (C-like array notation).
+    */
+   ExpansionMatrixSpace(
+      Index        NLargeVec,
+      Index        NSmallVec,
+      const Index* ExpPos,
+      const int    offset = 0
+   );
+
+   /** Destructor */
+   ~ExpansionMatrixSpace()
+   {
+      delete[] compressed_pos_;
+      delete[] expanded_pos_;
+   }
+   ///@}
+
+   /** Method for creating a new matrix of this specific type. */
+   ExpansionMatrix* MakeNewExpansionMatrix() const
+   {
+      return new ExpansionMatrix(this);
+   }
+
+   virtual Matrix* MakeNew() const
+   {
+      return MakeNewExpansionMatrix();
+   }
+
+   /** Accessor Method to obtain the Index array (of length
+    *  NSmallVec=NCols()) that stores the mapping from the small
+    *  vector to the large vector.
+    *
+    *  For each element i=0,..,NSmallVec
+    *  in the small vector, ExpandedPosIndices()[i] give the
+    *  corresponding index in the large vector.
+    */
+   const Index* ExpandedPosIndices() const
+   {
+      return expanded_pos_;
+   }
+
+   /** Accessor Method to obtain the Index array (of length
+    *  NLargeVec=NRows()) that stores the mapping from the large
+    *  vector to the small vector.
+    *
+    *  For each element i=0,..,NLargeVec
+    *  in the large vector, CompressedPosIndices()[i] gives the
+    *  corresponding index in the small vector, unless
+    *  CompressedPosIndices()[i] is negative.
+    */
+   const Index* CompressedPosIndices() const
+   {
+      return compressed_pos_;
+   }
+
+private:
+   Index* expanded_pos_;
+   Index* compressed_pos_;
+};
+
+/* inline methods */
+inline const Index* ExpansionMatrix::ExpandedPosIndices() const
+{
+   return owner_space_->ExpandedPosIndices();
+}
+
+inline const Index* ExpansionMatrix::CompressedPosIndices() const
+{
+   return owner_space_->CompressedPosIndices();
+}
+
+} // namespace Ipopt
+#endif