IpInexactLSAcceptor.hpp

Go to the documentation of this file.

// Copyright (C) 2008 International Business Machines and others.
// All Rights Reserved.
// This code is published under the Eclipse Public License.
//
// Authors:  Andreas Waechter                 IBM    2008-09-11
//               derived file from IpPenaltyLSAcceptor.hpp (rev 019)
 
#ifndef __IPINEXACTLSACCEPTOR_HPP__
#define __IPINEXACTLSACCEPTOR_HPP__
 
#include "IpBacktrackingLSAcceptor.hpp"
#include "IpInexactCq.hpp"
 
namespace Ipopt
{
 
class InexactLSAcceptor: public BacktrackingLSAcceptor
{
public:
 
   InexactLSAcceptor();
 
   virtual ~InexactLSAcceptor();
 
   virtual bool InitializeImpl(
      const OptionsList& options,
      const std::string& prefix
   );
 
   virtual void Reset();
 
   virtual void InitThisLineSearch(
      bool in_watchdog
   );
 
   virtual void PrepareRestoPhaseStart();
 
   virtual Number CalculateAlphaMin();
 
   virtual bool CheckAcceptabilityOfTrialPoint(
      Number alpha_primal
   );
 
   virtual bool TrySecondOrderCorrection(
      Number                    alpha_primal_test,
      Number&                   alpha_primal,
      SmartPtr<IteratesVector>& actual_delta
   );
 
   virtual bool TryCorrector(
      Number                    alpha_primal_test,
      Number&                   alpha_primal,
      SmartPtr<IteratesVector>& actual_delta
   );
 
   virtual char UpdateForNextIteration(
      Number alpha_primal_test
   );
 
   virtual void StartWatchDog();
 
   virtual void StopWatchDog();
 
 
   bool IsAcceptableToCurrentIterate(
      Number trial_barr,
      Number trial_theta,
      bool   called_from_restoration = false
   ) const;
 
   virtual Number ComputeAlphaForY(
      Number                    alpha_primal,
      Number                    alpha_dual,
      SmartPtr<IteratesVector>& delta
   );
 
   virtual bool HasComputeAlphaForY() const
   {
      return true;
   }
 
   static void RegisterOptions(
      SmartPtr<RegisteredOptions> roptions
   );
 
protected:
   InexactData& InexData()
   {
      InexactData& inexact_data = static_cast<InexactData&>(IpData().AdditionalData());
      DBG_ASSERT(dynamic_cast<InexactData*>(&IpData().AdditionalData()));
      return inexact_data;
   }
 
   InexactCq& InexCq()
   {
      InexactCq& inexact_cq = static_cast<InexactCq&>(IpCq().AdditionalCq());
      DBG_ASSERT(dynamic_cast<InexactCq*>(&IpCq().AdditionalCq()));
      return inexact_cq;
   }
 
private:
 
   InexactLSAcceptor(
      const InexactLSAcceptor&
   );
 
   void operator=(
      const InexactLSAcceptor&
   );
 
   Number CalcPred(
      Number alpha
   );
 
   void ResetSlacks();
 
 
   Number nu_init_;
   Number nu_low_init_;
   Number nu_low_fact_;
   Number nu_inc_;
   Number eta_;
   Number rho_;
   Number tcc_theta_;
   Number nu_update_inf_skip_tol_;
   bool flexible_penalty_function_;
 
 
   Number reference_theta_;
   Number reference_barr_;
   Number reference_pred_;
   Number watchdog_theta_;
   Number watchdog_barr_;
   Number watchdog_pred_;
 
 
   Number nu_;
   Number last_nu_;
   Number nu_low_;
   Number last_nu_low_;
   Number inexact_decomposition_activate_tol_;
   Number inexact_decomposition_inactivate_tol_;
 
   bool in_tt2_;
 
   Number resto_pred_;
 
   bool accepted_by_low_only_;
};
 
} // namespace Ipopt
 
#endif