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

Go to the documentation of this file.

// Copyright (C) 2005, 2006 International Business Machines and others.
// All Rights Reserved.
// This code is published under the Common Public License.
//
// $Id: IpLimMemQuasiNewtonUpdater.hpp 1019 2007-06-24 03:52:34Z andreasw $
//
// 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,
      CONSTANT
    };
    LMInitialization limited_memory_initialization_;
    Number limited_memory_init_val_;
    Index limited_memory_max_skipping_;
    Number sigma_safe_min_;
    Number sigma_safe_max_;

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

    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(Vector& s_new, 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(MultiVectorMatrix& S,
                 MultiVectorMatrix& Y,
                 SmartPtr<DenseVector>& D);
    void RecalcL(MultiVectorMatrix& S,
                 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

---