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

casadi/include/coin-or/IpZeroSymMatrix.hpp

@@ -0,0 +1,155 @@
+// 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 __IPZEROSYMMATRIX_HPP__
+#define __IPZEROSYMMATRIX_HPP__
+
+#include "IpUtils.hpp"
+#include "IpSymMatrix.hpp"
+
+namespace Ipopt
+{
+
+/** Class for Symmetric Matrices with only zero entries. */
+class IPOPTLIB_EXPORT ZeroSymMatrix: public SymMatrix
+{
+public:
+   /**@name Constructors / Destructors */
+   ///@{
+   /** Constructor, taking the corresponding matrix space. */
+   ZeroSymMatrix(
+      const SymMatrixSpace* owner_space
+   );
+
+   /** Destructor */
+   ~ZeroSymMatrix();
+   ///@}
+
+protected:
+   /**@name Methods overloaded from matrix */
+   ///@{
+   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 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;
+   ///@}
+
+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 */
+   ZeroSymMatrix();
+
+   /** Copy Constructor */
+   ZeroSymMatrix(
+      const ZeroSymMatrix&
+   );
+
+   /** Default Assignment Operator */
+   void operator=(
+      const ZeroSymMatrix&
+   );
+   ///@}
+};
+
+/** Class for matrix space for ZeroSymMatrix. */
+class IPOPTLIB_EXPORT ZeroSymMatrixSpace: public SymMatrixSpace
+{
+public:
+   /** @name Constructors / Destructors */
+   ///@{
+   /** Constructor, given the number of row and columns. */
+   ZeroSymMatrixSpace(
+      Index dim
+   )
+      : SymMatrixSpace(dim)
+   { }
+
+   /** Destructor */
+   virtual ~ZeroSymMatrixSpace()
+   { }
+   ///@}
+
+   virtual Matrix* MakeNew() const
+   {
+      return MakeNewZeroSymMatrix();
+   }
+
+   virtual SymMatrix* MakeNewSymMatrix() const
+   {
+      return MakeNewZeroSymMatrix();
+   }
+
+   /** Method for creating a new matrix of this specific type. */
+   ZeroSymMatrix* MakeNewZeroSymMatrix() const
+   {
+      return new ZeroSymMatrix(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 */
+   ZeroSymMatrixSpace();
+
+   /** Copy Constructor */
+   ZeroSymMatrixSpace(
+      const ZeroSymMatrixSpace&
+   );
+
+   /** Default Assignment Operator */
+   void operator=(
+      const ZeroSymMatrixSpace&
+   );
+   ///@}
+};
+
+} // namespace Ipopt
+#endif

casadi/include/coin-or/IpoptConfig.h

@@ -0,0 +1,45 @@
+/* src/Common/config_ipopt.h.  Generated from config_ipopt.h.in by configure.  */
+/* src/Common/config_ipopt.h.in. */
+
+#ifndef __CONFIG_IPOPT_H__
+#define __CONFIG_IPOPT_H__
+
+/* Version number of project */
+#define IPOPT_VERSION "3.14.11"
+
+/* Major Version number of project */
+#define IPOPT_VERSION_MAJOR 3
+
+/* Minor Version number of project */
+#define IPOPT_VERSION_MINOR 14
+
+/* Release Version number of project */
+#define IPOPT_VERSION_RELEASE 11
+
+/* Define to the debug sanity check level (0 is no test) */
+#define IPOPT_CHECKLEVEL 0
+
+/* Define to the debug verbosity level (0 is no output) */
+#define IPOPT_VERBOSITY 0
+
+/* Define to 1 if using single precision floating point */
+/* #undef IPOPT_SINGLE */
+
+/* Define to 1 if Ipopt index type is int64_t */
+/* #undef IPOPT_INT64 */
+
+/* Library Visibility Attribute */
+#define IPOPTAMPLINTERFACELIB_EXPORT 
+
+/* Library Visibility Attribute */
+#define IPOPTLIB_EXPORT 
+
+/* Library Visibility Attribute */
+#define SIPOPTLIB_EXPORT 
+
+/** type corresponding to integers in Fortran
+ * @deprecated Use ipindex instead.
+ */
+#define IPOPT_FORTRAN_INTEGER_TYPE ipindex
+
+#endif

casadi/include/coin-or/SensAlgorithm.hpp

@@ -0,0 +1,114 @@
+// Copyright 2009, 2011 Hans Pirnay
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// Date   : 2009-05-06
+
+#ifndef __SENSALGORITHM_HPP__
+#define __SENSALGORITHM_HPP__
+
+#include "IpAlgStrategy.hpp"
+#include "SensStepCalc.hpp"
+#include "SensMeasurement.hpp"
+#include "SensSchurDriver.hpp"
+#include "SensUtils.hpp"
+
+namespace Ipopt
+{
+
+/** This is the interface for the actual controller.
+ *
+ *  It handles Data input to the controller (measurement) and returns controls.
+ */
+class SIPOPTLIB_EXPORT SensAlgorithm : public AlgorithmStrategyObject
+{
+public:
+   SensAlgorithm(
+      std::vector< SmartPtr<SchurDriver> >& driver_vec,
+      SmartPtr<SensitivityStepCalculator>   sens_step_calc,
+      SmartPtr<Measurement>                 measurement,
+      Index                                 n_sens_steps
+   );
+
+   virtual ~SensAlgorithm();
+
+   virtual bool InitializeImpl(
+      const OptionsList& options,
+      const std::string& prefix
+   );
+
+   /** Main loop: Wait for new measurement, Get new step, maybe deal with
+    *  bounds,  see to it that everything happens in the required
+    *  timeframe. */
+   SensAlgorithmExitStatus Run();
+   SensAlgorithmExitStatus ComputeSensitivityMatrix(void);
+
+   /** accessor methods to get access to variable sizes */
+   Index nl(void)
+   {
+      return nl_;
+   }
+   Index nx(void)
+   {
+      return nx_;
+   }
+   Index nzl(void)
+   {
+      return nzl_;
+   }
+   Index nzu(void)
+   {
+      return nzu_;
+   }
+   Index ns(void)
+   {
+      return ns_;
+   }
+   Index np(void)
+   {
+      return np_;
+   }
+
+   /** array place holders to store the vector of sensitivities */
+   Number* DirectionalD_X_;
+   Number* DirectionalD_L_;
+   Number* DirectionalD_Z_L_;
+   Number* DirectionalD_Z_U_;
+
+   /** array place holders for the sensitivity matrix */
+   Number* SensitivityM_X_;
+   Number* SensitivityM_L_;
+   Number* SensitivityM_Z_L_;
+   Number* SensitivityM_Z_U_;
+
+private:
+   Index nl_;
+   Index nx_;
+   Index nzl_;
+   Index nzu_;
+   Index nceq_;
+   Index ncineq_;
+   Index ns_;
+   Index np_;
+
+   std::vector< SmartPtr<SchurDriver> > driver_vec_;
+   SmartPtr<SensitivityStepCalculator> sens_step_calc_;
+   SmartPtr<Measurement> measurement_;
+   Index n_sens_steps_; // I think it is useful to state this number explicitly in the constructor and here.
+
+   /** method to extract sensitivity vectors */
+   void GetDirectionalDerivatives(void);
+
+   /** method to extract sensitivity matrix */
+   void GetSensitivityMatrix(
+      Index col
+   );
+
+   /** private method used to uncale perturbed solution and sensitivities */
+   void UnScaleIteratesVector(
+      SmartPtr<IteratesVector>* V
+   );
+};
+}
+
+#endif

casadi/include/coin-or/SensApplication.hpp

@@ -0,0 +1,188 @@
+// Copyright 2009, 2011 Hans Pirnay
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// Date   : 2009-05-06
+
+#ifndef __SENSAPPLICATION_HPP__
+#define __SENSAPPLICATION_HPP__
+
+#include "IpReferenced.hpp"
+#include "SensUtils.hpp"
+#include "SensUtils.hpp"
+#include "SensAlgorithm.hpp"
+#include "IpRegOptions.hpp"
+
+#include "IpIpoptApplication.hpp"
+#include "IpPDSystemSolver.hpp"
+
+#include "IpSmartPtr.hpp"
+
+namespace Ipopt
+{
+/** Standard exception for wrong/inconsistent suffixes for sipopt */
+DECLARE_STD_SIPOPT_EXCEPTION(SENS_SUFFIX_ERROR);
+
+class SIPOPTLIB_EXPORT SensApplication: public ReferencedObject
+{
+public:
+   // constructor
+   SensApplication(
+      SmartPtr<Journalist>        jnlst,
+      SmartPtr<OptionsList>       options,
+      SmartPtr<RegisteredOptions> reg_options
+   );
+
+   ~SensApplication();
+
+   static void RegisterOptions(
+      SmartPtr<RegisteredOptions> roptions
+   );
+
+   SensAlgorithmExitStatus Run();
+
+   void Initialize();
+
+   void SetIpoptAlgorithmObjects(
+      SmartPtr<IpoptApplication> app_ipopt,
+      ApplicationReturnStatus    ipopt_retval
+   );
+
+   SmartPtr<Journalist> Jnlst()
+   {
+      return jnlst_;
+   }
+
+   SmartPtr<OptionsList> Options()
+   {
+      return options_;
+   }
+
+   /** Get the options list for setting options (const version) */
+   SmartPtr<const OptionsList> Options() const
+   {
+      return ConstPtr(options_);
+   }
+
+   /** Copy over value of Directional Derivatives K^(-1)N_p(p-p0) */
+   void GetDirectionalDerivatives(
+      Number* SX,
+      Number* SL,
+      Number* SZL,
+      Number* SZU
+   )
+   {
+      if( GetRawPtr(controller) != NULL && NULL != DirectionalD_X && NULL != DirectionalD_Z_L
+          && NULL != DirectionalD_Z_U && NULL != DirectionalD_L )
+      {
+
+         for( Index i = 0; i < controller->nx(); ++i )
+         {
+            SX[i] = DirectionalD_X[i];
+         }
+         for( Index i = 0; i < controller->nzu(); ++i )
+         {
+            SZU[i] = DirectionalD_Z_U[i];
+         }
+         for( Index i = 0; i < controller->nzl(); ++i )
+         {
+            SZL[i] = DirectionalD_Z_L[i];
+         }
+         for( Index i = 0; i < controller->nl(); ++i )
+         {
+            SL[i] = DirectionalD_L[i];
+         }
+      }
+   }
+
+   /** Copy over value of ds/dp */
+   void GetSensitivityMatrix(
+      Number* SX,
+      Number* SL,
+      Number* SZL,
+      Number* SZU
+   )
+   {
+      if( GetRawPtr(controller) != NULL && NULL != SensitivityM_X && NULL != SensitivityM_Z_L
+          && NULL != SensitivityM_Z_U && NULL != SensitivityM_L )
+      {
+         for( Index i = 0; i < controller->nx() * controller->np(); ++i )
+         {
+            SX[i] = SensitivityM_X[i];
+         }
+         for( Index i = 0; i < controller->nzu() * controller->np(); ++i )
+         {
+            SZU[i] = SensitivityM_Z_U[i];
+         }
+         for( Index i = 0; i < controller->nzl() * controller->np(); ++i )
+         {
+            SZL[i] = SensitivityM_Z_L[i];
+         }
+         for( Index i = 0; i < controller->nl() * controller->np(); ++i )
+         {
+            SL[i] = SensitivityM_L[i];
+         }
+
+      }
+   }
+
+   /** accessor methods to get sizing info */
+   Index nx()
+   {
+      return (GetRawPtr(controller) != NULL) ? controller->nx() : -1;
+   }
+   Index nl()
+   {
+      return (GetRawPtr(controller) != NULL) ? controller->nl() : -1;
+   }
+   Index nzu()
+   {
+      return (GetRawPtr(controller) != NULL) ? controller->nzu() : -1;
+   }
+   Index nzl()
+   {
+      return (GetRawPtr(controller) != NULL) ? controller->nzl() : -1;
+   }
+   Index np()
+   {
+      return (GetRawPtr(controller) != NULL) ? controller->np() : -1;
+   }
+
+   /* place holders to keep the values of the directional derivatives for each type of variable */
+   Number* DirectionalD_X;
+   Number* DirectionalD_L;
+   Number* DirectionalD_Z_L;
+   Number* DirectionalD_Z_U;
+
+   /* place holders to keep the values of ds/dp for each type of variable */
+   Number* SensitivityM_X;
+   Number* SensitivityM_L;
+   Number* SensitivityM_Z_L;
+   Number* SensitivityM_Z_U;
+
+private:
+   // standard constructor just so it can't be used
+   //    SensApplication();
+
+   // Pointers that are immediately passed from Ipopt and initialized by the constructor
+   SmartPtr<Journalist> jnlst_;
+   SmartPtr<OptionsList> options_;
+   SmartPtr<IpoptData> ip_data_;
+   SmartPtr<IpoptCalculatedQuantities> ip_cq_;
+   SmartPtr<PDSystemSolver> pd_solver_;
+   SmartPtr<IpoptNLP> ip_nlp_;
+   SmartPtr<RegisteredOptions> reg_options_;
+   ApplicationReturnStatus ipopt_retval_;
+
+   SmartPtr<SensAlgorithm> controller;
+
+   /** storing options values */
+   bool run_sens_;
+   bool compute_red_hessian_;
+   bool compute_dsdp_;
+   Index n_sens_steps_;
+};
+
+}
+
+#endif

casadi/include/coin-or/SensBacksolver.hpp

@@ -0,0 +1,36 @@
+// Copyright 2009, 2011 Hans Pirnay
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// Date   : 2009-05-14
+
+#ifndef __ASASBACKSOLVER_HPP__
+#define __ASASBACKSOLVER_HPP__
+
+#include "IpAlgStrategy.hpp"
+#include "IpIteratesVector.hpp"
+
+namespace Ipopt
+{
+
+class SIPOPTLIB_EXPORT SensBacksolver: public AlgorithmStrategyObject
+{
+
+   /** This class is the interface to all backsolvers that may
+    *  be used for the sIPOPT. */
+public:
+   SensBacksolver()
+   { }
+
+   virtual ~SensBacksolver()
+   { }
+
+   virtual bool Solve(
+      SmartPtr<IteratesVector>       delta_lhs,
+      SmartPtr<const IteratesVector> delta_rhs
+   ) = 0;
+};
+
+}
+
+#endif

casadi/include/coin-or/SensMeasurement.hpp

@@ -0,0 +1,56 @@
+// Copyright 2009, 2011 Hans Pirnay
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// Date   : 2009-05-16
+
+#ifndef __AS_MEASUREMENT_HPP__
+#define __AS_MEASUREMENT_HPP__
+
+#include "IpReferenced.hpp"
+#include "IpDenseVector.hpp"
+#include "IpIteratesVector.hpp"
+
+namespace Ipopt
+{
+
+class SIPOPTLIB_EXPORT Measurement: public ReferencedObject
+{
+   /** This class provides an abstraction for the measurements of the states coming in
+    * and the solutions of the controller.
+    *
+    * It basically acts as the "plant" of the controller.
+    */
+public:
+
+   Measurement()
+   { }
+
+   virtual ~Measurement()
+   { }
+
+   /** This function returns a std::vector holding the indices in IteratesVector of the
+    *  equations that are to be "slacked" to free the initial values for sIPOPT.
+    *
+    *  This std::vector is used in the construction of the A-SchurData for the Schur Decomposition.
+    */
+   virtual std::vector<Index> GetInitialEqConstraints() = 0;
+
+   /** This function returns delta_u.
+    *
+    * It should use the values of IpData().trial()->x()
+    */
+   virtual SmartPtr<DenseVector> GetMeasurement(
+      Index measurement_number
+   ) = 0;
+
+   /** This function does whatever the measurement machine does with the solution of the SensAlgorithm */
+   virtual void SetSolution(
+      Index                    measurement_number,
+      SmartPtr<IteratesVector> sol
+   ) = 0;
+};
+
+}
+
+#endif