diff options
Diffstat (limited to 'thirdparty/linux/include/coin/IpIpoptAlg.hpp')
| -rw-r--r-- | thirdparty/linux/include/coin/IpIpoptAlg.hpp | 224 |
1 files changed, 224 insertions, 0 deletions
diff --git a/thirdparty/linux/include/coin/IpIpoptAlg.hpp b/thirdparty/linux/include/coin/IpIpoptAlg.hpp new file mode 100644 index 0000000..60e3147 --- /dev/null +++ b/thirdparty/linux/include/coin/IpIpoptAlg.hpp @@ -0,0 +1,224 @@ +// Copyright (C) 2004, 2010 International Business Machines and others. +// All Rights Reserved. +// This code is published under the Eclipse Public License. +// +// $Id: IpIpoptAlg.hpp 2167 2013-03-08 11:15:38Z stefan $ +// +// 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 +{ + + /** @name Exceptions */ + //@{ + DECLARE_STD_EXCEPTION(STEP_COMPUTATION_FAILED); + //@} + + /** 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 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!) + */ + IpoptAlgorithm(const SmartPtr<SearchDirectionCalculator>& search_dir_calculator, + const SmartPtr<LineSearch>& line_search, + const SmartPtr<MuUpdate>& mu_update, + const SmartPtr<ConvergenceCheck>& conv_check, + const SmartPtr<IterateInitializer>& iterate_initializer, + const SmartPtr<IterationOutput>& iter_output, + const SmartPtr<HessianUpdater>& hessian_updater, + const SmartPtr<EqMultiplierCalculator>& eq_multiplier_calculator = NULL); + + /** Default 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&); + + /** Overloaded Equals 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 multipler 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 algorthim */ + //@{ + /** 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. Returns 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. Returns + * 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 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 |