LDLT_factor.hpp

Go to the documentation of this file.

#ifndef STAN__AGRAD__REV__MATRIX__LDLT_FACTOR_HPP
#define STAN__AGRAD__REV__MATRIX__LDLT_FACTOR_HPP

#include <stan/agrad/rev/var.hpp>
#include <stan/agrad/rev/matrix/LDLT_alloc.hpp>
#include <stan/math/matrix/LDLT_factor.hpp>
#include <stan/math/error_handling/matrix/check_square.hpp>

namespace stan {
  namespace math {
    template<int R, int C>
    class LDLT_factor<stan::agrad::var,R,C> {
    public:
      LDLT_factor() : _alloc(new stan::agrad::LDLT_alloc<R,C>()) {}

      LDLT_factor(const Eigen::Matrix<stan::agrad::var,R,C> &A)
      : _alloc(new stan::agrad::LDLT_alloc<R,C>()) {
        compute(A);
      }
     
      inline void compute(const Eigen::Matrix<stan::agrad::var,R,C> &A) {
        stan::math::check_square("comute(%1%)",A,"A",(double*)0);
        _alloc->compute(A);
      }
      
      template<typename Rhs>
      inline const Eigen::internal::solve_retval<Eigen::LDLT< Eigen::Matrix<double,R,C> >, Rhs>
      solve(const Eigen::MatrixBase<Rhs>& b) const {
        return _alloc->_ldlt.solve(b);
      }
      
      inline bool success() const {
        bool ret;
        ret = _alloc->N_ != 0;
        ret = ret && _alloc->_ldlt.info() == Eigen::Success;
        ret = ret && _alloc->_ldlt.isPositive();
        ret = ret && (_alloc->_ldlt.vectorD().array() > 0).all();
        return ret;
      }

      inline Eigen::VectorXd vectorD() const {
        return _alloc->_ldlt.vectorD();
      }

      inline size_t rows() const { return _alloc->N_; }
      inline size_t cols() const { return _alloc->N_; }
      
      typedef size_t size_type;
      typedef stan::agrad::var value_type;

      stan::agrad::LDLT_alloc<R,C> *_alloc;
    };
  }
}
#endif