Cannot connect brms or rstan to Stan [Error in compileCode(f, code, language = language, verbose = verbose) : Error in sink(type = “output”) : invalid connection]

[krisanathema]

Summary:

I cannot connect to Stan from R, and therefore I cannot use the packages rstan or brms, for instance. The message error is always:

Error in compileCode(f, code, language = language, verbose = verbose) :
Error in sink(type = “output”) : invalid connection

with not a single line afterwards [seems to differ from other reported issues].

Description:

I try to run brms as usual a few days ago and then realized it was not working. I already had some issues in the past, but I somehow managed to deal with it. It seems like updating R is always an issue for rstan. I do not really get why. Currently, I can run brms on my personal laptop and I have issues with my work laptop. I generally keep both of them as updated as possible with regards to R, RStudio or R packages.
I have no clue what is the problem this time. I spent days trying to understand that. I went through many pages on the web for help [for instance here, here, here, or even here].
The solutions often appear to be somehow similar, but none of them work in my case.
As I am afraid that brms also stops working on my personal PC, I do not dare to look into the installation configuration on my personal PC. But I typically have very similar configurations on both PCs.

Reproducible Steps:

So I tried to uninstall all installations of R, RStudio, RTools, as well as deleting all associated folders, clearing all associated paths in the
System environment variables of my PC, but nothing has helped: always the same issue.

Current Output:

library("rstan") # observe startup messages
Loading required package: StanHeaders
Loading required package: ggplot2
rstan (Version 2.21.8, GitRev: 2e1f913d3ca3)
For execution on a local, multicore CPU with excess RAM we recommend calling
options(mc.cores = parallel::detectCores()).
To avoid recompilation of unchanged Stan programs, we recommend calling
rstan_options(auto_write = TRUE)
Do not specify '-march=native' in 'LOCAL_CPPFLAGS' or a Makevars file
> example(stan_model, package = "rstan", run.dontrun = TRUE)

stn_md> stancode <- 'data {real y_mean;} parameters {real y;} model {y ~ normal(y_mean,1);}'

stn_md> mod <- stan_model(model_code = stancode, verbose = TRUE)

TRANSLATING MODEL '73fc79f8b1915e8208c736914c86d1a1' FROM Stan CODE TO C++ CODE NOW.
successful in parsing the Stan model '73fc79f8b1915e8208c736914c86d1a1'.
COMPILING THE C++ CODE FOR MODEL '73fc79f8b1915e8208c736914c86d1a1' NOW.
OS: x86_64, mingw32; rstan: 2.21.8; Rcpp: 1.0.11; inline: 0.3.19 
 >> setting environment variables: 
LOCAL_LIBS =  "C:/Program Files/R/R-4.3.1/library/rstan/lib/x64/libStanServices.a" -L"C:/Program Files/R/R-4.3.1/library/StanHeaders/libs/x64" -lStanHeaders -L"C:/Program Files/R/R-4.3.1/library/RcppParallel/lib/x64" -ltbb
PKG_CPPFLAGS =   -I"C:/Program Files/R/R-4.3.1/library/Rcpp/include/"  -I"C:/Program Files/R/R-4.3.1/library/RcppEigen/include/"  -I"C:/Program Files/R/R-4.3.1/library/RcppEigen/include/unsupported"  -I"C:/Program Files/R/R-4.3.1/library/BH/include" -I"C:/Program Files/R/R-4.3.1/library/StanHeaders/include/src/"  -I"C:/Program Files/R/R-4.3.1/library/StanHeaders/include/"  -I"C:/Program Files/R/R-4.3.1/library/RcppParallel/include/"  -I"C:/Program Files/R/R-4.3.1/library/rstan/include" -DEIGEN_NO_DEBUG  -DBOOST_DISABLE_ASSERTS  -DBOOST_PENDING_INTEGER_LOG2_HPP  -DSTAN_THREADS  -DBOOST_NO_AUTO_PTR  -include "C:/Program Files/R/R-4.3.1/library/StanHeaders/include/stan/math/prim/fun/Eigen.hpp"  -std=c++1y
 >> Program source :

   1 : 
   2 : // includes from the plugin
   3 : // [[Rcpp::plugins(cpp14)]]
   4 : 
   5 : 
   6 : // user includes
   7 : #include <Rcpp.h>
   8 : #include <rstan/io/rlist_ref_var_context.hpp>
   9 : #include <rstan/io/r_ostream.hpp>
  10 : #include <rstan/stan_args.hpp>
  11 : #include <boost/integer/integer_log2.hpp>
  12 : // Code generated by Stan version 2.21.0
  13 : 
  14 : #include <stan/model/model_header.hpp>
  15 : 
  16 : namespace model16fc5fe3736f_73fc79f8b1915e8208c736914c86d1a1_namespace {
  17 : 
  18 : using std::istream;
  19 : using std::string;
  20 : using std::stringstream;
  21 : using std::vector;
  22 : using stan::io::dump;
  23 : using stan::math::lgamma;
  24 : using stan::model::prob_grad;
  25 : using namespace stan::math;
  26 : 
  27 : static int current_statement_begin__;
  28 : 
  29 : stan::io::program_reader prog_reader__() {
  30 :     stan::io::program_reader reader;
  31 :     reader.add_event(0, 0, "start", "model16fc5fe3736f_73fc79f8b1915e8208c736914c86d1a1");
  32 :     reader.add_event(3, 1, "end", "model16fc5fe3736f_73fc79f8b1915e8208c736914c86d1a1");
  33 :     return reader;
  34 : }
  35 : 
  36 : class model16fc5fe3736f_73fc79f8b1915e8208c736914c86d1a1
  37 :   : public stan::model::model_base_crtp<model16fc5fe3736f_73fc79f8b1915e8208c736914c86d1a1> {
  38 : private:
  39 :         double y_mean;
  40 : public:
  41 :     model16fc5fe3736f_73fc79f8b1915e8208c736914c86d1a1(rstan::io::rlist_ref_var_context& context__,
  42 :         std::ostream* pstream__ = 0)
  43 :         : model_base_crtp(0) {
  44 :         ctor_body(context__, 0, pstream__);
  45 :     }
  46 : 
  47 :     model16fc5fe3736f_73fc79f8b1915e8208c736914c86d1a1(stan::io::var_context& context__,
  48 :         unsigned int random_seed__,
  49 :         std::ostream* pstream__ = 0)
  50 :         : model_base_crtp(0) {
  51 :         ctor_body(context__, random_seed__, pstream__);
  52 :     }
  53 : 
  54 :     void ctor_body(stan::io::var_context& context__,
  55 :                    unsigned int random_seed__,
  56 :                    std::ostream* pstream__) {
  57 :         typedef double local_scalar_t__;
  58 : 
  59 :         boost::ecuyer1988 base_rng__ =
  60 :           stan::services::util::create_rng(random_seed__, 0);
  61 :         (void) base_rng__;  // suppress unused var warning
  62 : 
  63 :         current_statement_begin__ = -1;
  64 : 
  65 :         static const char* function__ = "model16fc5fe3736f_73fc79f8b1915e8208c736914c86d1a1_namespace::model16fc5fe3736f_73fc79f8b1915e8208c736914c86d1a1";
  66 :         (void) function__;  // dummy to suppress unused var warning
  67 :         size_t pos__;
  68 :         (void) pos__;  // dummy to suppress unused var warning
  69 :         std::vector<int> vals_i__;
  70 :         std::vector<double> vals_r__;
  71 :         local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
  72 :         (void) DUMMY_VAR__;  // suppress unused var warning
  73 : 
  74 :         try {
  75 :             // initialize data block variables from context__
  76 :             current_statement_begin__ = 1;
  77 :             context__.validate_dims("data initialization", "y_mean", "double", context__.to_vec());
  78 :             y_mean = double(0);
  79 :             vals_r__ = context__.vals_r("y_mean");
  80 :             pos__ = 0;
  81 :             y_mean = vals_r__[pos__++];
  82 : 
  83 : 
  84 :             // initialize transformed data variables
  85 :             // execute transformed data statements
  86 : 
  87 :             // validate transformed data
  88 : 
  89 :             // validate, set parameter ranges
  90 :             num_params_r__ = 0U;
  91 :             param_ranges_i__.clear();
  92 :             current_statement_begin__ = 1;
  93 :             num_params_r__ += 1;
  94 :         } catch (const std::exception& e) {
  95 :             stan::lang::rethrow_located(e, current_statement_begin__, prog_reader__());
  96 :             // Next line prevents compiler griping about no return
  97 :             throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***");
  98 :         }
  99 :     }
 100 : 
 101 :     ~model16fc5fe3736f_73fc79f8b1915e8208c736914c86d1a1() { }
 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 :                          std::ostream* pstream__) const {
 108 :         typedef double local_scalar_t__;
 109 :         stan::io::writer<double> writer__(params_r__, params_i__);
 110 :         size_t pos__;
 111 :         (void) pos__; // dummy call to supress warning
 112 :         std::vector<double> vals_r__;
 113 :         std::vector<int> vals_i__;
 114 : 
 115 :         current_statement_begin__ = 1;
 116 :         if (!(context__.contains_r("y")))
 117 :             stan::lang::rethrow_located(std::runtime_error(std::string("Variable y missing")), current_statement_begin__, prog_reader__());
 118 :         vals_r__ = context__.vals_r("y");
 119 :         pos__ = 0U;
 120 :         context__.validate_dims("parameter initialization", "y", "double", context__.to_vec());
 121 :         double y(0);
 122 :         y = vals_r__[pos__++];
 123 :         try {
 124 :             writer__.scalar_unconstrain(y);
 125 :         } catch (const std::exception& e) {
 126 :             stan::lang::rethrow_located(std::runtime_error(std::string("Error transforming variable y: ") + e.what()), current_statement_begin__, prog_reader__());
 127 :         }
 128 : 
 129 :         params_r__ = writer__.data_r();
 130 :         params_i__ = writer__.data_i();
 131 :     }
 132 : 
 133 :     void transform_inits(const stan::io::var_context& context,
 134 :                          Eigen::Matrix<double, Eigen::Dynamic, 1>& params_r,
 135 :                          std::ostream* pstream__) const {
 136 :       std::vector<double> params_r_vec;
 137 :       std::vector<int> params_i_vec;
 138 :       transform_inits(context, params_i_vec, params_r_vec, pstream__);
 139 :       params_r.resize(params_r_vec.size());
 140 :       for (int i = 0; i < params_r.size(); ++i)
 141 :         params_r(i) = params_r_vec[i];
 142 :     }
 143 : 
 144 : 
 145 :     template <bool propto__, bool jacobian__, typename T__>
 146 :     T__ log_prob(std::vector<T__>& params_r__,
 147 :                  std::vector<int>& params_i__,
 148 :                  std::ostream* pstream__ = 0) const {
 149 : 
 150 :         typedef T__ local_scalar_t__;
 151 : 
 152 :         local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
 153 :         (void) DUMMY_VAR__;  // dummy to suppress unused var warning
 154 : 
 155 :         T__ lp__(0.0);
 156 :         stan::math::accumulator<T__> lp_accum__;
 157 :         try {
 158 :             stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
 159 : 
 160 :             // model parameters
 161 :             current_statement_begin__ = 1;
 162 :             local_scalar_t__ y;
 163 :             (void) y;  // dummy to suppress unused var warning
 164 :             if (jacobian__)
 165 :                 y = in__.scalar_constrain(lp__);
 166 :             else
 167 :                 y = in__.scalar_constrain();
 168 : 
 169 :             // model body
 170 : 
 171 :             current_statement_begin__ = 1;
 172 :             lp_accum__.add(normal_log<propto__>(y, y_mean, 1));
 173 : 
 174 :         } catch (const std::exception& e) {
 175 :             stan::lang::rethrow_located(e, current_statement_begin__, prog_reader__());
 176 :             // Next line prevents compiler griping about no return
 177 :             throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***");
 178 :         }
 179 : 
 180 :         lp_accum__.add(lp__);
 181 :         return lp_accum__.sum();
 182 : 
 183 :     } // log_prob()
 184 : 
 185 :     template <bool propto, bool jacobian, typename T_>
 186 :     T_ log_prob(Eigen::Matrix<T_,Eigen::Dynamic,1>& params_r,
 187 :                std::ostream* pstream = 0) const {
 188 :       std::vector<T_> vec_params_r;
 189 :       vec_params_r.reserve(params_r.size());
 190 :       for (int i = 0; i < params_r.size(); ++i)
 191 :         vec_params_r.push_back(params_r(i));
 192 :       std::vector<int> vec_params_i;
 193 :       return log_prob<propto,jacobian,T_>(vec_params_r, vec_params_i, pstream);
 194 :     }
 195 : 
 196 : 
 197 :     void get_param_names(std::vector<std::string>& names__) const {
 198 :         names__.resize(0);
 199 :         names__.push_back("y");
 200 :     }
 201 : 
 202 : 
 203 :     void get_dims(std::vector<std::vector<size_t> >& dimss__) const {
 204 :         dimss__.resize(0);
 205 :         std::vector<size_t> dims__;
 206 :         dims__.resize(0);
 207 :         dimss__.push_back(dims__);
 208 :     }
 209 : 
 210 :     template <typename RNG>
 211 :     void write_array(RNG& base_rng__,
 212 :                      std::vector<double>& params_r__,
 213 :                      std::vector<int>& params_i__,
 214 :                      std::vector<double>& vars__,
 215 :                      bool include_tparams__ = true,
 216 :                      bool include_gqs__ = true,
 217 :                      std::ostream* pstream__ = 0) const {
 218 :         typedef double local_scalar_t__;
 219 : 
 220 :         vars__.resize(0);
 221 :         stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
 222 :         static const char* function__ = "model16fc5fe3736f_73fc79f8b1915e8208c736914c86d1a1_namespace::write_array";
 223 :         (void) function__;  // dummy to suppress unused var warning
 224 : 
 225 :         // read-transform, write parameters
 226 :         double y = in__.scalar_constrain();
 227 :         vars__.push_back(y);
 228 : 
 229 :         double lp__ = 0.0;
 230 :         (void) lp__;  // dummy to suppress unused var warning
 231 :         stan::math::accumulator<double> lp_accum__;
 232 : 
 233 :         local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
 234 :         (void) DUMMY_VAR__;  // suppress unused var warning
 235 : 
 236 :         if (!include_tparams__ && !include_gqs__) return;
 237 : 
 238 :         try {
 239 :             if (!include_gqs__ && !include_tparams__) return;
 240 :             if (!include_gqs__) return;
 241 :         } catch (const std::exception& e) {
 242 :             stan::lang::rethrow_located(e, current_statement_begin__, prog_reader__());
 243 :             // Next line prevents compiler griping about no return
 244 :             throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***");
 245 :         }
 246 :     }
 247 : 
 248 :     template <typename RNG>
 249 :     void write_array(RNG& base_rng,
 250 :                      Eigen::Matrix<double,Eigen::Dynamic,1>& params_r,
 251 :                      Eigen::Matrix<double,Eigen::Dynamic,1>& vars,
 252 :                      bool include_tparams = true,
 253 :                      bool include_gqs = true,
 254 :                      std::ostream* pstream = 0) const {
 255 :       std::vector<double> params_r_vec(params_r.size());
 256 :       for (int i = 0; i < params_r.size(); ++i)
 257 :         params_r_vec[i] = params_r(i);
 258 :       std::vector<double> vars_vec;
 259 :       std::vector<int> params_i_vec;
 260 :       write_array(base_rng, params_r_vec, params_i_vec, vars_vec, include_tparams, include_gqs, pstream);
 261 :       vars.resize(vars_vec.size());
 262 :       for (int i = 0; i < vars.size(); ++i)
 263 :         vars(i) = vars_vec[i];
 264 :     }
 265 : 
 266 :     std::string model_name() const {
 267 :         return "model16fc5fe3736f_73fc79f8b1915e8208c736914c86d1a1";
 268 :     }
 269 : 
 270 : 
 271 :     void constrained_param_names(std::vector<std::string>& param_names__,
 272 :                                  bool include_tparams__ = true,
 273 :                                  bool include_gqs__ = true) const {
 274 :         std::stringstream param_name_stream__;
 275 :         param_name_stream__.str(std::string());
 276 :         param_name_stream__ << "y";
 277 :         param_names__.push_back(param_name_stream__.str());
 278 : 
 279 :         if (!include_gqs__ && !include_tparams__) return;
 280 : 
 281 :         if (include_tparams__) {
 282 :         }
 283 : 
 284 :         if (!include_gqs__) return;
 285 :     }
 286 : 
 287 : 
 288 :     void unconstrained_param_names(std::vector<std::string>& param_names__,
 289 :                                    bool include_tparams__ = true,
 290 :                                    bool include_gqs__ = true) const {
 291 :         std::stringstream param_name_stream__;
 292 :         param_name_stream__.str(std::string());
 293 :         param_name_stream__ << "y";
 294 :         param_names__.push_back(param_name_stream__.str());
 295 : 
 296 :         if (!include_gqs__ && !include_tparams__) return;
 297 : 
 298 :         if (include_tparams__) {
 299 :         }
 300 : 
 301 :         if (!include_gqs__) return;
 302 :     }
 303 : 
 304 : }; // model
 305 : 
 306 : }  // namespace
 307 : 
 308 : typedef model16fc5fe3736f_73fc79f8b1915e8208c736914c86d1a1_namespace::model16fc5fe3736f_73fc79f8b1915e8208c736914c86d1a1 stan_model;
 309 : 
 310 : #ifndef USING_R
 311 : 
 312 : stan::model::model_base& new_model(
 313 :         stan::io::var_context& data_context,
 314 :         unsigned int seed,
 315 :         std::ostream* msg_stream) {
 316 :   stan_model* m = new stan_model(data_context, seed, msg_stream);
 317 :   return *m;
 318 : }
 319 : 
 320 : #endif
 321 : 
 322 : 
 323 : 
 324 : #include <rstan_next/stan_fit.hpp>
 325 : 
 326 : struct stan_model_holder {
 327 :     stan_model_holder(rstan::io::rlist_ref_var_context rcontext,
 328 :                       unsigned int random_seed)
 329 :     : rcontext_(rcontext), random_seed_(random_seed)
 330 :      {
 331 :      }
 332 : 
 333 :    //stan::math::ChainableStack ad_stack;
 334 :    rstan::io::rlist_ref_var_context rcontext_;
 335 :    unsigned int random_seed_;
 336 : };
 337 : 
 338 : Rcpp::XPtr<stan::model::model_base> model_ptr(stan_model_holder* smh) {
 339 :   Rcpp::XPtr<stan::model::model_base> model_instance(new stan_model(smh->rcontext_, smh->random_seed_), true);
 340 :   return model_instance;
 341 : }
 342 : 
 343 : Rcpp::XPtr<rstan::stan_fit_base> fit_ptr(stan_model_holder* smh) {
 344 :   return Rcpp::XPtr<rstan::stan_fit_base>(new rstan::stan_fit(model_ptr(smh), smh->random_seed_), true);
 345 : }
 346 : 
 347 : std::string model_name(stan_model_holder* smh) {
 348 :   return model_ptr(smh).get()->model_name();
 349 : }
 350 : 
 351 : RCPP_MODULE(stan_fit4model16fc5fe3736f_73fc79f8b1915e8208c736914c86d1a1_mod){
 352 :   Rcpp::class_<stan_model_holder>("stan_fit4model16fc5fe3736f_73fc79f8b1915e8208c736914c86d1a1")
 353 :   .constructor<rstan::io::rlist_ref_var_context, unsigned int>()
 354 :   .method("model_ptr", &model_ptr)
 355 :   .method("fit_ptr", &fit_ptr)
 356 :   .method("model_name", &model_name)
 357 :   ;
 358 : }
 359 : 
 360 : 
 361 : // declarations
 362 : extern "C" {
 363 : SEXP file16fc31a21df9( ) ;
 364 : }
 365 : 
 366 : // definition
 367 : SEXP file16fc31a21df9() {
 368 :  return Rcpp::wrap("73fc79f8b1915e8208c736914c86d1a1");
 369 : }

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

Program source:
  1: 
  2: // includes from the plugin
  3: // [[Rcpp::plugins(cpp14)]]
  4: 
  5: 
  6: // user includes
  7: #include <Rcpp.h>
  8: #include <rstan/io/rlist_ref_var_context.hpp>
  9: #include <rstan/io/r_ostream.hpp>
 10: #include <rstan/stan_args.hpp>
 11: #include <boost/integer/integer_log2.hpp>
 12: // Code generated by Stan version 2.21.0
 13: 
 14: #include <stan/model/model_header.hpp>
 15: 
 16: namespace model16fc5fe3736f_73fc79f8b1915e8208c736914c86d1a1_namespace {
 17: 
 18: using std::istream;
 19: using std::string;
 20: using std::stringstream;
 21: using std::vector;
 22: using stan::io::dump;
 23: using stan::math::lgamma;
 24: using stan::model::prob_grad;
 25: using namespace stan::math;
 26: 
 27: static int current_statement_begin__;
 28: 
 29: stan::io::program_reader prog_reader__() {
 30:     stan::io::program_reader reader;
 31:     reader.add_event(0, 0, "start", "model16fc5fe3736f_73fc79f8b1915e8208c736914c86d1a1");
 32:     reader.add_event(3, 1, "end", "model16fc5fe3736f_73fc79f8b1915e8208c736914c86d1a1");
 33:     return reader;
 34: }
 35: 
 36: class model16fc5fe3736f_73fc79f8b1915e8208c736914c86d1a1
 37:   : public stan::model::model_base_crtp<model16fc5fe3736f_73fc79f8b1915e8208c736914c86d1a1> {
 38: private:
 39:         double y_mean;
 40: public:
 41:     model16fc5fe3736f_73fc79f8b1915e8208c736914c86d1a1(rstan::io::rlist_ref_var_context& context__,
 42:         std::ostream* pstream__ = 0)
 43:         : model_base_crtp(0) {
 44:         ctor_body(context__, 0, pstream__);
 45:     }
 46: 
 47:     model16fc5fe3736f_73fc79f8b1915e8208c736914c86d1a1(stan::io::var_context& context__,
 48:         unsigned int random_seed__,
 49:         std::ostream* pstream__ = 0)
 50:         : model_base_crtp(0) {
 51:         ctor_body(context__, random_seed__, pstream__);
 52:     }
 53: 
 54:     void ctor_body(stan::io::var_context& context__,
 55:                    unsigned int random_seed__,
 56:                    std::ostream* pstream__) {
 57:         typedef double local_scalar_t__;
 58: 
 59:         boost::ecuyer1988 base_rng__ =
 60:           stan::services::util::create_rng(random_seed__, 0);
 61:         (void) base_rng__;  // suppress unused var warning
 62: 
 63:         current_statement_begin__ = -1;
 64: 
 65:         static const char* function__ = "model16fc5fe3736f_73fc79f8b1915e8208c736914c86d1a1_namespace::model16fc5fe3736f_73fc79f8b1915e8208c736914c86d1a1";
 66:         (void) function__;  // dummy to suppress unused var warning
 67:         size_t pos__;
 68:         (void) pos__;  // dummy to suppress unused var warning
 69:         std::vector<int> vals_i__;
 70:         std::vector<double> vals_r__;
 71:         local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
 72:         (void) DUMMY_VAR__;  // suppress unused var warning
 73: 
 74:         try {
 75:             // initialize data block variables from context__
 76:             current_statement_begin__ = 1;
 77:             context__.validate_dims("data initialization", "y_mean", "double", context__.to_vec());
 78:             y_mean = double(0);
 79:             vals_r__ = context__.vals_r("y_mean");
 80:             pos__ = 0;
 81:             y_mean = vals_r__[pos__++];
 82: 
 83: 
 84:             // initialize transformed data variables
 85:             // execute transformed data statements
 86: 
 87:             // validate transformed data
 88: 
 89:             // validate, set parameter ranges
 90:             num_params_r__ = 0U;
 91:             param_ranges_i__.clear();
 92:             current_statement_begin__ = 1;
 93:             num_params_r__ += 1;
 94:         } catch (const std::exception& e) {
 95:             stan::lang::rethrow_located(e, current_statement_begin__, prog_reader__());
 96:             // Next line prevents compiler griping about no return
 97:             throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***");
 98:         }
 99:     }
100: 
101:     ~model16fc5fe3736f_73fc79f8b1915e8208c736914c86d1a1() { }
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:                          std::ostream* pstream__) const {
108:         typedef double local_scalar_t__;
109:         stan::io::writer<double> writer__(params_r__, params_i__);
110:         size_t pos__;
111:         (void) pos__; // dummy call to supress warning
112:         std::vector<double> vals_r__;
113:         std::vector<int> vals_i__;
114: 
115:         current_statement_begin__ = 1;
116:         if (!(context__.contains_r("y")))
117:             stan::lang::rethrow_located(std::runtime_error(std::string("Variable y missing")), current_statement_begin__, prog_reader__());
118:         vals_r__ = context__.vals_r("y");
119:         pos__ = 0U;
120:         context__.validate_dims("parameter initialization", "y", "double", context__.to_vec());
121:         double y(0);
122:         y = vals_r__[pos__++];
123:         try {
124:             writer__.scalar_unconstrain(y);
125:         } catch (const std::exception& e) {
126:             stan::lang::rethrow_located(std::runtime_error(std::string("Error transforming variable y: ") + e.what()), current_statement_begin__, prog_reader__());
127:         }
128: 
129:         params_r__ = writer__.data_r();
130:         params_i__ = writer__.data_i();
131:     }
132: 
133:     void transform_inits(const stan::io::var_context& context,
134:                          Eigen::Matrix<double, Eigen::Dynamic, 1>& params_r,
135:                          std::ostream* pstream__) const {
136:       std::vector<double> params_r_vec;
137:       std::vector<int> params_i_vec;
138:       transform_inits(context, params_i_vec, params_r_vec, pstream__);
139:       params_r.resize(params_r_vec.size());
140:       for (int i = 0; i < params_r.size(); ++i)
141:         params_r(i) = params_r_vec[i];
142:     }
143: 
144: 
145:     template <bool propto__, bool jacobian__, typename T__>
146:     T__ log_prob(std::vector<T__>& params_r__,
147:                  std::vector<int>& params_i__,
148:                  std::ostream* pstream__ = 0) const {
149: 
150:         typedef T__ local_scalar_t__;
151: 
152:         local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
153:         (void) DUMMY_VAR__;  // dummy to suppress unused var warning
154: 
155:         T__ lp__(0.0);
156:         stan::math::accumulator<T__> lp_accum__;
157:         try {
158:             stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
159: 
160:             // model parameters
161:             current_statement_begin__ = 1;
162:             local_scalar_t__ y;
163:             (void) y;  // dummy to suppress unused var warning
164:             if (jacobian__)
165:                 y = in__.scalar_constrain(lp__);
166:             else
167:                 y = in__.scalar_constrain();
168: 
169:             // model body
170: 
171:             current_statement_begin__ = 1;
172:             lp_accum__.add(normal_log<propto__>(y, y_mean, 1));
173: 
174:         } catch (const std::exception& e) {
175:             stan::lang::rethrow_located(e, current_statement_begin__, prog_reader__());
176:             // Next line prevents compiler griping about no return
177:             throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***");
178:         }
179: 
180:         lp_accum__.add(lp__);
181:         return lp_accum__.sum();
182: 
183:     } // log_prob()
184: 
185:     template <bool propto, bool jacobian, typename T_>
186:     T_ log_prob(Eigen::Matrix<T_,Eigen::Dynamic,1>& params_r,
187:                std::ostream* pstream = 0) const {
188:       std::vector<T_> vec_params_r;
189:       vec_params_r.reserve(params_r.size());
190:       for (int i = 0; i < params_r.size(); ++i)
191:         vec_params_r.push_back(params_r(i));
192:       std::vector<int> vec_params_i;
193:       return log_prob<propto,jacobian,T_>(vec_params_r, vec_params_i, pstream);
194:     }
195: 
196: 
197:     void get_param_names(std::vector<std::string>& names__) const {
198:         names__.resize(0);
199:         names__.push_back("y");
200:     }
201: 
202: 
203:     void get_dims(std::vector<std::vector<size_t> >& dimss__) const {
204:         dimss__.resize(0);
205:         std::vector<size_t> dims__;
206:         dims__.resize(0);
207:         dimss__.push_back(dims__);
208:     }
209: 
210:     template <typename RNG>
211:     void write_array(RNG& base_rng__,
212:                      std::vector<double>& params_r__,
213:                      std::vector<int>& params_i__,
214:                      std::vector<double>& vars__,
215:                      bool include_tparams__ = true,
216:                      bool include_gqs__ = true,
217:                      std::ostream* pstream__ = 0) const {
218:         typedef double local_scalar_t__;
219: 
220:         vars__.resize(0);
221:         stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
222:         static const char* function__ = "model16fc5fe3736f_73fc79f8b1915e8208c736914c86d1a1_namespace::write_array";
223:         (void) function__;  // dummy to suppress unused var warning
224: 
225:         // read-transform, write parameters
226:         double y = in__.scalar_constrain();
227:         vars__.push_back(y);
228: 
229:         double lp__ = 0.0;
230:         (void) lp__;  // dummy to suppress unused var warning
231:         stan::math::accumulator<double> lp_accum__;
232: 
233:         local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
234:         (void) DUMMY_VAR__;  // suppress unused var warning
235: 
236:         if (!include_tparams__ && !include_gqs__) return;
237: 
238:         try {
239:             if (!include_gqs__ && !include_tparams__) return;
240:             if (!include_gqs__) return;
241:         } catch (const std::exception& e) {
242:             stan::lang::rethrow_located(e, current_statement_begin__, prog_reader__());
243:             // Next line prevents compiler griping about no return
244:             throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***");
245:         }
246:     }
247: 
248:     template <typename RNG>
249:     void write_array(RNG& base_rng,
250:                      Eigen::Matrix<double,Eigen::Dynamic,1>& params_r,
251:                      Eigen::Matrix<double,Eigen::Dynamic,1>& vars,
252:                      bool include_tparams = true,
253:                      bool include_gqs = true,
254:                      std::ostream* pstream = 0) const {
255:       std::vector<double> params_r_vec(params_r.size());
256:       for (int i = 0; i < params_r.size(); ++i)
257:         params_r_vec[i] = params_r(i);
258:       std::vector<double> vars_vec;
259:       std::vector<int> params_i_vec;
260:       write_array(base_rng, params_r_vec, params_i_vec, vars_vec, include_tparams, include_gqs, pstream);
261:       vars.resize(vars_vec.size());
262:       for (int i = 0; i < vars.size(); ++i)
263:         vars(i) = vars_vec[i];
264:     }
265: 
266:     std::string model_name() const {
267:         return "model16fc5fe3736f_73fc79f8b1915e8208c736914c86d1a1";
268:     }
269: 
270: 
271:     void constrained_param_names(std::vector<std::string>& param_names__,
272:                                  bool include_tparams__ = true,
273:                                  bool include_gqs__ = true) const {
274:         std::stringstream param_name_stream__;
275:         param_name_stream__.str(std::string());
276:         param_name_stream__ << "y";
277:         param_names__.push_back(param_name_stream__.str());
278: 
279:         if (!include_gqs__ && !include_tparams__) return;
280: 
281:         if (include_tparams__) {
282:         }
283: 
284:         if (!include_gqs__) return;
285:     }
286: 
287: 
288:     void unconstrained_param_names(std::vector<std::string>& param_names__,
289:                                    bool include_tparams__ = true,
290:                                    bool include_gqs__ = true) const {
291:         std::stringstream param_name_stream__;
292:         param_name_stream__.str(std::string());
293:         param_name_stream__ << "y";
294:         param_names__.push_back(param_name_stream__.str());
295: 
296:         if (!include_gqs__ && !include_tparams__) return;
297: 
298:         if (include_tparams__) {
299:         }
300: 
301:         if (!include_gqs__) return;
302:     }
303: 
304: }; // model
305: 
306: }  // namespace
307: 
308: typedef model16fc5fe3736f_73fc79f8b1915e8208c736914c86d1a1_namespace::model16fc5fe3736f_73fc79f8b1915e8208c736914c86d1a1 stan_model;
309: 
310: #ifndef USING_R
311: 
312: stan::model::model_base& new_model(
313:         stan::io::var_context& data_context,
314:         unsigned int seed,
315:         std::ostream* msg_stream) {
316:   stan_model* m = new stan_model(data_context, seed, msg_stream);
317:   return *m;
318: }
319: 
320: #endif
321: 
322: 
323: 
324: #include <rstan_next/stan_fit.hpp>
325: 
326: struct stan_model_holder {
327:     stan_model_holder(rstan::io::rlist_ref_var_context rcontext,
328:                       unsigned int random_seed)
329:     : rcontext_(rcontext), random_seed_(random_seed)
330:      {
331:      }
332: 
333:    //stan::math::ChainableStack ad_stack;
334:    rstan::io::rlist_ref_var_context rcontext_;
335:    unsigned int random_seed_;
336: };
337: 
338: Rcpp::XPtr<stan::model::model_base> model_ptr(stan_model_holder* smh) {
339:   Rcpp::XPtr<stan::model::model_base> model_instance(new stan_model(smh->rcontext_, smh->random_seed_), true);
340:   return model_instance;
341: }
342: 
343: Rcpp::XPtr<rstan::stan_fit_base> fit_ptr(stan_model_holder* smh) {
344:   return Rcpp::XPtr<rstan::stan_fit_base>(new rstan::stan_fit(model_ptr(smh), smh->random_seed_), true);
345: }
346: 
347: std::string model_name(stan_model_holder* smh) {
348:   return model_ptr(smh).get()->model_name();
349: }
350: 
351: RCPP_MODULE(stan_fit4model16fc5fe3736f_73fc79f8b1915e8208c736914c86d1a1_mod){
352:   Rcpp::class_<stan_model_holder>("stan_fit4model16fc5fe3736f_73fc79f8b1915e8208c736914c86d1a1")
353:   .constructor<rstan::io::rlist_ref_var_context, unsigned int>()
354:   .method("model_ptr", &model_ptr)
355:   .method("fit_ptr", &fit_ptr)
356:   .method("model_name", &model_name)
357:   ;
358: }
359: 
360: 
361: // declarations
362: extern "C" {
363: SEXP file16fc31a21df9( ) ;
364: }
365: 
366: // definition
367: SEXP file16fc31a21df9() {
368:  return Rcpp::wrap("73fc79f8b1915e8208c736914c86d1a1");
369: }

Compilation ERROR, function(s)/method(s) not created!
Error in compileCode(f, code, language = language, verbose = verbose) :

To be more specific with brms:

Compiling Stan program...
Error in compileCode(f, code, language = language, verbose = verbose) :
Error in sink(type = “output”) : invalid connection

Expected Output:

Compiling Stan program...
Start sampling

SAMPLING FOR MODEL...

RStan Version:

2.21.8

R Version:

R version 4.3.1 (2023-06-16 ucrt)

Operating System:

Windows 10

[jkylearmstrong]

@krisanathema not sure if you saw this https://github.com/stan-dev/rstan/wiki/Configuring-C---Toolchain-for-Windows#r-43

however, when I attempt to run

> install.packages("StanHeaders", repos = c("https://mc-stan.org/r-packages/", getOption("repos")))

I get this error

Installing package into ‘C:/Users/jkyle/AppData/Local/R/win-library/4.3’
(as ‘lib’ is unspecified)
Warning in install.packages :
  unable to access index for repository https://mc-stan.org/r-packages/bin/windows/contrib/4.3:
  cannot open URL 'https://mc-stan.org/r-packages/bin/windows/contrib/4.3/PACKAGES'
trying URL 'https://cran.rstudio.com/bin/windows/contrib/4.3/StanHeaders_2.26.27.zip'
Content type 'application/zip' length 3030157 bytes (2.9 MB)
downloaded 2.9 MB

which indicates that it's defaulting back to CRAN

and when I try to install using this

> install.packages("rstan", repos = c("https://mc-stan.org/r-packages/", getOption("repos")))

I get this error:

Error in sink(type = "output") : invalid connection
Error: unexpected symbol in

so even following the walk though I am getting similar errors

[krisanathema]

Hi kylearmstrong! Thanks for your message. Yes, exactly, I also looked into this thread, as I was expecting it to be the official procedure and solution to my problem. But this does not work neither... I have no clue :-(
I might end up using my personal laptop at work... and hope for the configuration on my laptop to keep working...

[bob-carpenter]

Sorry you're having such a hard time here. I wish we knew how to fix Windows and R environments so they were easier for our users. The combination has given us more work than everything else put together. Windows just had to make everything different enough that the usual Unix solutions that work on Linux and Mac OS X fail on Windows. R has also proved challenging given the restrictive policies of CRAN and lack of dependency management. Things are particularly challenging right now as our R dev team's trying to push through a new version of RStan, but it's not been easy without dependency management.

One way to get around all these problems with Windows without getting new hardware is to use the Windows Subsystem for Linux: https://learn.microsoft.com/en-us/windows/wsl/install

It does look like your current RStan version is our latest stable version (2.21)

library("rstan") # observe startup messages
...
rstan (Version 2.21.8, GitRev: 2e1f913d3ca3)

but then you're trying to install our latest version (2.26).

> install.packages("rstan", repos = c("https://mc-stan.org/r-packages/", getOption("repos")))

I'm not sure why that's going through mc-stan.org rather than through GitHub. I believe CRAN had 2.26 for a while and then it got reverted back to 2.19. brms is listed at a version 2.19 with a dependency on rstan (≥ 2.19.2). It might be better to use an older version of RStan if all you're trying to do is run brms.

What we really need to do is get rid of the rstan dependency in brms so that it just depends on cmdstanr, which is non-trivial to install, but easier than rstan.

[bob-carpenter]

P.S. This should probably be an issue in the brms repo as it's fundamentally a problem installing brms.

[jgabry]

In addition to Bob’s comment: * brms can now run with cmdstanr if you can install cmdstanr and cmdstan (see mc-stan.org/cmdstanr). You have to specify backend="cmdstanr" when running brms. * you could try installing StanHeaders and RStan from source instead of binaries. See my reply here: https://discourse.mc-stan.org/t/cannot-compile-stan-program-from-r-package-brms/32294/

…

On Mon, Jul 31, 2023 at 2:49 PM Bob Carpenter ***@***.***> wrote: P.S. This should probably be an issue in the brms repo as it's fundamentally a problem installing brms. — Reply to this email directly, view it on GitHub <#1082 (comment)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/AB3PQQ6BUKP7LF3J7TSSQITXTAK4LANCNFSM6AAAAAA23ZOLXA> . You are receiving this because you are subscribed to this thread.Message ID: ***@***.***>

[krisanathema]

Thanks @bob-carpenter and @jgabry. I understand that the relationship between Windows, R and Stan is complicated and I am sorry for that.
Unfortunately, I could not install cmdstanr neither: the command
remotes::install_github("stan-dev/cmdstanr")
gives the following output:

Downloading GitHub repo stan-dev/cmdstanr@HEAD
── R CMD build ─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
Error: Failed to install 'cmdstanr' from GitHub:
  ! System command 'Rcmd.exe' failed

I will try to keep brms working on my personal computer.... and hope for the best for my tutorial on Thursday [thankfully not entirely devoted to the Bayesian approach].

I could also not install StanHeaders and RStan from source:

> install.packages(c("StanHeaders", "rstan"), type = "source")
Installing packages into ‘C:/R/library’
(as ‘lib’ is unspecified)
--- Please select a CRAN mirror for use in this session ---
trying URL 'https://ftp.gwdg.de/pub/misc/cran/src/contrib/StanHeaders_2.26.27.tar.gz'
Content type 'application/octet-stream' length 2307044 bytes (2.2 MB)
downloaded 2.2 MB

trying URL 'https://ftp.gwdg.de/pub/misc/cran/src/contrib/rstan_2.21.8.tar.gz'
Content type 'application/octet-stream' length 1203455 bytes (1.1 MB)
downloaded 1.1 MB


The downloaded source packages are in
        ‘C:\Users\Christophe Bousquet\AppData\Local\Temp\Rtmpw1ZmPV\downloaded_packages’
Warning messages:
1: In install.packages(c("StanHeaders", "rstan"), type = "source") :
  installation of package ‘StanHeaders’ had non-zero exit status
2: In install.packages(c("StanHeaders", "rstan"), type = "source") :
  installation of package ‘rstan’ had non-zero exit status
> library(rstan)
Error in library(rstan) : there is no package called ‘rstan’
> library(StanHeaders)
Error in library(StanHeaders) : there is no package called ‘StanHeaders’

But actually, all files for each package are located in a Temp folder: C:\Users\UserName\AppData\Local\Temp\Rtmpw1ZmPV\downloaded_packages
There, I have:

• cmdstanr_0.6.0.tar.gz
• rstan_2.21.8.tar.gz
• StanHeaders_2.26.27.tar.gz

Maybe I should do something with these files and put them somewhere else on my computer?
My output in response to .libPaths() is:
[1] "C:/R/library" "C:/Program Files/R/R-4.3.1/library"

When I afterwards run install.packages("brms"), this will install all packages in the folder C:/R/library.
So, to summarize:

• when I try to install rstan and StanHeaders from source, the process gets stuck and I end up with the .tar.gz files in an R temporary folder [versions rstan_2.21.8 and StanHeaders_2.26.27],
• when I install brms, all dependent packages [rstan_2.21.8, rstantools_2.3.1.1, StanHeaders_2.26.27, brms_2.19.0 and Rcpp_1.0.11] are also "correctly" (?) installed in C:/R/library

But, overall, brms still does not work:

> brm_prior3bis <- brm(Effect ~ 1, data = ObsEffect, prior = prior3)
Compiling Stan program...
Error in compileCode(f, code, language = language, verbose = verbose) : 
Error in sink(type = "output") : invalid connection

[bob-carpenter]

Have you installed the C++ toolchain using R tools and verified your C++ environment is working?

Is RCmd.exe on your path?

I'm afraid I don't know how to check either of these things in Windows.

[krisanathema]

I thought that was what was done when following these steps: https://github.com/stan-dev/rstan/wiki/Configuring-C---Toolchain-for-Windows
I have no clue how to do that on Windows, so I guess I have to let it be and accept that I cannot fix this issue.

[bob-carpenter]

That page starts with a compatibility warning that the latest RTools versions only work with RStan 2.26, which you need to get from GitHub rather than CRAN. So if you want to keep using RStan 2.21, as is on CRAN, you'll need to install an older version of RTools, like RTools4. Then you want to make sure that the C++ is working and you can compile and execute a C++ program using the tools. If you can't do that, you won't be able to run RStan or CmdStanR.

This link [ https://cran.r-project.org/bin/windows/Rtools/rtools40.html ] contains instructions on how to test if the installation can access make and then if you can install packages from source in R. Could you check that those things are working? If not, those need to be fixed before you can get RStan or CmdStanR installed on Windows.

[saudiwin]

This seems bad and I'm not sure how rstan is still on CRAN if it can't compile on Windows from CRAN sources. Without rstan, brms will fail and all the packages that depend on both.

[andrjohns]

@bgoodri how's the rstan 2.26 submission going?