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

casadi/include/coin-or/IpIpoptAlg.hpp

@@ -0,0 +1,257 @@
+// Copyright (C) 2004, 2010 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 __IPIPOPTALG_HPP__
+#define __IPIPOPTALG_HPP__
+
+#include "IpIpoptNLP.hpp"
+#include "IpAlgStrategy.hpp"
+#include "IpSearchDirCalculator.hpp"
+#include "IpLineSearch.hpp"
+#include "IpMuUpdate.hpp"
+#include "IpConvCheck.hpp"
+#include "IpOptionsList.hpp"
+#include "IpIterateInitializer.hpp"
+#include "IpIterationOutput.hpp"
+#include "IpAlgTypes.hpp"
+#include "IpHessianUpdater.hpp"
+#include "IpEqMultCalculator.hpp"
+
+namespace Ipopt
+{
+
+/** The main ipopt algorithm class.
+ *
+ *  Main Ipopt algorithm class, contains the main optimize method,
+ *  handles the execution of the optimization.
+ *  The constructor initializes the data structures through the nlp,
+ *  and the Optimize method then assumes that everything is
+ *  initialized and ready to go.
+ *  After an optimization is complete, the user can access the
+ *  solution through the passed in ip_data structure.
+ *  Multiple calls to the Optimize method are allowed as long as the
+ *  structure of the problem remains the same (i.e. starting point
+ *  or nlp parameter changes only).
+ */
+class IPOPTLIB_EXPORT IpoptAlgorithm: public AlgorithmStrategyObject
+{
+public:
+
+   /**@name Constructors/Destructors */
+   ///@{
+   /** Constructor.
+    *
+    *  The IpoptAlgorithm uses smart pointers for these
+    *  passed-in pieces to make sure that a user of IpoptAlgoroithm
+    *  cannot pass in an object created on the stack!
+    *
+    *  The optional linear_solver_name is used for printing.
+    */
+   IpoptAlgorithm(
+      const SmartPtr<SearchDirectionCalculator>& search_dir_calculator,  ///< search direction calculator
+      const SmartPtr<LineSearch>&                line_search,            ///< line search
+      const SmartPtr<MuUpdate>&                  mu_update,              ///< mu updater
+      const SmartPtr<ConvergenceCheck>&          conv_check,             ///< convergence check
+      const SmartPtr<IterateInitializer>&        iterate_initializer,    ///< iterate initializer
+      const SmartPtr<IterationOutput>&           iter_output,            ///< iteration output
+      const SmartPtr<HessianUpdater>&            hessian_updater,        ///< hessian updater
+      const SmartPtr<EqMultiplierCalculator>&    eq_multiplier_calculator = NULL,  ///< calculator for multipliers
+      const std::string&                         linear_solver_name = ""  ///< name of linear solver @since 3.14.0
+   );
+
+   /** Destructor */
+   virtual ~IpoptAlgorithm();
+   ///@}
+
+   /** overloaded from AlgorithmStrategyObject */
+   virtual bool InitializeImpl(
+      const OptionsList& options,
+      const std::string& prefix
+   );
+
+   /** Main solve method. */
+   SolverReturn Optimize(
+      bool isResto = false
+   );
+
+   /** Methods for IpoptType */
+   ///@{
+   static void RegisterOptions(
+      SmartPtr<RegisteredOptions> roptions
+   );
+   ///@}
+
+   /**@name Access to internal strategy objects */
+   ///@{
+   SmartPtr<SearchDirectionCalculator> SearchDirCalc()
+   {
+      return search_dir_calculator_;
+   }
+   ///@}
+
+   static void print_copyright_message(
+      const Journalist& jnlst
+   );
+
+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 */
+   IpoptAlgorithm();
+
+   /** Copy Constructor */
+   IpoptAlgorithm(
+      const IpoptAlgorithm&
+   );
+
+   /** Default Assignment Operator */
+   void operator=(
+      const IpoptAlgorithm&
+   );
+   ///@}
+
+   /** @name Strategy objects */
+   ///@{
+   SmartPtr<SearchDirectionCalculator> search_dir_calculator_;
+   SmartPtr<LineSearch> line_search_;
+   SmartPtr<MuUpdate> mu_update_;
+   SmartPtr<ConvergenceCheck> conv_check_;
+   SmartPtr<IterateInitializer> iterate_initializer_;
+   SmartPtr<IterationOutput> iter_output_;
+   SmartPtr<HessianUpdater> hessian_updater_;
+   /** The multiplier calculator (for y_c and y_d) has to be set only
+    *  if option recalc_y is set to true
+    */
+   SmartPtr<EqMultiplierCalculator> eq_multiplier_calculator_;
+   ///@}
+
+   /** @name Main steps of the algorithm */
+   ///@{
+   /** Method for updating the current Hessian.
+    *
+    *  This can either just evaluate the exact Hessian (based on
+    *  the current iterate), or perform a quasi-Newton update.
+    */
+   void UpdateHessian();
+
+   /** Method to update the barrier parameter.
+    *
+    *  @return false, if the algorithm can't continue with the
+    *  regular procedure and needs to revert to a fallback
+    *  mechanism in the line search (such as restoration phase)
+    */
+   bool UpdateBarrierParameter();
+
+   /** Method to setup the call to the PDSystemSolver.
+    *
+    *  @return false, if the algorithm can't continue with the regular
+    *  procedure and needs to revert to a fallback mechanism in the
+    *  line search (such as restoration phase)
+    */
+   bool ComputeSearchDirection();
+
+   /** Method computing the new iterate (usually vialine search).
+    *
+    *  The acceptable point is the one in trial after return.
+    */
+   void ComputeAcceptableTrialPoint();
+
+   /** Method for accepting the trial point as the new iteration,
+    *  possibly after adjusting the variable bounds in the NLP.
+    */
+   void AcceptTrialPoint();
+
+   /** Do all the output for one iteration */
+   void OutputIteration();
+
+   /** Sets up initial values for the iterates.
+    *
+    * Corrects the initial values for x and s (force in bounds)
+    */
+   void InitializeIterates();
+
+   /** Print the problem size statistics */
+   void PrintProblemStatistics();
+
+   /** Compute the Lagrangian multipliers for a feasibility problem */
+   void ComputeFeasibilityMultipliers();
+   ///@}
+
+   /** @name internal flags */
+   ///@{
+   /** Flag indicating if the statistic should not be printed */
+   bool skip_print_problem_stats_;
+   ///@}
+
+   /** @name Algorithmic parameters */
+   ///@{
+   /** safeguard factor for bound multipliers.
+    *
+    *  If value >= 1, then
+    *  the dual variables will never deviate from the primal estimate
+    *  by more than the factors kappa_sigma and 1./kappa_sigma.
+    */
+   Number kappa_sigma_;
+   /** Flag indicating whether the y multipliers should be
+    *  recalculated with the eq_mutliplier_calculator object for each
+    *  new point.
+    */
+   bool recalc_y_;
+   /** Feasibility threshold for recalc_y */
+   Number recalc_y_feas_tol_;
+   /** Flag indicating if we want to do Mehrotras's algorithm.
+    *
+    *  This means that a number of options are ignored, or have to be set
+    *  (or are automatically set) to certain values.
+    */
+   bool mehrotra_algorithm_;
+   /** String specifying linear solver */
+   std::string linear_solver_name_;
+   ///@}
+
+   /** @name auxiliary functions */
+   ///@{
+   void calc_number_of_bounds(
+      const Vector& x,
+      const Vector& x_L,
+      const Vector& x_U,
+      const Matrix& Px_L,
+      const Matrix& Px_U,
+      Index&        n_tot,
+      Index&        n_only_lower,
+      Index&        n_both,
+      Index&        n_only_upper
+   );
+
+   /** Method for ensuring that the trial multipliers are not too far
+    *  from the primal estime.
+    *
+    *  If a correction is made, new_trial_z
+    *  is a pointer to the corrected multiplier, and the return value
+    *  of this method give the magnitutde of the largest correction
+    *  that we done.  If no correction was made, new_trial_z is just
+    *  a pointer to trial_z, and the return value is zero.
+    */
+   Number correct_bound_multiplier(
+      const Vector&           trial_z,
+      const Vector&           trial_slack,
+      const Vector&           trial_compl,
+      SmartPtr<const Vector>& new_trial_z
+   );
+   ///@}
+};
+
+} // namespace Ipopt
+
+#endif

casadi/include/coin-or/IpIpoptApplication.hpp

@@ -0,0 +1,367 @@
+// Copyright (C) 2004, 2010 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 __IPIPOPTAPPLICATION_HPP__
+#define __IPIPOPTAPPLICATION_HPP__
+
+#include <iostream>
+
+#include "IpJournalist.hpp"
+#include "IpTNLP.hpp"
+#include "IpNLP.hpp"
+#include "IpReturnCodes.hpp"
+
+namespace Ipopt
+{
+DECLARE_STD_EXCEPTION(IPOPT_APPLICATION_ERROR);
+
+/* forward declarations */
+class IpoptAlgorithm;
+class IpoptNLP;
+class IpoptData;
+class IpoptCalculatedQuantities;
+class AlgorithmBuilder;
+class RegisteredOptions;
+class OptionsList;
+class SolveStatistics;
+
+/** This is the main application class for making calls to Ipopt. */
+class IPOPTLIB_EXPORT IpoptApplication: public ReferencedObject
+{
+public:
+   IpoptApplication(
+      bool create_console_out = true,
+      bool create_empty = false
+   );
+
+   /** Another constructor that assumes that the code in the
+    *  (default) constructor has already been executed
+    */
+   IpoptApplication(
+      SmartPtr<RegisteredOptions> reg_options,
+      SmartPtr<OptionsList>       options,
+      SmartPtr<Journalist>        jnlst
+   );
+
+   virtual ~IpoptApplication();
+
+   /** Method for creating a new IpoptApplication that uses the same
+    *  journalist and registered options, and a copy of the options list.
+    */
+   virtual SmartPtr<IpoptApplication> clone();
+
+   /** Initialization method.
+    *
+    *  This method reads options from the
+    *  input stream and initializes the journalists.
+    *
+    *  @return Solve_Succeeded or something else if there was a
+    *  problem in the initialization (such as an invalid option).
+    *
+    *  You should call one of the initialization methods at some
+    *  point before the first optimize call.
+    *  Set @par allow_clobber to true if you want to allow
+    *  overwriting options that are set by the input stream.
+    */
+   virtual ApplicationReturnStatus Initialize(
+      std::istream& is,
+      bool          allow_clobber = false
+   );
+
+   /** Initialization method.
+    *
+    *  This method reads options from the
+    *  params file and initializes the journalists.
+
+    *  @return Solve_Succeeded or something else if there was a
+    *  problem in the initialization (such as an invalid option).
+
+    *  You should call one of the initialization methods at some
+    *  point before the first optimize call.
+    *
+    *  @note You can skip the processing of a params file by
+    *  setting params_file to "".
+    *
+    *  Set @par allow_clobber to true if you want to allow
+    *  overwriting options that are set by the params file.
+    */
+   virtual ApplicationReturnStatus Initialize(
+      std::string params_file,
+      bool        allow_clobber = false
+   );
+
+   /** Initialization method.
+    *
+    *  This method reads options from the
+    *  params file and initializes the journalists.
+
+    *  @return Solve_Succeeded or something else if there was a
+    *  problem in the initialization (such as an invalid option).
+    *
+    *  You should call one of the initialization methods at some
+    *  point before the first optimize call.
+    *
+    *  @note You can skip the processing of a params file by
+    *  setting params_file to "".
+    *
+    *  Set @par allow_clobber to true if you want to allow
+    *  overwriting options that are set by the params file.
+    */
+   virtual ApplicationReturnStatus Initialize(
+      const char* params_file,
+      bool        allow_clobber = false
+   )
+   {
+      return Initialize(std::string(params_file), allow_clobber);
+   }
+
+   /** Initialize method.
+    *
+    *  This method reads the options file specified
+    *  by the option_file_name option and initializes the journalists.
+
+    *  @return Solve_Succeeded or something else if there was a
+    *  problem in the initialization (such as an invalid option).
+
+    *  You should call this method at some point before the first optimize
+    *  call.
+
+    *  Set @par allow_clobber to true if you want to allow
+    *  overwriting options that are set by the options file.
+    */
+   virtual ApplicationReturnStatus Initialize(
+      bool allow_clobber = false
+   );
+
+   /**@name Solve methods */
+   ///@{
+   /** Solve a problem that inherits from TNLP */
+   virtual ApplicationReturnStatus OptimizeTNLP(
+      const SmartPtr<TNLP>& tnlp
+   );
+
+   /** Solve a problem that inherits from NLP */
+   virtual ApplicationReturnStatus OptimizeNLP(
+      const SmartPtr<NLP>& nlp
+   );
+
+   /** Solve a problem that inherits from NLP */
+   virtual ApplicationReturnStatus OptimizeNLP(
+      const SmartPtr<NLP>&        nlp,
+      SmartPtr<AlgorithmBuilder>& alg_builder
+   );
+
+   /** Solve a problem (that inherits from TNLP) for a repeated time.
+    *
+    *  The OptimizeTNLP method must have been called before.  The
+    *  TNLP must be the same object. The IpoptAlgorithm object from the
+    *  previous solve will be reused.
+    */
+   virtual ApplicationReturnStatus ReOptimizeTNLP(
+      const SmartPtr<TNLP>& tnlp
+   );
+
+   /** Solve a problem (that inherits from NLP) for a repeated time.
+    *
+    *  The OptimizeNLP method must have been called before.  The
+    *  NLP must be the same object. The IpoptAlgorithm object from the
+    *  previous solve will be reused.
+    */
+   virtual ApplicationReturnStatus ReOptimizeNLP(
+      const SmartPtr<NLP>& nlp
+   );
+   ///@}
+
+   /** Method for opening an output file with given print_level.
+    *
+    *  @return false if there was a problem
+    */
+   virtual bool OpenOutputFile(
+      std::string  file_name,
+      EJournalLevel print_level
+   );
+
+   /**@name Accessor methods */
+   ///@{
+   /** Get the Journalist for printing output */
+   virtual SmartPtr<Journalist> Jnlst()
+   {
+      return jnlst_;
+   }
+
+   /** Get a pointer to RegisteredOptions object to add new options */
+   virtual SmartPtr<RegisteredOptions> RegOptions()
+   {
+      return reg_options_;
+   }
+
+   /** Get the options list for setting options */
+   virtual SmartPtr<OptionsList> Options()
+   {
+      return options_;
+   }
+
+   /** Get the options list for setting options (const version) */
+   virtual SmartPtr<const OptionsList> Options() const
+   {
+      return ConstPtr(options_);
+   }
+
+   /** Get the object with the statistics about the most recent
+    *  optimization run.
+    *
+    *  @note Statistics are not available if optimization terminated
+    *  with a serious problem, that is, an ApplicationReturnStatus of
+    *  Not_Enough_Degrees_Of_Freedom or lower.
+    */
+   virtual SmartPtr<SolveStatistics> Statistics();
+
+   /** Get the IpoptNLP Object */
+   virtual SmartPtr<IpoptNLP> IpoptNLPObject();
+
+   /** Get the IpoptData Object */
+   SmartPtr<IpoptData> IpoptDataObject();
+
+   /** Get the IpoptCQ Object */
+   virtual SmartPtr<IpoptCalculatedQuantities> IpoptCQObject();
+
+   /** Get the Algorithm Object */
+   SmartPtr<IpoptAlgorithm> AlgorithmObject();
+   ///@}
+
+   /** Method for printing Ipopt copyright message now instead of
+    *  just before the optimization.
+    *
+    *  If you want to have the copy right message printed earlier
+    *  than by default, call this method at the convenient time.
+    */
+   void PrintCopyrightMessage();
+
+   /** Method to set whether non-ipopt non-bad_alloc non-overflow_error exceptions
+    * are rethrown by Ipopt.
+    *
+    * By default, non-Ipopt and non-bad_alloc and non-overflow_error exceptions are
+    * caught by Ipopts initialization and optimization methods
+    * and the status NonIpopt_Exception_Thrown is returned.
+    * This function allows to enable rethrowing of such exceptions.
+    *
+    * @return Returns whether non-ipopt exceptions were rethrown before.
+    */
+   bool RethrowNonIpoptException(
+      bool dorethrow
+   )
+   {
+      bool oldval = rethrow_nonipoptexception_;
+      rethrow_nonipoptexception_ = dorethrow;
+      return oldval;
+   }
+
+   static void RegisterOptions(
+      SmartPtr<RegisteredOptions> roptions
+   );
+
+   /** Method to register all Ipopt options. */
+   static void
+   RegisterAllIpoptOptions(
+      const SmartPtr<RegisteredOptions>& roptions
+   );
+
+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 */
+   IpoptApplication(
+      const IpoptApplication&
+   );
+
+   /** Default Assignment Operator */
+   void operator=(
+      const IpoptApplication&
+   );
+   ///@}
+
+   /** Method for the actual optimize call of the Ipopt algorithm.
+    *
+    *  This is used both for Optimize and ReOptimize
+    */
+   ApplicationReturnStatus call_optimize();
+
+   /**@name Variables that customize the application behavior */
+   ///@{
+   /** Decide whether or not the ipopt.opt file should be read */
+   bool read_params_dat_;
+
+   /** Decide whether non-ipopt non-bad_alloc non-overflow_error exceptions should be rethrown */
+   bool rethrow_nonipoptexception_;
+   ///@}
+
+   /** Journalist for reporting output */
+   SmartPtr<Journalist> jnlst_;
+
+   /** RegisteredOptions */
+   SmartPtr<RegisteredOptions> reg_options_;
+
+   /** OptionsList used for the application */
+   SmartPtr<OptionsList> options_;
+
+   /** Object for storing statistics about the most recent
+    *  optimization run.
+    */
+   SmartPtr<SolveStatistics> statistics_;
+
+   /** Object with the algorithm skeleton.
+    */
+   SmartPtr<IpoptAlgorithm> alg_;
+
+   /** IpoptNLP Object for the NLP.
+    *
+    *  We keep this around for a ReOptimize warm start.
+    */
+   SmartPtr<IpoptNLP> ip_nlp_;
+
+   /** IpoptData Object for the NLP.
+    *
+    *  We keep this around for a ReOptimize warm start.
+    */
+   SmartPtr<IpoptData> ip_data_;
+
+   /** IpoptCalculatedQuantities Object for the NLP.
+    *
+    *  We keep this around for a ReOptimize warm start.
+    */
+   SmartPtr<IpoptCalculatedQuantities> ip_cq_;
+
+   /** Pointer to the TNLPAdapter used to convert the TNLP to an NLP.
+    *
+    *  We keep this around for the ReOptimizerTNLP call.
+    */
+   SmartPtr<NLP> nlp_adapter_;
+
+   /** @name Algorithmic parameters */
+   ///@{
+   /** Flag indicating if we are to use the inexact linear solver option */
+   bool inexact_algorithm_;
+
+   /** Flag indicating if all bounds should be replaced by inequality
+    *  constraints.
+    *
+    *  This is necessary for the inexact algorithm.
+    */
+   bool replace_bounds_;
+   ///@}
+};
+
+} // namespace Ipopt
+
+extern "C" IPOPTLIB_EXPORT class Ipopt::IpoptApplication* IPOPT_CALLCONV IpoptApplicationFactory();
+
+#endif