Cannot resolve the "cannot allocate vector of size … " error

It looks like you’re passing three characters as data, rather than data itself. Does it differ if you use: data=list(J = J, y = y, n = n)?

Didn’t notice it not making it past the compile stage, this wouldn’t help

Stan dose not work with R-4.0.0. on Win10.
What should I do so that Stan works fine.

I updated Rtools and R.
I also cannot fined the Makevars file in the pass ~/document/.R.
Thus, using Notepad, I made it by my hands in two ways,
one is without extension and the other is with win extension.

The error “cannot allocate vector of size … ” also occured when I run my original Stan model.

I also run the follwoing codes. from R studio cosole. I listed the codes and results , separately.
Codes

cat("CXX14FLAGS += -mtune=native -march=native -Wno-ignored-attributes -Wno-deprecated-declarations", file = "~/.R/Makevars.win", append = TRUE)
readLines("~/.Renviron")
readLines("~/.R/Makevars")
example(cxxfunction, package = "inline", run.dontrun = TRUE)



library(rstan)  
  stanmodelcode <- "
data {
  int<lower=0> N;
  real y[N];
} 

parameters {
  real mu;
} 

model {
  target += normal_lpdf(mu | 0, 10);
  target += normal_lpdf(y  | mu, 1);
} 
"
  
  y <- rnorm(20) 
  dat <- list(N = 20, y = y); 
  fit <- stan(model_code = stanmodelcode, model_name = "example", 
              data = dat, iter = 2012, chains = 3, verbose = TRUE,
              sample_file = file.path(tempdir(), 'norm.csv')) 

Results
> cat(“CXX14FLAGS += -mtune=native -march=native -Wno-ignored-attributes -Wno-deprecated-declarations”, file = “~/.R/Makevars.win”, append = TRUE)
> readLines("~/.Renviron")
[1] "PATH=\"${RTOOLS40_HOME}\\usr\\bin;${PATH}\""
> readLines("~/.R/Makevars")
character(0)
> example(cxxfunction, package = “inline”, run.dontrun = TRUE)

cxxfnc> # default plugin
cxxfnc> fx <- cxxfunction( signature(x = "integer", y = "numeric" ) , '
cxxfnc+ 	return ScalarReal( INTEGER(x)[0] * REAL(y)[0] ) ;
cxxfnc+ ' )

cxxfnc> fx( 2L, 5 )
[1] 10

cxxfnc> # Rcpp plugin
cxxfnc> if( require( Rcpp ) ){
cxxfnc+ 
cxxfnc+ 	fx <- cxxfunction( signature(x = "integer", y = "numeric" ) , '
cxxfnc+ 		return wrap( as<int>(x) * as<double>(y) ) ;
cxxfnc+ 	', plugin = "Rcpp" )
cxxfnc+ 	fx( 2L, 5 )
cxxfnc+ 
cxxfnc+         ## equivalent shorter form using rcpp()
cxxfnc+ 	fx <- rcpp(signature(x = "integer", y = "numeric"),
cxxfnc+                    ' return wrap( as<int>(x) * as<double>(y) ) ; ')
cxxfnc+ 
cxxfnc+ }

cxxfnc> # RcppArmadillo plugin
cxxfnc> if( require( RcppArmadillo ) ){
cxxfnc+ 	
cxxfnc+ 	fx <- cxxfunction( signature(x = "integer", y = "numeric" ) , '
cxxfnc+ 		int dim = as<int>( x ) ;
cxxfnc+ 		arma::mat z = as<double>(y) * arma::eye<arma::mat>( dim, dim ) ;
cxxfnc+ 		return wrap( arma::accu(z) ) ;
cxxfnc+ 	', plugin = "RcppArmadillo" )
cxxfnc+ 	fx( 2L, 5 )
cxxfnc+ 	
cxxfnc+ 	
cxxfnc+ }
[1] 10
> 
> 
> 
> library(rstan)  
>   stanmodelcode <- "
+ data {
+   int<lower=0> N;
+   real y[N];
+ } 
+ 
+ parameters {
+   real mu;
+ } 
+ 
+ model {
+   target += normal_lpdf(mu | 0, 10);
+   target += normal_lpdf(y  | mu, 1);
+ } 
+ "
>   
>   y <- rnorm(20) 
>   dat <- list(N = 20, y = y); 
>   fit <- stan(model_code = stanmodelcode, model_name = "example", 
+               data = dat, iter = 2012, chains = 3, verbose = TRUE,
+               sample_file = file.path(tempdir(), 'norm.csv')) 

TRANSLATING MODEL 'example' FROM Stan CODE TO C++ CODE NOW.
successful in parsing the Stan model 'example'.
COMPILING THE C++ CODE FOR MODEL 'example' NOW.
OS: x86_64, mingw32; rstan: 2.19.3; Rcpp: 1.0.4.6; inline: 0.3.15 
 >> setting environment variables: 
PKG_LIBS =  -L"C:/Users/81909/Documents/R/win-library/4.0/StanHeaders/libs/x64" -lStanHeaders
PKG_CPPFLAGS =   -I"C:/Users/81909/Documents/R/win-library/4.0/Rcpp/include/"  -I"C:/Users/81909/Documents/R/win-library/4.0/RcppEigen/include/"  -I"C:/Users/81909/Documents/R/win-library/4.0/RcppEigen/include/unsupported"  -I"C:/Users/81909/Documents/R/win-library/4.0/BH/include" -I"C:/Users/81909/Documents/R/win-library/4.0/StanHeaders/include/src/"  -I"C:/Users/81909/Documents/R/win-library/4.0/StanHeaders/include/"  -I"C:/Users/81909/Documents/R/win-library/4.0/rstan/include" -DEIGEN_NO_DEBUG  -D_REENTRANT  -DBOOST_DISABLE_ASSERTS -DBOOST_PENDING_INTEGER_LOG2_HPP -include stan/math/prim/mat/fun/Eigen.hpp  -std=c++1y
 >> Program source :

   1 : 
   2 : // includes from the plugin
   3 : // [[Rcpp::plugins(cpp14)]]
   4 : 
   5 : // user includes
   6 : #define STAN__SERVICES__COMMAND_HPP#include <boost/integer/integer_log2.hpp>
   7 : #include <rstan/rstaninc.hpp>
   8 : // Code generated by Stan version 2.19.1
   9 : 
  10 : #include <stan/model/model_header.hpp>
  11 : 
  12 : namespace model31e475206b_example_namespace {
  13 : 
  14 : using std::istream;
  15 : using std::string;
  16 : using std::stringstream;
  17 : using std::vector;
  18 : using stan::io::dump;
  19 : using stan::math::lgamma;
  20 : using stan::model::prob_grad;
  21 : using namespace stan::math;
  22 : 
  23 : static int current_statement_begin__;
  24 : 
  25 : stan::io::program_reader prog_reader__() {
  26 :     stan::io::program_reader reader;
  27 :     reader.add_event(0, 0, "start", "model31e475206b_example");
  28 :     reader.add_event(16, 14, "end", "model31e475206b_example");
  29 :     return reader;
  30 : }
  31 : 
  32 : class model31e475206b_example : public prob_grad {
  33 : private:
  34 :         int N;
  35 :         std::vector<double> y;
  36 : public:
  37 :     model31e475206b_example(stan::io::var_context& context__,
  38 :         std::ostream* pstream__ = 0)
  39 :         : prob_grad(0) {
  40 :         ctor_body(context__, 0, pstream__);
  41 :     }
  42 : 
  43 :     model31e475206b_example(stan::io::var_context& context__,
  44 :         unsigned int random_seed__,
  45 :         std::ostream* pstream__ = 0)
  46 :         : prob_grad(0) {
  47 :         ctor_body(context__, random_seed__, pstream__);
  48 :     }
  49 : 
  50 :     void ctor_body(stan::io::var_context& context__,
  51 :                    unsigned int random_seed__,
  52 :                    std::ostream* pstream__) {
  53 :         typedef double local_scalar_t__;
  54 : 
  55 :         boost::ecuyer1988 base_rng__ =
  56 :           stan::services::util::create_rng(random_seed__, 0);
  57 :         (void) base_rng__;  // suppress unused var warning
  58 : 
  59 :         current_statement_begin__ = -1;
  60 : 
  61 :         static const char* function__ = "model31e475206b_example_namespace::model31e475206b_example";
  62 :         (void) function__;  // dummy to suppress unused var warning
  63 :         size_t pos__;
  64 :         (void) pos__;  // dummy to suppress unused var warning
  65 :         std::vector<int> vals_i__;
  66 :         std::vector<double> vals_r__;
  67 :         local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
  68 :         (void) DUMMY_VAR__;  // suppress unused var warning
  69 : 
  70 :         try {
  71 :             // initialize data block variables from context__
  72 :             current_statement_begin__ = 3;
  73 :             context__.validate_dims("data initialization", "N", "int", context__.to_vec());
  74 :             N = int(0);
  75 :             vals_i__ = context__.vals_i("N");
  76 :             pos__ = 0;
  77 :             N = vals_i__[pos__++];
  78 :             check_greater_or_equal(function__, "N", N, 0);
  79 : 
  80 :             current_statement_begin__ = 4;
  81 :             validate_non_negative_index("y", "N", N);
  82 :             context__.validate_dims("data initialization", "y", "double", context__.to_vec(N));
  83 :             y = std::vector<double>(N, double(0));
  84 :             vals_r__ = context__.vals_r("y");
  85 :             pos__ = 0;
  86 :             size_t y_k_0_max__ = N;
  87 :             for (size_t k_0__ = 0; k_0__ < y_k_0_max__; ++k_0__) {
  88 :                 y[k_0__] = vals_r__[pos__++];
  89 :             }
  90 : 
  91 : 
  92 :             // initialize transformed data variables
  93 :             // execute transformed data statements
  94 : 
  95 :             // validate transformed data
  96 : 
  97 :             // validate, set parameter ranges
  98 :             num_params_r__ = 0U;
  99 :             param_ranges_i__.clear();
 100 :             current_statement_begin__ = 8;
 101 :             num_params_r__ += 1;
 102 :         } catch (const std::exception& e) {
 103 :             stan::lang::rethrow_located(e, current_statement_begin__, prog_reader__());
 104 :             // Next line prevents compiler griping about no return
 105 :             throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***");
 106 :         }
 107 :     }
 108 : 
 109 :     ~model31e475206b_example() { }
 110 : 
 111 : 
 112 :     void transform_inits(const stan::io::var_context& context__,
 113 :                          std::vector<int>& params_i__,
 114 :                          std::vector<double>& params_r__,
 115 :                          std::ostream* pstream__) const {
 116 :         typedef double local_scalar_t__;
 117 :         stan::io::writer<double> writer__(params_r__, params_i__);
 118 :         size_t pos__;
 119 :         (void) pos__; // dummy call to supress warning
 120 :         std::vector<double> vals_r__;
 121 :         std::vector<int> vals_i__;
 122 : 
 123 :         current_statement_begin__ = 8;
 124 :         if (!(context__.contains_r("mu")))
 125 :             stan::lang::rethrow_located(std::runtime_error(std::string("Variable mu missing")), current_statement_begin__, prog_reader__());
 126 :         vals_r__ = context__.vals_r("mu");
 127 :         pos__ = 0U;
 128 :         context__.validate_dims("parameter initialization", "mu", "double", context__.to_vec());
 129 :         double mu(0);
 130 :         mu = vals_r__[pos__++];
 131 :         try {
 132 :             writer__.scalar_unconstrain(mu);
 133 :         } catch (const std::exception& e) {
 134 :             stan::lang::rethrow_located(std::runtime_error(std::string("Error transforming variable mu: ") + e.what()), current_statement_begin__, prog_reader__());
 135 :         }
 136 : 
 137 :         params_r__ = writer__.data_r();
 138 :         params_i__ = writer__.data_i();
 139 :     }
 140 : 
 141 :     void transform_inits(const stan::io::var_context& context,
 142 :                          Eigen::Matrix<double, Eigen::Dynamic, 1>& params_r,
 143 :                          std::ostream* pstream__) const {
 144 :       std::vector<double> params_r_vec;
 145 :       std::vector<int> params_i_vec;
 146 :       transform_inits(context, params_i_vec, params_r_vec, pstream__);
 147 :       params_r.resize(params_r_vec.size());
 148 :       for (int i = 0; i < params_r.size(); ++i)
 149 :         params_r(i) = params_r_vec[i];
 150 :     }
 151 : 
 152 : 
 153 :     template <bool propto__, bool jacobian__, typename T__>
 154 :     T__ log_prob(std::vector<T__>& params_r__,
 155 :                  std::vector<int>& params_i__,
 156 :                  std::ostream* pstream__ = 0) const {
 157 : 
 158 :         typedef T__ local_scalar_t__;
 159 : 
 160 :         local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
 161 :         (void) DUMMY_VAR__;  // dummy to suppress unused var warning
 162 : 
 163 :         T__ lp__(0.0);
 164 :         stan::math::accumulator<T__> lp_accum__;
 165 :         try {
 166 :             stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
 167 : 
 168 :             // model parameters
 169 :             current_statement_begin__ = 8;
 170 :             local_scalar_t__ mu;
 171 :             (void) mu;  // dummy to suppress unused var warning
 172 :             if (jacobian__)
 173 :                 mu = in__.scalar_constrain(lp__);
 174 :             else
 175 :                 mu = in__.scalar_constrain();
 176 : 
 177 :             // model body
 178 : 
 179 :             current_statement_begin__ = 12;
 180 :             lp_accum__.add(normal_log(mu, 0, 10));
 181 :             current_statement_begin__ = 13;
 182 :             lp_accum__.add(normal_log(y, mu, 1));
 183 : 
 184 :         } catch (const std::exception& e) {
 185 :             stan::lang::rethrow_located(e, current_statement_begin__, prog_reader__());
 186 :             // Next line prevents compiler griping about no return
 187 :             throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***");
 188 :         }
 189 : 
 190 :         lp_accum__.add(lp__);
 191 :         return lp_accum__.sum();
 192 : 
 193 :     } // log_prob()
 194 : 
 195 :     template <bool propto, bool jacobian, typename T_>
 196 :     T_ log_prob(Eigen::Matrix<T_,Eigen::Dynamic,1>& params_r,
 197 :                std::ostream* pstream = 0) const {
 198 :       std::vector<T_> vec_params_r;
 199 :       vec_params_r.reserve(params_r.size());
 200 :       for (int i = 0; i < params_r.size(); ++i)
 201 :         vec_params_r.push_back(params_r(i));
 202 :       std::vector<int> vec_params_i;
 203 :       return log_prob<propto,jacobian,T_>(vec_params_r, vec_params_i, pstream);
 204 :     }
 205 : 
 206 : 
 207 :     void get_param_names(std::vector<std::string>& names__) const {
 208 :         names__.resize(0);
 209 :         names__.push_back("mu");
 210 :     }
 211 : 
 212 : 
 213 :     void get_dims(std::vector<std::vector<size_t> >& dimss__) const {
 214 :         dimss__.resize(0);
 215 :         std::vector<size_t> dims__;
 216 :         dims__.resize(0);
 217 :         dimss__.push_back(dims__);
 218 :     }
 219 : 
 220 :     template <typename RNG>
 221 :     void write_array(RNG& base_rng__,
 222 :                      std::vector<double>& params_r__,
 223 :                      std::vector<int>& params_i__,
 224 :                      std::vector<double>& vars__,
 225 :                      bool include_tparams__ = true,
 226 :                      bool include_gqs__ = true,
 227 :                      std::ostream* pstream__ = 0) const {
 228 :         typedef double local_scalar_t__;
 229 : 
 230 :         vars__.resize(0);
 231 :         stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
 232 :         static const char* function__ = "model31e475206b_example_namespace::write_array";
 233 :         (void) function__;  // dummy to suppress unused var warning
 234 : 
 235 :         // read-transform, write parameters
 236 :         double mu = in__.scalar_constrain();
 237 :         vars__.push_back(mu);
 238 : 
 239 :         double lp__ = 0.0;
 240 :         (void) lp__;  // dummy to suppress unused var warning
 241 :         stan::math::accumulator<double> lp_accum__;
 242 : 
 243 :         local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
 244 :         (void) DUMMY_VAR__;  // suppress unused var warning
 245 : 
 246 :         if (!include_tparams__ && !include_gqs__) return;
 247 : 
 248 :         try {
 249 :             if (!include_gqs__ && !include_tparams__) return;
 250 :             if (!include_gqs__) return;
 251 :         } catch (const std::exception& e) {
 252 :             stan::lang::rethrow_located(e, current_statement_begin__, prog_reader__());
 253 :             // Next line prevents compiler griping about no return
 254 :             throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***");
 255 :         }
 256 :     }
 257 : 
 258 :     template <typename RNG>
 259 :     void write_array(RNG& base_rng,
 260 :                      Eigen::Matrix<double,Eigen::Dynamic,1>& params_r,
 261 :                      Eigen::Matrix<double,Eigen::Dynamic,1>& vars,
 262 :                      bool include_tparams = true,
 263 :                      bool include_gqs = true,
 264 :                      std::ostream* pstream = 0) const {
 265 :       std::vector<double> params_r_vec(params_r.size());
 266 :       for (int i = 0; i < params_r.size(); ++i)
 267 :         params_r_vec[i] = params_r(i);
 268 :       std::vector<double> vars_vec;
 269 :       std::vector<int> params_i_vec;
 270 :       write_array(base_rng, params_r_vec, params_i_vec, vars_vec, include_tparams, include_gqs, pstream);
 271 :       vars.resize(vars_vec.size());
 272 :       for (int i = 0; i < vars.size(); ++i)
 273 :         vars(i) = vars_vec[i];
 274 :     }
 275 : 
 276 :     static std::string model_name() {
 277 :         return "model31e475206b_example";
 278 :     }
 279 : 
 280 : 
 281 :     void constrained_param_names(std::vector<std::string>& param_names__,
 282 :                                  bool include_tparams__ = true,
 283 :                                  bool include_gqs__ = true) const {
 284 :         std::stringstream param_name_stream__;
 285 :         param_name_stream__.str(std::string());
 286 :         param_name_stream__ << "mu";
 287 :         param_names__.push_back(param_name_stream__.str());
 288 : 
 289 :         if (!include_gqs__ && !include_tparams__) return;
 290 : 
 291 :         if (include_tparams__) {
 292 :         }
 293 : 
 294 :         if (!include_gqs__) return;
 295 :     }
 296 : 
 297 : 
 298 :     void unconstrained_param_names(std::vector<std::string>& param_names__,
 299 :                                    bool include_tparams__ = true,
 300 :                                    bool include_gqs__ = true) const {
 301 :         std::stringstream param_name_stream__;
 302 :         param_name_stream__.str(std::string());
 303 :         param_name_stream__ << "mu";
 304 :         param_names__.push_back(param_name_stream__.str());
 305 : 
 306 :         if (!include_gqs__ && !include_tparams__) return;
 307 : 
 308 :         if (include_tparams__) {
 309 :         }
 310 : 
 311 :         if (!include_gqs__) return;
 312 :     }
 313 : 
 314 : }; // model
 315 : 
 316 : }  // namespace
 317 : 
 318 : typedef model31e475206b_example_namespace::model31e475206b_example stan_model;
 319 : 
 320 : /**
 321 :  * Define Rcpp Module to expose stan_fit's functions to R.
 322 :  */
 323 : RCPP_MODULE(stan_fit4model31e475206b_example_mod){
 324 :   Rcpp::class_<rstan::stan_fit<model31e475206b_example_namespace::model31e475206b_example,
 325 :                boost::random::ecuyer1988> >("stan_fit4model31e475206b_example")
 326 :     // .constructor<Rcpp::List>()
 327 :     .constructor<SEXP, SEXP, SEXP>()
 328 :     // .constructor<SEXP, SEXP>()
 329 :     .method("call_sampler",
 330 :             &rstan::stan_fit<model31e475206b_example_namespace::model31e475206b_example, boost::random::ecuyer1988>::call_sampler)
 331 :     .method("param_names",
 332 :             &rstan::stan_fit<model31e475206b_example_namespace::model31e475206b_example, boost::random::ecuyer1988>::param_names)
 333 :     .method("param_names_oi",
 334 :             &rstan::stan_fit<model31e475206b_example_namespace::model31e475206b_example, boost::random::ecuyer1988>::param_names_oi)
 335 :     .method("param_fnames_oi",
 336 :             &rstan::stan_fit<model31e475206b_example_namespace::model31e475206b_example, boost::random::ecuyer1988>::param_fnames_oi)
 337 :     .method("param_dims",
 338 :             &rstan::stan_fit<model31e475206b_example_namespace::model31e475206b_example, boost::random::ecuyer1988>::param_dims)
 339 :     .method("param_dims_oi",
 340 :             &rstan::stan_fit<model31e475206b_example_namespace::model31e475206b_example, boost::random::ecuyer1988>::param_dims_oi)
 341 :     .method("update_param_oi",
 342 :             &rstan::stan_fit<model31e475206b_example_namespace::model31e475206b_example, boost::random::ecuyer1988>::update_param_oi)
 343 :     .method("param_oi_tidx",
 344 :             &rstan::stan_fit<model31e475206b_example_namespace::model31e475206b_example, boost::random::ecuyer1988>::param_oi_tidx)
 345 :     .method("grad_log_prob",
 346 :             &rstan::stan_fit<model31e475206b_example_namespace::model31e475206b_example, boost::random::ecuyer1988>::grad_log_prob)
 347 :     .method("log_prob",
 348 :             &rstan::stan_fit<model31e475206b_example_namespace::model31e475206b_example, boost::random::ecuyer1988>::log_prob)
 349 :     .method("unconstrain_pars",
 350 :             &rstan::stan_fit<model31e475206b_example_namespace::model31e475206b_example, boost::random::ecuyer1988>::unconstrain_pars)
 351 :     .method("constrain_pars",
 352 :             &rstan::stan_fit<model31e475206b_example_namespace::model31e475206b_example, boost::random::ecuyer1988>::constrain_pars)
 353 :     .method("num_pars_unconstrained",
 354 :             &rstan::stan_fit<model31e475206b_example_namespace::model31e475206b_example, boost::random::ecuyer1988>::num_pars_unconstrained)
 355 :     .method("unconstrained_param_names",
 356 :             &rstan::stan_fit<model31e475206b_example_namespace::model31e475206b_example, boost::random::ecuyer1988>::unconstrained_param_names)
 357 :     .method("constrained_param_names",
 358 :             &rstan::stan_fit<model31e475206b_example_namespace::model31e475206b_example, boost::random::ecuyer1988>::constrained_param_names)
 359 :     .method("standalone_gqs",
 360 :             &rstan::stan_fit<model31e475206b_example_namespace::model31e475206b_example, boost::random::ecuyer1988>::standalone_gqs)
 361 :   ;
 362 : }
 363 : 
 364 : // declarations
 365 : extern "C" {
 366 : SEXP file31e450a57d4( ) ;
 367 : }
 368 : 
 369 : // definition
 370 : 
 371 : SEXP file31e450a57d4(  ){
 372 :  return Rcpp::wrap("example");
 373 : }
 374 : 
 375 : 
Compilation argument:
 C:/PROGRA~1/R/R-40~1.0/bin/x64/R CMD SHLIB file31e450a57d4.cpp 2> file31e450a57d4.cpp.err.txt 
C:\Rtools\mingw64\bin\g++ -m64 -std=gnu++14 -I"C:/PROGRA~1/R/R-40~1.0/include" -DNDEBUG   -I"C:/Users/81909/Documents/R/win-library/4.0/Rcpp/include/"  -I"C:/Users/81909/Documents/R/win-library/4.0/RcppEigen/include/"  -I"C:/Users/81909/Documents/R/win-library/4.0/RcppEigen/include/unsupported"  -I"C:/Users/81909/Documents/R/win-library/4.0/BH/include" -I"C:/Users/81909/Documents/R/win-library/4.0/StanHeaders/include/src/"  -I"C:/Users/81909/Documents/R/win-library/4.0/StanHeaders/include/"  -I"C:/Users/81909/Documents/R/win-library/4.0/rstan/include" -DEIGEN_NO_DEBUG  -D_REENTRANT  -DBOOST_DISABLE_ASSERTS -DBOOST_PENDING_INTEGER_LOG2_HPP -include stan/math/prim/mat/fun/Eigen.hpp  -std=c++1y -I"C:/Users/81909/Documents/R/win-library/4.0/RcppArmadillo/include" -I"C:/Users/81909/Documents/R/win-library/4.0/Rcpp/include"   -march=core2     -O2 -Wall  -mfpmath=sse -msse2 -mstackrealign -mtune=native -march=native -Wno-ignored-attributes -Wno-deprecated-declarationsCXX14FLAGS += -mtune=native -march=native -Wno-ignored-attributes -Wno-deprecated-declarationsCXX14FLAGS += -mtune=native -march=native -Wno-ignored-attributes -Wno-deprecated-declarationsCXX14FLAGS += -mtune=native -march=native -Wno-ignored-attributes -Wno-deprecated-declarationsCXX14FLAGS += -mtune=native -march=native -Wno-ignored-attributes -Wno-deprecated-declarationsCXX14FLAGS += -mtune=native -march=native -Wno-ignored-attributes -Wno-deprecated-declarationsCXX14FLAGS += -mtune=native -march=native -Wno-ignored-attributes -Wno-deprecated-declarationsCXX14FLAGS += -mtune=native -march=native -Wno-ignored-attributes -Wno-deprecated-declarationsCXX14FLAGS += -mtune=native -march=native -Wno-ignored-attributes -Wno-deprecated-declarationsCXX14FLAGS += -mtune=native -march=native -Wno-ignored-attributes -Wno-deprecated-declarationsCXX14FLAGS += -mtune=native -march=native -Wno-ignored-attributes -Wno-deprecated-declarationsCXX14FLAGS += -mtune=native -march=native -Wno-ignored-attributes -Wno-deprecated-declarationsCXX14FLAGS += -mtune=native -march=native -Wno-ignored-attributes -Wno-deprecated-declarationsCXX14FLAGS += -mtune=native -march=native -Wno-ignored-attributes -Wno-deprecated-declarations -c file31e450a57d4.cpp -o file31e450a57d4.o
sh: C:Rtoolsmingw64bing++: command not found
make: *** [C:/PROGRA~1/R/R-40~1.0/etc/x64/Makeconf:229: file31e450a57d4.o] Error 127
Error in file(con, "r") : cannot open the connection
In addition: Warning message:
In file(con, "r") :
  cannot open file 'file31e450a57d4.cpp.err.txt': No such file or directory

The slashes are pointed the wrong way in CXX14. It should be

CXX14 = C:/Rtools/mingw64/bin/g++

Note, my model and code work on R 3.6

In this thread, you said

On the other hand, in the first post in the thread, it is described

CXX14 = C:\Rtools\mingw64\bin\g++ -m$(WIN)

I am comfused…

Now, Stan works.
My Makevars.win file in the file .R is the following.

CXX14 = C:/Rtools/mingw64/bin/g++

CXX14 = C:/rtools40/mingw64/bin/g++ -m$(WIN) -v
CXX14FLAGS += -mtune=native -march=native -Wno-ignored-attributes -Wno-deprecated-declarations

I was comfused the code
CXX14 = C:/Rtools/mingw64/bin/g++

with

CXX14 = C:/rtools40/mingw64/bin/g++ -m$(WIN) -v
and I guess it is the reason why Stan does not work.

Anyway,
Thank you.

If the example compiles but not your model, are you able to test other stan models?

For example, does it work with:

stancode <- 'data {real y_mean;} parameters {real y;} model {y ~ normal(y_mean,1);}'
out = stan(model_code = stancode,data=list(y_mean=0))

If it’s specific to your model, you’ll probably need to post some code and data that causes the error for you so that we can see if it reproduces on other systems

Hi I have a similar problem but with my developing package, now I can not install it from source, I got this error re oxygenizing

roxygen2::roxygenize(clean = TRUE)
Loading varstan
Error in Rcpp::loadModule(module = “stan_fit4Bekk_mod”, what = TRUE, env = ns, :
Unable to load module “stan_fit4Bekk_mod”: cannot allocate a vector of size 15599.7 Gb

I updated my R and Rtools and my make vars file have:

CXX14FLAGS=-O3 -march=native -mtune=native
CXX11FLAGS=-O3 -march=corei7 -mtune=corei7
CXX14FLAGS += -mtune=native -march=native -Wno-ignored-attributes -Wno-deprecated-declarations
Can somebody help me please?:)

It seems like the best thing to do is put the full path the new C++ compiler in ~/.R/Makevars like

CXX14 = C:/rtools40/mingw64/bin/g++

or wherever it is installed.

Thanks @bgoodri it works :)

Here is my model that continues to run on R3.6 but not R4.0 (Windows 10):

J <- 21
n <- c(5,98,238,266,25,10,5,5,5,5,5,18,5,5,5,33,23,383,61,15,56)
y <- c(0,0,165,246,15,0,0,0,0,5,0,18,5,0,5,0,23,345,61,15,56)

ratio <- y/n
plot(y/n,ratio)
plot(n,ratio)

library(rstan)
rstan_options(auto_write = TRUE)
Sys.setenv(LOCAL_CPPFLAGS = '-march=native')
options(mc.cores = parallel::detectCores())
datafitX <- stan(file="model.stan",data=c("J","y","n"), iter = 10000, chains = 4,control=list(adapt_delta=0.8, max_treedepth =10))

model.stan as follows:

data {
  int<lower=0> J; 
  int<lower=0> y[J]; 
  int<lower=0> n[J]; 
}
parameters {
  real<lower=0,upper=1> theta[J]; 
  real<lower=0,upper=1> lambda; 
  real<lower=0.1> kappa; 
}
transformed parameters {
  real<lower=0> alpha;
  real<lower=0> beta; 
  alpha = lambda* kappa;  
  beta =   (1 - lambda)* kappa; 
}
model {
  lambda ~ uniform(0,1); 
  kappa ~ uniform(0.1,5); 
  theta ~ beta(alpha,beta); 
  y ~ binomial(n,theta); 
  
}
generated quantities {
  real<lower=0,upper=1> avg; 
  int<lower=0,upper=1> above_avg[J]; 
  int<lower=1,upper=J> rnk[J]; 
  int<lower=0,upper=1> highest[J]; 
  avg = mean(theta);
    for (j in 1:J)
    above_avg[j] = (theta[j] > avg);
    for (j in 1:J) {
    rnk[j] = rank(theta,j) + 1;
    highest[j] = rnk[j] == 1;
  }
}

Can somebody please help me. I am continuing to get the error “cannot callocate vector of size …” when running the above model using R4 and Rtools40 on Windows 10.

This model runs for me on Windows with RTools40. When I compile it with verbose = TRUE, it compiles like

Compilation argument:
C:/PROGRA~1/R/R-40~1.0/bin/x64/R CMD SHLIB file40e424ba7b98.cpp 2> file40e424ba7b98.cpp.err.txt
C:/RBuildTools/4.0/mingw64/bin/g++ -m64 -std=gnu++14 -I"C:/PROGRA~1/R/R-40~1.0/include" -DNDEBUG -I"C:/Users/Stan/Documents/R/win-library/4.0/Rcpp/include/" -I"C:/Users/Stan/Documents/R/win-library/4.0/RcppEigen/include/" -I"C:/Users/Stan/Documents/R/win-library/4.0/RcppEigen/include/unsupported" -I"C:/Users/Stan/Documents/R/win-library/4.0/BH/include" -I"C:/Users/Stan/Documents/R/win-library/4.0/StanHeaders/include/src/" -I"C:/Users/Stan/Documents/R/win-library/4.0/StanHeaders/include/" -I"C:/Users/Stan/Documents/R/win-library/4.0/rstan/include" -DEIGEN_NO_DEBUG -D_REENTRANT -DBOOST_DISABLE_ASSERTS -DBOOST_PENDING_INTEGER_LOG2_HPP -include stan/math/prim/mat/fun/Eigen.hpp -std=c++1y -march=native -O3 -march=native -mtune=native -Wno-ignored-attributes -Wno-deprecated-declarations -c file40e424ba7b98.cpp -o file40e424ba7b98.o

How is your Compilation argument: line different that that?

But do you have both version of R and Rtools installed at the same time? Maybe is that!

I took down previous versions of Rtools and only have Rtools40 installed.
How would I get the compilation argument?
Console shows this:

TRANSLATING MODEL ‘flights_model’ FROM Stan CODE TO C++ CODE NOW.
successful in parsing the Stan model ‘flights_model’.

CHECKING DATA AND PREPROCESSING FOR MODEL ‘flights_model’ NOW.

COMPILING MODEL ‘flights_model’ NOW.
Error: cannot allocate vector of size 15482.7 Gb

You have to call stan or stan_model with the verbose = TRUE argument.

Ok I did and above is what I got.

You have the same Compilation argument as I do?

But I am still getting the error. We have not solved the issue. Any recommendations?

What is your Complilation argument line?