ConstrainedOptPack_MatrixSymPosDefLBFGSSerial.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 "AbstractLinAlgPack_MatrixSymSecant.hpp"
#include "AbstractLinAlgPack_MatrixSymAddDelUpdateable.hpp"
#include "AbstractLinAlgPack/src/MatrixSymWithOpFactorized.hpp"
#include "DenseLinAlgPack_DMatrixAsTriSym.hpp"
#include "Teuchos_StandardMemberCompositionMacros.hpp"

namespace ConstrainedOptPack {

class MatrixSymPosDefLBFGS
  : public MatrixSymWithOpFactorized
  , public MatrixSymSecant
  , public MatrixSymAddDelUpdateable
{
public:

  // //////////////////////////////////////////////
  // Constructors and initializers

  MatrixSymPosDefLBFGS(
    size_type   max_size           = 0
      ,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   max_size           = 0
     ,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;
  size_type k_bar() const;
  value_type gamma_k() const;
  const DMatrixSlice S() const;
  const DMatrixSlice Y() const;
  bool maintain_original() const;
  bool maintain_inverse() const;
  size_type num_secant_updates() const;

  // /////////////////////////////////////////////////////
  // Overridden from Matrix

  size_type rows() const;

  // /////////////////////////////////////////////////////////

  std::ostream& output(std::ostream& out) const;
  MatrixOp& operator=(const MatrixOp& m);
  void Vp_StMtV(DVectorSlice* vs_lhs, value_type alpha, BLAS_Cpp::Transp trans_rhs1
    , const DVectorSlice& vs_rhs2, value_type beta) const;


  // ////////////////////////////////////////////////////////////

  void V_InvMtV( DVectorSlice* v_lhs, BLAS_Cpp::Transp trans_rhs1
    , const DVectorSlice& vs_rhs2) const;


  // ///////////////////////////////////////////////////////////

  void init_identity( size_type n, value_type alpha );
  void init_diagonal( const DVectorSlice& diag );
  void secant_update(DVectorSlice* s, DVectorSlice* y, DVectorSlice* Bs);

  //    end Overridden from MatrixSymSecant

  // ////////////////////////////////////////////////////////

  void initialize(
    value_type         alpha
    ,size_type         max_size
    );
  void initialize(
    const DMatrixSliceSym      &A
    ,size_type         max_size
    ,bool              force_factorization
    ,Inertia           inertia
    ,PivotTolerances   pivot_tols
    );
  size_type max_size() const;
  Inertia inertia() const;
  void set_uninitialized();
  void augment_update(
    const DVectorSlice  *t
    ,value_type        alpha
    ,bool              force_refactorization
    ,EEigenValType     add_eigen_val
    ,PivotTolerances   pivot_tols
    );
  void delete_update(
    size_type          jd
    ,bool              force_refactorization
    ,EEigenValType     drop_eigen_val
    ,PivotTolerances   pivot_tols
    );
  
  
private:

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

  // //////////////////////////////////
  // 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

  size_type n_max_, // The maximum size the matrix is allowed to become.
        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
        k_bar_, // Position of the most recently stored update vector in S & Y
            // 1 <= k_bar <= m_bar
            num_secant_updates_; // Records the number of secant updates performed
  value_type  gamma_k_;// Scaling factor for Bo = (1/gamma_k) * I.

  DMatrix S_,   // (n_max x m) Matrix of stored update vectors = [ s1, ..., sm ]
            // S(:,k_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
        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.

  mutable DVector   work_;  // workspace for performing operations.

  // //////////////////////////////////
  // 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
size_type MatrixSymPosDefLBFGS::k_bar() const
{
  return k_bar_;
}

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

inline
const DMatrixSlice MatrixSymPosDefLBFGS::S() const
{
  return S_(1,n_,1,m_bar_);
}

inline
const DMatrixSlice MatrixSymPosDefLBFGS::Y() const
{
  return Y_(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