/home/coin/SVN-release/CoinAll-1.1.0/Ipopt/src/Algorithm/IpIpoptAlg.hpp

Go to the documentation of this file.

// Copyright (C) 2004, 2007 International Business Machines and others.
// All Rights Reserved.
// This code is published under the Common Public License.
//
// $Id: IpIpoptAlg.hpp 988 2007-06-01 21:57:27Z andreasw $
//
// 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();

    static void RegisterOptions(SmartPtr<RegisteredOptions> roptions);

  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_;

    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

---