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

casadi/include/casadi/mem.h

@@ -46,6 +46,7 @@ extern "C" {
 #endif
 
 /* Function types corresponding to entry points in CasADi's C API */
+typedef int (*casadi_config_t)(int, const char**);
 typedef void (*casadi_signal_t)(void);
 typedef casadi_int (*casadi_getint_t)(void);
 typedef int (*casadi_checkout_t)(void);

casadi/include/coin-or/IpAlgBuilder.hpp

@@ -0,0 +1,417 @@
+// Copyright (C) 2004, 2007 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-29
+
+#ifndef __IPALGBUILDER_HPP__
+#define __IPALGBUILDER_HPP__
+
+#include "IpIpoptAlg.hpp"
+#include "IpReferenced.hpp"
+#include "IpAugSystemSolver.hpp"
+#include "IpPDSystemSolver.hpp"
+#include "IpLibraryLoader.hpp"
+
+namespace Ipopt
+{
+
+// forward declarations
+class IterationOutput;
+class HessianUpdater;
+class ConvergenceCheck;
+class SearchDirectionCalculator;
+class EqMultiplierCalculator;
+class IterateInitializer;
+class LineSearch;
+class MuUpdate;
+
+/** Builder for creating a complete IpoptAlg object.
+ *
+ *  This object contains all subelements (such as line search objects
+ *  etc).  How the resulting IpoptAlg object is built can be influenced
+ *  by the options.
+ *
+ *  More advanced customization can be achieved by subclassing this
+ *  class and overloading the virtual methods that build the
+ *  individual parts. The advantage of doing this is that it allows
+ *  one to reuse the extensive amount of options processing that
+ *  takes place, for instance, when generating the symmetric linear
+ *  system solver. Another method for customizing the algorithm is
+ *  using the optional custom_solver argument, which allows the
+ *  expert user to provide a specialized linear solver for the
+ *  augmented system (e.g., type GenAugSystemSolver), possibly for
+ *  user-defined matrix objects. The optional custom_solver constructor
+ *  argument is likely obsolete, however, as more control over this
+ *  this process can be achieved by implementing a subclass of this
+ *  AlgBuilder (e.g., by overloading the AugSystemSolverFactory method).
+ */
+class IPOPTLIB_EXPORT AlgorithmBuilder: public ReferencedObject
+{
+public:
+   /**@name Constructors/Destructors */
+   ///@{
+   /** Constructor */
+   AlgorithmBuilder(
+      SmartPtr<AugSystemSolver> custom_solver = NULL
+   );
+
+   /** Destructor */
+   virtual ~AlgorithmBuilder()
+   { }
+
+   ///@}
+
+   /** Methods for IpoptTypeInfo */
+   ///@{
+   /** register the options used by the algorithm builder */
+   static void RegisterOptions(
+      SmartPtr<RegisteredOptions> roptions
+   );
+   ///@}
+
+   /** @name Convenience methods for building solvers without having
+    *  to duplicate the significant amount of preprocessor flag and
+    *  option checking that takes place. These solvers are used to
+    *  create a number of core algorithm components across the
+    *  different Build* methods, but depending on what options are
+    *  chosen, the first method requiring the solver to be used can
+    *  vary. Therefore, each of the Factory methods below is paired
+    *  with a Getter method, which is called by all parts of this
+    *  algorithm builder to ensure the Factory is only called once. */
+   ///@{
+   /** Create a solver that can be used to solve a symmetric linear
+    *  system.
+    *  Dependencies: None
+    */
+   virtual SmartPtr<SymLinearSolver> SymLinearSolverFactory(
+      const Journalist&  jnlst,
+      const OptionsList& options,
+      const std::string& prefix
+   );
+
+   /** Get the symmetric linear system solver for this
+    *  algorithm. This method will call the SymLinearSolverFactory
+    *  exactly once (the first time it is used), and store its
+    *  instance on SymSolver_ for use in subsequent calls.
+    */
+   SmartPtr<SymLinearSolver> GetSymLinearSolver(
+      const Journalist&  jnlst,
+      const OptionsList& options,
+      const std::string& prefix
+   );
+
+   /** Create a solver that can be used to solve an
+    *  augmented system.
+    *  Dependencies:
+    *     -> GetSymLinearSolver()
+    *         -> SymLinearSolverFactory()
+    *     -> custom_solver_
+    */
+   virtual SmartPtr<AugSystemSolver> AugSystemSolverFactory(
+      const Journalist&  jnlst,
+      const OptionsList& options,
+      const std::string& prefix
+   );
+
+   /** Get the augmented system solver for this algorithm. This
+    *  method will call the AugSystemSolverFactory exactly once (the
+    *  first time it is used), and store its instance on AugSolver_
+    *  for use in subsequent calls.
+    */
+   SmartPtr<AugSystemSolver> GetAugSystemSolver(
+      const Journalist&  jnlst,
+      const OptionsList& options,
+      const std::string& prefix
+   );
+
+   /** Create a solver that can be used to solve a
+    *  primal-dual system.
+    *  Dependencies:
+    *     -> GetAugSystemSolver()
+    *         -> AugSystemSolverFactory()
+    *             -> GetSymLinearSolver()
+    *                 -> SymLinearSolverFactory()
+    *             -> custom_solver_
+    */
+   virtual SmartPtr<PDSystemSolver> PDSystemSolverFactory(
+      const Journalist&  jnlst,
+      const OptionsList& options,
+      const std::string& prefix
+   );
+
+   /** Get the primal-dual system solver for this algorithm. This
+    *  method will call the PDSystemSolverFactory exactly once (the
+    *  first time it is used), and store its instance on PDSolver_
+    *  for use in subsequent calls.
+    */
+   SmartPtr<PDSystemSolver> GetPDSystemSolver(
+      const Journalist&  jnlst,
+      const OptionsList& options,
+      const std::string& prefix
+   );
+   ///@}
+
+   /** @name Methods to build parts of the algorithm */
+   ///@{
+   /** Allocates memory for the IpoptNLP, IpoptData, and
+    *  IpoptCalculatedQuanties arguments.
+    *  Dependencies: None
+    */
+   virtual void BuildIpoptObjects(
+      const Journalist&                    jnlst,
+      const OptionsList&                   options,
+      const std::string&                   prefix,
+      const SmartPtr<NLP>&                 nlp,
+      SmartPtr<IpoptNLP>&                  ip_nlp,
+      SmartPtr<IpoptData>&                 ip_data,
+      SmartPtr<IpoptCalculatedQuantities>& ip_cq
+   );
+
+   /** Creates an instance of the IpoptAlgorithm class by building
+    *  each of its required constructor arguments piece-by-piece. The
+    *  default algorithm can be customized by overloading this method
+    *  or by overloading one or more of the Build* methods called in
+    *  this method's default implementation. Additional control can
+    *  be achieved by overloading any of the *SolverFactory methods.
+    *  This method will call (in this order):
+    *     -> BuildIterationOutput()
+    *     -> BuildHessianUpdater()
+    *     -> BuildConvergenceCheck()
+    *     -> BuildSearchDirectionCalculator()
+    *     -> BuildEqMultiplierCalculator()
+    *     -> BuildIterateInitializer()
+    *     -> BuildLineSearch()
+    *     -> BuildMuUpdate()
+    */
+   virtual SmartPtr<IpoptAlgorithm> BuildBasicAlgorithm(
+      const Journalist&  jnlst,
+      const OptionsList& options,
+      const std::string& prefix
+   );
+
+   /** Creates an instance of the IterationOutput class. This method
+    *  is called in the default implementation of
+    *  BuildBasicAlgorithm. It can be overloaded to customize that
+    *  portion the default algorithm.
+    *  Dependencies: None
+    */
+   virtual SmartPtr<IterationOutput> BuildIterationOutput(
+      const Journalist&  jnlst,
+      const OptionsList& options,
+      const std::string& prefix
+   );
+
+   /** Creates an instance of the HessianUpdater class. This method
+    *  is called in the default implementation of
+    *  BuildBasicAlgorithm.  It can be overloaded to customize that
+    *  portion the default algorithm.
+    *  Dependencies: None
+    */
+   virtual SmartPtr<HessianUpdater> BuildHessianUpdater(
+      const Journalist&  jnlst,
+      const OptionsList& options,
+      const std::string& prefix
+   );
+
+   /** Creates an instance of the ConvergenceCheck class. This method
+    *  is called in the default implementation of
+    *  BuildBasicAlgorithm.  It can be overloaded to customize that
+    *  portion the default algorithm.
+    *  Dependencies: None
+    */
+   virtual SmartPtr<ConvergenceCheck> BuildConvergenceCheck(
+      const Journalist&  jnlst,
+      const OptionsList& options,
+      const std::string& prefix
+   );
+
+   /** Creates an instance of the SearchDirectionCalculator
+    *  class. This method is called in the default implementation of
+    *  BuildBasicAlgorithm.  It can be overloaded to customize that
+    *  portion the default algorithm.
+    *  Dependencies:
+    *     -> GetPDSystemSolver()
+    *         -> PDSystemSolverFactory()
+    *             -> GetAugSystemSolver()
+    *                 -> AugSystemSolverFactory()
+    *                     -> GetSymLinearSolver()
+    *                         -> SymLinearSolverFactory()
+    *                     -> custom_solver_
+    */
+   virtual SmartPtr<SearchDirectionCalculator> BuildSearchDirectionCalculator(
+      const Journalist&  jnlst,
+      const OptionsList& options,
+      const std::string& prefix
+   );
+
+   /** Creates an instance of the EqMultiplierCalculator class. This
+    *  method is called in the default implementation of
+    *  BuildBasicAlgorithm.  It can be overloaded to customize that
+    *  portion the default algorithm.
+    *  Dependencies:
+    *     -> GetAugSystemSolver()
+    *         -> AugSystemSolverFactory()
+    *             -> GetSymLinearSolver()
+    *                 -> SymLinearSolverFactory()
+    *             -> custom_solver_
+    */
+   virtual SmartPtr<EqMultiplierCalculator> BuildEqMultiplierCalculator(
+      const Journalist&  jnlst,
+      const OptionsList& options,
+      const std::string& prefix
+   );
+
+   /** Creates an instance of the IterateInitializer class. This
+    *  method is called in the default implementation of
+    *  BuildBasicAlgorithm.  It can be overloaded to customize that
+    *  portion the default algorithm.
+    *  Dependencies:
+    *     -> EqMultCalculator_
+    *     -> GetAugSystemSolver()
+    *         -> AugSystemSolverFactory()
+    *             -> GetSymLinearSolver()
+    *                 -> SymLinearSolverFactory()
+    *             -> custom_solver_
+    */
+   virtual SmartPtr<IterateInitializer> BuildIterateInitializer(
+      const Journalist&  jnlst,
+      const OptionsList& options,
+      const std::string& prefix
+   );
+
+   /** Creates an instance of the LineSearch class. This method is
+    *  called in the default implementation of BuildBasicAlgorithm.
+    *  It can be overloaded to customize that portion the default
+    *  algorithm.
+    *  Dependencies:
+    *     -> EqMultCalculator_
+    *     -> ConvCheck_
+    *     -> GetAugSystemSolver()
+    *         -> AugSystemSolverFactory()
+    *             -> GetSymLinearSolver()
+    *                 -> SymLinearSolverFactory()
+    *             -> custom_solver_
+    *     -> GetPDSystemSolver()
+    *         -> PDSystemSolverFactory()
+    *             -> GetAugSystemSolver()
+    *                 -> AugSystemSolverFactory()
+    *                     -> GetSymLinearSolver()
+    *                         -> SymLinearSolverFactory()
+    *                     -> custom_solver_
+    */
+   virtual SmartPtr<LineSearch> BuildLineSearch(
+      const Journalist&  jnlst,
+      const OptionsList& options,
+      const std::string& prefix
+   );
+
+   /** Creates an instance of the MuUpdate class. This method is
+    *  called in the default implementation of BuildBasicAlgorithm.
+    *  It can be overloaded to customize that portion the default
+    *  algorithm.
+    *  Dependencies:
+    *     -> LineSearch_
+    *         -> EqMultCalculator_
+    *         -> ConvCheck_
+    *     -> GetPDSystemSolver()
+    *         -> PDSystemSolverFactory()
+    *             -> GetAugSystemSolver()
+    *                 -> AugSystemSolverFactory()
+    *                     -> GetSymLinearSolver()
+    *                         -> SymLinearSolverFactory()
+    *                     -> custom_solver_
+    */
+   virtual SmartPtr<MuUpdate> BuildMuUpdate(
+      const Journalist&  jnlst,
+      const OptionsList& options,
+      const std::string& prefix
+   );
+   ///@}
+
+protected:
+   /// Gives Library Loader for HSL library if not all HSL routines are linked in
+   ///
+   /// Creates new loader if not existing yet.
+   /// @since 3.14.0
+   SmartPtr<LibraryLoader> GetHSLLoader(
+      const OptionsList& options,
+      const std::string& prefix
+   );
+
+   /// Gives Library Loader for Pardiso library from pardiso-project.org.
+   ///
+   /// Creates new loader if not existing yet.
+   /// @since 3.14.0
+   SmartPtr<LibraryLoader> GetPardisoLoader(
+      const OptionsList& options,
+      const std::string& prefix
+   );
+
+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 */
+   //AlgorithmBuilder();
+
+   /** Copy Constructor */
+   AlgorithmBuilder(
+      const AlgorithmBuilder&
+   );
+
+   /** Default Assignment Operator */
+   void operator=(
+      const AlgorithmBuilder&
+   );
+   ///@}
+
+   /** @name IpoptAlgorithm constructor arguments.
+    *  These components are built in separate Build
+    *  methods in the order defined by BuildBasicAlgorithm.
+    *  A single core component may require one or more
+    *  other core components in its constructor, so the
+    *  this class holds pointers to each component for use
+    *  between the separate Build methods. */
+   ///@{
+   SmartPtr<IterationOutput> IterOutput_;
+   SmartPtr<HessianUpdater> HessUpdater_;
+   SmartPtr<ConvergenceCheck> ConvCheck_;
+   SmartPtr<SearchDirectionCalculator> SearchDirCalc_;
+   SmartPtr<EqMultiplierCalculator> EqMultCalculator_;
+   SmartPtr<IterateInitializer> IterInitializer_;
+   SmartPtr<LineSearch> LineSearch_;
+   SmartPtr<MuUpdate> MuUpdate_;
+   ///@}
+
+   /** @name Commonly used solver components
+    *  for building core algorithm components. Each
+    *  of these members is paired with a Factory/Getter
+    *  method. */
+   ///@{
+   SmartPtr<SymLinearSolver> SymSolver_;
+   SmartPtr<AugSystemSolver> AugSolver_;
+   SmartPtr<PDSystemSolver> PDSolver_;
+   ///@}
+
+   /** Optional pointer to AugSystemSolver.  If this is set in the
+    *  constructor, we will use this to solve the linear systems. */
+   SmartPtr<AugSystemSolver> custom_solver_;
+
+   /// name of linear solver constructed in SymLinearSolverFactory
+   std::string linear_solver;
+
+   /// loader of HSL library (at runtime)
+   SmartPtr<LibraryLoader> hslloader;
+   /// loader of Pardiso library (at runtime)
+   SmartPtr<LibraryLoader> pardisoloader;
+
+};
+} // namespace Ipopt
+
+#endif

casadi/include/coin-or/IpAlgStrategy.hpp

@@ -0,0 +1,201 @@
+// 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
+
+#ifndef __IPALGSTRATEGY_HPP__
+#define __IPALGSTRATEGY_HPP__
+
+#include "IpOptionsList.hpp"
+#include "IpJournalist.hpp"
+#include "IpIpoptCalculatedQuantities.hpp"
+#include "IpIpoptNLP.hpp"
+#include "IpIpoptData.hpp"
+
+namespace Ipopt
+{
+
+/** This is the base class for all algorithm strategy objects.
+ *
+ *  The AlgorithmStrategyObject base class implements a common interface
+ *  for all algorithm strategy objects.  A strategy object is a
+ *  component of the algorithm for which different alternatives or
+ *  implementations exists.  It allows to compose the algorithm
+ *  before execution for a particular configuration, without the
+ *  need to call alternatives based on enums. For example, the
+ *  LineSearch object is a strategy object, since different line
+ *  search options might be used for different runs.
+ *
+ *  This interface is used for
+ *  things that are done to all strategy objects, like
+ *  initialization and setting options.
+ */
+class IPOPTLIB_EXPORT AlgorithmStrategyObject: public ReferencedObject
+{
+public:
+   /**@name Constructors/Destructors */
+   ///@{
+   /** Default Constructor */
+   AlgorithmStrategyObject()
+      : initialize_called_(false)
+   { }
+
+   /** Destructor */
+   virtual ~AlgorithmStrategyObject()
+   { }
+   ///@}
+
+   /** This method is called every time the algorithm starts again -
+    *  it is used to reset any internal state.
+    *
+    *  The pointers to the
+    *  Journalist, as well as to the IpoptNLP, IpoptData, and
+    *  IpoptCalculatedQuantities objects should be stored in the
+    *  instantiation of this base class.  This method is also used to
+    *  get all required user options from the OptionsList.  Here, if
+    *  prefix is given, each tag (identifying the options) is first
+    *  looked for with the prefix in front, and if not found, without
+    *  the prefix.  Note: you should not cue off of the iteration
+    *  count to indicate the "start" of an algorithm!
+    *
+    *  Do not overload this method, since it does some general
+    *  initialization that is common for all strategy objects.
+    *  Overload the protected InitializeImpl method instead.
+    */
+   bool Initialize(
+      const Journalist&          jnlst,
+      IpoptNLP&                  ip_nlp,
+      IpoptData&                 ip_data,
+      IpoptCalculatedQuantities& ip_cq,
+      const OptionsList&         options,
+      const std::string&         prefix
+   )
+   {
+      initialize_called_ = true;
+      // Copy the pointers for the problem defining objects
+      jnlst_ = &jnlst;
+      ip_nlp_ = &ip_nlp;
+      ip_data_ = &ip_data;
+      ip_cq_ = &ip_cq;
+
+      bool retval = InitializeImpl(options, prefix);
+      if( !retval )
+      {
+         initialize_called_ = false;
+      }
+
+      return retval;
+   }
+
+   /** Reduced version of the Initialize method, which does not
+    *  require special Ipopt information.
+    *
+    *  This is useful for algorithm objects that could be used
+    *  outside Ipopt, such as linear solvers.
+    */
+   bool ReducedInitialize(
+      const Journalist&  jnlst,
+      const OptionsList& options,
+      const std::string& prefix
+   )
+   {
+      initialize_called_ = true;
+      // Copy the pointers for the problem defining objects
+      jnlst_ = &jnlst;
+      ip_nlp_ = NULL;
+      ip_data_ = NULL;
+      ip_cq_ = NULL;
+
+      bool retval = InitializeImpl(options, prefix);
+      if( !retval )
+      {
+         initialize_called_ = false;
+      }
+
+      return retval;
+   }
+
+protected:
+   /** Implementation of the initialization method that has to be
+    *  overloaded by for each derived class.
+    */
+   virtual bool InitializeImpl(
+      const OptionsList& options,
+      const std::string& prefix
+   ) = 0;
+
+   /** @name Accessor methods for the problem defining objects.
+    *
+    *  Those should be used by the derived classes.
+    */
+   ///@{
+   const Journalist& Jnlst() const
+   {
+      DBG_ASSERT(initialize_called_);
+      return *jnlst_;
+   }
+   IpoptNLP& IpNLP() const
+   {
+      DBG_ASSERT(initialize_called_);
+      DBG_ASSERT(IsValid(ip_nlp_));
+      return *ip_nlp_;
+   }
+   IpoptData& IpData() const
+   {
+      DBG_ASSERT(initialize_called_);
+      DBG_ASSERT(IsValid(ip_data_));
+      return *ip_data_;
+   }
+   IpoptCalculatedQuantities& IpCq() const
+   {
+      DBG_ASSERT(initialize_called_);
+      DBG_ASSERT(IsValid(ip_cq_));
+      return *ip_cq_;
+   }
+   bool HaveIpData() const
+   {
+      return IsValid(ip_data_);
+   }
+   ///@}
+
+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 */
+   //AlgorithmStrategyObject();
+
+   /** Copy Constructor */
+   AlgorithmStrategyObject(
+      const AlgorithmStrategyObject&
+   );
+
+   /** Default Assignment Operator */
+   void operator=(
+      const AlgorithmStrategyObject&
+   );
+   ///@}
+
+   /** @name Pointers to objects defining a particular optimization problem */
+   ///@{
+   SmartPtr<const Journalist> jnlst_;
+   SmartPtr<IpoptNLP> ip_nlp_;
+   SmartPtr<IpoptData> ip_data_;
+   SmartPtr<IpoptCalculatedQuantities> ip_cq_;
+   ///@}
+
+   /** flag indicating if Initialize method has been called (for debugging) */
+   bool initialize_called_;
+};
+
+} // namespace Ipopt
+
+#endif

casadi/include/coin-or/IpAlgTypes.hpp

@@ -0,0 +1,64 @@
+// Copyright (C) 2005, 2010 International Business Machines and others.
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// Authors:  Carl Laird, Andreas Waechter     IBM    2005-07-19
+
+#ifndef __IPALGTYPES_HPP__
+#define __IPALGTYPES_HPP__
+
+#include "IpTypes.hpp"
+#include "IpException.hpp"
+
+namespace Ipopt
+{
+
+/**@name Enumerations */
+///@{
+/** enum for the return from the optimize algorithm */
+enum SolverReturn
+{
+   SUCCESS,
+   MAXITER_EXCEEDED,
+   CPUTIME_EXCEEDED,
+   WALLTIME_EXCEEDED,   ///< @since 3.14.0
+   STOP_AT_TINY_STEP,
+   STOP_AT_ACCEPTABLE_POINT,
+   LOCAL_INFEASIBILITY,
+   USER_REQUESTED_STOP,
+   FEASIBLE_POINT_FOUND,
+   DIVERGING_ITERATES,
+   RESTORATION_FAILURE,
+   ERROR_IN_STEP_COMPUTATION,
+   INVALID_NUMBER_DETECTED,
+   TOO_FEW_DEGREES_OF_FREEDOM,
+   INVALID_OPTION,
+   OUT_OF_MEMORY,
+   INTERNAL_ERROR,
+   UNASSIGNED
+};
+///@}
+
+/** @name Some exceptions used in multiple places */
+///@{
+DECLARE_STD_EXCEPTION(LOCALLY_INFEASIBLE);
+DECLARE_STD_EXCEPTION(TOO_FEW_DOF);
+DECLARE_STD_EXCEPTION(TINY_STEP_DETECTED);
+DECLARE_STD_EXCEPTION(STEP_COMPUTATION_FAILED);
+DECLARE_STD_EXCEPTION(ACCEPTABLE_POINT_REACHED);
+DECLARE_STD_EXCEPTION(FEASIBILITY_PROBLEM_SOLVED);
+DECLARE_STD_EXCEPTION(INVALID_WARMSTART);
+DECLARE_STD_EXCEPTION(INTERNAL_ABORT);
+DECLARE_STD_EXCEPTION(INCONSISTENT_BOUNDS);
+/** Exception FAILED_INITIALIZATION for problem during
+ *  initialization of a strategy object (or other problems).
+ *
+ *  This is thrown by a strategy object, if a problem arises during
+ *  initialization, such as a value out of a feasible range.
+ */
+DECLARE_STD_EXCEPTION(FAILED_INITIALIZATION);
+///@}
+
+}
+
+#endif