Error(s) in re-building vignettes:
Error in readRDS(file) : error reading from connection
--- re-building ‘guidline.Rmd’ using rmarkdown
DMC                    package:ream                    R Documentation

_D_i_f_f_u_s_i_o_n _M_o_d_e_l _f_o_r _C_o_n_f_l_i_c_t _T_a_s_k_s

_D_e_s_c_r_i_p_t_i_o_n:

     The DMC is a two-process evidence accumulation model for the study
     of conflict tasks. It sums together a controlled and an automatic
     process to generate a single accumulator for generating the
     likelihood function. This accumulator has the same parameters as
     the SDDM with the exception of the drift rate, given by

     v(x,t) = s*A*exp(-t/tau)*[e*t/(tau*(alpha-1))]^{alpha-1}*[(alpha-1)/t - 1/tau] + mu_c.
     
_U_s_a_g_e:

     dDMC(rt, resp, phi, x_res = "default", t_res = "default")
     
     pDMC(rt, resp, phi, x_res = "default", t_res = "default")
     
     rDMC(n, phi, dt = 1e-05)
     
_A_r_g_u_m_e_n_t_s:

      rt: vector of response times

    resp: vector of responses ("upper" and "lower")

     phi: parameter vector in the following order:

           1. Non-decision time (t_{nd}). Time for non-decision
              processes such as stimulus encoding and response
              execution. Total decision time t is the sum of the
              decision and non-decision times.

           2. Relative start (w). Sets the start point of accumulation
              as a ratio of the two decision thresholds. Related to the
              absolute start z point via equation z = b_l + w*(b_u -
              b_l).

           3. Coherence parameter (s). Sets stimulus coherence. If s =
              1, coherent condition; if s = 0, neutral condition; if s
              = -1, incoherent condition.

           4. Automatic process amplitude (A). Max value of automatic
              process.

           5. Scale parameter (tau). Contributes to time automatic
              process. Time to max t_{max} = (alpha – 1)*tau.

           6. Shape parameter (alpha). Indicates the shape of the
              automatic process. Must have value more than 1 (alpha >
              1).

           7. Drift rate of the controlled process (mu_c).

           8. Noise scale (sigma). Model noise scale parameter.

           9. Decision thresholds (b). Sets the location of each
              decision threshold. The upper threshold b_u is above 0
              and the lower threshold b_l is below 0 such that b_u =
              -b_l = b. The threshold separation a = 2b.

          10. Contamination (g). Sets the strength of the contamination
              process. Contamination process is a uniform distribution
              f_c(t) where f_c(t) = 1/(g_u-g_l) if g_l <= t <= g_u and
              f_c(t) = 0 if t < g_l or t > g_u. It is combined with PDF
              f_i(t) to give the final combined distribution f_{i,c}(t)
              = g*f_c(t) + (1-g)*f_i(t), which is then output by the
              program. If g = 0, it just outputs f_i(t).

          11. Lower bound of contamination distribution (g_l). See
              parameter g.

          12. Upper bound of contamination distribution (g_u). See
              parameter g.

   x_res: spatial/evidence resolution

   t_res: time resolution

       n: number of samples

      dt: step size of time. We recommend 0.00001 (1e-5)

_V_a_l_u_e:

     For the density a list of PDF values, log-PDF values, and the sum
     of the log-PDFs, for the distribution function a list of of CDF
     values, log-CDF values, and the sum of the log-CDFs, and for the
     random sampler a list of response times (rt) and response
     thresholds (resp).

_A_u_t_h_o_r(_s):

     Raphael Hartmann & Matthew Murrow

_R_e_f_e_r_e_n_c_e_s:

     Ulrich, R., Schröter, H., Leuthold, H., & Birngruber, T. (2015).
     Automatic and controlled stimulus processing in conflict tasks:
     Superimposed diffusion processes and delta functions. _Cognitive
     psychology, 78_, 148-174.

_E_x_a_m_p_l_e_s:

     # Probability density function
     dDMC(rt = c(1.2, 0.6, 0.4), resp = c("upper", "lower", "lower"),
          phi = c(0.3, 0.5, -1.0, 0.2, 0.05, 2.5, 3.0, 1.0, 0.5, 0.0, 0.0, 1.0))
     
     # Cumulative distribution function
     pDMC(rt = c(1.2, 0.6, 0.4), resp = c("upper", "lower", "lower"),
          phi = c(0.3, 0.5, -1.0, 0.2, 0.05, 2.5, 3.0, 1.0, 0.5, 0.0, 0.0, 1.0))
     
     # Random sampling
     rDMC(n = 100, phi = c(0.3, 0.5, -1.0, 0.2, 0.05, 2.5, 3.0, 1.0, 0.5, 0.0, 0.0, 1.0))
     


 *** caught illegal operation ***
address 0x1107e47c4, cause 'illegal opcode'

Traceback:
 1: rDMC(n = 10, phi = c(0.3, 0.5, -1, 0.2, 0.05, 2.5, 3, 1, 0.5,     0, 0, 1), dt = 1e-04)
 2: eval(expr, envir, enclos)
 3: eval(expr, envir, enclos)
 4: eval_with_user_handlers(expr, envir, enclos, user_handlers)
 5: withVisible(eval_with_user_handlers(expr, envir, enclos, user_handlers))
 6: withCallingHandlers(withVisible(eval_with_user_handlers(expr,     envir, enclos, user_handlers)), warning = wHandler, error = eHandler,     message = mHandler)
 7: handle(ev <- withCallingHandlers(withVisible(eval_with_user_handlers(expr,     envir, enclos, user_handlers)), warning = wHandler, error = eHandler,     message = mHandler))
 8: timing_fn(handle(ev <- withCallingHandlers(withVisible(eval_with_user_handlers(expr,     envir, enclos, user_handlers)), warning = wHandler, error = eHandler,     message = mHandler)))
 9: evaluate_call(expr, parsed$src[[i]], envir = envir, enclos = enclos,     debug = debug, last = i == length(out), use_try = stop_on_error !=         2L, keep_warning = keep_warning, keep_message = keep_message,     log_echo = log_echo, log_warning = log_warning, output_handler = output_handler,     include_timing = include_timing)
10: evaluate::evaluate(...)
11: evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning,     keep_message = if (is.numeric(options$message)) TRUE else options$message,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options))
12: in_dir(input_dir(), expr)
13: in_input_dir(evaluate(code, envir = env, new_device = FALSE,     keep_warning = if (is.numeric(options$warning)) TRUE else options$warning,     keep_message = if (is.numeric(options$message)) TRUE else options$message,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options)))
14: eng_r(options)
15: block_exec(params)
16: call_block(x)
17: process_group(group)
18: withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     error = function(e) if (xfun::pkg_available("rlang", "1.0.0")) rlang::entrace(e))
19: xfun:::handle_error(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     error = function(e) if (xfun::pkg_available("rlang", "1.0.0")) rlang::entrace(e)),     function(loc) {        setwd(wd)        write_utf8(res, output %n% stdout())        paste0("\nQuitting from lines ", loc)    }, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)
20: process_file(text, output)
21: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
22: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
23: vweave_rmarkdown(...)
24: engine$weave(file, quiet = quiet, encoding = enc)
25: doTryCatch(return(expr), name, parentenv, handler)
26: tryCatchOne(expr, names, parentenv, handlers[[1L]])
27: tryCatchList(expr, classes, parentenv, handlers)
28: tryCatch({    engine$weave(file, quiet = quiet, encoding = enc)    setwd(startdir)    output <- find_vignette_product(name, by = "weave", engine = engine)    if (!have.makefile && vignette_is_tex(output)) {        texi2pdf(file = output, clean = FALSE, quiet = quiet)        output <- find_vignette_product(name, by = "texi2pdf",             engine = engine)    }    outputs <- c(outputs, output)}, error = function(e) {    thisOK <<- FALSE    fails <<- c(fails, file)    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})
29: tools::buildVignettes(dir = "/Volumes/Builds/packages/big-sur-x86_64/results/4.4/ream.Rcheck/vign_test/ream",     skip = TRUE, ser_elibs = "/var/folders/2b/t0kwbtmn3p7brv2mvx39c9cr0000gn/T//RtmpK1DKlC/file1568b9dcbd48.rds")
An irrecoverable exception occurred. R is aborting now ...