reader.hpp

Go to the documentation of this file.

#ifndef STAN__IO__READER_HPP
#define STAN__IO__READER_HPP

#include <boost/throw_exception.hpp>
#include <stan/prob/transform.hpp>

namespace stan {

  namespace io {


    template <typename T>
    class reader {

    private:

      std::vector<T>& data_r_;
      std::vector<int>& data_i_;
      size_t pos_;
      size_t int_pos_;
      
      inline T& scalar_ptr() {
        return data_r_.at(pos_);
      }
      
      inline T& scalar_ptr_increment(size_t m) {
        pos_ += m;
        return data_r_.at(pos_ - m);
      }

      inline int& int_ptr() {
        return data_i_.at(int_pos_);
      }
      
      inline int& int_ptr_increment(size_t m) {
        int_pos_ += m;
        return data_i_.at(int_pos_ - m);
      }

    public:

      typedef Eigen::Matrix<T,Eigen::Dynamic,Eigen::Dynamic> matrix_t;
      typedef Eigen::Matrix<T,Eigen::Dynamic,1> vector_t;
      typedef Eigen::Matrix<T,1,Eigen::Dynamic> row_vector_t;

      typedef Eigen::Map<matrix_t> map_matrix_t;
      typedef Eigen::Map<vector_t> map_vector_t;
      typedef Eigen::Map<row_vector_t> map_row_vector_t;


      reader(std::vector<T>& data_r,
             std::vector<int>& data_i)
        : data_r_(data_r),
          data_i_(data_i),
          pos_(0),
          int_pos_(0) {
      }

      ~reader() { }

      inline size_t available() {
        return data_r_.size() - pos_;
      }

      inline size_t available_i() {
        return data_i_.size() - int_pos_;
      }

      inline int integer() {
        if (int_pos_ >= data_i_.size())
          BOOST_THROW_EXCEPTION(
              std::runtime_error("no more integers to read."));
        return data_i_[int_pos_++];
      }

      inline int integer_constrain() {
        return integer();
      }
      
      inline int integer_constrain(T& /*log_prob*/) {
        return integer();
      }
      


      inline T scalar() {
        if (pos_ >= data_r_.size())
          BOOST_THROW_EXCEPTION(std::runtime_error("no more scalars to read"));
        return data_r_[pos_++];
      }

      inline T scalar_constrain() {
        return scalar();
      }

      T scalar_constrain(T& /*log_prob*/) {
        return scalar();
      }


      inline std::vector<T> std_vector(size_t m) {
        std::vector<T> vec;
        T& start = scalar_ptr_increment(m);
        vec.insert(vec.begin(), &start, &scalar_ptr());
        return vec;
      }

      inline vector_t vector(size_t m) {
        return map_vector_t(&scalar_ptr_increment(m),m);
      }
      inline vector_t vector_constrain(size_t m) {
        return map_vector_t(&scalar_ptr_increment(m),m);
      }
      inline vector_t vector_constrain(size_t m, T& /*lp*/) {
        return map_vector_t(&scalar_ptr_increment(m),m);
      }



      inline row_vector_t row_vector(size_t m) {
        return map_row_vector_t(&scalar_ptr_increment(m),m);
      }

      inline row_vector_t row_vector_constrain(size_t m) {
        return map_row_vector_t(&scalar_ptr_increment(m),m);
      }

      inline row_vector_t row_vector_constrain(size_t m, T& /*lp*/) {
        return map_row_vector_t(&scalar_ptr_increment(m),m);
      }
      
      inline matrix_t matrix(size_t m, size_t n) {
        return map_matrix_t(&scalar_ptr_increment(m*n),m,n);
      }

      inline matrix_t matrix_constrain(size_t m, size_t n) {
        return map_matrix_t(&scalar_ptr_increment(m*n),m,n);
      }

      inline matrix_t matrix_constrain(size_t m, size_t n, T& /*lp*/) {
        return map_matrix_t(&scalar_ptr_increment(m*n),m,n);
      }


      inline int integer_lb(int lb) {
        int i = integer();
        if (!(i >= lb))
          BOOST_THROW_EXCEPTION(
              std::runtime_error("required value greater than or equal to lb"));
        return i;
      }
      inline int integer_lb_constrain(int lb) {
        return integer_lb(lb);
      }
      inline int integer_lb_constrain(int lb, T& /*lp*/) {
        return integer_lb(lb);
      }


      inline int integer_ub(int ub) {
        int i = integer();
        if (!(i <= ub))
          BOOST_THROW_EXCEPTION(
              std::runtime_error("required value less than or equal to ub"));
        return i;
      }
      inline int integer_ub_constrain(int ub) {
        return integer_ub(ub);
      }
      int integer_ub_constrain(int ub, T& /*lp*/) {
        return integer_ub(ub);
      }

      inline int integer_lub(int lb, int ub) {
        // read first to make position deterministic [arbitrary choice]
        int i = integer(); 
        if (lb > ub)
          BOOST_THROW_EXCEPTION(
            std::runtime_error("lower bound must be less than or equal to ub"));
        if (!(i >= lb))
          BOOST_THROW_EXCEPTION(
            std::runtime_error("required value greater than or equal to lb"));
        if (!(i <= ub))
          BOOST_THROW_EXCEPTION(
            std::runtime_error("required value less than or equal to ub"));
        return i;
      }
      inline int integer_lub_constrain(int lb, int ub) {
        return integer_lub(lb,ub);
      }
      inline int integer_lub_constrain(int lb, int ub, T& /*lp*/) {
        return integer_lub(lb,ub);
      }
      


      inline T scalar_pos() {
        T x(scalar());
        stan::math::check_positive("stan::io::scalar_pos(%1%)", x, 
                                   "Constrained scalar", (double*)0);
        return x;
      }

      inline T scalar_pos_constrain() {
        return stan::prob::positive_constrain(scalar());
      }

      inline T scalar_pos_constrain(T& lp) {
        return stan::prob::positive_constrain(scalar(),lp);
      }

      template <typename TL>
      inline T scalar_lb(const TL lb) {
        T x(scalar());
        stan::math::check_greater_or_equal("stan::io::scalar_lb(%1%)",
                                           x, lb, "Constrained scalar", 
                                           (double*)0);
        return x;
      }

      template <typename TL>
      inline T scalar_lb_constrain(const TL lb) {
        return stan::prob::lb_constrain(scalar(),lb);
      }

      template <typename TL>
      inline T scalar_lb_constrain(const TL lb, T& lp) {
        return stan::prob::lb_constrain(scalar(),lb,lp);
      }



      template <typename TU>
      inline T scalar_ub(TU ub) {
        T x(scalar());
        stan::math::check_less_or_equal("stan::io::scalar_ub(%1%)", x, ub, 
                                        "Constrained scalar", (double*)0);
        return x;
      }

      template <typename TU>
      inline T scalar_ub_constrain(const TU ub) {
        return stan::prob::ub_constrain(scalar(),ub);
      }

      template <typename TU>
      inline T scalar_ub_constrain(const TU ub, T& lp) {
        return stan::prob::ub_constrain(scalar(),ub,lp);
      }

      template <typename TL, typename TU>
      inline T scalar_lub(const TL lb, const TU ub) {
        T x(scalar());
        stan::math::check_bounded<T,TL,TU,T>
          ("stan::io::scalar_lub(%1%)", x, lb, ub, "Constrained scalar",0);
        return x;
      }

      template <typename TL, typename TU>
      inline T scalar_lub_constrain(const TL lb, const TU ub) {
        return stan::prob::lub_constrain(scalar(),lb,ub);
      }

      template <typename TL, typename TU>
      inline T scalar_lub_constrain(TL lb, TU ub, T& lp) {
        return stan::prob::lub_constrain(scalar(),lb,ub,lp);
      }

      inline T prob() {
        T x(scalar());
        stan::math::check_bounded<T,double,double,double>
          ("stan::io::prob(%1%)", x, 0, 1, "Constrained probability", 0);
        return x;
      }

      inline T prob_constrain() {
        return stan::prob::prob_constrain(scalar());
      }

      inline T prob_constrain(T& lp) {
        return stan::prob::prob_constrain(scalar(),lp);
      }




      inline T corr() {
        T x(scalar());
        stan::math::check_bounded<T,double,double,double>
          ("stan::io::corr(%1%)", x, -1, 1, "Correlation value",0);
        return x;
      }

      inline T corr_constrain() {
        return stan::prob::corr_constrain(scalar());
      }

      inline T corr_constrain(T& lp) {
        return stan::prob::corr_constrain(scalar(),lp);
      }

      inline vector_t unit_vector(size_t k) {
        vector_t theta(vector(k));
        stan::math::check_unit_vector("stan::io::unit_vector(%1%)", theta, "Constrained vector",
                                      (double*)0);
        return theta;
      }

      inline 
      Eigen::Matrix<T,Eigen::Dynamic,1> unit_vector_constrain(size_t k) {
        return stan::prob::unit_vector_constrain(vector(k-1));
      }

      inline vector_t unit_vector_constrain(size_t k, T& lp) {
        return stan::prob::unit_vector_constrain(vector(k-1),lp);
      }

      inline vector_t simplex(size_t k) {
        vector_t theta(vector(k));
        stan::math::check_simplex("stan::io::simplex(%1%)", theta, "Constrained vector",
                                  (double*)0);
        return theta;
      }

      inline 
      Eigen::Matrix<T,Eigen::Dynamic,1> simplex_constrain(size_t k) {
        return stan::prob::simplex_constrain(vector(k-1));
      }

      inline vector_t simplex_constrain(size_t k, T& lp) {
        return stan::prob::simplex_constrain(vector(k-1),lp);
      }

      inline vector_t ordered(size_t k) {
        vector_t x(vector(k));
        stan::math::check_ordered("stan::io::ordered(%1%)", x, "Constrained vector");
        return x;
      }

      inline vector_t ordered_constrain(size_t k) {
        return stan::prob::ordered_constrain(vector(k));
      }

      inline vector_t ordered_constrain(size_t k, T& lp) {
        return stan::prob::ordered_constrain(vector(k),lp);
      }

      inline vector_t positive_ordered(size_t k) {
        vector_t x(vector(k));
        stan::math::check_positive_ordered("stan::io::positive_ordered(%1%)", 
                                           x, "Constrained vector",
                                           (double*)0);
        return x;
      }

      inline vector_t positive_ordered_constrain(size_t k) {
        return stan::prob::positive_ordered_constrain(vector(k));
      }

      inline vector_t positive_ordered_constrain(size_t k, T& lp) {
        return stan::prob::positive_ordered_constrain(vector(k),lp);
      }



      inline matrix_t cholesky_factor(size_t M, size_t N) {
        matrix_t y(matrix(M,N));
        stan::math::check_cholesky_factor("stan::io::cholesky_factor(%1%)", 
                                          y, "Constrained matrix",
                                          (double*)0);
        return y;
      }

      inline matrix_t cholesky_factor_constrain(size_t M, size_t N) {
        return stan::prob::cholesky_factor_constrain(vector((N * (N + 1)) / 2 + (M - N) * N),
                                                     M,N);
      }

      inline matrix_t cholesky_factor_constrain(size_t M, size_t N, T& lp) {
        return stan::prob::cholesky_factor_constrain(vector((N * (N + 1)) / 2 + (M - N) * N),
                                                     M,N,lp);
      }



      inline matrix_t cholesky_corr(size_t K) {
        matrix_t y(matrix(K,K));
        stan::math::check_cholesky_factor_corr("stan::io::cholesky_factor_corr(%1%)", y, "Constrained matrix");
        return y;
      }

      inline matrix_t cholesky_corr_constrain(size_t K) {
        return stan::prob::cholesky_corr_constrain(vector((K * (K - 1)) / 2),
                                                          K);
      }

      inline matrix_t cholesky_corr_constrain(size_t K, T& lp) {
        return stan::prob::cholesky_corr_constrain(vector((K * (K - 1)) / 2),
                                                   K,lp);
      }



      inline matrix_t cov_matrix(size_t k) {
        matrix_t y(matrix(k,k));
        stan::math::check_cov_matrix("stan::io::cov_matrix(%1%)", y, "Constrained matrix",
                                     (double*)0);
        return y;
      }

      inline matrix_t cov_matrix_constrain(size_t k) {
        return stan::prob::cov_matrix_constrain(vector(k + (k * (k - 1)) / 2),
                                                k);
      }

      inline matrix_t cov_matrix_constrain(size_t k, T& lp) {
        return stan::prob::cov_matrix_constrain(vector(k + (k * (k - 1)) / 2),
                                                k,lp);
      }


      inline matrix_t corr_matrix(size_t k) {
        matrix_t x(matrix(k,k));
        stan::math::check_corr_matrix("stan::math::corr_matrix(%1%)", 
                                      x, "Constrained matrix",
                                      (double*)0);
        return x;
      }

      inline matrix_t corr_matrix_constrain(size_t k) {
        return stan::prob::corr_matrix_constrain(vector((k * (k - 1)) / 2),k);
      }

      inline matrix_t corr_matrix_constrain(size_t k, T& lp) {
        return stan::prob::corr_matrix_constrain(vector((k * (k - 1)) / 2),
                                                 k,lp);
      }

      template <typename TL>
      inline vector_t vector_lb(const TL lb, size_t m) {
        vector_t v(m);
        for (size_t i = 0; i < m; ++i)
          v(i) = scalar_lb(lb);
        return v;
      }
      template <typename TL>
      inline vector_t vector_lb_constrain(const TL lb, size_t m) {
        vector_t v(m);
        for (size_t i = 0; i < m; ++i)
          v(i) = scalar_lb_constrain(lb);
        return v;
      }
      template <typename TL>
      inline vector_t vector_lb_constrain(const TL lb, size_t m, T& lp) {
        vector_t v(m);
        for (size_t i = 0; i < m; ++i)
          v(i) = scalar_lb_constrain(lb,lp);
        return v;
      }

      template <typename TL>
      inline row_vector_t row_vector_lb(const TL lb, size_t m) {
        row_vector_t v(m);
        for (size_t i = 0; i < m; ++i)
          v(i) = scalar_lb(lb);
        return v;
      }
      template <typename TL>
      inline row_vector_t row_vector_lb_constrain(const TL lb, size_t m) {
        row_vector_t v(m);
        for (size_t i = 0; i < m; ++i)
          v(i) = scalar_lb_constrain(lb);
        return v;
      }
      template <typename TL>
      inline row_vector_t row_vector_lb_constrain(const TL lb, size_t m, T& lp) {
        row_vector_t v(m);
        for (size_t i = 0; i < m; ++i)
          v(i) = scalar_lb_constrain(lb,lp);
        return v;
      }

      template <typename TL>
      inline matrix_t matrix_lb(const TL lb, size_t m, size_t n) {
        matrix_t v(m,n);
        for (size_t j  = 0; j < n; ++j)
          for (size_t i = 0; i < m; ++i)
            v(i,j) = scalar_lb(lb);
        return v;
      }
      template <typename TL>
      inline matrix_t matrix_lb_constrain(const TL lb, size_t m, size_t n) {
        matrix_t v(m,n);
        for (size_t j = 0; j < n; ++j)
          for (size_t i = 0; i < m; ++i)
            v(i,j) = scalar_lb_constrain(lb);
        return v;
      }
      template <typename TL>
      inline matrix_t matrix_lb_constrain(const TL lb, size_t m, size_t n, T& lp) {
        matrix_t v(m,n);
        for (size_t j = 0; j < n; ++j)
          for (size_t i = 0; i < m; ++i)
            v(i,j) = scalar_lb_constrain(lb,lp);
        return v;
      }

      template <typename TU>
      inline vector_t vector_ub(const TU ub, size_t m) {
        vector_t v(m);
        for (size_t i = 0; i < m; ++i)
          v(i) = scalar_ub(ub);
        return v;
      }
      template <typename TU>
      inline vector_t vector_ub_constrain(const TU ub, size_t m) {
        vector_t v(m);
        for (size_t i = 0; i < m; ++i)
          v(i) = scalar_ub_constrain(ub);
        return v;
      }
      template <typename TU>
      inline vector_t vector_ub_constrain(const TU ub, size_t m, T& lp) {
        vector_t v(m);
        for (size_t i = 0; i < m; ++i)
          v(i) = scalar_ub_constrain(ub,lp);
        return v;
      }

      template <typename TU>
      inline row_vector_t row_vector_ub(const TU ub, size_t m) {
        row_vector_t v(m);
        for (size_t i = 0; i < m; ++i)
          v(i) = scalar_ub(ub);
        return v;
      }
      template <typename TU>
      inline row_vector_t row_vector_ub_constrain(const TU ub, size_t m) {
        row_vector_t v(m);
        for (size_t i = 0; i < m; ++i)
          v(i) = scalar_ub_constrain(ub);
        return v;
      }
      template <typename TU>
      inline row_vector_t row_vector_ub_constrain(const TU ub, size_t m, T& lp) {
        row_vector_t v(m);
        for (size_t i = 0; i < m; ++i)
          v(i) = scalar_ub_constrain(ub,lp);
        return v;
      }

      template <typename TU>
      inline matrix_t matrix_ub(const TU ub, size_t m, size_t n) {
        matrix_t v(m,n);
        for (size_t j  = 0; j < n; ++j)
          for (size_t i = 0; i < m; ++i)
            v(i,j) = scalar_ub(ub);
        return v;
      }
      template <typename TU>
      inline matrix_t matrix_ub_constrain(const TU ub, size_t m, size_t n) {
        matrix_t v(m,n);
        for (size_t j = 0; j < n; ++j)
          for (size_t i = 0; i < m; ++i)
            v(i,j) = scalar_ub_constrain(ub);
        return v;
      }
      template <typename TU>
      inline matrix_t matrix_ub_constrain(const TU ub, size_t m, size_t n, T& lp) {
        matrix_t v(m,n);
        for (size_t j = 0; j < n; ++j)
          for (size_t i = 0; i < m; ++i)
            v(i,j) = scalar_ub_constrain(ub,lp);
        return v;
      }


      template <typename TL, typename TU>
      inline vector_t vector_lub(const TL lb, const TU ub, size_t m) {
        vector_t v(m);
        for (size_t i = 0; i < m; ++i)
          v(i) = scalar_lub(lb,ub);
        return v;
      }
      template <typename TL, typename TU>
      inline vector_t vector_lub_constrain(const TL lb, const TU ub, size_t m) {
        vector_t v(m);
        for (size_t i = 0; i < m; ++i)
          v(i) = scalar_lub_constrain(lb,ub);
        return v;
      }
      template <typename TL, typename TU>
      inline vector_t vector_lub_constrain(const TL lb, const TU ub, size_t m, T& lp) {
        vector_t v(m);
        for (size_t i = 0; i < m; ++i)
          v(i) = scalar_lub_constrain(lb,ub,lp);
        return v;
      }

      template <typename TL, typename TU>
      inline row_vector_t row_vector_lub(const TL lb, const TU ub, size_t m) {
        row_vector_t v(m);
        for (size_t i = 0; i < m; ++i)
          v(i) = scalar_lub(lb,ub);
        return v;
      }
      template <typename TL, typename TU>
      inline row_vector_t row_vector_lub_constrain(const TL lb, const TU ub, size_t m) {
        row_vector_t v(m);
        for (size_t i = 0; i < m; ++i)
          v(i) = scalar_lub_constrain(lb,ub);
        return v;
      }
      template <typename TL, typename TU>
      inline row_vector_t row_vector_lub_constrain(const TL lb, const TU ub, size_t m, T& lp) {
        row_vector_t v(m);
        for (size_t i = 0; i < m; ++i)
          v(i) = scalar_lub_constrain(lb,ub,lp);
        return v;
      }

      template <typename TL, typename TU>
      inline matrix_t matrix_lub(const TL lb, const TU ub, size_t m, size_t n) {
        matrix_t v(m,n);
        for (size_t j  = 0; j < n; ++j)
          for (size_t i = 0; i < m; ++i)
            v(i,j) = scalar_lub(lb,ub);
        return v;
      }
      template <typename TL, typename TU>
      inline matrix_t matrix_lub_constrain(const TL lb, const TU ub, size_t m, size_t n) {
        matrix_t v(m,n);
        for (size_t j = 0; j < n; ++j)
          for (size_t i = 0; i < m; ++i)
            v(i,j) = scalar_lub_constrain(lb,ub);
        return v;
      }
      template <typename TL, typename TU>
      inline matrix_t matrix_lub_constrain(const TL lb, const TU ub, size_t m, size_t n, T& lp) {
        matrix_t v(m,n);
        for (size_t j = 0; j < n; ++j)
          for (size_t i = 0; i < m; ++i)
            v(i,j) = scalar_lub_constrain(lb,ub,lp);
        return v;
      }



    };

  }

}

#endif