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.
//
// $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
{

  DECLARE_STD_EXCEPTION(STEP_COMPUTATION_FAILED);

  class 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);

    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();

    bool skip_print_problem_stats_;

    Number kappa_sigma_;
    bool recalc_y_;
    Number recalc_y_feas_tol_;
    bool mehrotra_algorithm_;
    std::string linear_solver_;

    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