From 938fef4a37a7b7c61b4b6ff74cb4cfd2f100c427 Mon Sep 17 00:00:00 2001 From: Georgey Date: Wed, 5 Jul 2017 11:40:43 +0530 Subject: Added linux shared libraries and header files for int and ecos functions --- thirdparty/linux/include/coin1/IpIpoptAlg.hpp | 224 ++++++++++++++++++++++++++ 1 file changed, 224 insertions(+) create mode 100644 thirdparty/linux/include/coin1/IpIpoptAlg.hpp (limited to 'thirdparty/linux/include/coin1/IpIpoptAlg.hpp') diff --git a/thirdparty/linux/include/coin1/IpIpoptAlg.hpp b/thirdparty/linux/include/coin1/IpIpoptAlg.hpp new file mode 100644 index 0000000..60e3147 --- /dev/null +++ b/thirdparty/linux/include/coin1/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& search_dir_calculator, + const SmartPtr& line_search, + const SmartPtr& mu_update, + const SmartPtr& conv_check, + const SmartPtr& iterate_initializer, + const SmartPtr& iter_output, + const SmartPtr& hessian_updater, + const SmartPtr& 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 roptions); + //@} + + /**@name Access to internal strategy objects */ + //@{ + SmartPtr 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 search_dir_calculator_; + SmartPtr line_search_; + SmartPtr mu_update_; + SmartPtr conv_check_; + SmartPtr iterate_initializer_; + SmartPtr iter_output_; + SmartPtr 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 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& new_trial_z); + //@} + }; + +} // namespace Ipopt + +#endif -- cgit