ConstrainedOptPack_MatrixSymPosDefLBFGS.hpp

// @HEADER
// ***********************************************************************
// 
// Moocho: Multi-functional Object-Oriented arCHitecture for Optimization
//                  Copyright (2003) Sandia Corporation
// 
// Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
// license for use of this work by or on behalf of the U.S. Government.
// 
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 2.1 of the
// License, or (at your option) any later version.
//  
// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//  
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
// USA
// Questions? Contact Roscoe A. Bartlett (rabartl@sandia.gov) 
// 
// ***********************************************************************
// @HEADER

#ifndef MATRIX_SYM_POS_DEF_LBFGS_H
#define MATRIX_SYM_POS_DEF_LBFGS_H

#include <vector>

#include "ConstrainedOptPack_Types.hpp"
#include "AbstractLinAlgPack_MatrixSymSecant.hpp"
#include "AbstractLinAlgPack_MatrixSymOpNonsing.hpp"
#include "AbstractLinAlgPack_MultiVectorMutable.hpp"
#include "AbstractLinAlgPack_VectorSpace.hpp"
#include "DenseLinAlgPack_DMatrixAsTriSym.hpp"
#include "Teuchos_StandardMemberCompositionMacros.hpp"

namespace ConstrainedOptPack {

class MatrixSymPosDefLBFGS
  : public AbstractLinAlgPack::MatrixSymOpNonsing // doxygen needs full path
  , public MatrixSymSecant
{
public:


  typedef Teuchos::RCP<const MultiVector>   multi_vec_ptr_t;

  class PostMod {
  public:
    PostMod(
      size_type     m                   = 10
      ,bool         maintain_original   = true
      ,bool         maintain_inverse    = true
      ,bool         auto_rescaling      = false
      )
      :m_(m)
      ,maintain_original_(maintain_original)
      ,maintain_inverse_(maintain_inverse)
      ,auto_rescaling_(auto_rescaling)
    {}
    void initialize(MatrixSymPosDefLBFGS* p) const
    {
      p->initial_setup(m_,maintain_original_,maintain_inverse_,auto_rescaling_);
    }
  private:
    size_type   m_;
    bool        maintain_original_;
    bool        maintain_inverse_;
    bool        auto_rescaling_;
  }; // end PostMod



  MatrixSymPosDefLBFGS(
      size_type     m                   = 10
    ,bool         maintain_original   = true
    ,bool         maintain_inverse    = true
    ,bool         auto_rescaling      = false
    );

  STANDARD_MEMBER_COMPOSITION_MEMBERS( bool, auto_rescaling );

   void initial_setup(
      size_type     m                   = 10
    ,bool         maintain_original   = true
    ,bool         maintain_inverse    = true
    ,bool         auto_rescaling      = false
     );

  // //////////////////////////////////
  // Representation access

  size_type m() const;
  size_type m_bar() const;
  value_type gamma_k() const;
  const multi_vec_ptr_t S() const;
  const multi_vec_ptr_t Y() const;
  bool maintain_original() const;
  bool maintain_inverse() const;
  size_type num_secant_updates() const;



  const VectorSpace& space_cols() const;
  std::ostream& output(std::ostream& out) const;
  MatrixOp& operator=(const MatrixOp& mwo);
  void Vp_StMtV(
    VectorMutable* v_lhs, value_type alpha, BLAS_Cpp::Transp trans_rhs1
    , const Vector& v_rhs2, value_type beta ) const;



  void V_InvMtV(
    VectorMutable* v_lhs, BLAS_Cpp::Transp trans_rhs1
    , const Vector& v_rhs2 ) const;



  void init_identity( const VectorSpace& space_diag, value_type alpha );
  void init_diagonal( const Vector& diag );
  void secant_update(
    VectorMutable     *s
    ,VectorMutable    *y
    ,VectorMutable    *Bs
    );


private:

  // //////////////////////////////////
  // Private types

  typedef VectorSpace::multi_vec_mut_ptr_t   multi_vec_mut_ptr_t;

  // //////////////////////////////////
  // Private data members

  bool        maintain_original_;  // If true, qualities needed for Bk will be maintained
  bool        original_is_updated_;// If true, qualities needed for Bk are already updated
  bool        maintain_inverse_;   // If true, quantities needed for Hk will be maintained
  bool        inverse_is_updated_; // If true, quantities needed for Hk are already updated

  VectorSpace::space_ptr_t
            vec_spc_; // The vector space that everything is based on.

  size_type   n_,   // Size of the matrix.  If 0 then is uninitialized
              m_,   // Maximum number of update vectors that can be stored.
                m_bar_, // Current number of update vectors being stored.
                    // 0 <= m_bar <= m
                num_secant_updates_; // Records the number of secant updates performed
  value_type  gamma_k_;// Scaling factor for Bo = (1/gamma_k) * I.

  multi_vec_mut_ptr_t
                S_,     // (n x m) Matrix of stored update vectors = [ s1, ..., sm ]
                    // S(:,m_bar) is the most recently stored s update vector
              Y_;     // (n_max x m) Matrix of stored update vectors = [ y1, ..., ym ]
            // Y(:,k_bar) is the most recently stored y update vector
  DMatrix   STY_,   // (m x m) The matrix S'Y
              STSYTY_;// ((m+1) x (m+1)) The strictly upper triangular part stores the
                      // upper triangular part Y'Y and the strictly lower triangular
                      // part stores the lower triangular part of S'S.  The diagonal
                      // can be used for workspace.

  mutable bool        Q_updated_; // True if Q has been updated for the most current update.
  mutable DMatrix   QJ_;        // Used to store factorization of the schur complement of Q.

  // //////////////////////////////////
  // Private member functions

  // Access to important matrices.

  const DMatrixSliceTri R() const;
  const DMatrixSliceTri Lb() const;
  DMatrixSlice STY();
  const DMatrixSlice STY() const;
  DMatrixSliceSym STS();
  const DMatrixSliceSym STS() const;
  DMatrixSliceSym YTY();
  const DMatrixSliceSym YTY() const;
  void V_invQtV( DVectorSlice* y, const DVectorSlice& x ) const;
  void Vp_DtV( DVectorSlice* y, const DVectorSlice& x ) const;

  // Updates

  void update_Q() const;

  void assert_initialized() const;

};  // end class MatrixSymPosDefLBFGS

// //////////////////////////////////////////////
// Inline member functions

inline
size_type MatrixSymPosDefLBFGS::m() const
{
  return m_;
}

inline
size_type MatrixSymPosDefLBFGS::m_bar() const
{
  return m_bar_;
}

inline
value_type MatrixSymPosDefLBFGS::gamma_k() const
{
  return gamma_k_;
}

inline
const MatrixSymPosDefLBFGS::multi_vec_ptr_t
MatrixSymPosDefLBFGS::S() const
{
  return S_->mv_sub_view(1,n_,1,m_bar_);
}

inline
const MatrixSymPosDefLBFGS::multi_vec_ptr_t
MatrixSymPosDefLBFGS::Y() const
{
  return Y_->mv_sub_view(1,n_,1,m_bar_);
}

inline
bool MatrixSymPosDefLBFGS::maintain_original() const
{
  return maintain_original_;
}

inline
bool MatrixSymPosDefLBFGS::maintain_inverse() const
{
  return maintain_inverse_;
}

inline
size_type MatrixSymPosDefLBFGS::num_secant_updates() const
{
  return num_secant_updates_;
}

} // end namespace ConstrainedOptPack 

#endif  // MATRIX_SYM_POS_DEF_LBFGS_H