Skip to content

Instantly share code, notes, and snippets.

@SteveBronder

SteveBronder/sparse_ex.hpp

Created April 25, 2020 15:42
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save SteveBronder/2d932b35258668305784a33fe17196c9 to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save SteveBronder/2d932b35258668305784a33fe17196c9 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
sparse_ex.hpp
// Code generated by %%NAME%% %%VERSION%%
#include <stan/model/model_header.hpp>
namespace sparse_model_namespace {
template <typename T, typename S>
std::vector<T> resize_to_match__(std::vector<T> &dst,
const std::vector<S> &src) {
dst.resize(src.size());
return dst;
}
template <typename T>
Eigen::Matrix<T, -1, -1>
resize_to_match__(Eigen::Matrix<T, -1, -1> &dst,
const Eigen::Matrix<T, -1, -1> &src) {
dst.resize(src.rows(), src.cols());
return dst;
}
template <typename T>
Eigen::Matrix<T, 1, -1> resize_to_match__(Eigen::Matrix<T, 1, -1> &dst,
const Eigen::Matrix<T, 1, -1> &src) {
dst.resize(src.size());
return dst;
}
template <typename T>
Eigen::Matrix<T, -1, 1> resize_to_match__(Eigen::Matrix<T, -1, 1> &dst,
const Eigen::Matrix<T, -1, 1> &src) {
dst.resize(src.size());
return dst;
}
std::vector<double> to_doubles__(std::initializer_list<double> x) { return x; }
std::vector<stan::math::var>
to_vars__(std::initializer_list<stan::math::var> x) {
return x;
}
inline void validate_positive_index(const char *var_name, const char *expr,
int val) {
if (val < 1) {
std::stringstream msg;
msg << "Found dimension size less than one in simplex declaration"
<< "; variable=" << var_name << "; dimension size expression=" << expr
<< "; expression value=" << val;
std::string msg_str(msg.str());
throw std::invalid_argument(msg_str.c_str());
}
}
inline void validate_unit_vector_index(const char *var_name, const char *expr,
int val) {
if (val <= 1) {
std::stringstream msg;
if (val == 1) {
msg << "Found dimension size one in unit vector declaration."
<< " One-dimensional unit vector is discrete"
<< " but the target distribution must be continuous."
<< " variable=" << var_name << "; dimension size expression=" << expr;
} else {
msg << "Found dimension size less than one in unit vector declaration"
<< "; variable=" << var_name << "; dimension size expression=" << expr
<< "; expression value=" << val;
}
std::string msg_str(msg.str());
throw std::invalid_argument(msg_str.c_str());
}
}
using stan::io::dump;
using stan::math::lgamma;
using stan::model::cons_list;
using stan::model::index_max;
using stan::model::index_min;
using stan::model::index_min_max;
using stan::model::index_multi;
using stan::model::index_omni;
using stan::model::index_uni;
using stan::model::model_base_crtp;
using stan::model::nil_index_list;
using stan::model::rvalue;
using std::istream;
using std::pow;
using std::string;
using std::stringstream;
using std::vector;
using namespace stan::math;
static int current_statement__ = 0;
static const std::vector<string> locations_array__ = {
" (found before start of program)",
" (in './examples/sparse/sparse.stan', line 20, column 2 to column 43)",
" (in './examples/sparse/sparse.stan', line 24, column 2 to column 40)",
" (in './examples/sparse/sparse.stan', line 25, column 2 to column 29)",
" (in './examples/sparse/sparse.stan', line 26, column 2 to column 14)",
" (in './examples/sparse/sparse.stan', line 27, column 2 to column 22)",
" (in './examples/sparse/sparse.stan', line 37, column 2 to column 43)",
" (in './examples/sparse/sparse.stan', line 32, column 2 to column 19)",
" (in './examples/sparse/sparse.stan', line 33, column 2 to column 28)",
" (in './examples/sparse/sparse.stan', line 2, column 2 to column 8)",
" (in './examples/sparse/sparse.stan', line 3, column 2 to column 8)",
" (in './examples/sparse/sparse.stan', line 4, column 2 to column 14)",
" (in './examples/sparse/sparse.stan', line 5, column 2 to column 23)",
" (in './examples/sparse/sparse.stan', line 6, column 2 to column 23)",
" (in './examples/sparse/sparse.stan', line 7, column 2 to column 42)",
" (in './examples/sparse/sparse.stan', line 8, column 2 to column 14)",
" (in './examples/sparse/sparse.stan', line 12, column 2 to column 44)",
" (in './examples/sparse/sparse.stan', line 14, column 2 to column 28)"};
class sparse_model : public model_base_crtp<sparse_model> {
private:
int pos__;
int N;
int M;
int nz_vals;
std::vector<int> nz_rows;
std::vector<int> nz_cols;
Eigen::SparseMatrix<double> x;
Eigen::Matrix<double, -1, 1> y;
Eigen::SparseMatrix<double> xx;
double data_cool;
public:
~sparse_model() {}
std::string model_name() const { return "sparse_model"; }
sparse_model(stan::io::var_context &context__, unsigned int random_seed__ = 0,
std::ostream *pstream__ = nullptr)
: model_base_crtp(0) {
typedef double local_scalar_t__;
boost::ecuyer1988 base_rng__ =
stan::services::util::create_rng(random_seed__, 0);
(void)base_rng__; // suppress unused var warning
static const char *function__ = "sparse_model_namespace::sparse_model";
(void)function__; // suppress unused var warning
try {
pos__ = 1;
current_statement__ = 9;
N = context__.vals_i("N")[(1 - 1)];
current_statement__ = 10;
M = context__.vals_i("M")[(1 - 1)];
current_statement__ = 11;
nz_vals = context__.vals_i("nz_vals")[(1 - 1)];
current_statement__ = 12;
validate_non_negative_index("nz_rows", "nz_vals", nz_vals);
context__.validate_dims("data initialization", "nz_rows", "int",
context__.to_vec(nz_vals));
nz_rows = std::vector<int>(nz_vals, 0);
current_statement__ = 12;
assign(nz_rows, nil_index_list(), context__.vals_i("nz_rows"),
"assigning variable nz_rows");
current_statement__ = 13;
validate_non_negative_index("nz_cols", "nz_vals", nz_vals);
context__.validate_dims("data initialization", "nz_cols", "int",
context__.to_vec(nz_vals));
nz_cols = std::vector<int>(nz_vals, 0);
current_statement__ = 13;
assign(nz_cols, nil_index_list(), context__.vals_i("nz_cols"),
"assigning variable nz_cols");
current_statement__ = 14;
validate_non_negative_index("x", "N", N);
current_statement__ = 14;
validate_non_negative_index("x", "M", M);
context__.validate_dims("data initialization", "x", "double",
context__.to_vec(stan::math::size(nz_rows)));
x = Eigen::SparseMatrix<double>(N, M);
{
std::vector<local_scalar_t__> x_flat__;
current_statement__ = 14;
assign(x_flat__, nil_index_list(), context__.vals_r("x"),
"assigning variable x_flat__");
current_statement__ = 14;
pos__ = 1;
current_statement__ = 14;
for (size_t sym1__ = 1; sym1__ <= stan::math::size(nz_rows); ++sym1__) {
current_statement__ = 14;
assign(x,
cons_list(index_uni(nz_cols[(sym1__ - 1)]),
cons_list(index_uni(nz_rows[(sym1__ - 1)]),
nil_index_list())),
x_flat__[(pos__ - 1)], "assigning variable x");
current_statement__ = 14;
pos__ = (pos__ + 1);
}
}
current_statement__ = 15;
validate_non_negative_index("y", "M", M);
context__.validate_dims("data initialization", "y", "double",
context__.to_vec(M));
y = Eigen::Matrix<double, -1, 1>(M);
{
std::vector<local_scalar_t__> y_flat__;
current_statement__ = 15;
assign(y_flat__, nil_index_list(), context__.vals_r("y"),
"assigning variable y_flat__");
current_statement__ = 15;
pos__ = 1;
current_statement__ = 15;
for (size_t sym1__ = 1; sym1__ <= M; ++sym1__) {
current_statement__ = 15;
assign(y, cons_list(index_uni(sym1__), nil_index_list()),
y_flat__[(pos__ - 1)], "assigning variable y");
current_statement__ = 15;
pos__ = (pos__ + 1);
}
}
current_statement__ = 16;
validate_non_negative_index("xx", "N", N);
current_statement__ = 16;
validate_non_negative_index("xx", "M", M);
xx = Eigen::SparseMatrix<double>(N, M);
current_statement__ = 16;
assign(xx, nil_index_list(), multiply(x, transpose(x)),
"assigning variable xx");
current_statement__ = 17;
data_cool = std::numeric_limits<double>::quiet_NaN();
current_statement__ = 17;
data_cool = rvalue(
xx,
cons_list(index_uni(1), cons_list(index_uni(1), nil_index_list())),
"xx");
} catch (const std::exception &e) {
stan::lang::rethrow_located(e, locations_array__[current_statement__]);
// Next line prevents compiler griping about no return
throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***");
}
num_params_r__ = 0U;
try {
current_statement__ = 1;
validate_non_negative_index("VV", "N", N);
current_statement__ = 1;
validate_non_negative_index("VV", "M", M);
num_params_r__ += stan::math::size(nz_rows);
} catch (const std::exception &e) {
stan::lang::rethrow_located(e, locations_array__[current_statement__]);
// Next line prevents compiler griping about no return
throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***");
}
}
template <bool propto__, bool jacobian__, typename T__>
T__ log_prob(std::vector<T__> &params_r__, std::vector<int> &params_i__,
std::ostream *pstream__ = 0) const {
typedef T__ local_scalar_t__;
T__ lp__(0.0);
stan::math::accumulator<T__> lp_accum__;
static const char *function__ = "sparse_model_namespace::log_prob";
(void)function__; // suppress unused var warning
stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
try {
current_statement__ = 1;
validate_non_negative_index("VV", "N", N);
current_statement__ = 1;
validate_non_negative_index("VV", "M", M);
Eigen::SparseMatrix<local_scalar_t__> VV;
VV = Eigen::SparseMatrix<local_scalar_t__>(N, M);
current_statement__ = 1;
VV = in__.sparse_matrix(nz_rows, nz_cols, N, M);
current_statement__ = 2;
validate_non_negative_index("ZZ", "N", N);
current_statement__ = 2;
validate_non_negative_index("ZZ", "M", M);
Eigen::SparseMatrix<local_scalar_t__> ZZ;
ZZ = Eigen::SparseMatrix<local_scalar_t__>(N, M);
current_statement__ = 2;
assign(ZZ, nil_index_list(), multiply(VV, nz_vals),
"assigning variable ZZ");
local_scalar_t__ param_cool;
current_statement__ = 3;
param_cool = std::numeric_limits<double>::quiet_NaN();
current_statement__ = 3;
param_cool = rvalue(
ZZ,
cons_list(index_uni(1), cons_list(index_uni(1), nil_index_list())),
"ZZ");
current_statement__ = 4;
validate_non_negative_index("A", "M", M);
Eigen::Matrix<local_scalar_t__, -1, 1> A;
A = Eigen::Matrix<local_scalar_t__, -1, 1>(M);
current_statement__ = 4;
for (size_t sym1__ = 1; sym1__ <= M; ++sym1__) {
current_statement__ = 4;
assign(A, cons_list(index_uni(sym1__), nil_index_list()),
std::numeric_limits<double>::quiet_NaN(),
"assigning variable A");
}
local_scalar_t__ sigma;
current_statement__ = 5;
sigma = std::numeric_limits<double>::quiet_NaN();
current_statement__ = 5;
current_statement__ = 5;
check_greater_or_equal(function__, "sigma", sigma, 0);
{
current_statement__ = 7;
lp_accum__.add(normal_log<propto__>(A, 0, 1));
current_statement__ = 8;
lp_accum__.add(normal_log<propto__>(y, multiply(xx, A), sigma));
}
} catch (const std::exception &e) {
stan::lang::rethrow_located(e, locations_array__[current_statement__]);
// Next line prevents compiler griping about no return
throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***");
}
lp_accum__.add(lp__);
return lp_accum__.sum();
} // log_prob()
template <typename RNG>
void write_array(RNG &base_rng__, std::vector<double> &params_r__,
std::vector<int> &params_i__, std::vector<double> &vars__,
bool emit_transformed_parameters__ = true,
bool emit_generated_quantities__ = true,
std::ostream *pstream__ = 0) const {
typedef double local_scalar_t__;
vars__.resize(0);
stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
static const char *function__ = "sparse_model_namespace::write_array";
(void)function__; // suppress unused var warning
(void)function__; // suppress unused var warning
double lp__ = 0.0;
(void)lp__; // dummy to suppress unused var warning
stan::math::accumulator<double> lp_accum__;
try {
current_statement__ = 1;
validate_non_negative_index("VV", "N", N);
current_statement__ = 1;
validate_non_negative_index("VV", "M", M);
Eigen::SparseMatrix<double> VV;
VV = Eigen::SparseMatrix<double>(N, M);
current_statement__ = 1;
VV = in__.sparse_matrix(nz_rows, nz_cols, N, M);
current_statement__ = 2;
validate_non_negative_index("ZZ", "N", N);
current_statement__ = 2;
validate_non_negative_index("ZZ", "M", M);
Eigen::SparseMatrix<double> ZZ;
ZZ = Eigen::SparseMatrix<double>(N, M);
double param_cool;
current_statement__ = 3;
param_cool = std::numeric_limits<double>::quiet_NaN();
current_statement__ = 4;
validate_non_negative_index("A", "M", M);
Eigen::Matrix<double, -1, 1> A;
A = Eigen::Matrix<double, -1, 1>(M);
current_statement__ = 4;
for (size_t sym1__ = 1; sym1__ <= M; ++sym1__) {
current_statement__ = 4;
assign(A, cons_list(index_uni(sym1__), nil_index_list()),
std::numeric_limits<double>::quiet_NaN(),
"assigning variable A");
}
double sigma;
current_statement__ = 5;
sigma = std::numeric_limits<double>::quiet_NaN();
for (size_t sym1__ = 1; sym1__ <= stan::math::size(nz_rows); ++sym1__) {
vars__.push_back(
rvalue(VV,
cons_list(index_uni(nz_cols[(sym1__ - 1)]),
cons_list(index_uni(nz_rows[(sym1__ - 1)]),
nil_index_list())),
"VV"));
}
if (logical_negation((primitive_value(emit_transformed_parameters__) ||
primitive_value(emit_generated_quantities__)))) {
return;
}
current_statement__ = 2;
assign(ZZ, nil_index_list(), multiply(VV, nz_vals),
"assigning variable ZZ");
current_statement__ = 3;
param_cool = rvalue(
ZZ,
cons_list(index_uni(1), cons_list(index_uni(1), nil_index_list())),
"ZZ");
for (size_t sym1__ = 1; sym1__ <= N; ++sym1__) {
for (size_t sym2__ = 1; sym2__ <= M; ++sym2__) {
vars__.push_back(
rvalue(ZZ,
cons_list(index_uni(sym2__),
cons_list(index_uni(sym1__), nil_index_list())),
"ZZ"));
}
}
vars__.push_back(param_cool);
for (size_t sym1__ = 1; sym1__ <= M; ++sym1__) {
vars__.push_back(A[(sym1__ - 1)]);
}
vars__.push_back(sigma);
if (logical_negation(emit_generated_quantities__)) {
return;
}
current_statement__ = 6;
validate_non_negative_index("BB", "N", N);
current_statement__ = 6;
validate_non_negative_index("BB", "M", M);
Eigen::SparseMatrix<double> BB;
BB = Eigen::SparseMatrix<double>(N, M);
current_statement__ = 6;
assign(BB, nil_index_list(), multiply(ZZ, param_cool),
"assigning variable BB");
for (size_t sym1__ = 1; sym1__ <= N; ++sym1__) {
for (size_t sym2__ = 1; sym2__ <= M; ++sym2__) {
vars__.push_back(
rvalue(BB,
cons_list(index_uni(sym2__),
cons_list(index_uni(sym1__), nil_index_list())),
"BB"));
}
}
} catch (const std::exception &e) {
stan::lang::rethrow_located(e, locations_array__[current_statement__]);
// Next line prevents compiler griping about no return
throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***");
}
} // write_array()
void transform_inits(const stan::io::var_context &context__,
std::vector<int> &params_i__,
std::vector<double> &vars__,
std::ostream *pstream__) const {
typedef double local_scalar_t__;
vars__.resize(0);
vars__.reserve(num_params_r__);
try {
int pos__;
pos__ = 1;
current_statement__ = 1;
validate_non_negative_index("VV", "N", N);
current_statement__ = 1;
validate_non_negative_index("VV", "M", M);
Eigen::SparseMatrix<double> VV;
VV = Eigen::SparseMatrix<double>(N, M);
{
std::vector<local_scalar_t__> VV_flat__;
current_statement__ = 1;
assign(VV_flat__, nil_index_list(), context__.vals_r("VV"),
"assigning variable VV_flat__");
current_statement__ = 1;
pos__ = 1;
current_statement__ = 1;
for (size_t sym1__ = 1; sym1__ <= stan::math::size(nz_rows); ++sym1__) {
current_statement__ = 1;
assign(VV,
cons_list(index_uni(nz_cols[(sym1__ - 1)]),
cons_list(index_uni(nz_rows[(sym1__ - 1)]),
nil_index_list())),
VV_flat__[(pos__ - 1)], "assigning variable VV");
current_statement__ = 1;
pos__ = (pos__ + 1);
}
}
for (size_t sym1__ = 1; sym1__ <= stan::math::size(nz_rows); ++sym1__) {
vars__.push_back(
rvalue(VV,
cons_list(index_uni(nz_cols[(sym1__ - 1)]),
cons_list(index_uni(nz_rows[(sym1__ - 1)]),
nil_index_list())),
"VV"));
}
} catch (const std::exception &e) {
stan::lang::rethrow_located(e, locations_array__[current_statement__]);
// Next line prevents compiler griping about no return
throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***");
}
} // transform_inits()
void get_param_names(std::vector<std::string> &names__) const {
names__.resize(0);
names__.push_back("VV");
names__.push_back("ZZ");
names__.push_back("param_cool");
names__.push_back("A");
names__.push_back("sigma");
names__.push_back("BB");
} // get_param_names()
void get_dims(std::vector<std::vector<size_t>> &dimss__) const {
dimss__.resize(0);
std::vector<size_t> dims__;
dims__.push_back(stan::math::size(nz_rows));
dimss__.push_back(dims__);
dims__.resize(0);
dims__.push_back(N);
dims__.push_back(M);
dimss__.push_back(dims__);
dims__.resize(0);
dimss__.push_back(dims__);
dims__.resize(0);
dims__.push_back(M);
dimss__.push_back(dims__);
dims__.resize(0);
dimss__.push_back(dims__);
dims__.resize(0);
dims__.push_back(N);
dims__.push_back(M);
dimss__.push_back(dims__);
dims__.resize(0);
} // get_dims()
void constrained_param_names(std::vector<std::string> &param_names__,
bool emit_transformed_parameters__ = true,
bool emit_generated_quantities__ = true) const {
for (size_t sym1__ = 1; sym1__ <= stan::math::size(nz_rows); ++sym1__) {
{
param_names__.push_back(std::string() + "VV" + '.' +
std::to_string(nz_rows[(sym1__ - 1)]) + '.' +
std::to_string(nz_cols[(sym1__ - 1)]));
}
}
if (emit_transformed_parameters__) {
for (size_t sym1__ = 0; sym1__ < ZZ.outerSize(); ++sym1__)
for (Eigen::SparseMatrix<double>::InnerIterator sym2__(ZZ, sym1__);
sym2__; ++sym2__) {
param_names__.push_back(std::string() + "ZZ" + '.' +
std::to_string(sym2__.row()) + '.' +
std::to_string(sym2__.col()));
}
param_names__.push_back(std::string() + "param_cool");
for (size_t sym1__ = 1; sym1__ <= M; ++sym1__) {
{
param_names__.push_back(std::string() + "A" + '.' +
std::to_string(sym1__));
}
}
param_names__.push_back(std::string() + "sigma");
}
if (emit_generated_quantities__) {
for (size_t sym2__ = 0; sym2__ < BB.outerSize(); ++sym2__)
for (Eigen::SparseMatrix<double>::InnerIterator sym3__(BB, sym2__);
sym3__; ++sym3__) {
param_names__.push_back(std::string() + "BB" + '.' +
std::to_string(sym3__.row()) + '.' +
std::to_string(sym3__.col()));
}
}
} // constrained_param_names()
void
unconstrained_param_names(std::vector<std::string> &param_names__,
bool emit_transformed_parameters__ = true,
bool emit_generated_quantities__ = true) const {
for (size_t sym2__ = 1; sym2__ <= stan::math::size(nz_rows); ++sym2__) {
{
param_names__.push_back(std::string() + "VV" + '.' +
std::to_string(nz_rows[(sym2__ - 1)]) + '.' +
std::to_string(nz_cols[(sym2__ - 1)]));
}
}
if (emit_transformed_parameters__) {
for (size_t sym2__ = 0; sym2__ < ZZ.outerSize(); ++sym2__)
for (Eigen::SparseMatrix<double>::InnerIterator sym3__(ZZ, sym2__);
sym3__; ++sym3__) {
param_names__.push_back(std::string() + "ZZ" + '.' +
std::to_string(sym3__.row()) + '.' +
std::to_string(sym3__.col()));
}
param_names__.push_back(std::string() + "param_cool");
for (size_t sym2__ = 1; sym2__ <= M; ++sym2__) {
{
param_names__.push_back(std::string() + "A" + '.' +
std::to_string(sym2__));
}
}
param_names__.push_back(std::string() + "sigma");
}
if (emit_generated_quantities__) {
for (size_t sym3__ = 0; sym3__ < BB.outerSize(); ++sym3__)
for (Eigen::SparseMatrix<double>::InnerIterator sym4__(BB, sym3__);
sym4__; ++sym4__) {
param_names__.push_back(std::string() + "BB" + '.' +
std::to_string(sym4__.row()) + '.' +
std::to_string(sym4__.col()));
}
}
} // unconstrained_param_names()
std::string get_constrained_sizedtypes() const {
stringstream s__;
s__ << "[{\"name\":\"VV\",\"type\":{\"name\":\"sparse_matrix\",\"rows\":"
<< N << ",\"cols\":" << M
<< "},\"block\":\"parameters\"},{\"name\":\"ZZ\",\"type\":{\"name\":"
"\"sparse_matrix\",\"rows\":"
<< N << ",\"cols\":" << M
<< "},\"block\":\"transformed_parameters\"},{\"name\":\"param_cool\","
"\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"},"
"{\"name\":\"A\",\"type\":{\"name\":\"vector\",\"length\":"
<< M
<< "},\"block\":\"transformed_parameters\"},{\"name\":\"sigma\","
"\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"},"
"{\"name\":\"BB\",\"type\":{\"name\":\"sparse_matrix\",\"rows\":"
<< N << ",\"cols\":" << M << "},\"block\":\"generated_quantities\"}]";
return s__.str();
} // get_constrained_sizedtypes()
std::string get_unconstrained_sizedtypes() const {
stringstream s__;
s__ << "[{\"name\":\"VV\",\"type\":{\"name\":\"sparse_matrix\",\"rows\":"
<< N << ",\"cols\":" << M
<< "},\"block\":\"parameters\"},{\"name\":\"ZZ\",\"type\":{\"name\":"
"\"sparse_matrix\",\"rows\":"
<< N << ",\"cols\":" << M
<< "},\"block\":\"transformed_parameters\"},{\"name\":\"param_cool\","
"\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"},"
"{\"name\":\"A\",\"type\":{\"name\":\"vector\",\"length\":"
<< M
<< "},\"block\":\"transformed_parameters\"},{\"name\":\"sigma\","
"\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"},"
"{\"name\":\"BB\",\"type\":{\"name\":\"sparse_matrix\",\"rows\":"
<< N << ",\"cols\":" << M << "},\"block\":\"generated_quantities\"}]";
return s__.str();
} // get_unconstrained_sizedtypes()
// Begin method overload boilerplate
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 emit_transformed_parameters__ = true,
bool emit_generated_quantities__ = 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,
emit_transformed_parameters__, emit_generated_quantities__,
pstream);
vars.resize(vars_vec.size());
for (int i = 0; i < vars.size(); ++i)
vars(i) = vars_vec[i];
}
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 transform_inits(const stan::io::var_context &context,
Eigen::Matrix<double, Eigen::Dynamic, 1> &params_r,
std::ostream *pstream__) const {
std::vector<double> params_r_vec;
std::vector<int> params_i_vec;
transform_inits(context, params_i_vec, params_r_vec, pstream__);
params_r.resize(params_r_vec.size());
for (int i = 0; i < params_r.size(); ++i)
params_r(i) = params_r_vec[i];
}
};
} // namespace sparse_model_namespace
typedef sparse_model_namespace::sparse_model stan_model;
#ifndef USING_R
// Boilerplate
stan::model::model_base &new_model(stan::io::var_context &data_context,
unsigned int seed,
std::ostream *msg_stream) {
stan_model *m = new stan_model(data_context, seed, msg_stream);
return *m;
}
#endif
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment