diff options
Diffstat (limited to 'thirdparty/linux/include/coin1/IpIpoptApplication.hpp')
| -rw-r--r-- | thirdparty/linux/include/coin1/IpIpoptApplication.hpp | 296 |
1 files changed, 296 insertions, 0 deletions
diff --git a/thirdparty/linux/include/coin1/IpIpoptApplication.hpp b/thirdparty/linux/include/coin1/IpIpoptApplication.hpp new file mode 100644 index 0000000..0febc94 --- /dev/null +++ b/thirdparty/linux/include/coin1/IpIpoptApplication.hpp @@ -0,0 +1,296 @@ +// Copyright (C) 2004, 2010 International Business Machines and others. +// All Rights Reserved. +// This code is published under the Eclipse Public License. +// +// $Id: IpIpoptApplication.hpp 2617 2015-11-26 16:00:20Z stefan $ +// +// Authors: Carl Laird, Andreas Waechter IBM 2004-08-13 + +#ifndef __IPIPOPTAPPLICATION_HPP__ +#define __IPIPOPTAPPLICATION_HPP__ + +#ifndef IPOPT_EXPORT +#ifdef _MSC_VER +#ifdef IPOPT_DLL +#define IPOPT_EXPORT(type) __declspec(dllexport) type __cdecl +#else +#define IPOPT_EXPORT(type) type __cdecl +#endif +#else +#define IPOPT_EXPORT(type) type +#endif +#endif + +#include <iostream> + +#include "IpJournalist.hpp" +#include "IpTNLP.hpp" +#include "IpNLP.hpp" +/* Return codes for the Optimize call for an application */ +#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 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. It returns + * something other than Solve_Succeeded 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. It returns + * something other than Solve_Succeeded 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. It returns + * something other than Solve_Succeeded 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. + * You should call this method at some point before the first optimize + * call. + * It returns something other than Solve_Succeeded if there was a + * problem in the initialization (such as an invalid option). + * 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, and the structure (number of + * variables and constraints and position of nonzeros in Jacobian + * and Hessian must be the same). */ + 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, and the structure (number of + * variables and constraints and position of nonzeros in Jacobian + * and Hessian must be the same). */ + virtual ApplicationReturnStatus ReOptimizeNLP(const SmartPtr<NLP>& nlp); + //@} + + /** Method for opening an output file with given print_level. + * Returns 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. */ + 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 exceptions + * are rethrown by Ipopt. + * By default, non-Ipopt and non-std::bad_alloc 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. + */ + void RethrowNonIpoptException(bool dorethrow) + { + rethrow_nonipoptexception_ = dorethrow; + } + + /** @name Methods for IpoptTypeInfo */ + //@{ + static void RegisterOptions(SmartPtr<RegisteredOptions> roptions); + //@} + + /** Method to registering 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. */ + //@{ + /** Default Constructor */ + // IpoptApplication(); + + /** Copy Constructor */ + IpoptApplication(const IpoptApplication&); + + /** Overloaded Equals 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 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 sceleton. + */ + 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" IPOPT_EXPORT(class Ipopt::IpoptApplication *) IpoptApplicationFactory(); + +#endif |