Model Compiles using Command Line but not R

[Peter Li]

The following model compiles using the command line,

data {
int<lower=0> N;
vector[N] dist;
vector[N] arsenic;
int<lower=0,upper=1> switc[N];
}
transformed data {
vector[N] dist100;
dist100 <- dist / 100;
}
parameters {
vector[2] beta;
}
model {
switc ~ bernoulli_logit(beta[1] + beta[2] * dist100 + beta[3] * arsenic);
}

but when I try to run it in R, with this code,

> library(rstan)
> source("wells.data.R")
> if (!file.exists("wells_two_pred.sm.RData")) {
+ rt <- stanc("wells_two_pred.stan", model_name="wells_two_pred")
+ wells_two_pred.sm <- stan_model(stanc_ret=rt)
+ save(wells_two_pred.sm, file="wells_two_pred.sm.RData")
+ } else {
+ load("wells_two_pred.sm.RData", verbose=TRUE)
+ }

I get the following error:

TRANSLATING MODEL 'wells_two_pred' FROM Stan CODE TO C++ CODE NOW.
COMPILING THE C++ CODE FOR MODEL 'wells_two_pred' NOW.
/Library/Frameworks/R.framework/Versions/2.15/Resources/library/rstan/include//stanlib/eigen_3.1.2/Eigen/src/Core/Assign.h:
In member function �Derived& Eigen::DenseBase<Derived>::lazyAssign(const
Eigen::DenseBase<OtherDerived>&) [with OtherDerived =
Eigen::Matrix<stan::agrad::var, -0x00000000000000001, 1, 0,
-0x00000000000000001, 1>, Derived = Eigen::Matrix<double,
-0x00000000000000001, 1, 0, -0x00000000000000001, 1>]�:
/Library/Frameworks/R.framework/Versions/2.15/Resources/library/rstan/include//stanlib/eigen_3.1.2/Eigen/src/Core/PlainObjectBase.h:393:
instantiated from �Derived&
Eigen::PlainObjectBase<Derived>::lazyAssign(const
Eigen::DenseBase<OtherDerived>&) [with OtherDerived =
Eigen::Matrix<stan::agrad::var, -0x00000000000000001, 1, 0,
-0x00000000000000001, 1>, Derived = Eigen::Matrix<double,
-0x00000000000000001, 1, 0, -0x00000000000000001, 1>]�
/Library/Frameworks/R.framework/Versions/2.15/Resources/library/rstan/include//stanlib/eigen_3.1.2/Eigen/src/Core/Assign.h:522:
instantiated from �static Derived&
Eigen::internal::assign_selector<Derived, OtherDerived, false,
false>::run(Derived&, const OtherDerived&) [with Derived =
Eigen::Matrix<double, -0x00000000000000001, 1, 0, -0x00000000000000001,
1>, OtherDerived = Eigen::Matrix<stan::agrad::var, -0x00000000000000001,
1, 0, -0x00000000000000001, 1>]�
/Library/Frameworks/R.framework/Versions/2.15/Resources/library/rstan/include//stanlib/eigen_3.1.2/Eigen/src/Core/PlainObjectBase.h:599:
instantiated from �Derived&
Eigen::PlainObjectBase<Derived>::_set_noalias(const
Eigen::DenseBase<OtherDerived>&) [with OtherDerived =
Eigen::Matrix<stan::agrad::var, -0x00000000000000001, 1, 0,
-0x00000000000000001, 1>, Derived = Eigen::Matrix<double,
-0x00000000000000001, 1, 0, -0x00000000000000001, 1>]�
/Library/Frameworks/R.framework/Versions/2.15/Resources/library/rstan/include//stanlib/eigen_3.1.2/Eigen/src/Core/PlainObjectBase.h:584:
instantiated from �void
Eigen::PlainObjectBase<Derived>::_set_selector(const OtherDerived&,
const Eigen::internal::false_type&) [with OtherDerived =
Eigen::Matrix<stan::agrad::var, -0x00000000000000001, 1, 0,
-0x00000000000000001, 1>, Derived = Eigen::Matrix<double,
-0x00000000000000001, 1, 0, -0x00000000000000001, 1>]�
/Library/Frameworks/R.framework/Versions/2.15/Resources/library/rstan/include//stanlib/eigen_3.1.2/Eigen/src/Core/PlainObjectBase.h:576:
instantiated from �Derived& Eigen::PlainObjectBase<Derived>::_set(const
Eigen::DenseBase<OtherDerived>&) [with OtherDerived =
Eigen::Matrix<stan::agrad::var, -0x00000000000000001, 1, 0,
-0x00000000000000001, 1>, Derived = Eigen::Matrix<double,
-0x00000000000000001, 1, 0, -0x00000000000000001, 1>]�
/Library/Frameworks/R.framework/Versions/2.15/Resources/library/rstan/include//stanlib/eigen_3.1.2/Eigen/src/Core/Matrix.h:172:
instantiated from �Eigen::Matrix<_Scalar, _Rows, _Cols, _Options,
_MaxRows, _MaxCols>& Eigen::Matrix<_Scalar, _Rows, _Cols, _Options,
_MaxRows, _MaxCols>::operator=(const Eigen::MatrixBase<OtherDerived>&)
[with OtherDerived = Eigen::Matrix<stan::agrad::var,
-0x00000000000000001, 1, 0, -0x00000000000000001, 1>, _Scalar = double,
int _Rows = -0x00000000000000001, int _Cols = 1, int _Options = 0, int
_MaxRows = -0x00000000000000001, int _MaxCols = 1]�
/Library/Frameworks/R.framework/Versions/2.15/Resources/library/rstan/include//stansrc/stan/agrad/rev/matrix/assign.hpp:34:
instantiated from �static void stan::agrad::<unnamed>::assigner<false,
LHS, RHS>::assign(LHS&, const RHS&) [with LHS = Eigen::Matrix<double,
-0x00000000000000001, 1, 0, -0x00000000000000001, 1>, RHS =
Eigen::Matrix<stan::agrad::var, -0x00000000000000001, 1, 0,
-0x00000000000000001, 1>]�
/Library/Frameworks/R.framework/Versions/2.15/Resources/library/rstan/include//stansrc/stan/agrad/rev/matrix/assign.hpp:53:
instantiated from �void stan::agrad::assign(LHS&, const RHS&) [with LHS
= modela901cf35d4c_wells_two_pred_namespace::vector_d, RHS =
Eigen::Matrix<stan::agrad::var, -0x00000000000000001, 1, 0,
-0x00000000000000001, 1>]�
filea902d72376d.cpp:92: instantiated from here
/Library/Frameworks/R.framework/Versions/2.15/Resources/library/rstan/include//stanlib/eigen_3.1.2/Eigen/src/Core/Assign.h:493:
error:
�YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY�
is not a member of �Eigen::internal::static_assertion<false>�
make: *** [filea902d72376d.o] Error 1

ERROR(s) during compilation: source code errors or compiler
configuration errors!

Program source:
1:
2: // includes from the plugin
3:
4:
5: // user includes
6: #include <rstan/rstaninc.hpp>
7: // Code generated by Stan version 1.3
8:
9: #include <stan/model/model_header.hpp>
10:
11: namespace modela901cf35d4c_wells_two_pred_namespace {
12:
13: using std::vector;
14: using std::string;
15: using std::stringstream;
16: using stan::agrad::var;
17: using stan::model::prob_grad_ad;
18: using stan::math::get_base1;
19: using stan::math::stan_print;
20: using stan::io::dump;
21: using std::istream;
22: using namespace stan::math;
23: using namespace stan::prob;
24: using namespace stan::agrad;
25:
26: typedef Eigen::Matrix<double,Eigen::Dynamic,1> vector_d;
27: typedef Eigen::Matrix<double,1,Eigen::Dynamic> row_vector_d;
28: typedef Eigen::Matrix<double,Eigen::Dynamic,Eigen::Dynamic> matrix_d;
29:
30: class modela901cf35d4c_wells_two_pred : public prob_grad_ad {
31: private:
32: int N;
33: vector_d dist;
34: vector_d arsenic;
35: vector<int> switc;
36: vector_d dist100;
37: public:
38: modela901cf35d4c_wells_two_pred(stan::io::var_context& context__,
39: std::ostream* pstream__ = 0)
40: : prob_grad_ad::prob_grad_ad(0) {
41: static const char* function__ =
"modela901cf35d4c_wells_two_pred_namespace::modela901cf35d4c_wells_two_pred(%1%)";
42: (void) function__; // dummy call to supress warning
43: size_t pos__;
44: (void) pos__; // dummy call to supress warning
45: std::vector<int> vals_i__;
46: std::vector<double> vals_r__;
47: context__.validate_dims("data initialization", "N", "int",
context__.to_vec());
48: N = int(0);
49: vals_i__ = context__.vals_i("N");
50: pos__ = 0;
51: N = vals_i__[pos__++];
52: stan::math::validate_non_negative_index("dist", "N", N);
53: dist = vector_d(N);
54: context__.validate_dims("data initialization", "dist", "vector_d",
context__.to_vec(N));
55: vals_r__ = context__.vals_r("dist");
56: pos__ = 0;
57: size_t dist_i_vec_lim__ = N;
58: for (size_t i_vec__ = 0; i_vec__ < dist_i_vec_lim__; ++i_vec__) {
59: dist[i_vec__] = vals_r__[pos__++];
60: }
61: stan::math::validate_non_negative_index("arsenic", "N", N);
62: arsenic = vector_d(N);
63: context__.validate_dims("data initialization", "arsenic",
"vector_d", context__.to_vec(N));
64: vals_r__ = context__.vals_r("arsenic");
65: pos__ = 0;
66: size_t arsenic_i_vec_lim__ = N;
67: for (size_t i_vec__ = 0; i_vec__ < arsenic_i_vec_lim__; ++i_vec__) {
68: arsenic[i_vec__] = vals_r__[pos__++];
69: }
70: context__.validate_dims("data initialization", "switc", "int",
context__.to_vec(N));
71: stan::math::validate_non_negative_index("switc", "N", N);
72: switc = std::vector<int>(N,int(0));
73: vals_i__ = context__.vals_i("switc");
74: pos__ = 0;
75: size_t switc_limit_0__ = N;
76: for (size_t i_0__ = 0; i_0__ < switc_limit_0__; ++i_0__) {
77: switc[i_0__] = vals_i__[pos__++];
78: }
79: // validate data
80: try {
81: check_greater_or_equal(function__,N,0,"N");
82: } catch (std::domain_error& e) { throw
std::domain_error(std::string("Invalid value of N: ") +
std::string(e.what())); };
83: for (int k0__ = 0; k0__ < N; ++k0__) {
84: try {
85: check_greater_or_equal(function__,switc[k0__],0,"switc[k0__]");
86: check_less_or_equal(function__,switc[k0__],1,"switc[k0__]");
87: } catch (std::domain_error& e) { throw
std::domain_error(std::string("Invalid value of switc: ") +
std::string(e.what())); };
88: }
89: stan::math::validate_non_negative_index("dist100", "N", N);
90: dist100 = vector_d(N);
91:
92: assign(dist100, divide(dist,100));
93: // validate transformed data
94:
95: set_param_ranges();
96: } // dump ctor
97:
98: void set_param_ranges() {
99: num_params_r__ = 0U;
100: param_ranges_i__.clear();
101: num_params_r__ += 2;
102: }
103:
104: void transform_inits(const stan::io::var_context& context__,
105: std::vector<int>& params_i__,
106: std::vector<double>& params_r__) {
107: stan::io::writer<double> writer__(params_r__,params_i__);
108: size_t pos__;
109: std::vector<double> vals_r__;
110: std::vector<int> vals_i__;
111:
112:
113: if (!(context__.contains_r("beta")))
114: throw std::runtime_error("variable beta missing");
115: vals_r__ = context__.vals_r("beta");
116: pos__ = 0U;
117: context__.validate_dims("initialization", "beta", "vector_d",
context__.to_vec(2));
118: vector_d beta(2);
119: for (int j1__ = 0U; j1__ < 2; ++j1__)
120: beta(j1__) = vals_r__[pos__++];
121: writer__.vector_unconstrain(beta);
122: params_r__ = writer__.data_r();
123: params_i__ = writer__.data_i();
124: }
125:
126: var log_prob(vector<var>& params_r__,
127: vector<int>& params_i__,
128: std::ostream* pstream__ = 0) {
129: return log_prob_poly<true,var>(params_r__,params_i__,pstream__);
130: }
131:
132: template <bool propto__, typename T__>
133: T__ log_prob_poly(vector<T__>& params_r__,
134: vector<int>& params_i__,
135: std::ostream* pstream__ = 0) {
136:
137: T__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
138: (void) DUMMY_VAR__; // suppress unused var warning
139:
140: T__ lp__(0.0);
141:
142: // model parameters
143: stan::io::reader<T__> in__(params_r__,params_i__);
144:
145: Eigen::Matrix<T__,Eigen::Dynamic,1> beta =
in__.vector_constrain(2,lp__);
146: (void) beta; // supress unused variable warning
147:
148: // transformed parameters
149:
150: // initialized transformed params to avoid seg fault on val access
151:
152:
153: // validate transformed parameters
154:
155: const char* function__ = "validate transformed params %1%";
156: (void) function__; // dummy to suppress unused var warning
157: // model body
158: lp__ += stan::prob::bernoulli_logit_log<true>(switc,
add(add(get_base1(beta,1,"beta",1),multiply(get_base1(beta,2,"beta",1),dist100)),multiply(get_base1(beta,3,"beta",1),arsenic)));
159:
160: return lp__;
161:
162: } // log_prob(...var...)
163:
164:
165: void get_param_names(std::vector<std::string>& names__) {
166: names__.resize(0);
167: names__.push_back("beta");
168: }
169:
170:
171: void get_dims(std::vector<std::vector<size_t> >& dimss__) {
172: dimss__.resize(0);
173: std::vector<size_t> dims__;
174: dims__.resize(0);
175: dims__.push_back(2);
176: dimss__.push_back(dims__);
177: }
178:
179: template <typename RNG>
180: void write_array(RNG& base_rng__,
181: std::vector<double>& params_r__,
182: std::vector<int>& params_i__,
183: std::vector<double>& vars__,
184: std::ostream* pstream__ = 0) {
185: vars__.resize(0);
186: stan::io::reader<double> in__(params_r__,params_i__);
187: static const char* function__ =
"modela901cf35d4c_wells_two_pred_namespace::write_array(%1%)";
188: (void) function__; // dummy call to supress warning
189: // read-transform, write parameters
190: vector_d beta = in__.vector_constrain(2);
191: for (int k_0__ = 0; k_0__ < 2; ++k_0__) {
192: vars__.push_back(beta[k_0__]);
193: }
194:
195: // declare and define transformed parameters
196: double lp__ = 0.0;
197: (void) lp__; // dummy call to supress warning
198:
199:
200: // validate transformed parameters
201:
202: // write transformed parameters
203:
204: // declare and define generated quantities
205:
206:
207: // validate generated quantities
208:
209: // write generated quantities
210: }
211:
212:
213: void write_csv_header(std::ostream& o__) {
214: stan::io::csv_writer writer__(o__);
215: for (int k_0__ = 1; k_0__ <= 2; ++k_0__) {
216: writer__.comma();
217: o__ << "beta" << '.' << k_0__;
218: }
219: writer__.newline();
220: }
221:
222: template <typename RNG>
223: void write_csv(RNG& base_rng__,
224: std::vector<double>& params_r__,
225: std::vector<int>& params_i__,
226: std::ostream& o__,
227: std::ostream* pstream__ = 0) {
228: stan::io::reader<double> in__(params_r__,params_i__);
229: stan::io::csv_writer writer__(o__);
230: static const char* function__ =
"modela901cf35d4c_wells_two_pred_namespace::write_csv(%1%)";
231: (void) function__; // dummy call to supress warning
232: // read-transform, write parameters
233: vector_d beta = in__.vector_constrain(2);
234: writer__.write(beta);
235:
236: // declare, define and validate transformed parameters
237: double lp__ = 0.0;
238: (void) lp__; // dummy call to supress warning
239:
240:
241:
242: // write transformed parameters
243:
244: // declare and define generated quantities
245:
246:
247: // validate generated quantities
248:
249: // write generated quantities
250: writer__.newline();
251: }
252:
253: }; // model
254:
255: } // namespace
256:
257: /**
258: * Define Rcpp Module to expose stan_fit's functions to R.
259: */
260: RCPP_MODULE(stan_fit4modela901cf35d4c_wells_two_pred_mod){
261:
Rcpp::class_<rstan::stan_fit<modela901cf35d4c_wells_two_pred_namespace::modela901cf35d4c_wells_two_pred,

262: boost::random::ecuyer1988>
>("stan_fit4modela901cf35d4c_wells_two_pred")
263: // .constructor<Rcpp::List>()
264: .constructor<SEXP, SEXP>()
265: // .constructor<SEXP, SEXP>()
266: .method("call_sampler",
267:
&rstan::stan_fit<modela901cf35d4c_wells_two_pred_namespace::modela901cf35d4c_wells_two_pred,
boost::random::ecuyer1988>::call_sampler)
268: .method("param_names",
269:
&rstan::stan_fit<modela901cf35d4c_wells_two_pred_namespace::modela901cf35d4c_wells_two_pred,
boost::random::ecuyer1988>::param_names)
270: .method("param_names_oi",
271:
&rstan::stan_fit<modela901cf35d4c_wells_two_pred_namespace::modela901cf35d4c_wells_two_pred,
boost::random::ecuyer1988>::param_names_oi)
272: .method("param_fnames_oi",
273:
&rstan::stan_fit<modela901cf35d4c_wells_two_pred_namespace::modela901cf35d4c_wells_two_pred,
boost::random::ecuyer1988>::param_fnames_oi)
274: .method("param_dims",
275:
&rstan::stan_fit<modela901cf35d4c_wells_two_pred_namespace::modela901cf35d4c_wells_two_pred,
boost::random::ecuyer1988>::param_dims)
276: .method("param_dims_oi",
277:
&rstan::stan_fit<modela901cf35d4c_wells_two_pred_namespace::modela901cf35d4c_wells_two_pred,
boost::random::ecuyer1988>::param_dims_oi)
278: .method("update_param_oi",
279:
&rstan::stan_fit<modela901cf35d4c_wells_two_pred_namespace::modela901cf35d4c_wells_two_pred,
boost::random::ecuyer1988>::update_param_oi)
280: .method("param_oi_tidx",
281:
&rstan::stan_fit<modela901cf35d4c_wells_two_pred_namespace::modela901cf35d4c_wells_two_pred,
boost::random::ecuyer1988>::param_oi_tidx)
282: .method("grad_log_prob",
283:
&rstan::stan_fit<modela901cf35d4c_wells_two_pred_namespace::modela901cf35d4c_wells_two_pred,
boost::random::ecuyer1988>::grad_log_prob)
284: .method("log_prob",
285:
&rstan::stan_fit<modela901cf35d4c_wells_two_pred_namespace::modela901cf35d4c_wells_two_pred,
boost::random::ecuyer1988>::log_prob)
286: .method("unconstrain_pars",
287:
&rstan::stan_fit<modela901cf35d4c_wells_two_pred_namespace::modela901cf35d4c_wells_two_pred,
boost::random::ecuyer1988>::unconstrain_pars)
288: .method("constrain_pars",
289:
&rstan::stan_fit<modela901cf35d4c_wells_two_pred_namespace::modela901cf35d4c_wells_two_pred,
boost::random::ecuyer1988>::constrain_pars)
290: .method("num_pars_unconstrained",
291:
&rstan::stan_fit<modela901cf35d4c_wells_two_pred_namespace::modela901cf35d4c_wells_two_pred,
boost::random::ecuyer1988>::num_pars_unconstrained)
292: ;
293: }
294:
295: // declarations
296: extern "C" {
297: SEXP filea902d72376d( ) ;
298: }
299:
300: // definition
301:
302: SEXP filea902d72376d( ){
303: return Rcpp::wrap("wells_two_pred");
304: }
305:
306:
Error in compileCode(f, code, language = language, verbose = verbose) :
Compilation ERROR, function(s)/method(s) not created!
/Library/Frameworks/R.framework/Versions/2.15/Resources/library/rstan/include//stanlib/eigen_3.1.2/Eigen/src/Core/Assign.h:
In member function �Derived& Eigen::DenseBase<Derived>::lazyAssign(const
Eigen::DenseBase<OtherDerived>&) [with OtherDerived =
Eigen::Matrix<stan::agrad::var, -0x00000000000000001, 1, 0,
-0x00000000000000001, 1>, Derived = Eigen::Matrix<double,
-0x00000000000000001, 1, 0, -0x00000000000000001, 1>]�:
/Library/Frameworks/R.framework/Versions/2.15/Resources/library/rstan/include//stanlib/eigen_3.1.2/Eigen/src/Core/PlainObjectBase.h:393:
instantiated from �Derived&
Eigen::PlainObjectBase<Derived>::lazyAssign(const
Eigen::DenseBase<OtherDerived>&) [with OtherDerived =
Eigen::Matrix<stan::agrad::var, -0x00000000000000001, 1, 0,
-0x00000000000000001, 1>, Derived = Eigen::Matrix<double,
-0x00000000000000001, 1, 0, -0x00000000000000001, 1>]�
/Library/Frameworks/R.framework/Versions/2.15/Resources/lib
In addition: Warning message:
running command '/Library/Frameworks/R.framework/Resources/bin/R CMD
SHLIB filea902d72376d.cpp 2> filea902d72376d.cpp.err.txt' had status 1

[Bob Carpenter]

The issue for 1.3 is in dividing by integer 100.

data {
int<lower=0> N;
vector[N] dist;

...

}
transformed data {
vector[N] dist100;

dist100 <- dist / 100.0; // / 100.0;
}

If you replace 100 with 100.0, it works. Or
0.01 * dist.

Are you using the 1.3 release version of Stan for
the command line? If not, it's probably a traits
issue we sorted out already on the develop branch.

You also need beta to be declared to be size 3.

- Bob

[Peter Li]

Ah, I'm using the develop branch for command line and 1.3 for R. Thanks!


Peter

[Ben Goodrich]

You can make yourself an updated R package fairly easily just by git pulling the most recent Stan stuff and doing

make install

in the rstan directory. You may want to do

export MAKEFLAGS="-j4"

or something to make the install go faster. It is pretty slow.

Ben

[Bob Carpenter]

I also meant to mention that I verified it is indeed
parsing OK on the develop branch (or at least on my branch
from the develop branch, which will be merged by 1.3).

- Bob

On 7/17/13 3:51 PM, Bob Carpenter wrote: