Unable to load Prophet package

[JulienAlex]

Hello,

I have an issue loading Prophet on R (I am on Windows). I load required packages (ggplot2, rstan, Rcpp...) and it worked perfectly fine few months ago, but not anymore. I tried to re-install the package, R tools and even tried on different versions of R (3.4.3, 3.3.3...) but I still got the kind of error message as below. Could maybe someone help me on this please?

library(prophet)
filef2ca6b7628.cpp:8:39: fatal error: stan/model/model_header.hpp: No such file or directory
#include <stan/model/model_header.hpp>
^
compilation terminated.
make: *** [filef2ca6b7628.o] Error 1
Warning message:
running command 'make -f "C:/PROGRA1/R/R-331.3/etc/i386/Makeconf" -f "C:/PROGRA1/R/R-331.3/share/make/winshlib.mk" -f "//fs001lu1.lu1.arcelor.net/home$/A0592158/My Documents/.R/Makevars" SHLIB_LDFLAGS='$(SHLIB_CXXLDFLAGS)' SHLIB_LD='$(SHLIB_CXXLD)' SHLIB="filef2ca6b7628.dll" OBJECTS="filef2ca6b7628.o"' had status 2

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: #define STAN__SERVICES__COMMAND_HPP// Code generated by Stan version 2.17.0
7:
8: #include <stan/model/model_header.hpp>
9:
10: namespace modelf2c9436f33_prophet_linear_growth_namespace {
11:
12: using std::istream;
13: using std::string;
14: using std::stringstream;
15: using std::vector;
16: using stan::io::dump;
17: using stan::math::lgamma;
18: using stan::model::prob_grad;
19: using namespace stan::math;
20:
21: typedef Eigen::Matrix<double,Eigen::Dynamic,1> vector_d;
22: typedef Eigen::Matrix<double,1,Eigen::Dynamic> row_vector_d;
23: typedef Eigen::Matrix<double,Eigen::Dynamic,Eigen::Dynamic> matrix_d;
24:
25: static int current_statement_begin__;
26:
27: stan::io::program_reader prog_reader__() {
28: stan::io::program_reader reader;
29: reader.add_event(0, 0, "start", "modelf2c9436f33_prophet_linear_growth");
30: reader.add_event(40, 40, "end", "modelf2c9436f33_prophet_linear_growth");
31: return reader;
32: }
33:
34: class modelf2c9436f33_prophet_linear_growth : public prob_grad {
35: private:
36: int T;
37: int K;
38: vector_d t;
39: vector_d y;
40: int S;
41: matrix_d A;
42: vector t_change;
43: matrix_d X;
44: vector_d sigmas;
45: double tau;
46: public:
47: modelf2c9436f33_prophet_linear_growth(stan::io::var_context& context__,
48: std::ostream* pstream__ = 0)
49: : prob_grad(0) {
50: ctor_body(context__, 0, pstream__);
51: }
52:
53: modelf2c9436f33_prophet_linear_growth(stan::io::var_context& context__,
54: unsigned int random_seed__,
55: std::ostream* pstream__ = 0)
56: : prob_grad(0) {
57: ctor_body(context__, random_seed__, pstream__);
58: }
59:
60: void ctor_body(stan::io::var_context& context__,
61: unsigned int random_seed__,
62: std::ostream* pstream__) {
63: boost::ecuyer1988 base_rng__ =
64: stan::services::util::create_rng(random_seed__, 0);
65: (void) base_rng__; // suppress unused var warning
66:
67: current_statement_begin__ = -1;
68:
69: static const char* function__ = "modelf2c9436f33_prophet_linear_growth_namespace::modelf2c9436f33_prophet_linear_growth";
70: (void) function__; // dummy to suppress unused var warning
71: size_t pos__;
72: (void) pos__; // dummy to suppress unused var warning
73: std::vector vals_i__;
74: std::vector vals_r__;
75: double DUMMY_VAR__(std::numeric_limits::quiet_NaN());
76: (void) DUMMY_VAR__; // suppress unused var warning
77:
78: // initialize member variables
79: try {
80: current_statement_begin__ = 2;
81: context__.validate_dims("data initialization", "T", "int", context__.to_vec());
82: T = int(0);
83: vals_i__ = context__.vals_i("T");
84: pos__ = 0;
85: T = vals_i__[pos__++];
86: current_statement_begin__ = 3;
87: context__.validate_dims("data initialization", "K", "int", context__.to_vec());
88: K = int(0);
89: vals_i__ = context__.vals_i("K");
90: pos__ = 0;
91: K = vals_i__[pos__++];
92: current_statement_begin__ = 4;
93: validate_non_negative_index("t", "T", T);
94: context__.validate_dims("data initialization", "t", "vector_d", context__.to_vec(T));
95: validate_non_negative_index("t", "T", T);
96: t = vector_d(static_castEigen::VectorXd::Index(T));
97: vals_r__ = context__.vals_r("t");
98: pos__ = 0;
99: size_t t_i_vec_lim__ = T;
100: for (size_t i_vec__ = 0; i_vec__ < t_i_vec_lim__; ++i_vec__) {
101: t[i_vec__] = vals_r__[pos__++];
102: }
103: current_statement_begin__ = 5;
104: validate_non_negative_index("y", "T", T);
105: context__.validate_dims("data initialization", "y", "vector_d", context__.to_vec(T));
106: validate_non_negative_index("y", "T", T);
107: y = vector_d(static_castEigen::VectorXd::Index(T));
108: vals_r__ = context__.vals_r("y");
109: pos__ = 0;
110: size_t y_i_vec_lim__ = T;
111: for (size_t i_vec__ = 0; i_vec__ < y_i_vec_lim__; ++i_vec__) {
112: y[i_vec__] = vals_r__[pos__++];
113: }
114: current_statement_begin__ = 6;
115: context__.validate_dims("data initialization", "S", "int", context__.to_vec());
116: S = int(0);
117: vals_i__ = context__.vals_i("S");
118: pos__ = 0;
119: S = vals_i__[pos__++];
120: current_statement_begin__ = 7;
121: validate_non_negative_index("A", "T", T);
122: validate_non_negative_index("A", "S", S);
123: context__.validate_dims("data initialization", "A", "matrix_d", context__.to_vec(T,S));
124: validate_non_negative_index("A", "T", T);
125: validate_non_negative_index("A", "S", S);
126: A = matrix_d(static_castEigen::VectorXd::Index(T),static_castEigen::VectorXd::Index(S));
127: vals_r__ = context__.vals_r("A");
128: pos__ = 0;
129: size_t A_m_mat_lim__ = T;
130: size_t A_n_mat_lim__ = S;
131: for (size_t n_mat__ = 0; n_mat__ < A_n_mat_lim__; ++n_mat__) {
132: for (size_t m_mat__ = 0; m_mat__ < A_m_mat_lim__; ++m_mat__) {
133: A(m_mat__,n_mat__) = vals_r__[pos__++];
134: }
135: }
136: current_statement_begin__ = 8;
137: validate_non_negative_index("t_change", "S", S);
138: context__.validate_dims("data initialization", "t_change", "double", context__.to_vec(S));
139: validate_non_negative_index("t_change", "S", S);
140: t_change = std::vector(S,double(0));
141: vals_r__ = context__.vals_r("t_change");
142: pos__ = 0;
143: size_t t_change_limit_0__ = S;
144: for (size_t i_0__ = 0; i_0__ < t_change_limit_0__; ++i_0__) {
145: t_change[i_0__] = vals_r__[pos__++];
146: }
147: current_statement_begin__ = 9;
148: validate_non_negative_index("X", "T", T);
149: validate_non_negative_index("X", "K", K);
150: context__.validate_dims("data initialization", "X", "matrix_d", context__.to_vec(T,K));
151: validate_non_negative_index("X", "T", T);
152: validate_non_negative_index("X", "K", K);
153: X = matrix_d(static_castEigen::VectorXd::Index(T),static_castEigen::VectorXd::Index(K));
154: vals_r__ = context__.vals_r("X");
155: pos__ = 0;
156: size_t X_m_mat_lim__ = T;
157: size_t X_n_mat_lim__ = K;
158: for (size_t n_mat__ = 0; n_mat__ < X_n_mat_lim__; ++n_mat__) {
159: for (size_t m_mat__ = 0; m_mat__ < X_m_mat_lim__; ++m_mat__) {
160: X(m_mat__,n_mat__) = vals_r__[pos__++];
161: }
162: }
163: current_statement_begin__ = 10;
164: validate_non_negative_index("sigmas", "K", K);
165: context__.validate_dims("data initialization", "sigmas", "vector_d", context__.to_vec(K));
166: validate_non_negative_index("sigmas", "K", K);
167: sigmas = vector_d(static_castEigen::VectorXd::Index(K));
168: vals_r__ = context__.vals_r("sigmas");
169: pos__ = 0;
170: size_t sigmas_i_vec_lim__ = K;
171: for (size_t i_vec__ = 0; i_vec__ < sigmas_i_vec_lim__; ++i_vec__) {
172: sigmas[i_vec__] = vals_r__[pos__++];
173: }
174: current_statement_begin__ = 11;
175: context__.validate_dims("data initialization", "tau", "double", context__.to_vec());
176: tau = double(0);
177: vals_r__ = context__.vals_r("tau");
178: pos__ = 0;
179: tau = vals_r__[pos__++];
180:
181: // validate, data variables
182: current_statement_begin__ = 2;
183: current_statement_begin__ = 3;
184: check_greater_or_equal(function__,"K",K,1);
185: current_statement_begin__ = 4;
186: current_statement_begin__ = 5;
187: current_statement_begin__ = 6;
188: current_statement_begin__ = 7;
189: current_statement_begin__ = 8;
190: current_statement_begin__ = 9;
191: current_statement_begin__ = 10;
192: current_statement_begin__ = 11;
193: check_greater_or_equal(function__,"tau",tau,0);
194: // initialize data variables
195:
196:
197: // validate transformed data
198:
199: // validate, set parameter ranges
200: num_params_r__ = 0U;
201: param_ranges_i__.clear();
202: current_statement_begin__ = 15;
203: ++num_params_r__;
204: current_statement_begin__ = 16;
205: ++num_params_r__;
206: current_statement_begin__ = 17;
207: validate_non_negative_index("delta", "S", S);
208: num_params_r__ += S;
209: current_statement_begin__ = 18;
210: ++num_params_r__;
211: current_statement_begin__ = 19;
212: validate_non_negative_index("beta", "K", K);
213: num_params_r__ += K;
214: } catch (const std::exception& e) {
215: stan::lang::rethrow_located(e, current_statement_begin__, prog_reader__());
216: // Next line prevents compiler griping about no return
217: throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ");
218: }
219: }
220:
221: ~modelf2c9436f33_prophet_linear_growth() { }
222:
223:
224: void transform_inits(const stan::io::var_context& context__,
225: std::vector& params_i__,
226: std::vector& params_r__,
227: std::ostream pstream__) const {
228: stan::io::writer writer__(params_r__,params_i__);
229: size_t pos__;
230: (void) pos__; // dummy call to supress warning
231: std::vector vals_r__;
232: std::vector vals_i__;
233:
234: if (!(context__.contains_r("k")))
235: throw std::runtime_error("variable k missing");
236: vals_r__ = context__.vals_r("k");
237: pos__ = 0U;
238: context__.validate_dims("initialization", "k", "double", context__.to_vec());
239: double k(0);
240: k = vals_r__[pos__++];
241: try {
242: writer__.scalar_unconstrain(k);
243: } catch (const std::exception& e) {
244: throw std::runtime_error(std::string("Error transforming variable k: ") + e.what());
245: }
246:
247: if (!(context__.contains_r("m")))
248: throw std::runtime_error("variable m missing");
249: vals_r__ = context__.vals_r("m");
250: pos__ = 0U;
251: context__.validate_dims("initialization", "m", "double", context__.to_vec());
252: double m(0);
253: m = vals_r__[pos__++];
254: try {
255: writer__.scalar_unconstrain(m);
256: } catch (const std::exception& e) {
257: throw std::runtime_error(std::string("Error transforming variable m: ") + e.what());
258: }
259:
260: if (!(context__.contains_r("delta")))
261: throw std::runtime_error("variable delta missing");
262: vals_r__ = context__.vals_r("delta");
263: pos__ = 0U;
264: validate_non_negative_index("delta", "S", S);
265: context__.validate_dims("initialization", "delta", "vector_d", context__.to_vec(S));
266: vector_d delta(static_castEigen::VectorXd::Index(S));
267: for (int j1__ = 0U; j1__ < S; ++j1__)
268: delta(j1__) = vals_r__[pos__++];
269: try {
270: writer__.vector_unconstrain(delta);
271: } catch (const std::exception& e) {
272: throw std::runtime_error(std::string("Error transforming variable delta: ") + e.what());
273: }
274:
275: if (!(context__.contains_r("sigma_obs")))
276: throw std::runtime_error("variable sigma_obs missing");
277: vals_r__ = context__.vals_r("sigma_obs");
278: pos__ = 0U;
279: context__.validate_dims("initialization", "sigma_obs", "double", context__.to_vec());
280: double sigma_obs(0);
281: sigma_obs = vals_r__[pos__++];
282: try {
283: writer__.scalar_lb_unconstrain(0,sigma_obs);
284: } catch (const std::exception& e) {
285: throw std::runtime_error(std::string("Error transforming variable sigma_obs: ") + e.what());
286: }
287:
288: if (!(context__.contains_r("beta")))
289: throw std::runtime_error("variable beta missing");
290: vals_r__ = context__.vals_r("beta");
291: pos__ = 0U;
292: validate_non_negative_index("beta", "K", K);
293: context__.validate_dims("initialization", "beta", "vector_d", context__.to_vec(K));
294: vector_d beta(static_castEigen::VectorXd::Index(K));
295: for (int j1__ = 0U; j1__ < K; ++j1__)
296: beta(j1__) = vals_r__[pos__++];
297: try {
298: writer__.vector_unconstrain(beta);
299: } catch (const std::exception& e) {
300: throw std::runtime_error(std::string("Error transforming variable beta: ") + e.what());
301: }
302:
303: params_r__ = writer__.data_r();
304: params_i__ = writer__.data_i();
305: }
306:
307: void transform_inits(const stan::io::var_context& context,
308: Eigen::Matrix<double,Eigen::Dynamic,1>& params_r,
309: std::ostream pstream__) const {
310: std::vector params_r_vec;
311: std::vector params_i_vec;
312: transform_inits(context, params_i_vec, params_r_vec, pstream__);
313: params_r.resize(params_r_vec.size());
314: for (int i = 0; i < params_r.size(); ++i)
315: params_r(i) = params_r_vec[i];
316: }
317:
318:
319: template <bool propto__, bool jacobian__, typename T__>
320: T__ log_prob(vector<T__>& params_r__,
321: vector& params_i__,
322: std::ostream pstream__ = 0) const {
323:
324: T__ DUMMY_VAR__(std::numeric_limits::quiet_NaN());
325: (void) DUMMY_VAR__; // suppress unused var warning
326:
327: T__ lp__(0.0);
328: stan::math::accumulator<T__> lp_accum__;
329:
330: try {
331: // model parameters
332: stan::io::reader<T__> in__(params_r__,params_i__);
333:
334: T__ k;
335: (void) k; // dummy to suppress unused var warning
336: if (jacobian__)
337: k = in__.scalar_constrain(lp__);
338: else
339: k = in__.scalar_constrain();
340:
341: T__ m;
342: (void) m; // dummy to suppress unused var warning
343: if (jacobian__)
344: m = in__.scalar_constrain(lp__);
345: else
346: m = in__.scalar_constrain();
347:
348: Eigen::Matrix<T__,Eigen::Dynamic,1> delta;
349: (void) delta; // dummy to suppress unused var warning
350: if (jacobian__)
351: delta = in__.vector_constrain(S,lp__);
352: else
353: delta = in__.vector_constrain(S);
354:
355: T__ sigma_obs;
356: (void) sigma_obs; // dummy to suppress unused var warning
357: if (jacobian__)
358: sigma_obs = in__.scalar_lb_constrain(0,lp__);
359: else
360: sigma_obs = in__.scalar_lb_constrain(0);
361:
362: Eigen::Matrix<T__,Eigen::Dynamic,1> beta;
363: (void) beta; // dummy to suppress unused var warning
364: if (jacobian__)
365: beta = in__.vector_constrain(K,lp__);
366: else
367: beta = in__.vector_constrain(K);
368:
369:
370: // transformed parameters
371: current_statement_begin__ = 23;
372: validate_non_negative_index("gamma", "S", S);
373: Eigen::Matrix<T__,Eigen::Dynamic,1> gamma(static_castEigen::VectorXd::Index(S));
374: (void) gamma; // dummy to suppress unused var warning
375:
376: stan::math::initialize(gamma, DUMMY_VAR__);
377: stan::math::fill(gamma,DUMMY_VAR__);
378:
379:
380: current_statement_begin__ = 25;
381: for (int i = 1; i <= S; ++i) {
382:
383: current_statement_begin__ = 26;
384: stan::math::assign(get_base1_lhs(gamma,i,"gamma",1), (-(get_base1(t_change,i,"t_change",1)) * get_base1(delta,i,"delta",1)));
385: }
386:
387: // validate transformed parameters
388: for (int i0__ = 0; i0__ < S; ++i0__) {
389: if (stan::math::is_uninitialized(gamma(i0__))) {
390: std::stringstream msg__;
391: msg__ << "Undefined transformed parameter: gamma" << '[' << i0__ << ']';
392: throw std::runtime_error(msg__.str());
393: }
394: }
395:
396: const char* function__ = "validate transformed params";
397: (void) function__; // dummy to suppress unused var warning
398: current_statement_begin__ = 23;
399:
400: // model body
401:
402: current_statement_begin__ = 32;
403: lp_accum__.add(normal_log<propto__>(k, 0, 5));
404: current_statement_begin__ = 33;
405: lp_accum__.add(normal_log<propto__>(m, 0, 5));
406: current_statement_begin__ = 34;
407: lp_accum__.add(double_exponential_log<propto__>(delta, 0, tau));
408: current_statement_begin__ = 35;
409: lp_accum__.add(normal_log<propto__>(sigma_obs, 0, 0.5));
410: current_statement_begin__ = 36;
411: lp_accum__.add(normal_log<propto__>(beta, 0, sigmas));
412: current_statement_begin__ = 39;
413: lp_accum__.add(normal_log<propto__>(y, add(add(elt_multiply(add(k,multiply(A,delta)),t),add(m,multiply(A,gamma))),multiply(X,beta)), sigma_obs));
414:
415: } catch (const std::exception& e) {
416: stan::lang::rethrow_located(e, current_statement_begin__, prog_reader__());
417: // Next line prevents compiler griping about no return
418: throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ");
419: }
420:
421: lp_accum__.add(lp__);
422: return lp_accum__.sum();
423:
424: } // log_prob()
425:
426: template <bool propto, bool jacobian, typename T_>
427: T_ log_prob(Eigen::Matrix<T_,Eigen::Dynamic,1>& params_r,
428: std::ostream pstream = 0) const {
429: std::vector<T_> vec_params_r;
430: vec_params_r.reserve(params_r.size());
431: for (int i = 0; i < params_r.size(); ++i)
432: vec_params_r.push_back(params_r(i));
433: std::vector vec_params_i;
434: return log_prob<propto,jacobian,T_>(vec_params_r, vec_params_i, pstream);
435: }
436:
437:
438: void get_param_names(std::vectorstd::string& names__) const {
439: names__.resize(0);
440: names__.push_back("k");
441: names__.push_back("m");
442: names__.push_back("delta");
443: names__.push_back("sigma_obs");
444: names__.push_back("beta");
445: names__.push_back("gamma");
446: }
447:
448:
449: void get_dims(std::vector<std::vector<size_t> >& dimss__) const {
450: dimss__.resize(0);
451: std::vector<size_t> dims__;
452: dims__.resize(0);
453: dimss__.push_back(dims__);
454: dims__.resize(0);
455: dimss__.push_back(dims__);
456: dims__.resize(0);
457: dims__.push_back(S);
458: dimss__.push_back(dims__);
459: dims__.resize(0);
460: dimss__.push_back(dims__);
461: dims__.resize(0);
462: dims__.push_back(K);
463: dimss__.push_back(dims__);
464: dims__.resize(0);
465: dims__.push_back(S);
466: dimss__.push_back(dims__);
467: }
468:
469: template
470: void write_array(RNG& base_rng__,
471: std::vector& params_r__,
472: std::vector& params_i__,
473: std::vector& vars__,
474: bool include_tparams__ = true,
475: bool include_gqs__ = true,
476: std::ostream pstream__ = 0) const {
477: vars__.resize(0);
478: stan::io::reader in__(params_r__,params_i__);
479: static const char function__ = "modelf2c9436f33_prophet_linear_growth_namespace::write_array";
480: (void) function__; // dummy to suppress unused var warning
481: // read-transform, write parameters
482: double k = in__.scalar_constrain();
483: double m = in__.scalar_constrain();
484: vector_d delta = in__.vector_constrain(S);
485: double sigma_obs = in__.scalar_lb_constrain(0);
486: vector_d beta = in__.vector_constrain(K);
487: vars__.push_back(k);
488: vars__.push_back(m);
489: for (int k_0__ = 0; k_0__ < S; ++k_0__) {
490: vars__.push_back(delta[k_0__]);
491: }
492: vars__.push_back(sigma_obs);
493: for (int k_0__ = 0; k_0__ < K; ++k_0__) {
494: vars__.push_back(beta[k_0__]);
495: }
496:
497: if (!include_tparams__) return;
498: // declare and define transformed parameters
499: double lp__ = 0.0;
500: (void) lp__; // dummy to suppress unused var warning
501: stan::math::accumulator lp_accum__;
502:
503: double DUMMY_VAR__(std::numeric_limits::quiet_NaN());
504: (void) DUMMY_VAR__; // suppress unused var warning
505:
506: try {
507: current_statement_begin__ = 23;
508: validate_non_negative_index("gamma", "S", S);
509: vector_d gamma(static_castEigen::VectorXd::Index(S));
510: (void) gamma; // dummy to suppress unused var warning
511:
512: stan::math::initialize(gamma, std::numeric_limits::quiet_NaN());
513: stan::math::fill(gamma,DUMMY_VAR__);
514:
515:
516: current_statement_begin__ = 25;
517: for (int i = 1; i <= S; ++i) {
518:
519: current_statement_begin__ = 26;
520: stan::math::assign(get_base1_lhs(gamma,i,"gamma",1), (-(get_base1(t_change,i,"t_change",1)) * get_base1(delta,i,"delta",1)));
521: }
522:
523: // validate transformed parameters
524: current_statement_begin__ = 23;
525:
526: // write transformed parameters
527: for (int k_0__ = 0; k_0__ < S; ++k_0__) {
528: vars__.push_back(gamma[k_0__]);
529: }
530:
531: if (!include_gqs__) return;
532: // declare and define generated quantities
533:
534:
535:
536: // validate generated quantities
537:
538: // write generated quantities
539: } catch (const std::exception& e) {
540: stan::lang::rethrow_located(e, current_statement_begin__, prog_reader__());
541: // Next line prevents compiler griping about no return
542: throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ");
543: }
544: }
545:
546: template
547: void write_array(RNG& base_rng,
548: Eigen::Matrix<double,Eigen::Dynamic,1>& params_r,
549: Eigen::Matrix<double,Eigen::Dynamic,1>& vars,
550: bool include_tparams = true,
551: bool include_gqs = true,
552: std::ostream pstream = 0) const {
553: std::vector params_r_vec(params_r.size());
554: for (int i = 0; i < params_r.size(); ++i)
555: params_r_vec[i] = params_r(i);
556: std::vector vars_vec;
557: std::vector params_i_vec;
558: write_array(base_rng,params_r_vec,params_i_vec,vars_vec,include_tparams,include_gqs,pstream);
559: vars.resize(vars_vec.size());
560: for (int i = 0; i < vars.size(); ++i)
561: vars(i) = vars_vec[i];
562: }
563:
564: static std::string model_name() {
565: return "modelf2c9436f33_prophet_linear_growth";
566: }
567:
568:
569: void constrained_param_names(std::vectorstd::string& param_names__,
570: bool include_tparams__ = true,
571: bool include_gqs__ = true) const {
572: std::stringstream param_name_stream__;
573: param_name_stream__.str(std::string());
574: param_name_stream__ << "k";
575: param_names__.push_back(param_name_stream__.str());
576: param_name_stream__.str(std::string());
577: param_name_stream__ << "m";
578: param_names__.push_back(param_name_stream__.str());
579: for (int k_0__ = 1; k_0__ <= S; ++k_0__) {
580: param_name_stream__.str(std::string());
581: param_name_stream__ << "delta" << '.' << k_0__;
582: param_names__.push_back(param_name_stream__.str());
583: }
584: param_name_stream__.str(std::string());
585: param_name_stream__ << "sigma_obs";
586: param_names__.push_back(param_name_stream__.str());
587: for (int k_0__ = 1; k_0__ <= K; ++k_0__) {
588: param_name_stream__.str(std::string());
589: param_name_stream__ << "beta" << '.' << k_0__;
590: param_names__.push_back(param_name_stream__.str());
591: }
592:
593: if (!include_gqs__ && !include_tparams__) return;
594: for (int k_0__ = 1; k_0__ <= S; ++k_0__) {
595: param_name_stream__.str(std::string());
596: param_name_stream__ << "gamma" << '.' << k_0__;
597: param_names__.push_back(param_name_stream__.str());
598: }
599:
600: if (!include_gqs__) return;
601: }
602:
603:
604: void unconstrained_param_names(std::vectorstd::string& param_names__,
605: bool include_tparams__ = true,
606: bool include_gqs__ = true) const {
607: std::stringstream param_name_stream__;
608: param_name_stream__.str(std::string());
609: param_name_stream__ << "k";
610: param_names__.push_back(param_name_stream__.str());
611: param_name_stream__.str(std::string());
612: param_name_stream__ << "m";
613: param_names__.push_back(param_name_stream__.str());
614: for (int k_0__ = 1; k_0__ <= S; ++k_0__) {
615: param_name_stream__.str(std::string());
616: param_name_stream__ << "delta" << '.' << k_0__;
617: param_names__.push_back(param_name_stream__.str());
618: }
619: param_name_stream__.str(std::string());
620: param_name_stream__ << "sigma_obs";
621: param_names__.push_back(param_name_stream__.str());
622: for (int k_0__ = 1; k_0__ <= K; ++k_0__) {
623: param_name_stream__.str(std::string());
624: param_name_stream__ << "beta" << '.' << k_0__;
625: param_names__.push_back(param_name_stream__.str());
626: }
627:
628: if (!include_gqs__ && !include_tparams__) return;
629: for (int k_0__ = 1; k_0__ <= S; ++k_0__) {
630: param_name_stream__.str(std::string());
631: param_name_stream__ << "gamma" << '.' << k_0__;
632: param_names__.push_back(param_name_stream__.str());
633: }
634:
635: if (!include_gqs__) return;
636: }
637:
638: }; // model
639:
640: }
641:
642: typedef modelf2c9436f33_prophet_linear_growth_namespace::modelf2c9436f33_prophet_linear_growth stan_model;
643:
644: #include <rstan/rstaninc.hpp>
645: /
646: * Define Rcpp Module to expose stan_fit's functions to R.
647: */
648: RCPP_MODULE(stan_fit4modelf2c9436f33_prophet_linear_growth_mod){
649: Rcpp::class_<rstan::stan_fit<modelf2c9436f33_prophet_linear_growth_namespace::modelf2c9436f33_prophet_linear_growth,
650: boost::random::ecuyer1988> >("stan_fit4modelf2c9436f33_prophet_linear_growth")
651: // .constructorRcpp::List()
652: .constructor<SEXP, SEXP, SEXP>()
653: // .constructor<SEXP, SEXP>()
654: .method("call_sampler",
655: &rstan::stan_fit<modelf2c9436f33_prophet_linear_growth_namespace::modelf2c9436f33_prophet_linear_growth, boost::random::ecuyer1988>::call_sampler)
656: .method("param_names",
657: &rstan::stan_fit<modelf2c9436f33_prophet_linear_growth_namespace::modelf2c9436f33_prophet_linear_growth, boost::random::ecuyer1988>::param_names)
658: .method("param_names_oi",
659: &rstan::stan_fit<modelf2c9436f33_prophet_linear_growth_namespace::modelf2c9436f33_prophet_linear_growth, boost::random::ecuyer1988>::param_names_oi)
660: .method("param_fnames_oi",
661: &rstan::stan_fit<modelf2c9436f33_prophet_linear_growth_namespace::modelf2c9436f33_prophet_linear_growth, boost::random::ecuyer1988>::param_fnames_oi)
662: .method("param_dims",
663: &rstan::stan_fit<modelf2c9436f33_prophet_linear_growth_namespace::modelf2c9436f33_prophet_linear_growth, boost::random::ecuyer1988>::param_dims)
664: .method("param_dims_oi",
665: &rstan::stan_fit<modelf2c9436f33_prophet_linear_growth_namespace::modelf2c9436f33_prophet_linear_growth, boost::random::ecuyer1988>::param_dims_oi)
666: .method("update_param_oi",
667: &rstan::stan_fit<modelf2c9436f33_prophet_linear_growth_namespace::modelf2c9436f33_prophet_linear_growth, boost::random::ecuyer1988>::update_param_oi)
668: .method("param_oi_tidx",
669: &rstan::stan_fit<modelf2c9436f33_prophet_linear_growth_namespace::modelf2c9436f33_prophet_linear_growth, boost::random::ecuyer1988>::param_oi_tidx)
670: .method("grad_log_prob",
671: &rstan::stan_fit<modelf2c9436f33_prophet_linear_growth_namespace::modelf2c9436f33_prophet_linear_growth, boost::random::ecuyer1988>::grad_log_prob)
672: .method("log_prob",
673: &rstan::stan_fit<modelf2c9436f33_prophet_linear_growth_namespace::modelf2c9436f33_prophet_linear_growth, boost::random::ecuyer1988>::log_prob)
674: .method("unconstrain_pars",
675: &rstan::stan_fit<modelf2c9436f33_prophet_linear_growth_namespace::modelf2c9436f33_prophet_linear_growth, boost::random::ecuyer1988>::unconstrain_pars)
676: .method("constrain_pars",
677: &rstan::stan_fit<modelf2c9436f33_prophet_linear_growth_namespace::modelf2c9436f33_prophet_linear_growth, boost::random::ecuyer1988>::constrain_pars)
678: .method("num_pars_unconstrained",
679: &rstan::stan_fit<modelf2c9436f33_prophet_linear_growth_namespace::modelf2c9436f33_prophet_linear_growth, boost::random::ecuyer1988>::num_pars_unconstrained)
680: .method("unconstrained_param_names",
681: &rstan::stan_fit<modelf2c9436f33_prophet_linear_growth_namespace::modelf2c9436f33_prophet_linear_growth, boost::random::ecuyer1988>::unconstrained_param_names)
682: .method("constrained_param_names",
683: &rstan::stan_fit<modelf2c9436f33_prophet_linear_growth_namespace::modelf2c9436f33_prophet_linear_growth, boost::random::ecuyer1988>::constrained_param_names)
684: ;
685: }
686:
687: // declarations
688: extern "C" {
689: SEXP filef2ca6b7628( ) ;
690: }
691:
692: // definition
693:
694: SEXP filef2ca6b7628( ){
695: return Rcpp::wrap("prophet_linear_growth");
696: }
697:
698:
Error : .onLoad failed in loadNamespace() for 'prophet', details:
call: compileCode(f, code, language = language, verbose = verbose)
error: Compilation ERROR, function(s)/method(s) not created! filef2ca6b7628.cpp:8:39: fatal error: stan/model/model_header.hpp: No such file or directory
#include <stan/model/model_header.hpp>
^
compilation terminated.
make: *** [filef2ca6b7628.o] Error 1
Warning message:
running command 'make -f "C:/PROGRA1/R/R-331.3/etc/i386/Makeconf" -f "C:/PROGRA1/R/R-331.3/share/make/winshlib.mk" -f "//fs001lu1.lu1.arcelor.net/home$/A0592158/My Documents/.R/Makevars" SHLIB_LDFLAGS='$(SHLIB_CXXLDFLAGS)' SHLIB_LD='$(SHLIB_CXXLD)' SHLIB="filef2ca6b7628.dll" OBJECTS="filef2ca6b7628.o"' had status 2
In addition: Warning message:
running command 'C:/PROGRA1/R/R-331.3/bin/i386/R CMD SHLIB filef2ca6b7628.cpp 2> filef2ca6b7628.cpp.err.txt' had status 1
Error: package or namespace load failed for ‘prophet’

[bletham]

The things you described are the things I would try.

It looks like Stan is generally not working. Does this run?

library(rstan)
model_code <- 'parameters {real y;} model {y ~ normal(0,1);}'
fit <- stan(model_code=model_code)  # this will take a minute
mean(extract(fit)$y)  # should be close to 0

According to the 2nd to last post here (stan-dev/rstan#210), this issue might arise if there is a $ in the path, which seems to be the case here (/home$/). Maybe that is it?

[JulienAlex]

Hi bletham,

Thank you for your reply. I tried to run it and you're right, it did not work. Thank you also for the link, I will try to change the path and see if it works.

[JulienAlex]

Ok, it works again ! Thank you very much for your help. Problem was indeed caused by the library path. I could not install packages on another library path as I don't have the rights to make it writable (company computer...)
But manually installing the packages from the Zip and copying them in a new library (without $ on the path) and loading packages from this new folder solved the issue.

[bletham]

Great, love when it's something simple!

[bhavinn]

Hi.. Even I am facing the same issue.
@JulienAlex : How did you change the path. Could you please help with the same.