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

casadi/include/coin-or/SensPCalculator.hpp

@@ -0,0 +1,137 @@
+// Copyright 2009, 2011 Hans Pirnay
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// Date   : 2009-05-06
+
+#ifndef __ASPCALCULATOR_HPP__
+#define __ASPCALCULATOR_HPP__
+
+#include "IpAlgStrategy.hpp"
+#include "SensSimpleBacksolver.hpp"
+#include "SensSchurData.hpp"
+
+namespace Ipopt
+{
+
+/** This class is the interface for implementations of any class that calculates the matrix \f$P =K^{-1}A\f$
+ *  of the following matrix:
+ *  \f[
+ *  \left(\begin{array}{cc}
+ *  K & A\\
+ *  B & 0
+ *  \end{array}\right)
+ *  \f]
+ */
+class SIPOPTLIB_EXPORT PCalculator: public AlgorithmStrategyObject
+{
+public:
+   PCalculator(
+      SmartPtr<SensBacksolver> backsolver,
+      SmartPtr<SchurData>      A_data
+   )
+      : backsolver_(backsolver),
+        data_A_init(ConstPtr(A_data->MakeNewSchurDataCopy())),
+        data_A_(A_data)
+   { }
+
+   virtual ~PCalculator()
+   { }
+
+   /* Overloaded from AlgorithmStrategyObject */
+   virtual bool InitializeImpl(
+      const OptionsList& /*options*/,
+      const std::string& /*prefix*/
+   )
+   {
+      return true;
+   }
+
+   /** Function to start the computation of  P from E_0 and KKT*/
+   virtual bool ComputeP() = 0;
+
+   /** Function to extract a SchurMatrix corresponding to $B K^{-1} A$.
+    *
+    * If B==NULL, use A=B.
+    */
+   virtual bool GetSchurMatrix(
+      const SmartPtr<const SchurData>& B,
+      SmartPtr<Matrix>&                S
+   ) = 0;
+
+   virtual void PrintImpl(
+      const Journalist&  jnlst,
+      EJournalLevel      level,
+      EJournalCategory   category,
+      const std::string& name,
+      Index              indent,
+      const std::string& prefix
+   ) const = 0;
+
+   void Print(
+      const Journalist&  jnlst,
+      EJournalLevel      level,
+      EJournalCategory   category,
+      const std::string& name,
+      Index              indent = 0,
+      const std::string& prefix = ""
+   ) const
+   {
+      if( jnlst.ProduceOutput(level, category) )
+      {
+         PrintImpl(jnlst, level, category, name, indent, prefix);
+      }
+   }
+
+   void Print(
+      SmartPtr<const Journalist> jnlst,
+      EJournalLevel              level,
+      EJournalCategory           category,
+      const std::string&         name,
+      Index                      indent,
+      const std::string&         prefix
+   ) const
+   {
+      if( IsValid(jnlst) && jnlst->ProduceOutput(level, category) )
+      {
+         PrintImpl(*jnlst, level, category, name, indent, prefix);
+      }
+   }
+
+   /** Accessor methods for data and backsolver.
+    *
+    *  This unconstness seems
+    *  kind of dangerous but I don't think there is a way around it. Anyway,
+    *  there is no difference between this and the IpData() method of AlgStrategy.
+    */
+   SmartPtr<SensBacksolver> Solver() const
+   {
+      return backsolver_;
+   }
+
+   SmartPtr<const SchurData> data_A() const
+   {
+      return ConstPtr(data_A_);
+   }
+
+   SmartPtr<SchurData> data_A_nonconst() const
+   {
+      return data_A_;
+   }
+
+   void reset_data_A()
+   {
+      data_A_ = data_A_init->MakeNewSchurDataCopy();
+   }
+
+private:
+
+   SmartPtr<SensBacksolver> backsolver_;
+
+   SmartPtr<const SchurData> data_A_init;
+   SmartPtr<SchurData> data_A_;
+};
+
+}
+
+#endif

casadi/include/coin-or/SensRegOp.hpp

@@ -0,0 +1,21 @@
+// Copyright 2009, 2011 Hans Pirnay
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+
+#ifndef __SENSREGOP_HPP__
+#define __SENSREGOP_HPP__
+
+#include "IpSmartPtr.hpp"
+
+namespace Ipopt
+{
+
+class RegisteredOptions;
+
+SIPOPTLIB_EXPORT void RegisterOptions_sIPOPT(
+   const SmartPtr<RegisteredOptions>& roptions
+);
+
+} // namespace Ipopt
+
+#endif

casadi/include/coin-or/SensSchurData.hpp

@@ -0,0 +1,182 @@
+// Copyright 2009, 2011 Hans Pirnay
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// Date   : 2009-05-06
+
+#ifndef __ASSCHURDATA_HPP__
+#define __ASSCHURDATA_HPP__
+
+#include "IpVector.hpp"
+#include "IpIteratesVector.hpp"
+#include <vector>
+
+namespace Ipopt
+{
+
+/** This interface serves as a reference point for multiple classes
+ *  that need to use SchurData (PCalculator, SchurDriver).
+ *
+ *  It declares as little as possible, so that SchurData implementations
+ *  can be very special and fast.
+ *
+ *  I have not decided yet if there are certain ways I want to impose
+ *  that SchurData can be set. I will figure this out as soon as I
+ *  write the upstream classes that need to do that
+ *
+ *  Nomenclature in this program is based on Victor Zavalas thesis.
+ */
+class SIPOPTLIB_EXPORT SchurData: public ReferencedObject
+{
+public:
+   SchurData()
+      : initialized_(false),
+        nrows_(0)
+   { }
+
+   virtual ~SchurData()
+   { }
+
+   virtual SmartPtr<SchurData> MakeNewSchurDataCopy() const = 0;
+
+   /* Functions to set the Schurdata. At least one must be overloaded */
+
+   /** Set Data to one for given indices. Size of vector is ipopt_x_<full_x_ */
+   virtual void SetData_Flag(
+      Index        dim,
+      const Index* flags,
+      Number       v = 1.0
+   ) = 0;
+
+   /** Set Data to corresponing Number */
+   virtual void SetData_Flag(
+      Index         dim,
+      const Index*  flags,
+      const Number* values
+   ) = 0;
+
+   virtual Index SetData_Index(
+      Index        dim,
+      const Index* flags,
+      Number       v = 1.0
+   ) = 0;
+
+   virtual void SetData_List(
+      const std::vector<Index>& list,
+      Number                    v = 1.0
+   ) = 0;
+
+   virtual void AddData_List(
+      std::vector<Index>  cols,
+      std::vector<Index>& delta_u_sort,
+      Index&              new_du_size,
+      Index               v
+   ) = 0;
+
+   /** Returns number of rows/columns in schur matrix */
+   virtual Index GetNRowsAdded() const
+   {
+      return nrows_;
+   }
+
+   virtual bool Is_Initialized() const
+   {
+      return initialized_;
+   }
+
+   /** Returns the i-th column vector of the matrix */
+   virtual void GetRow(
+      Index           i,
+      IteratesVector& v
+   ) const = 0;
+
+   /** Returns two vectors that are needed for matrix-vector
+    *  multiplication of B and P.
+    *
+    *  The index is the row, the first vector are the indices
+    *  of non-zero components, in this row of B,
+    *  the second vector gives the numbers in B(row,indices)/
+    */
+   virtual void GetMultiplyingVectors(
+      Index                row,
+      std::vector<Index>&  indices,
+      std::vector<Number>& factors
+   ) const = 0;
+
+   /** Computes B*v with B in R(mxn) */
+   virtual void Multiply(
+      const IteratesVector& v,
+      Vector&               u
+   ) const = 0;
+
+   /** Computes A*u with A in R(nxm), KKT in R(n,n) */
+   virtual void TransMultiply(
+      const Vector&   u,
+      IteratesVector& v
+   ) const = 0;
+
+   virtual void PrintImpl(
+      const Journalist&  jnlst,
+      EJournalLevel      level,
+      EJournalCategory   category,
+      const std::string& name,
+      Index              indent,
+      const std::string& prefix
+   ) const = 0;
+
+   void Print(
+      const Journalist&  jnlst,
+      EJournalLevel      level,
+      EJournalCategory   category,
+      const std::string& name,
+      Index              indent = 0,
+      const std::string& prefix = ""
+   ) const
+   {
+      if( jnlst.ProduceOutput(level, category) )
+      {
+         PrintImpl(jnlst, level, category, name, indent, prefix);
+      }
+   }
+
+   void Print(
+      SmartPtr<const Journalist> jnlst,
+      EJournalLevel              level,
+      EJournalCategory           category,
+      const std::string&         name,
+      Index                      indent,
+      const std::string&         prefix
+   ) const
+   {
+      if( IsValid(jnlst) && jnlst->ProduceOutput(level, category) )
+      {
+         PrintImpl(*jnlst, level, category, name, indent, prefix);
+      }
+   }
+
+protected:
+
+   virtual void Set_Initialized()
+   {
+      initialized_ = true;
+   }
+
+   virtual void Set_NRows(
+      Index nrows
+   )
+   {
+      nrows_ = nrows;
+   }
+
+private:
+
+   /** Makes sure that data is not set twice accidentially */
+   bool initialized_;
+
+   /** Number of columns/rows of corresponding Schur Matrix*/
+   Index nrows_;
+};
+
+}
+
+#endif

casadi/include/coin-or/SensSchurDriver.hpp

@@ -0,0 +1,118 @@
+// Copyright 2009, 2011 Hans Pirnay
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// Date   : 2009-05-06
+
+#ifndef __ASSCHURDRIVER_HPP__
+#define __ASSCHURDRIVER_HPP__
+
+#include "SensSchurData.hpp"
+#include "SensPCalculator.hpp"
+#include "IpVector.hpp"
+#include "IpIteratesVector.hpp"
+
+namespace Ipopt
+{
+
+/** This class is the interface for any class that deals with the Schur matrix
+ *  from the point when it is constructed by the PCalculator to the solution
+ *  against one vector.
+ *
+ *  Specific implementations may also incorporate the
+ *  treatment of adding rows/cols (like QPSchur).
+ *
+ *  The computations done by this class are
+ *  1. Solve \f$S \Delta\nu = r_s\f$
+ *  2. Solve \f$K\Delta s = ... - \Delta nu\f$ (really?)
+ */
+class SIPOPTLIB_EXPORT SchurDriver: public AlgorithmStrategyObject
+{
+public:
+
+   SchurDriver(
+      SmartPtr<PCalculator> pcalc,
+      SmartPtr<SchurData>   data_B
+   )
+      : pcalc_(pcalc),
+        data_B_(data_B)
+   { }
+
+   virtual ~SchurDriver()
+   { }
+
+   virtual bool InitializeImpl(
+      const OptionsList& /*options*/,
+      const std::string& /*prefix*/
+   )
+   {
+      return true;
+   }
+
+   /** Const accessor methods to the SchurData for for the derived classes */
+   virtual SmartPtr<const SchurData> data_A() const
+   {
+      return pcalc_->data_A();
+   }
+
+   virtual SmartPtr<const SchurData> data_B() const
+   {
+      return ConstPtr(data_B_);
+   }
+
+   virtual SmartPtr<SchurData> data_A_nonconst()
+   {
+      return pcalc_->data_A_nonconst();
+   }
+
+   virtual SmartPtr<SchurData> data_B_nonconst()
+   {
+      return data_B_;
+   }
+
+   virtual SmartPtr<const PCalculator> pcalc() const
+   {
+      return ConstPtr(pcalc_);
+   }
+
+   virtual SmartPtr<PCalculator> pcalc_nonconst()
+   {
+      return pcalc_;
+   }
+
+   /* Sets the Data for which this SchurMatrix will be built. */
+
+   /** Creates the SchurMatrix from B and P */
+   virtual bool SchurBuild() = 0;
+
+   /** Calls the factorization routine for the SchurMatrix */
+   virtual bool SchurFactorize() = 0;
+
+   /** Performs a backsolve on S and K
+    *
+    * sol is the vector K^(-1)*r_s which usually should have been computed before
+    */
+   virtual bool SchurSolve(
+      SmartPtr<IteratesVector>       lhs,
+      SmartPtr<const IteratesVector> rhs,
+      SmartPtr<Vector>               delta_u,
+      SmartPtr<IteratesVector>       sol = NULL
+   ) = 0;
+
+   /* Performs a backsolve on S and K; calls the latter with sol=K^(-1)*r_s=0
+    virtual bool SchurSolve(SmartPtr<IteratesVector> lhs,
+    SmartPtr<const IteratesVector> rhs,
+    SmartPtr<Vector> delta_u) =0;
+    */
+private:
+   SchurDriver()
+   { }
+
+   SmartPtr<PCalculator> pcalc_;
+
+   SmartPtr<SchurData> data_B_;
+};
+
+}
+
+#endif

casadi/include/coin-or/SensSimpleBacksolver.hpp

@@ -0,0 +1,49 @@
+// Copyright 2009, 2011 Hans Pirnay
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// Date    : 2009-04-06
+//
+// Purpose : This is the same as IpSensitivityCalculator.hpp
+//           It implements the SensBacksolver Interface.
+
+#ifndef __ASSIMPLEBACKSOLVER_HPP__
+#define __ASSIMPLEBACKSOLVER_HPP__
+
+#include "IpPDSystemSolver.hpp"
+#include "SensBacksolver.hpp"
+
+namespace Ipopt
+{
+
+class SIPOPTLIB_EXPORT SimpleBacksolver: public SensBacksolver
+{
+public:
+
+   SimpleBacksolver(
+      SmartPtr<PDSystemSolver> pd_solver
+   );
+
+   ~SimpleBacksolver()
+   { }
+
+   bool InitializeImpl(
+      const OptionsList& options,
+      const std::string& prefix
+   );
+
+   bool Solve(
+      SmartPtr<IteratesVector>       delta_lhs,
+      SmartPtr<const IteratesVector> delta_rhs
+   );
+
+private:
+   SimpleBacksolver();
+
+   SmartPtr<PDSystemSolver> pd_solver_;
+   bool allow_inexact_;
+};
+
+}
+
+#endif

casadi/include/coin-or/SensStepCalc.hpp

@@ -0,0 +1,85 @@
+// Copyright 2009, 2011 Hans Pirnay
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// Date   : 2009-05-14
+
+#ifndef __ASSENSSTEPCALC_HPP__
+#define __ASSENSSTEPCALC_HPP__
+
+#include "IpAlgStrategy.hpp"
+#include "SensSchurDriver.hpp"
+
+namespace Ipopt
+{
+/* Forward declarations */
+class DenseVector;
+class IteratesVector;
+
+/** This is the interface for the classes that perform the actual step. */
+class SIPOPTLIB_EXPORT SensitivityStepCalculator: public AlgorithmStrategyObject
+{
+public:
+   SensitivityStepCalculator()
+      : driver_(NULL),
+        do_boundcheck_(false)
+   { }
+
+   virtual ~SensitivityStepCalculator()
+   { }
+
+   virtual bool InitializeImpl(
+      const OptionsList& options,
+      const std::string& prefix
+   )
+   {
+      options.GetBoolValue("sens_boundcheck", do_boundcheck_, prefix);
+      return true;
+   }
+
+   bool Do_Boundcheck() const
+   {
+      return do_boundcheck_;
+   }
+
+   void SetSchurDriver(
+      SmartPtr<SchurDriver> driver
+   )
+   {
+      DBG_ASSERT(IsValid(driver));
+
+      driver_ = driver;
+      if( IsValid(driver_->pcalc_nonconst()) )
+      {
+         driver_->pcalc_nonconst()->reset_data_A();
+         // when the schurdriver is set, the data in the pcalculator has to be reset to its data?
+      }
+   }
+
+   SmartPtr<SchurDriver> Driver() // this should be const or protected
+   {
+      DBG_ASSERT(IsValid(driver_));
+
+      return driver_;
+   }
+
+   /** This is the main algorithmic function of this class.
+    *
+    * It calculates a step using its SchurDriver, checks bounds, and returns it
+    */
+   virtual bool Step(
+      DenseVector&    delta_u,
+      IteratesVector& sol
+   ) = 0;
+
+   /** return the sensitivity vector */
+   virtual SmartPtr<IteratesVector> GetSensitivityVector() = 0;
+
+private:
+   SmartPtr<SchurDriver> driver_;
+   bool do_boundcheck_;
+};
+
+}
+
+#endif

casadi/include/coin-or/SensUtils.hpp

@@ -0,0 +1,63 @@
+// Copyright 2009, 2011 Hans Pirnay
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// Date   : 2009-05-14
+
+#ifndef __SENSCUTILS_HPP__
+#define __SENSCUTILS_HPP__
+
+#include "IpUtils.hpp"
+#include "IpAlgTypes.hpp"
+#include "IpReturnCodes.hpp"
+
+#include <string>
+
+namespace Ipopt
+{
+
+/* This header file provides some definitions used throughout the program. */
+
+enum SensAlgorithmExitStatus
+{
+   SOLVE_SUCCESS,
+   FATAL_ERROR
+};
+
+SIPOPTLIB_EXPORT Index AsIndexMax(
+   Index        length,
+   const Index* x,
+   Index        Incr
+);
+
+SIPOPTLIB_EXPORT Index AsIndexSum(
+   Index        length,
+   const Index* x,
+   Index        Incr
+);
+
+SIPOPTLIB_EXPORT void append_Index(
+   std::string& str,
+   Index        idx
+);
+
+SIPOPTLIB_EXPORT SolverReturn AppReturn2SolverReturn(
+   ApplicationReturnStatus ipopt_retval
+);
+}
+
+// same as DECLARE_STD_EXCEPTION, but using SIPOPTLIB_EXPORT instead of IPOPTLIB_EXPORT
+#define DECLARE_STD_SIPOPT_EXCEPTION(__except_type) \
+    class SIPOPTLIB_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