IpIpoptAlg.hpp

Go to the documentation of this file.

// 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
{
 
class IPOPTLIB_EXPORT IpoptAlgorithm: public AlgorithmStrategyObject
{
public:
 
 
   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,  
      const std::string&                         linear_solver_name = ""  
   );
 
   virtual ~IpoptAlgorithm();
 
   virtual bool InitializeImpl(
      const OptionsList& options,
      const std::string& prefix
   );
 
   SolverReturn Optimize(
      bool isResto = false
   );
 
   static void RegisterOptions(
      SmartPtr<RegisteredOptions> roptions
   );
 
   SmartPtr<SearchDirectionCalculator> SearchDirCalc()
   {
      return search_dir_calculator_;
   }
 
   static void print_copyright_message(
      const Journalist& jnlst
   );
 
private:
 
   IpoptAlgorithm();
 
   IpoptAlgorithm(
      const IpoptAlgorithm&
   );
 
   void operator=(
      const IpoptAlgorithm&
   );
 
   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_;
   SmartPtr<EqMultiplierCalculator> eq_multiplier_calculator_;
 
 
   void UpdateHessian();
 
   bool UpdateBarrierParameter();
 
   bool ComputeSearchDirection();
 
   void ComputeAcceptableTrialPoint();
 
   void AcceptTrialPoint();
 
   void OutputIteration();
 
   void InitializeIterates();
 
   void PrintProblemStatistics();
 
   void ComputeFeasibilityMultipliers();
 
   void ComputeFeasibilityMultipliersPostprocess();
 
 
   bool skip_print_problem_stats_;
 
 
   Number kappa_sigma_;
   bool recalc_y_;
   Number recalc_y_feas_tol_;
   bool mehrotra_algorithm_;
   std::string linear_solver_name_;
   Number constr_viol_tol_;
 
   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
   );
 
   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