IpBacktrackingLineSearch.hpp

Go to the documentation of this file.

// Copyright (C) 2004, 2009 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
//           Andreas Waechter                 IBM    2005-10-13
//               derived file from IpFilterLineSearch.hpp
 
#ifndef __IPBACKTRACKINGLINESEARCH_HPP__
#define __IPBACKTRACKINGLINESEARCH_HPP__
 
#include "IpLineSearch.hpp"
#include "IpBacktrackingLSAcceptor.hpp"
#include "IpRestoPhase.hpp"
#include "IpConvCheck.hpp"
 
namespace Ipopt
{
 
class BacktrackingLineSearch: public LineSearch
{
public:
 
   BacktrackingLineSearch(
      const SmartPtr<BacktrackingLSAcceptor>& acceptor,
      const SmartPtr<RestorationPhase>&       resto_phase,
      const SmartPtr<ConvergenceCheck>&       conv_check
   );
 
   virtual ~BacktrackingLineSearch();
 
   virtual bool InitializeImpl(
      const OptionsList& options,
      const std::string& prefix
   );
 
   virtual void FindAcceptableTrialPoint();
 
   virtual void Reset();
 
   virtual void SetRigorousLineSearch(
      bool rigorous
   )
   {
      rigorous_ = rigorous;
   }
 
   virtual bool CheckSkippedLineSearch()
   {
      return skipped_line_search_;
   }
 
   virtual bool ActivateFallbackMechanism();
 
   void StopWatchDog();
 
   static void RegisterOptions(
      SmartPtr<RegisteredOptions> roptions
   );
 
private:
 
   BacktrackingLineSearch(
      const BacktrackingLineSearch&
   );
 
   void operator=(
      const BacktrackingLineSearch&
   );
 
   bool DoBacktrackingLineSearch(
      bool                      skip_first_trial_point,
      Number&                   alpha_primal,
      bool&                     corr_taken,
      bool&                     soc_taken,
      Index&                    n_steps,
      bool&                     evaluation_error,
      SmartPtr<IteratesVector>& actual_delta
   );
 
   void StartWatchDog();
 
   void StopWatchDog(
      SmartPtr<IteratesVector>& actual_delta
   );
 
   bool CheckAcceptabilityOfTrialPoint(
      Number alpha_primal
   );
 
   void PerformDualStep(
      Number                    alpha_primal,
      Number                    alpha_dual,
      SmartPtr<IteratesVector>& delta
   );
 
   bool TrySoftRestoStep(
      SmartPtr<IteratesVector>& actual_delta,
      bool&                     satisfies_original_criterion
   );
 
   bool TrySecondOrderCorrection(
      Number                    alpha_primal_test,
      Number&                   alpha_primal,
      SmartPtr<IteratesVector>& actual_delta
   );
 
   bool TryCorrector(
      Number                    alpha_primal_test,
      Number&                   alpha_primal,
      SmartPtr<IteratesVector>& actual_delta
   );
 
   void PerformMagicStep();
 
   bool DetectTinyStep();
 
   void StoreAcceptablePoint();
 
   bool RestoreAcceptablePoint();
 
   bool CurrentIsAcceptable();
 
 
   Number alpha_red_factor_;
 
   enum AlphaForYEnum
   {
      PRIMAL_ALPHA_FOR_Y = 0,
      DUAL_ALPHA_FOR_Y,
      MIN_ALPHA_FOR_Y,
      MAX_ALPHA_FOR_Y,
      FULL_STEP_FOR_Y,
      MIN_DUAL_INFEAS_ALPHA_FOR_Y,
      SAFE_MIN_DUAL_INFEAS_ALPHA_FOR_Y,
      PRIMAL_AND_FULL_ALPHA_FOR_Y,
      DUAL_AND_FULL_ALPHA_FOR_Y,
      LSACCEPTOR_ALPHA_FOR_Y
   };
   AlphaForYEnum alpha_for_y_;
 
   Number alpha_for_y_tol_;
 
   Number soft_resto_pderror_reduction_factor_;
   Index max_soft_resto_iters_;
 
   bool magic_steps_;
   bool accept_every_trial_step_;
   Index accept_after_max_steps_;
   bool expect_infeasible_problem_;
   Number expect_infeasible_problem_ctol_;
   Number expect_infeasible_problem_ytol_;
 
   Number tiny_step_tol_;
 
   Number tiny_step_y_tol_;
 
   Index watchdog_trial_iter_max_;
   Index watchdog_shortened_iter_trigger_;
 
   bool start_with_resto_;
 
   Number constr_viol_tol_;
 
 
   bool in_watchdog_;
   Index watchdog_shortened_iter_;
   Index watchdog_trial_iter_;
   Number watchdog_alpha_primal_test_;
   SmartPtr<const IteratesVector> watchdog_iterate_;
   SmartPtr<const IteratesVector> watchdog_delta_;
   Number last_mu_;
 
   SmartPtr<const IteratesVector> acceptable_iterate_;
   Index acceptable_iteration_number_;
 
   bool fallback_activated_;
 
   bool rigorous_;
 
   bool skipped_line_search_;
 
   bool in_soft_resto_phase_;
 
   Index soft_resto_counter_;
 
   Index count_successive_shortened_steps_;
 
   bool tiny_step_last_iteration_;
 
   SmartPtr<BacktrackingLSAcceptor> acceptor_;
   SmartPtr<RestorationPhase> resto_phase_;
   SmartPtr<ConvergenceCheck> conv_check_;
};
 
} // namespace Ipopt
 
#endif