Package 'stanr'

(character vector) Which variables to extract. If NULL (the default), all variables are returned.

(logical) Should warmup draws be included? Defaults to FALSE. Errors unless the fit is a $sample() run with save_warmup = TRUE.

(string) The format of the returned draws. Must be a valid format from the posterior package. Defaults depend on the fitting method: "draws_array" for MCMC and generated quantities, "draws_matrix" for all other methods.

(logical) Should the exposed functions also be assigned into the global environment?

(logical) Should compiler progress messages be printed?

(string) The name of the variable in the Stan program containing the pointwise log-likelihood. The default is to look for "log_lik". This argument is passed to the $draws() method.

(multiple options) How to handle the r_eff argument for loo(). r_eff measures the amount of autocorrelation in MCMC draws, and is used to compute more accurate ESS and MCSE estimates for pointwise and total ELPDs.

• TRUE will call loo::relative_eff() to compute the r_eff argument to pass to loo::loo.array().

• FALSE (the default) or NULL will avoid computing r_eff, which can be very slow. The reported ESS and MCSE estimates may be over-optimistic if the posterior draws are far from independent.

• If r_eff is anything else, that object will be passed as the r_eff argument to loo::loo.array().

(logical) Whether to use a moment-matching correction for problematic observations. The default is FALSE. Using moment_match = TRUE uses the fit's model methods (see fit-method-model-methods) to automatically supply the functions for the log_lik_i, unconstrain_pars, log_prob_upars, and log_lik_i_upars arguments to loo::loo_moment_match().

Other arguments (e.g., cores, save_psis, etc.) passed to loo::loo.array() or loo::loo_moment_match.default() (if moment_match = TRUE is set).

(logical) For ⁠$inv_metric()⁠: return each chain's inverse metric as a matrix? For a diagonal metric, TRUE (the default) wraps the adapted diagonal in diag(); FALSE returns it as a vector. For a dense metric, the matrix is always returned and matrix = FALSE is an error.

(character vector) For ⁠$diagnostic_summary()⁠: which diagnostics to check. One or more of "divergences", "treedepth", and "ebfmi". The default checks all three; NULL or "" checks none.

(logical) For ⁠$diagnostic_summary()⁠: should messages about problems found in the requested diagnostics be suppressed? The default, FALSE, prints them in addition to returning the values. Diagnostics that could not be computed at all (rather than computed and found problematic) always warn, regardless of quiet.

(character vector) Which variables to extract. If NULL (the default), all variables are returned.

(numeric vector) The unconstrained parameter values at which to evaluate the function.

(logical) Should the log density be adjusted by the abs-determinant of the Jacobian of the inverse transformation?

(named list) Constrained parameter values to unconstrain.

A posterior draws object, or NULL to use the fit's draws.

(string) The format of the returned draws. Must be a valid format from the posterior package. Defaults depend on the fitting method: "draws_array" for MCMC and generated quantities, "draws_matrix" for all other methods.

(logical) Should warmup draws be included? Defaults to FALSE. Errors unless the fit is a $sample() run with save_warmup = TRUE.

(logical) Include transformed parameters?

(logical) Include generated quantities?

(integer) Number of digits for numeric summary statistics.

(integer) Maximum number of rows to print.

(string) Path where the file should be saved.

Additional arguments passed to base::saveRDS().

Additional arguments passed to posterior::summarise_draws().

(logical) Should stanc's pedantic-mode warnings be requested? The default is FALSE.

(logical) Should the success message be suppressed? The default is FALSE.

(logical) Should the model be recompiled even if it has not been modified since it was last compiled? The default is FALSE.

(logical) Should verbose output from compilation be suppressed? The default is TRUE.

(logical) Should the Stan program's functions block be exposed as part of this compilation? Defaults to whatever was set at stan_model() construction time. See $expose_stan_functions().

(named list) Values for all or part of the data block in the Stan program. Each element is named after the corresponding Stan variable and shaped as follows:

A length-1 R vector is read as a scalar, so a vector[1], ⁠array[1] ...⁠, or length-1 tuple-slot container value must be given an explicit shape (as.array(x) or dim(x) <- 1L) to match its declared dimension.

Real-valued input is accepted wherever a complex type is declared – it is coerced automatically, including inside tuple slots. All other Stan types use their ordinary R representation (numeric/integer scalars, vectors, matrices, arrays).

As a power-user escape hatch, tuple variables can instead be supplied pre-flattened using dotted names (e.g. list(t.1 = ..., t.2 = ...) for a tuple t), bypassing the list-shape conversion above; this is not the primary documented path. One caveat applies: a dotted entry for a complex tuple slot is assumed to hold exactly one complex value per enclosing array element, which is only correct when that slot is itself a plain (non-container) complex – for anything else (e.g. a complex_vector tuple slot), use the list shapes above instead.

(integer) The random seed for reproducibility.

Initial values for parameters. Either NULL (equivalent to the default radius of 2), a non-negative number, used as the range of CmdStan-style random initialization (Uniform(-init, init) on the unconstrained scale; the default is 2), or a named list / named numeric vector of constrained parameter values. Supplied values are shared by all chains; parameters not covered by the supplied values are randomly initialized with the default range. A named list may include tuple-shaped list entries and R complex values for tuple(...)/complex parameters, using the same canonical shapes (and the same dotted-name escape hatch) documented for data.

(number) The finite difference step size.

(number) The maximum allowed relative error.

(logical) When TRUE (the default), print progress and informational output (e.g. iteration and timing messages) to the console. Set to FALSE to silence it. Suppressed output is still recorded and available via the fit's ⁠$output()⁠ method.

(logical) When TRUE (the default), print informational messages about numerical exceptions – e.g. Metropolis proposal rejections and rejected initial values. Set to FALSE to silence them. Suppressed messages are still recorded and available via the fit's ⁠$output()⁠ method.

(logical) Should the exposed functions also be assigned into the global environment? The default, FALSE, only populates ⁠$functions⁠.

(logical) Should compiler progress messages be printed? No compilation happens (so this has no effect) if the functions were already compiled, e.g. via compile_standalone = TRUE.

(logical) Should the formatted code be written back to $stan_file()? The default is FALSE. Requires a model created with stan_file, and does not update this object's in-memory code – construct a new StanModel to pick up the change.

(logical or character) FALSE (the default) formats without canonicalizing, TRUE also canonicalizes deprecated syntax, and a character vector requests specific canonicalizations (e.g. c("braces", "parentheses")).

(logical) When overwrite_file = TRUE, should the original file be backed up first? The default is TRUE.

(integer) Maximum output line width. The default, NULL, uses stanc's default.

(logical) Should the backup message be suppressed? The default is FALSE.

A StanFit object, or anything accepted by posterior::as_draws_matrix(), containing draws with every model parameter present by name (e.g. beta[1], not a positional column).

(named list) Values for all or part of the data block in the Stan program. Each element is named after the corresponding Stan variable and shaped as follows:

A length-1 R vector is read as a scalar, so a vector[1], ⁠array[1] ...⁠, or length-1 tuple-slot container value must be given an explicit shape (as.array(x) or dim(x) <- 1L) to match its declared dimension.

Real-valued input is accepted wherever a complex type is declared – it is coerced automatically, including inside tuple slots. All other Stan types use their ordinary R representation (numeric/integer scalars, vectors, matrices, arrays).

As a power-user escape hatch, tuple variables can instead be supplied pre-flattened using dotted names (e.g. list(t.1 = ..., t.2 = ...) for a tuple t), bypassing the list-shape conversion above; this is not the primary documented path. One caveat applies: a dotted entry for a complex tuple slot is assumed to hold exactly one complex value per enclosing array element, which is only correct when that slot is itself a plain (non-container) complex – for anything else (e.g. a complex_vector tuple slot), use the list shapes above instead.

(integer) The random seed for reproducibility.

(integer) The total number of threads to use. Defaults to all available threads.

(logical) When TRUE (the default), print progress and informational output (e.g. iteration and timing messages) to the console. Set to FALSE to silence it. Suppressed output is still recorded and available via the fit's ⁠$output()⁠ method.

(logical) When TRUE (the default), print informational messages about numerical exceptions – e.g. Metropolis proposal rejections and rejected initial values. Set to FALSE to silence them. Suppressed messages are still recorded and available via the fit's ⁠$output()⁠ method.

(integer vector) c(platform_id, device_id) identifying the OpenCL platform/device to run on. Only meaningful for a model compiled with use_opencl = TRUE (see stan_model()); errors if the model was not compiled with OpenCL support. Defaults to NULL, meaning select_opencl_device() is never called and the platform/device baked in at compile time (0/0) is used.

(named list) Values for all or part of the data block in the Stan program. Each element is named after the corresponding Stan variable and shaped as follows:

A length-1 R vector is read as a scalar, so a vector[1], ⁠array[1] ...⁠, or length-1 tuple-slot container value must be given an explicit shape (as.array(x) or dim(x) <- 1L) to match its declared dimension.

Real-valued input is accepted wherever a complex type is declared – it is coerced automatically, including inside tuple slots. All other Stan types use their ordinary R representation (numeric/integer scalars, vectors, matrices, arrays).

As a power-user escape hatch, tuple variables can instead be supplied pre-flattened using dotted names (e.g. list(t.1 = ..., t.2 = ...) for a tuple t), bypassing the list-shape conversion above; this is not the primary documented path. One caveat applies: a dotted entry for a complex tuple slot is assumed to hold exactly one complex value per enclosing array element, which is only correct when that slot is itself a plain (non-container) complex – for anything else (e.g. a complex_vector tuple slot), use the list shapes above instead.

(integer) The random seed for reproducibility.

Initial values for parameters. Either NULL (equivalent to the default radius of 2), a non-negative number, used as the range of CmdStan-style random initialization (Uniform(-init, init) on the unconstrained scale; the default is 2), or a named list / named numeric vector of constrained parameter values. Supplied values are shared by all chains; parameters not covered by the supplied values are randomly initialized with the default range. A named list may include tuple-shaped list entries and R complex values for tuple(...)/complex parameters, using the same canonical shapes (and the same dotted-name escape hatch) documented for data.

A numeric vector of parameter values at the mode, or a StanMLE object from $optimize(). If NULL, optimization is run first.

(list) Additional arguments to pass to $optimize() when finding the mode.

(logical) Should the log density be adjusted by the abs-determinant of the Jacobian of the inverse transformation?

(integer) The number of draws from the Laplace approximation.

(logical) Should the log density of the Laplace approximation be calculated?

(integer) The total number of threads to use. Defaults to all available threads.

(logical) When TRUE (the default), print progress and informational output (e.g. iteration and timing messages) to the console. Set to FALSE to silence it. Suppressed output is still recorded and available via the fit's ⁠$output()⁠ method.

(logical) When TRUE (the default), print informational messages about numerical exceptions – e.g. Metropolis proposal rejections and rejected initial values. Set to FALSE to silence them. Suppressed messages are still recorded and available via the fit's ⁠$output()⁠ method.

(integer vector) c(platform_id, device_id) identifying the OpenCL platform/device to run on. Only meaningful for a model compiled with use_opencl = TRUE (see stan_model()); errors if the model was not compiled with OpenCL support. Defaults to NULL, meaning select_opencl_device() is never called and the platform/device baked in at compile time (0/0) is used.

(named list) Values for all or part of the data block in the Stan program. Each element is named after the corresponding Stan variable and shaped as follows:

A length-1 R vector is read as a scalar, so a vector[1], ⁠array[1] ...⁠, or length-1 tuple-slot container value must be given an explicit shape (as.array(x) or dim(x) <- 1L) to match its declared dimension.

Real-valued input is accepted wherever a complex type is declared – it is coerced automatically, including inside tuple slots. All other Stan types use their ordinary R representation (numeric/integer scalars, vectors, matrices, arrays).

As a power-user escape hatch, tuple variables can instead be supplied pre-flattened using dotted names (e.g. list(t.1 = ..., t.2 = ...) for a tuple t), bypassing the list-shape conversion above; this is not the primary documented path. One caveat applies: a dotted entry for a complex tuple slot is assumed to hold exactly one complex value per enclosing array element, which is only correct when that slot is itself a plain (non-container) complex – for anything else (e.g. a complex_vector tuple slot), use the list shapes above instead.

(integer) The random seed for reproducibility.

Initial values for parameters. Either NULL (equivalent to the default radius of 2), a non-negative number, used as the range of CmdStan-style random initialization (Uniform(-init, init) on the unconstrained scale; the default is 2), or a named list / named numeric vector of constrained parameter values. Supplied values are shared by all chains; parameters not covered by the supplied values are randomly initialized with the default range. A named list may include tuple-shaped list entries and R complex values for tuple(...)/complex parameters, using the same canonical shapes (and the same dotted-name escape hatch) documented for data.

(string) The optimization algorithm: "lbfgs", "bfgs", or "newton".

(logical) Should the log density be adjusted by the abs-determinant of the Jacobian of the inverse transformation?

(number) Initial step size for LBFGS.

(integer) Maximum number of optimization iterations.

(number) Absolute tolerance for changes in objective value.

(number) Relative tolerance for changes in objective value.

(number) Absolute tolerance for the norm of the gradient.

(number) Relative tolerance for the norm of the gradient.

(number) Absolute tolerance for changes in parameter values.

(integer) Number of corrections in LBFGS approximation.

(logical) Should optimization iterations be saved? When TRUE, $draws() on the returned StanMLE exposes the full optimization path (one row per saved iteration, including the initial point) instead of a single row for the final estimate. $mle() is unaffected either way and always reflects the final iteration.

(integer) The total number of threads to use. Defaults to all available threads.

(logical) When TRUE (the default), print progress and informational output (e.g. iteration and timing messages) to the console. Set to FALSE to silence it. Suppressed output is still recorded and available via the fit's ⁠$output()⁠ method.

(logical) When TRUE (the default), print informational messages about numerical exceptions – e.g. Metropolis proposal rejections and rejected initial values. Set to FALSE to silence them. Suppressed messages are still recorded and available via the fit's ⁠$output()⁠ method.

(integer vector) c(platform_id, device_id) identifying the OpenCL platform/device to run on. Only meaningful for a model compiled with use_opencl = TRUE (see stan_model()); errors if the model was not compiled with OpenCL support. Defaults to NULL, meaning select_opencl_device() is never called and the platform/device baked in at compile time (0/0) is used.

(named list) Values for all or part of the data block in the Stan program. Each element is named after the corresponding Stan variable and shaped as follows:

A length-1 R vector is read as a scalar, so a vector[1], ⁠array[1] ...⁠, or length-1 tuple-slot container value must be given an explicit shape (as.array(x) or dim(x) <- 1L) to match its declared dimension.

Real-valued input is accepted wherever a complex type is declared – it is coerced automatically, including inside tuple slots. All other Stan types use their ordinary R representation (numeric/integer scalars, vectors, matrices, arrays).

As a power-user escape hatch, tuple variables can instead be supplied pre-flattened using dotted names (e.g. list(t.1 = ..., t.2 = ...) for a tuple t), bypassing the list-shape conversion above; this is not the primary documented path. One caveat applies: a dotted entry for a complex tuple slot is assumed to hold exactly one complex value per enclosing array element, which is only correct when that slot is itself a plain (non-container) complex – for anything else (e.g. a complex_vector tuple slot), use the list shapes above instead.

(integer) The random seed for reproducibility.

Initial values for parameters. Either NULL (equivalent to the default radius of 2), a non-negative number, used as the range of CmdStan-style random initialization (Uniform(-init, init) on the unconstrained scale; the default is 2), or a named list / named numeric vector of constrained parameter values. Supplied values are shared by all chains; parameters not covered by the supplied values are randomly initialized with the default range. A named list may include tuple-shaped list entries and R complex values for tuple(...)/complex parameters, using the same canonical shapes (and the same dotted-name escape hatch) documented for data.

(integer) The number of paths to use.

(integer) Number of draws per path.

(integer) Total number of draws from the approximation.

(integer) Maximum LBFGS iterations per path.

(integer) Number of draws for ELBO estimation.

(logical) Should single path results be saved?

(logical) Should Pareto smoothed importance sampling resampling be used?

(logical) Should the log density be calculated?

(integer) The total number of threads to use. Defaults to all available threads.

(logical) When TRUE (the default), print progress and informational output (e.g. iteration and timing messages) to the console. Set to FALSE to silence it. Suppressed output is still recorded and available via the fit's ⁠$output()⁠ method.

(logical) When TRUE (the default), print informational messages about numerical exceptions – e.g. Metropolis proposal rejections and rejected initial values. Set to FALSE to silence them. Suppressed messages are still recorded and available via the fit's ⁠$output()⁠ method.

(integer vector) c(platform_id, device_id) identifying the OpenCL platform/device to run on. Only meaningful for a model compiled with use_opencl = TRUE (see stan_model()); errors if the model was not compiled with OpenCL support. Defaults to NULL, meaning select_opencl_device() is never called and the platform/device baked in at compile time (0/0) is used.

(named list) Values for all or part of the data block in the Stan program. Each element is named after the corresponding Stan variable and shaped as follows:

A length-1 R vector is read as a scalar, so a vector[1], ⁠array[1] ...⁠, or length-1 tuple-slot container value must be given an explicit shape (as.array(x) or dim(x) <- 1L) to match its declared dimension.

Real-valued input is accepted wherever a complex type is declared – it is coerced automatically, including inside tuple slots. All other Stan types use their ordinary R representation (numeric/integer scalars, vectors, matrices, arrays).

As a power-user escape hatch, tuple variables can instead be supplied pre-flattened using dotted names (e.g. list(t.1 = ..., t.2 = ...) for a tuple t), bypassing the list-shape conversion above; this is not the primary documented path. One caveat applies: a dotted entry for a complex tuple slot is assumed to hold exactly one complex value per enclosing array element, which is only correct when that slot is itself a plain (non-container) complex – for anything else (e.g. a complex_vector tuple slot), use the list shapes above instead.

(integer) The random seed for reproducibility.

(integer) How often (in iterations) to print progress.

Initial values for parameters. Either NULL (equivalent to the default radius of 2), a non-negative number, used as the range of CmdStan-style random initialization (Uniform(-init, init) on the unconstrained scale; the default is 2), or a named list / named numeric vector of constrained parameter values. Supplied values are shared by all chains; parameters not covered by the supplied values are randomly initialized with the default range. A named list may include tuple-shaped list entries and R complex values for tuple(...)/complex parameters, using the same canonical shapes (and the same dotted-name escape hatch) documented for data.

(integer) The number of MCMC chains.

(integer vector) The IDs for each chain.

(integer) The total number of threads to use. Defaults to all available threads.

(integer) The number of warmup iterations.

(integer) The number of sampling iterations.

(logical) Should warmup samples be saved? Ignored when fixed_param = TRUE, since that mode runs no warmup and so has nothing to save.

(integer) Thin interval.

(integer) Maximum tree depth for NUTS.

(logical) Should step size adaptation be used?

(number) Target acceptance statistic for HMC.

(number) Step size for HMC.

Character string indicating the metric to use: "diag_e", "dense_e", or "unit_e".

(numeric) Initial inverse mass matrix values.

(integer) Adaptation phase: initial buffer length.

(integer) Adaptation phase: terminal buffer length.

(integer) Adaptation phase: window length.

(logical) Treat all parameters as fixed (no adaptation).

(logical) When TRUE (the default), print progress and informational output (e.g. iteration and timing messages) to the console. Set to FALSE to silence it. Suppressed output is still recorded and available via the fit's ⁠$output()⁠ method.

(logical) When TRUE (the default), print informational messages about numerical exceptions – e.g. Metropolis proposal rejections and rejected initial values. Set to FALSE to silence them. Suppressed messages are still recorded and available via the fit's ⁠$output()⁠ method.

(character vector) Which sampler diagnostics to check immediately after sampling, printing a warning message for any problems found – see $diagnostic_summary(). One or more of "divergences", "treedepth", and "ebfmi". The default checks all three; NULL or "" skips the check entirely. Ignored when fixed_param = TRUE.

(string) The sampling engine: "nuts", "static", or "walnuts" (see walnutpie). walnuts only supports metric = "diag_e" and adapt_engaged = TRUE. It reuses max_treedepth as the maximum trajectory doublings, adapt_delta as the step size acceptance target, and step_size as the initial step size; refresh, step_size_jitter, init_buffer, term_buffer, window, and adapt_gamma/adapt_kappa/adapt_t0 are ignored, and no sampler diagnostics or progress output are produced.

(number) Integration time for static HMC.

(number) Jitter for step size after adaptation.

(number) Adaptation hyperparameter for dual averaging.

(number) Adaptation hyperparameter for dual averaging.

(number) Adaptation hyperparameter for dual averaging.

(integer) walnuts only: maximum number of step size halvings per macro step.

(integer) walnuts only: minimum number of micro steps per macro step.

(number) walnuts only: maximum allowed error in the Hamiltonian at a macro step.

(number) walnuts only: initial count for the mass matrix estimator.

(number) walnuts only: additive smoothing for the mass matrix estimator.

(number) walnuts only: target number of macro steps per iteration.

(number) walnuts only: learning rate for the Adam step size adaptation.

(number) walnuts only: gradient decay rate for the Adam step size adaptation.

(number) walnuts only: squared gradient decay rate for the Adam step size adaptation.

(number) walnuts only: stabilization term for the Adam step size adaptation.

(number) walnuts only: learning rate decay exponent for the Adam step size adaptation.

(integer vector) c(platform_id, device_id) identifying the OpenCL platform/device to run on. Only meaningful for a model compiled with use_opencl = TRUE (see stan_model()); errors if the model was not compiled with OpenCL support. Defaults to NULL, meaning select_opencl_device() is never called and the platform/device baked in at compile time (0/0) is used.

(named list) Values for all or part of the data block in the Stan program. Each element is named after the corresponding Stan variable and shaped as follows:

A length-1 R vector is read as a scalar, so a vector[1], ⁠array[1] ...⁠, or length-1 tuple-slot container value must be given an explicit shape (as.array(x) or dim(x) <- 1L) to match its declared dimension.

Real-valued input is accepted wherever a complex type is declared – it is coerced automatically, including inside tuple slots. All other Stan types use their ordinary R representation (numeric/integer scalars, vectors, matrices, arrays).

As a power-user escape hatch, tuple variables can instead be supplied pre-flattened using dotted names (e.g. list(t.1 = ..., t.2 = ...) for a tuple t), bypassing the list-shape conversion above; this is not the primary documented path. One caveat applies: a dotted entry for a complex tuple slot is assumed to hold exactly one complex value per enclosing array element, which is only correct when that slot is itself a plain (non-container) complex – for anything else (e.g. a complex_vector tuple slot), use the list shapes above instead.

(integer) The random seed for reproducibility.

Initial values for parameters. Either NULL (equivalent to the default radius of 2), a non-negative number, used as the range of CmdStan-style random initialization (Uniform(-init, init) on the unconstrained scale; the default is 2), or a named list / named numeric vector of constrained parameter values. Supplied values are shared by all chains; parameters not covered by the supplied values are randomly initialized with the default range. A named list may include tuple-shaped list entries and R complex values for tuple(...)/complex parameters, using the same canonical shapes (and the same dotted-name escape hatch) documented for data.

(string) The variational inference algorithm: "meanfield" or "fullrank".

(integer) The number of ADVI iterations.

(integer) Number of samples to use for gradient estimation.

(integer) Number of samples for ELBO evaluation.

(number) Learning rate for ADVI.

(logical) Should the learning rate be adapted?

(integer) Number of iterations for learning rate adaptation.

(number) Relative tolerance for ELBO convergence.

(integer) How often to evaluate the ELBO.

(integer) The number of draws from the variational approximation.

(integer) The total number of threads to use. Defaults to all available threads.

(logical) When TRUE (the default), print progress and informational output (e.g. iteration and timing messages) to the console. Set to FALSE to silence it. Suppressed output is still recorded and available via the fit's ⁠$output()⁠ method.

(logical) When TRUE (the default), print informational messages about numerical exceptions – e.g. Metropolis proposal rejections and rejected initial values. Set to FALSE to silence them. Suppressed messages are still recorded and available via the fit's ⁠$output()⁠ method.

(integer vector) c(platform_id, device_id) identifying the OpenCL platform/device to run on. Only meaningful for a model compiled with use_opencl = TRUE (see stan_model()); errors if the model was not compiled with OpenCL support. Defaults to NULL, meaning select_opencl_device() is never called and the platform/device baked in at compile time (0/0) is used.

(string) The path to a .stan file containing a Stan program. If stan_file is not specified then code must be specified.

(string) A Stan program as a single string. If code is not specified then stan_file must be specified.

(logical) Should the model be compiled? The default is TRUE. If FALSE compilation can be done later via the $compile() method.

(string) The name to use for the model. If NULL (the default), the model name is derived from the Stan file name (if provided) or set to "model".

(character vector) Paths to directories where Stan should look for files specified in ⁠#include⁠ directives.

(string) A path to a single C++ header file to prepend to the generated model code. A legacy alias for external_cpp; supplied headers are appended to external_cpp and treated identically.

(list) C++ compilation options, merged into the Makevars flags used to compile the model. Each element is either:

• A named element, e.g. list(CXX = "g++"). This overrides any value computed internally for that name (e.g. CXXFLAGS), replacing it rather than adding to it.

• An unnamed string of the form "<NAME> = <value>", e.g. "CXX = g++". Equivalent to the named form above – also overrides.

• An unnamed string of the form "<NAME> += <value>", e.g. "CXXFLAGS += -Wno-psabi". Appends ⁠<value>⁠ to any existing value for ⁠<NAME>⁠ instead of replacing it (space-separated), matching how ⁠+=⁠ behaves in a Makevars file.

Entries are applied in list order, so the same name may appear more than once, e.g. list(CXXFLAGS = "-O3", "CXXFLAGS += -Wall") first overrides CXXFLAGS, then appends to it.

(list) Stan-to-C++ transpiler options. Not yet supported.

(logical) Should the model be recompiled even if it has not been modified? The default is FALSE, but can be set via the stanr_force_recompile option.

(logical) Should precompiled headers be used to speed up compilation? The default is TRUE. Automatically disabled when cpp_options overrides compiler flags (e.g. CXXFLAGS), since the precompiled header is not built with those flags.

(logical) Should verbose output from compilation be suppressed? The default is TRUE.

(character vector) Paths to C++ files to prepend to the generated model code. Useful for defining custom functions.

(logical) Should the model be compiled with OpenCL support? The default is FALSE. When TRUE, stanc generates OpenCL-accelerated code for the functions that support it (most notably bernoulli_logit_glm and other GLM likelihoods), and the compiled model can run its computation on an OpenCL device. Which platform/device is used at runtime is controlled by the opencl_ids argument of the fit methods (e.g. $sample()), not by this argument; opencl_ids = NULL (the default there) means select_opencl_device() is simply never called, so the platform/device baked in at compile time (0/0) is used. The default OpenCL link flags are "-framework OpenCL" on macOS and "-lOpenCL" elsewhere.

(logical) Should the Stan program's functions block be exposed as part of this compilation? The default is FALSE. When TRUE, ⁠$functions⁠ is already populated when stan_model() returns – equivalent to FALSE here plus calling $expose_stan_functions() immediately after, but without a second compile. See $expose_stan_functions() for what gets exposed and how.

(string) Either "compiled" (the default), which compiles the model to a native shared library, or "stanli", which interprets the model instead of compiling it. The "stanli" backend supports constrained-scale initialization, but not use_opencl, external_cpp, or non-empty cpp_options. Its exposed-function backend supports deterministic integer/real scalar and container functions, but not RNG, ⁠_lp⁠, void, complex, or tuple functions.

Stan model code as a single string.

Character vector of directories to search for Stan include files. Defaults to no include directories.

Generate standalone function definitions.

Enable OpenCL code generation.

stanc optimization level.

Allow undefined functions.

Request pedantic compiler warnings.

Request uninitialized-variable warnings.

NULL (the default), or a character vector of paths to C++ source or header files. Their contents are prepended to the generated C++, in order. Supplying this argument enables allow_undefined so Stan functions implemented by the supplied C++ can be declared in the model.