IpLimMemQuasiNewtonUpdater.hpp

Go to the documentation of this file.

// Copyright (C) 2005, 2010 International Business Machines and others.
// All Rights Reserved.
// This code is published under the Eclipse Public License.
//
// Authors:  Andreas Waechter            IBM    2005-12-26
 
#ifndef __IPLIMMEMQUASINEWTONUPDATER_HPP__
#define __IPLIMMEMQUASINEWTONUPDATER_HPP__
 
#include "IpHessianUpdater.hpp"
#include "IpLowRankUpdateSymMatrix.hpp"
#include "IpMultiVectorMatrix.hpp"
#include "IpDenseVector.hpp"
#include "IpDenseGenMatrix.hpp"
#include "IpDenseSymMatrix.hpp"
 
namespace Ipopt
{
 
class LimMemQuasiNewtonUpdater: public HessianUpdater
{
public:
 
   LimMemQuasiNewtonUpdater(
      bool update_for_resto
   );
 
   virtual ~LimMemQuasiNewtonUpdater()
   { }
 
   virtual bool InitializeImpl(
      const OptionsList& options,
      const std::string& prefix
   );
 
   virtual void UpdateHessian();
 
   static void RegisterOptions(
      SmartPtr<RegisteredOptions> roptions
   );
 
private:
 
   LimMemQuasiNewtonUpdater(
      const LimMemQuasiNewtonUpdater&
   );
 
   void operator=(
      const LimMemQuasiNewtonUpdater&
   );
 
   SmartPtr<const LowRankUpdateSymMatrixSpace> h_space_;
 
 
   Index limited_memory_max_history_;
 
   enum LMUpdateType
   {
      BFGS = 0,
      SR1
   };
 
   LMUpdateType limited_memory_update_type_;
 
   enum LMInitialization
   {
      SCALAR1 = 0,
      SCALAR2,
      SCALAR3,
      SCALAR4,
      CONSTANT
   };
 
   LMInitialization limited_memory_initialization_;
 
   Number limited_memory_init_val_;
 
   Index limited_memory_max_skipping_;
 
   Number sigma_safe_min_;
 
   Number sigma_safe_max_;
 
   bool limited_memory_special_for_resto_;
 
   const bool update_for_resto_;
 
   Number last_eta_;
 
   SmartPtr<const Vector> curr_DR_x_;
 
   TaggedObject::Tag curr_DR_x_tag_;
 
   SmartPtr<const Vector> curr_red_DR_x_;
 
   Number curr_eta_;
 
   Index lm_skipped_iter_;
 
 
   Index curr_lm_memory_;
 
   SmartPtr<MultiVectorMatrix> S_;
 
   SmartPtr<MultiVectorMatrix> Y_;
 
   SmartPtr<MultiVectorMatrix> Ypart_;
 
   SmartPtr<DenseVector> D_;
 
   SmartPtr<DenseGenMatrix> L_;
 
   SmartPtr<Vector> B0_;
 
   Number sigma_;
 
   SmartPtr<MultiVectorMatrix> V_;
 
   SmartPtr<MultiVectorMatrix> U_;
 
   SmartPtr<DenseSymMatrix> SdotS_;
 
   bool SdotS_uptodate_;
 
   SmartPtr<MultiVectorMatrix> DRS_;
 
   SmartPtr<DenseSymMatrix> STDRS_;
 
   SmartPtr<const Vector> last_x_;
 
   SmartPtr<const Vector> last_grad_f_;
 
   SmartPtr<const Matrix> last_jac_c_;
 
   SmartPtr<const Matrix> last_jac_d_;
 
   Index curr_lm_memory_old_;
 
   SmartPtr<MultiVectorMatrix> S_old_;
 
   SmartPtr<MultiVectorMatrix> Y_old_;
 
   SmartPtr<MultiVectorMatrix> Ypart_old_;
 
   SmartPtr<DenseVector> D_old_;
 
   SmartPtr<DenseGenMatrix> L_old_;
 
   SmartPtr<Vector> B0_old_;
 
   Number sigma_old_;
 
   SmartPtr<MultiVectorMatrix> V_old_;
 
   SmartPtr<MultiVectorMatrix> U_old_;
 
   SmartPtr<DenseSymMatrix> SdotS_old_;
 
   bool SdotS_uptodate_old_;
 
   SmartPtr<MultiVectorMatrix> DRS_old_;
 
   SmartPtr<DenseSymMatrix> STDRS_old_;
 
 
   bool CheckSkippingBFGS(
      const Vector& s_new,
      const Vector& y_new
   );
 
   bool UpdateInternalData(
      const Vector&    s_new,
      const Vector&    y_new,
      SmartPtr<Vector> ypart_new
   );
 
   void AugmentMultiVector(
      SmartPtr<MultiVectorMatrix>& V,
      const Vector&                v_new
   );
 
   void AugmentDenseVector(
      SmartPtr<DenseVector>& V,
      Number                 v_new
   );
 
   void AugmentLMatrix(
      SmartPtr<DenseGenMatrix>& V,
      const MultiVectorMatrix&  S,
      const MultiVectorMatrix&  Y
   );
 
   void AugmentSdotSMatrix(
      SmartPtr<DenseSymMatrix>& V,
      const MultiVectorMatrix&  S
   );
 
   void AugmentSTDRSMatrix(
      SmartPtr<DenseSymMatrix>& V,
      const MultiVectorMatrix&  S,
      const MultiVectorMatrix&  DRS
   );
 
   void ShiftMultiVector(
      SmartPtr<MultiVectorMatrix>& V,
      const Vector&                v_new
   );
 
   void ShiftDenseVector(
      SmartPtr<DenseVector>& V,
      Number                 v_new
   );
 
   void ShiftLMatrix(
      SmartPtr<DenseGenMatrix>& V,
      const MultiVectorMatrix&  S,
      const MultiVectorMatrix&  Y
   );
 
   void ShiftSdotSMatrix(
      SmartPtr<DenseSymMatrix>& V,
      const MultiVectorMatrix&  S
   );
 
   void ShiftSTDRSMatrix(
      SmartPtr<DenseSymMatrix>& V,
      const MultiVectorMatrix&  S,
      const MultiVectorMatrix&  DRS
   );
 
   void RecalcY(
      Number                       eta,
      const Vector&                DR_x,
      MultiVectorMatrix&           S,
      MultiVectorMatrix&           Ypart,
      SmartPtr<MultiVectorMatrix>& Y
   );
 
   void RecalcD(
      const MultiVectorMatrix& S,
      const MultiVectorMatrix& Y,
      SmartPtr<DenseVector>&   D
   );
 
   void RecalcL(
      const MultiVectorMatrix&  S,
      const MultiVectorMatrix&  Y,
      SmartPtr<DenseGenMatrix>& L
   );
 
   bool SplitEigenvalues(
      DenseGenMatrix&           Q,
      const DenseVector&        E,
      SmartPtr<DenseGenMatrix>& Qminus,
      SmartPtr<DenseGenMatrix>& Qplus
   );
 
   void StoreInternalDataBackup();
 
   void RestoreInternalDataBackup();
 
   // void ReleaseInternalDataBackup();
 
   void SetW();
 
};
 
} // namespace Ipopt
 
#endif