diff options
Diffstat (limited to 'thirdparty/linux/include/coin1/IpAlgBuilder.hpp')
| -rw-r--r-- | thirdparty/linux/include/coin1/IpAlgBuilder.hpp | 360 |
1 files changed, 360 insertions, 0 deletions
diff --git a/thirdparty/linux/include/coin1/IpAlgBuilder.hpp b/thirdparty/linux/include/coin1/IpAlgBuilder.hpp new file mode 100644 index 0000000..05692bb --- /dev/null +++ b/thirdparty/linux/include/coin1/IpAlgBuilder.hpp @@ -0,0 +1,360 @@ +// Copyright (C) 2004, 2007 International Business Machines and others. +// All Rights Reserved. +// This code is published under the Eclipse Public License. +// +// $Id: IpAlgBuilder.hpp 2666 2016-07-20 16:02:55Z stefan $ +// +// 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" + +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 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); + //@} + + 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&); + + /** Overloaded Equals 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 + * contructor, we will use this to solve the linear systems. */ + SmartPtr<AugSystemSolver> custom_solver_; + + }; +} // namespace Ipopt + +#endif |