// Code generated by Stan version 2.1

#include <stan/model/model_header.hpp>

namespace model3cb591dbe6b_8schools_namespace {

using std::vector;
using std::string;
using std::stringstream;
using stan::model::prob_grad;
using stan::math::get_base1;
using stan::math::initialize;
using stan::math::stan_print;
using stan::math::lgamma;
using stan::io::dump;
using std::istream;
using namespace stan::math;
using namespace stan::prob;

typedef Eigen::Matrix<double,Eigen::Dynamic,1> vector_d;
typedef Eigen::Matrix<double,1,Eigen::Dynamic> row_vector_d;
typedef Eigen::Matrix<double,Eigen::Dynamic,Eigen::Dynamic> matrix_d;

class model3cb591dbe6b_8schools : public prob_grad {
private:
    int J;
    vector<double> y;
    vector<double> sigma;
public:
    model3cb591dbe6b_8schools(stan::io::var_context& context__,
        std::ostream* pstream__ = 0)
        : prob_grad::prob_grad(0) {
        static const char* function__ = \"model3cb591dbe6b_8schools_namespace::model3cb591dbe6b_8schools(%1%)\";
        (void) function__; // dummy call to supress warning
        size_t pos__;
        (void) pos__; // dummy call to supress warning
        std::vector<int> vals_i__;
        std::vector<double> vals_r__;
        context__.validate_dims(\"data initialization\", \"J\", \"int\", context__.to_vec());
        J = int(0);
        vals_i__ = context__.vals_i(\"J\");
        pos__ = 0;
        J = vals_i__[pos__++];
        context__.validate_dims(\"data initialization\", \"y\", \"double\", context__.to_vec(J));
        stan::math::validate_non_negative_index(\"y\", \"J\", J);
        y = std::vector<double>(J,double(0));
        vals_r__ = context__.vals_r(\"y\");
        pos__ = 0;
        size_t y_limit_0__ = J;
        for (size_t i_0__ = 0; i_0__ < y_limit_0__; ++i_0__) {
            y[i_0__] = vals_r__[pos__++];
        }
        context__.validate_dims(\"data initialization\", \"sigma\", \"double\", context__.to_vec(J));
        stan::math::validate_non_negative_index(\"sigma\", \"J\", J);
        sigma = std::vector<double>(J,double(0));
        vals_r__ = context__.vals_r(\"sigma\");
        pos__ = 0;
        size_t sigma_limit_0__ = J;
        for (size_t i_0__ = 0; i_0__ < sigma_limit_0__; ++i_0__) {
            sigma[i_0__] = vals_r__[pos__++];
        }

        // validate data
        try { 
            check_greater_or_equal(function__,J,0,\"J\");
        } catch (std::domain_error& e) { 
            throw std::domain_error(std::string(\"Invalid value of J: \") + std::string(e.what()));
        };
        for (int k0__ = 0; k0__ < J; ++k0__) {
            try { 
                check_greater_or_equal(function__,sigma[k0__],0,\"sigma[k0__]\");
            } catch (std::domain_error& e) { 
                throw std::domain_error(std::string(\"Invalid value of sigma: \") + std::string(e.what()));
            };
        }


        // validate transformed data

        // set parameter ranges
        num_params_r__ = 0U;
        param_ranges_i__.clear();
        ++num_params_r__;
        ++num_params_r__;
        num_params_r__ += J;
    }

    ~model3cb591dbe6b_8schools() { }


    void transform_inits(const stan::io::var_context& context__,
                         std::vector<int>& params_i__,
                         std::vector<double>& params_r__) const {
        stan::io::writer<double> writer__(params_r__,params_i__);
        size_t pos__;
        (void) pos__; // dummy call to supress warning
        std::vector<double> vals_r__;
        std::vector<int> vals_i__;


        if (!(context__.contains_r(\"mu\")))
            throw std::runtime_error(\"variable mu missing\");
        vals_r__ = context__.vals_r(\"mu\");
        pos__ = 0U;
        context__.validate_dims(\"initialization\", \"mu\", \"double\", context__.to_vec());
        double mu(0);
        mu = vals_r__[pos__++];
        try { writer__.scalar_unconstrain(mu); } catch (std::exception& e) {  throw std::runtime_error(std::string(\"Error transforming variable mu: \") + e.what()); }

        if (!(context__.contains_r(\"tau\")))
            throw std::runtime_error(\"variable tau missing\");
        vals_r__ = context__.vals_r(\"tau\");
        pos__ = 0U;
        context__.validate_dims(\"initialization\", \"tau\", \"double\", context__.to_vec());
        double tau(0);
        tau = vals_r__[pos__++];
        try { writer__.scalar_lb_unconstrain(0,tau); } catch (std::exception& e) {  throw std::runtime_error(std::string(\"Error transforming variable tau: \") + e.what()); }

        if (!(context__.contains_r(\"eta\")))
            throw std::runtime_error(\"variable eta missing\");
        vals_r__ = context__.vals_r(\"eta\");
        pos__ = 0U;
        context__.validate_dims(\"initialization\", \"eta\", \"vector_d\", context__.to_vec(J));
        vector_d eta(J);
        for (int j1__ = 0U; j1__ < J; ++j1__)
            eta(j1__) = vals_r__[pos__++];
        try { writer__.vector_unconstrain(eta); } catch (std::exception& e) {  throw std::runtime_error(std::string(\"Error transforming variable eta: \") + e.what()); }
        params_r__ = writer__.data_r();
        params_i__ = writer__.data_i();
    }

    void transform_inits(const stan::io::var_context& context,
                         Eigen::Matrix<double,Eigen::Dynamic,1>& params_r) const {
      std::vector<double> params_r_vec;
      std::vector<int> params_i_vec;
      transform_inits(context, params_i_vec, params_r_vec);
      params_r.resize(params_r_vec.size());
      for (int i = 0; i < params_r.size(); ++i)
        params_r(i) = params_r_vec[i];
    }


    template <bool propto__, bool jacobian__, typename T__>
    T__ log_prob(vector<T__>& params_r__,
                 vector<int>& params_i__,
                 std::ostream* pstream__ = 0) const {

        T__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
        (void) DUMMY_VAR__;  // suppress unused var warning

        T__ lp__(0.0);
        stan::math::accumulator<T__> lp_accum__;

        // model parameters
        stan::io::reader<T__> in__(params_r__,params_i__);

        T__ mu;
        (void) mu;   // dummy to suppress unused var warning
        if (jacobian__)
            mu = in__.scalar_constrain(lp__);
        else
            mu = in__.scalar_constrain();

        T__ tau;
        (void) tau;   // dummy to suppress unused var warning
        if (jacobian__)
            tau = in__.scalar_lb_constrain(0,lp__);
        else
            tau = in__.scalar_lb_constrain(0);

        Eigen::Matrix<T__,Eigen::Dynamic,1>  eta;
        (void) eta;   // dummy to suppress unused var warning
        if (jacobian__)
            eta = in__.vector_constrain(J,lp__);
        else
            eta = in__.vector_constrain(J);


        // transformed parameters
        Eigen::Matrix<T__,Eigen::Dynamic,1>  theta(J);
        (void) theta;   // dummy to suppress unused var warning
        stan::math::fill(theta,DUMMY_VAR__);

        // initialized transformed params to avoid seg fault on val access
                stan::math::fill(theta,DUMMY_VAR__);

        stan::math::assign(theta, add(mu,multiply(tau,eta)));

        // validate transformed parameters
        for (int i0__ = 0; i0__ < J; ++i0__) {
            if (stan::math::is_uninitialized(theta(i0__))) {
                std::stringstream msg__;
                msg__ << \"Undefined transformed parameter: theta\" << '[' << i0__ << ']';
                throw std::runtime_error(msg__.str());
            }
        }

        const char* function__ = \"validate transformed params %1%\";
        (void) function__; // dummy to suppress unused var warning
        // model body
        lp_accum__.add(normal_log<propto__>(eta, 0, 1));
        lp_accum__.add(normal_log<propto__>(y, theta, sigma));

        lp_accum__.add(lp__);
        return lp_accum__.sum();

    } // log_prob()

    template <bool propto, bool jacobian, typename T>
    T log_prob(Eigen::Matrix<T,Eigen::Dynamic,1>& params_r,
               std::ostream* pstream = 0) const {
      std::vector<T> vec_params_r;
      vec_params_r.reserve(params_r.size());
      for (int i = 0; i < params_r.size(); ++i)
        vec_params_r.push_back(params_r(i));
      std::vector<int> vec_params_i;
      return log_prob<propto,jacobian,T>(vec_params_r, vec_params_i, pstream);
    }


    void get_param_names(std::vector<std::string>& names__) const {
        names__.resize(0);
        names__.push_back(\"mu\");
        names__.push_back(\"tau\");
        names__.push_back(\"eta\");
        names__.push_back(\"theta\");
    }


    void get_dims(std::vector<std::vector<size_t> >& dimss__) const {
        dimss__.resize(0);
        std::vector<size_t> dims__;
        dims__.resize(0);
        dimss__.push_back(dims__);
        dims__.resize(0);
        dimss__.push_back(dims__);
        dims__.resize(0);
        dims__.push_back(J);
        dimss__.push_back(dims__);
        dims__.resize(0);
        dims__.push_back(J);
        dimss__.push_back(dims__);
    }

    template <typename RNG>
    void write_array(RNG& base_rng__,
                     std::vector<double>& params_r__,
                     std::vector<int>& params_i__,
                     std::vector<double>& vars__,
                     bool include_tparams__ = true,
                     bool include_gqs__ = true,
                     std::ostream* pstream__ = 0) const {
        vars__.resize(0);
        stan::io::reader<double> in__(params_r__,params_i__);
        static const char* function__ = \"model3cb591dbe6b_8schools_namespace::write_array(%1%)\";
        (void) function__; // dummy call to supress warning
        // read-transform, write parameters
        double mu = in__.scalar_constrain();
        double tau = in__.scalar_lb_constrain(0);
        vector_d eta = in__.vector_constrain(J);
        vars__.push_back(mu);
        vars__.push_back(tau);
        for (int k_0__ = 0; k_0__ < J; ++k_0__) {
            vars__.push_back(eta[k_0__]);
        }

        if (!include_tparams__) return;
        // declare and define transformed parameters
        double lp__ = 0.0;
        (void) lp__; // dummy call to supress warning
        stan::math::accumulator<double> lp_accum__;

        vector_d theta(J);
        (void) theta;   // dummy to suppress unused var warning

        stan::math::assign(theta, add(mu,multiply(tau,eta)));

        // validate transformed parameters

        // write transformed parameters
        for (int k_0__ = 0; k_0__ < J; ++k_0__) {
            vars__.push_back(theta[k_0__]);
        }

        if (!include_gqs__) return;
        // declare and define generated quantities


        // validate generated quantities

        // write generated quantities
    }

    template <typename RNG>
    void write_array(RNG& base_rng,
                     Eigen::Matrix<double,Eigen::Dynamic,1>& params_r,
                     Eigen::Matrix<double,Eigen::Dynamic,1>& vars,
                     bool include_tparams = true,
                     bool include_gqs = true,
                     std::ostream* pstream = 0) const {
      std::vector<double> params_r_vec(params_r.size());
      for (int i = 0; i < params_r.size(); ++i)
        params_r_vec[i] = params_r(i);
      std::vector<double> vars_vec;
      std::vector<int> params_i_vec;
      write_array(base_rng,params_r_vec,params_i_vec,vars_vec,include_tparams,include_gqs,pstream);
      vars.resize(vars_vec.size());
      for (int i = 0; i < vars.size(); ++i)
        vars(i) = vars_vec[i];
    }


    void write_csv_header(std::ostream& o__) const {
        stan::io::csv_writer writer__(o__);
        writer__.comma();
        o__ << \"mu\";
        writer__.comma();
        o__ << \"tau\";
        for (int k_0__ = 1; k_0__ <= J; ++k_0__) {
            writer__.comma();
            o__ << \"eta\" << '.' << k_0__;
        }
        for (int k_0__ = 1; k_0__ <= J; ++k_0__) {
            writer__.comma();
            o__ << \"theta\" << '.' << k_0__;
        }
        writer__.newline();
    }

    template <typename RNG>
    void write_csv(RNG& base_rng__,
                   std::vector<double>& params_r__,
                   std::vector<int>& params_i__,
                   std::ostream& o__,
                   std::ostream* pstream__ = 0) const {
        stan::io::reader<double> in__(params_r__,params_i__);
        stan::io::csv_writer writer__(o__);
        static const char* function__ = \"model3cb591dbe6b_8schools_namespace::write_csv(%1%)\";
        (void) function__; // dummy call to supress warning
        // read-transform, write parameters
        double mu = in__.scalar_constrain();
        writer__.write(mu);
        double tau = in__.scalar_lb_constrain(0);
        writer__.write(tau);
        vector_d eta = in__.vector_constrain(J);
        writer__.write(eta);

        // declare, define and validate transformed parameters
        double lp__ = 0.0;
        (void) lp__; // dummy call to supress warning
        stan::math::accumulator<double> lp_accum__;

        vector_d theta(J);
        (void) theta;   // dummy to suppress unused var warning

        stan::math::assign(theta, add(mu,multiply(tau,eta)));


        // write transformed parameters
        writer__.write(theta);

        // declare and define generated quantities


        // validate generated quantities

        // write generated quantities
        writer__.newline();
    }

    template <typename RNG>
    void write_csv(RNG& base_rng,
                   Eigen::Matrix<double,Eigen::Dynamic,1>& params_r,
                   std::ostream& o,
                   std::ostream* pstream = 0) const {
      std::vector<double> params_r_vec(params_r.size());
      for (int i = 0; i < params_r.size(); ++i)
        params_r_vec[i] = params_r(i);
      std::vector<int> params_i_vec;  // dummy
      write_csv(base_rng, params_r_vec, params_i_vec, o, pstream);
    }

    static std::string model_name() {
        return \"model3cb591dbe6b_8schools\";
    }


    void constrained_param_names(std::vector<std::string>& param_names__,
                                 bool include_tparams__ = true,
                                 bool include_gqs__ = true) const {
        std::stringstream param_name_stream__;
        param_name_stream__.str(std::string());
        param_name_stream__ << \"mu\";
        param_names__.push_back(param_name_stream__.str());
        param_name_stream__.str(std::string());
        param_name_stream__ << \"tau\";
        param_names__.push_back(param_name_stream__.str());
        for (int k_0__ = 1; k_0__ <= J; ++k_0__) {
            param_name_stream__.str(std::string());
            param_name_stream__ << \"eta\" << '.' << k_0__;
            param_names__.push_back(param_name_stream__.str());
        }

        if (!include_gqs__ && !include_tparams__) return;
        for (int k_0__ = 1; k_0__ <= J; ++k_0__) {
            param_name_stream__.str(std::string());
            param_name_stream__ << \"theta\" << '.' << k_0__;
            param_names__.push_back(param_name_stream__.str());
        }

        if (!include_gqs__) return;
    }


    void unconstrained_param_names(std::vector<std::string>& param_names__,
                                   bool include_tparams__ = true,
                                   bool include_gqs__ = true) const {
        std::stringstream param_name_stream__;
        param_name_stream__.str(std::string());
        param_name_stream__ << \"mu\";
        param_names__.push_back(param_name_stream__.str());
        param_name_stream__.str(std::string());
        param_name_stream__ << \"tau\";
        param_names__.push_back(param_name_stream__.str());
        for (int k_0__ = 1; k_0__ <= J; ++k_0__) {
            param_name_stream__.str(std::string());
            param_name_stream__ << \"eta\" << '.' << k_0__;
            param_names__.push_back(param_name_stream__.str());
        }

        if (!include_gqs__ && !include_tparams__) return;
        for (int k_0__ = 1; k_0__ <= J; ++k_0__) {
            param_name_stream__.str(std::string());
            param_name_stream__ << \"theta\" << '.' << k_0__;
            param_names__.push_back(param_name_stream__.str());
        }

        if (!include_gqs__) return;
    }

}; // model

} // namespace