LDLT_factor.hpp

Go to the documentation of this file.

#ifndef STAN__MATH__MATRIX__LDLT_FACTOR_HPP
#define STAN__MATH__MATRIX__LDLT_FACTOR_HPP

#include <stan/math/matrix/Eigen.hpp>
#include <boost/shared_ptr.hpp>
#include <stan/math/error_handling/matrix/check_square.hpp>

namespace stan {
  namespace math {

    // This class is conceptually similar to the corresponding Eigen class
    // Any spd matrix A can be decomposed as LDL' where L is unit lower-triangular
    // and D is diagonal with positive diagonal elements

    template<typename T, int R, int C>
    class LDLT_factor;
    
    template<int R, int C, typename T>
    class LDLT_factor<T,R,C> {
    public:
      LDLT_factor()
      : N_(0), _ldltP(new Eigen::LDLT< Eigen::Matrix<T,R,C> >()) {}

      LDLT_factor(const Eigen::Matrix<T,R,C> &A)
      : N_(0), _ldltP(new Eigen::LDLT< Eigen::Matrix<T,R,C> >())
      {
        compute(A);
      }
      
      inline void compute(const Eigen::Matrix<T,R,C> &A) {
        stan::math::check_square("LDLT_factor(%1%)",A,"A",(T*)0);
        N_ = A.rows();
        _ldltP->compute(A);
      }
      
      inline bool success() const {
        bool ret;
        ret = _ldltP->info() == Eigen::Success;
        ret = ret && _ldltP->isPositive();
        ret = ret && (_ldltP->vectorD().array() > 0).all();
        return ret;
      }

      inline T log_abs_det() const {
        return _ldltP->vectorD().array().log().sum();
      }
      
      inline void inverse(Eigen::Matrix<T,R,C> &invA) const {
        invA.setIdentity(N_);
        _ldltP->solveInPlace(invA);
      }

      template<typename Rhs>
      inline const Eigen::internal::solve_retval<Eigen::LDLT< Eigen::Matrix<T,R,C> >, Rhs>
      solve(const Eigen::MatrixBase<Rhs>& b) const {
        return _ldltP->solve(b);
      }

      inline Eigen::Matrix<T,R,C> solveRight(const Eigen::Matrix<T,R,C> &B) const {
        return _ldltP->solve(B.transpose()).transpose();
      }

      inline Eigen::Matrix<T,Eigen::Dynamic,1> vectorD() const {
        return _ldltP->vectorD();
      }
     
      inline Eigen::LDLT<Eigen::Matrix<T,R,C> > matrixLDLT() const {
        return _ldltP->matrixLDLT();
      }

      inline size_t rows() const { return N_; }
      inline size_t cols() const { return N_; }
      
      typedef size_t size_type;
      typedef double value_type;

      size_t N_;
      boost::shared_ptr< Eigen::LDLT< Eigen::Matrix<T,R,C> > > _ldltP;
    };
  }
}
#endif