writer.hpp

Go to the documentation of this file.

#ifndef STAN__IO__WRITER_HPP
#define STAN__IO__WRITER_HPP

#include <stdexcept>

#include <stan/math/matrix/meta/index_type.hpp>
#include <stan/math/meta/index_type.hpp>
#include <stan/prob/transform.hpp>


namespace stan {

  namespace io {

    template <typename T>
    class writer {
    private:
      std::vector<T> data_r_;
      std::vector<int> data_i_;
    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::Array<T,Eigen::Dynamic,1> array_vec_t;

      const double CONSTRAINT_TOLERANCE;

      writer(std::vector<T>& data_r,
             std::vector<int>& data_i)
        : data_r_(data_r),
          data_i_(data_i),
          CONSTRAINT_TOLERANCE(1E-8) {
        data_r_.clear();
        data_i_.clear();
      }

      ~writer() { }

      std::vector<T>& data_r() {
        return data_r_;
      }


      std::vector<int>& data_i() {
        return data_i_;
      }

      void integer(int n) {
        data_i_.push_back(n);
      }

      void scalar_unconstrain(T& y) {
        data_r_.push_back(y);
      }

      void scalar_pos_unconstrain(T& y) {
        if (y < 0.0)
          BOOST_THROW_EXCEPTION(std::runtime_error ("y is negative"));
        data_r_.push_back(log(y));
      }

      void scalar_lb_unconstrain(double lb, T& y) {
        data_r_.push_back(stan::prob::lb_free(y,lb));
      }

      void scalar_ub_unconstrain(double ub, T& y) {
        data_r_.push_back(stan::prob::ub_free(y,ub));
      }

      void scalar_lub_unconstrain(double lb, double ub, T& y) {
        data_r_.push_back(stan::prob::lub_free(y,lb,ub));
      }

      void corr_unconstrain(T& y) {
        data_r_.push_back(stan::prob::corr_free(y));
      }

      void prob_unconstrain(T& y) {
        data_r_.push_back(stan::prob::prob_free(y));
      }

      void ordered_unconstrain(vector_t& y) {
        typedef typename stan::math::index_type<vector_t>::type idx_t;
        if (y.size() == 0) return;
        stan::math::check_ordered("stan::io::ordered_unconstrain(%1%)",
                                  y, "Vector");
        data_r_.push_back(y[0]);
        for (idx_t i = 1; i < y.size(); ++i) {
          data_r_.push_back(log(y[i] - y[i-1]));
        }
      }

      void positive_ordered_unconstrain(vector_t& y) {
        typedef typename stan::math::index_type<vector_t>::type idx_t;

        // reimplements pos_ordered_free in prob to avoid malloc
        if (y.size() == 0) return;
        stan::math::check_positive_ordered("stan::io::positive_ordered_unconstrain(%1%)", 
                                           y, "Vector", (double*)0);
        data_r_.push_back(log(y[0]));
        for (idx_t i = 1; i < y.size(); ++i) {
          data_r_.push_back(log(y[i] - y[i-1]));
        }
      }


      void vector_unconstrain(const vector_t& y) {
        typedef typename stan::math::index_type<vector_t>::type idx_t;
        for (idx_t i = 0; i < y.size(); ++i)
          data_r_.push_back(y[i]);
      }

      void row_vector_unconstrain(const vector_t& y) {
        typedef typename stan::math::index_type<vector_t>::type idx_t;
        for (idx_t i = 0; i < y.size(); ++i)
          data_r_.push_back(y[i]);
      }

      void matrix_unconstrain(const matrix_t& y) {
        typedef typename stan::math::index_type<matrix_t>::type idx_t;
        for (idx_t j = 0; j < y.cols(); ++j) 
          for (idx_t i = 0; i < y.rows(); ++i)
            data_r_.push_back(y(i,j));
      }

      void vector_lb_unconstrain(double lb, vector_t& y) {
        typedef typename stan::math::index_type<vector_t>::type idx_t;
        for (idx_t i = 0; i < y.size(); ++i)
          scalar_lb_unconstrain(lb,y(i));
      }
      void row_vector_lb_unconstrain(double lb, row_vector_t& y) {
        typedef typename stan::math::index_type<row_vector_t>::type idx_t;
        for (idx_t i = 0; i < y.size(); ++i)
          scalar_lb_unconstrain(lb,y(i));
      }
      void matrix_lb_unconstrain(double lb, matrix_t& y) {
        typedef typename stan::math::index_type<matrix_t>::type idx_t;
        for (idx_t j = 0; j < y.cols(); ++j) 
          for (idx_t i = 0; i < y.rows(); ++i)
            scalar_lb_unconstrain(lb,y(i,j));
      }

      void vector_ub_unconstrain(double ub, vector_t& y) {
        typedef typename stan::math::index_type<vector_t>::type idx_t;
        for (idx_t i = 0; i < y.size(); ++i)
          scalar_ub_unconstrain(ub,y(i));
      }
      void row_vector_ub_unconstrain(double ub, row_vector_t& y) {
        typedef typename stan::math::index_type<row_vector_t>::type idx_t;
        for (idx_t i = 0; i < y.size(); ++i)
          scalar_ub_unconstrain(ub,y(i));
      }
      void matrix_ub_unconstrain(double ub, matrix_t& y) {
        typedef typename stan::math::index_type<matrix_t>::type idx_t;
        for (idx_t j = 0; j < y.cols(); ++j) 
          for (idx_t i = 0; i < y.rows(); ++i)
            scalar_ub_unconstrain(ub,y(i,j));
      }


      void vector_lub_unconstrain(double lb, double ub, vector_t& y) {
        typedef typename stan::math::index_type<vector_t>::type idx_t;
        for (idx_t i = 0; i < y.size(); ++i)
          scalar_lub_unconstrain(lb,ub,y(i));
      }
      void row_vector_lub_unconstrain(double lb, double ub, row_vector_t& y) {
        typedef typename stan::math::index_type<row_vector_t>::type idx_t;
        for (idx_t i = 0; i < y.size(); ++i)
          scalar_lub_unconstrain(lb,ub,y(i));
      }
      void matrix_lub_unconstrain(double lb, double ub, matrix_t& y) {
        typedef typename stan::math::index_type<matrix_t>::type idx_t;
        for (idx_t j = 0; j < y.cols(); ++j) 
          for (idx_t i = 0; i < y.rows(); ++i)
            scalar_lub_unconstrain(lb,ub,y(i,j));
      }

      

      void unit_vector_unconstrain(vector_t& y) {
        stan::math::check_unit_vector("stan::io::unit_vector_unconstrain(%1%)", 
                                      y, "Vector", (double*)0);
        typedef typename stan::math::index_type<vector_t>::type idx_t;
        vector_t uy = stan::prob::unit_vector_free(y);
        for (idx_t i = 0; i < uy.size(); ++i) 
          data_r_.push_back(uy[i]);
      }
 

      void simplex_unconstrain(vector_t& y) {
        typedef typename stan::math::index_type<vector_t>::type idx_t;

        stan::math::check_simplex("stan::io::simplex_unconstrain(%1%)", 
                                  y, "Vector",
                                  (double*)0);
        vector_t uy = stan::prob::simplex_free(y);
        for (idx_t i = 0; i < uy.size(); ++i) 
          data_r_.push_back(uy[i]);
      }

      void cholesky_factor_unconstrain(matrix_t& y) {
        typedef typename stan::math::index_type<matrix_t>::type idx_t;

        // FIXME:  optimize by unrolling cholesky_factor_free
        Eigen::Matrix<T,Eigen::Dynamic,1> y_free
          = stan::prob::cholesky_factor_free(y);
        for (idx_t i = 0; i < y_free.size(); ++i)
          data_r_.push_back(y_free[i]);
      }


      void cholesky_corr_unconstrain(matrix_t& y) {
        typedef typename stan::math::index_type<matrix_t>::type idx_t;

        // FIXME:  optimize by unrolling cholesky_factor_free
        Eigen::Matrix<T,Eigen::Dynamic,1> y_free
          = stan::prob::cholesky_corr_free(y);
        for (idx_t i = 0; i < y_free.size(); ++i)
          data_r_.push_back(y_free[i]);
      }


      void cov_matrix_unconstrain(matrix_t& y) {
        typedef typename stan::math::index_type<matrix_t>::type idx_t;
        idx_t k = y.rows();
        if (k == 0 || y.cols() != k)
          BOOST_THROW_EXCEPTION(
              std::runtime_error("y must have elements and"
                                 " y must be a square matrix"));
        idx_t k_choose_2 = (k * (k-1)) / 2;
        array_vec_t cpcs(k_choose_2);
        array_vec_t sds(k);
        bool successful = stan::prob::factor_cov_matrix(y,cpcs,sds);
        if (!successful)
          BOOST_THROW_EXCEPTION(
              std::runtime_error ("factor_cov_matrix failed"));
        for (idx_t i = 0; i < k_choose_2; ++i)
          data_r_.push_back(cpcs[i]);
        for (idx_t i = 0; i < k; ++i)
          data_r_.push_back(sds[i]);
      }

      void corr_matrix_unconstrain(matrix_t& y) {
        typedef typename stan::math::index_type<matrix_t>::type idx_t;

        stan::math::check_corr_matrix("stan::io::corr_matrix_unconstrain(%1%)", 
                                      y, "Matrix",
                                      (double*)0);
        idx_t k = y.rows();
        idx_t k_choose_2 = (k * (k-1)) / 2;
        array_vec_t cpcs(k_choose_2);
        array_vec_t sds(k);
        bool successful = stan::prob::factor_cov_matrix(y,cpcs,sds);
        if (!successful)
          BOOST_THROW_EXCEPTION(
            std::runtime_error ("y cannot be factorized by factor_cov_matrix"));
        for (idx_t i = 0; i < k; ++i) {
          // sds on log scale unconstrained
          if (fabs(sds[i] - 0.0) >= CONSTRAINT_TOLERANCE)
            BOOST_THROW_EXCEPTION(
              std::runtime_error ("sds on log scale are unconstrained"));
        }
        for (idx_t i = 0; i < k_choose_2; ++i)
          data_r_.push_back(cpcs[i]);
      }

    };
  }

}

#endif