Last updated on 2026-10-14 17:54:13 CEST.
| Flavor | Version | Tinstall | Tcheck | Ttotal | Status | Flags |
|---|---|---|---|---|---|---|
| r-devel-linux-x86_64-debian-clang | 2.0.2 | 3.38 | 227.64 | 231.02 | OK | |
| r-devel-linux-x86_64-debian-gcc | 2.0.2 | 2.56 | 230.65 | 233.21 | OK | |
| r-devel-linux-x86_64-fedora-clang | 2.0.2 | 179.98 | OK | |||
| r-devel-linux-x86_64-fedora-gcc | 2.0.2 | 189.02 | OK | |||
| r-devel-windows-x86_64 | 2.0.2 | 4.00 | 139.00 | 143.00 | OK | |
| r-patched-linux-x86_64 | 2.0.2 | 3.60 | 213.69 | 217.29 | OK | |
| r-release-linux-x86_64 | 2.0.2 | 3.18 | 212.69 | 215.87 | OK | |
| r-release-macos-arm64 | 2.0.2 | 1.00 | 56.00 | 57.00 | OK | |
| r-release-macos-x86_64 | 2.0.2 | 3.00 | 208.00 | 211.00 | OK | |
| r-release-windows-x86_64 | 2.0.2 | 5.00 | 137.00 | 142.00 | OK | |
| r-oldrel-macos-arm64 | 2.0.2 | 1.00 | 37.00 | 38.00 | ERROR | |
| r-oldrel-macos-x86_64 | 2.0.2 | 3.00 | 201.00 | 204.00 | OK | |
| r-oldrel-windows-x86_64 | 2.0.2 | 5.00 | 159.00 | 164.00 | OK |
Version: 2.0.2
Check: re-building of vignette outputs
Result: ERROR
Error(s) in re-building vignettes:
--- re-building ‘rEDM-tutorial.Rmd’ using rmarkdown
2026-10-14 18:08:39.586 R[46039:71173] XType: Using static font registry.
*** caught segfault ***
address 0x110, cause 'invalid permissions'
*** caught segfault ***
address 0x110, cause 'invalid permissions'
*** caught segfault ***
address 0x110, cause 'invalid permissions'
*** caught segfault ***
address 0x110, cause 'invalid permissions'
Traceback:
1: RowCumsum(valid)
2: FindNeighbors(embedding, lib_i, pred_i, knn, exclusionRadius = exclusionRadius, validLib = validLib, libOverlap = idx$libOverlap, backend = backend, tieBreak = FALSE, verbose = verbose)
3: SMap(dataFrame, columns, target, lib, pred, E = E, Tp = Tp, knn = knn, tau = tau, theta = th, exclusionRadius = exclusionRadius, embedded = embedded, validLib = validLib, noTime = noTime, ignoreNan = ignoreNan, backend = backend)
4: ComputeError(predictions$Observations, predictions$Predictions)
5: SweepRho(SMap(dataFrame, columns, target, lib, pred, E = E, Tp = Tp, knn = knn, tau = tau, theta = th, exclusionRadius = exclusionRadius, embedded = embedded, validLib = validLib, noTime = noTime, ignoreNan = ignoreNan, backend = backend)$predictions)
6: FUN(X[[i]], ...)
7: lapply(X = S, FUN = FUN, ...)
8: doTryCatch(return(expr), name, parentenv, handler)
9: tryCatchOne(expr, names, parentenv, handlers[[1L]])
Traceback:
1: 10: RowCumsum(valid)tryCatchList(expr, classes, parentenv, handlers)
2: 11: FindNeighbors(embedding, lib_i, pred_i, knn, exclusionRadius = exclusionRadius, tryCatch(expr, error = function(e) { validLib = validLib, libOverlap = idx$libOverlap, backend = backend, call <- conditionCall(e) tieBreak = FALSE, verbose = verbose) if (!is.null(call)) {
if (identical(call[[1L]], quote(doTryCatch))) 3: SMap(dataFrame, columns, target, lib, pred, E = E, Tp = Tp, knn = knn, call <- sys.call(-4L) tau = tau, theta = th, exclusionRadius = exclusionRadius, dcall <- deparse(call, nlines = 1L) embedded = embedded, validLib = validLib, noTime = noTime, prefix <- paste("Error in", dcall, ": ") LONG <- 75L ignoreNan = ignoreNan, backend = backend)
sm <- strsplit(conditionMessage(e), "\n")[[1L]] 4: w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")ComputeError(predictions$Observations, predictions$Predictions) if (is.na(w))
w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L], type = "b") 5: if (w > LONG) SweepRho(SMap(dataFrame, columns, target, lib, pred, E = E, Tp = Tp, prefix <- paste0(prefix, "\n ") knn = knn, tau = tau, theta = th, exclusionRadius = exclusionRadius, } embedded = embedded, validLib = validLib, noTime = noTime, else prefix <- "Error : " ignoreNan = ignoreNan, backend = backend)$predictions) msg <- paste0(prefix, conditionMessage(e), "\n")
.Internal(seterrmessage(msg[1L])) 6: if (!silent && isTRUE(getOption("show.error.messages"))) {FUN(X[[i]], ...) cat(msg, file = outFile)
.Internal(printDeferredWarnings()) 7: }lapply(X = S, FUN = FUN, ...) invisible(structure(msg, class = "try-error", condition = e))
}) 8:
doTryCatch(return(expr), name, parentenv, handler)12:
try(lapply(X = S, FUN = FUN, ...), silent = TRUE) 9:
tryCatchOne(expr, names, parentenv, handlers[[1L]])13:
sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))10:
tryCatchList(expr, classes, parentenv, handlers)14:
FUN(X[[i]], ...)11: tryCatch(expr, error = function(e) {
call <- conditionCall(e)15: if (!is.null(call)) {lapply(seq_len(cores), inner.do) if (identical(call[[1L]], quote(doTryCatch)))
call <- sys.call(-4L)16: dcall <- deparse(call, nlines = 1L)parallel::mclapply(values, worker, mc.cores = cores, mc.preschedule = TRUE) prefix <- paste("Error in", dcall, ": ")
LONG <- 75L17: sm <- strsplit(conditionMessage(e), "\n")[[1L]]doTryCatch(return(expr), name, parentenv, handler) w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")
if (is.na(w)) 18: w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L], tryCatchOne(expr, names, parentenv, handlers[[1L]]) type = "b")
if (w > LONG) 19: prefix <- paste0(prefix, "\n ")tryCatchList(expr, classes, parentenv, handlers) }
else prefix <- "Error : "20: tryCatch(parallel::mclapply(values, worker, mc.cores = cores, msg <- paste0(prefix, conditionMessage(e), "\n") mc.preschedule = TRUE), error = function(e) NULL) .Internal(seterrmessage(msg[1L]))
if (!silent && isTRUE(getOption("show.error.messages"))) {21: SweepApply(theta, worker, numProcess) cat(msg, file = outFile)
.Internal(printDeferredWarnings())22: }unlist(SweepApply(theta, worker, numProcess)) invisible(structure(msg, class = "try-error", condition = e))
})23:
PredictNonlinear(dataFrame = Thrips, columns = "Thrips_imaginis", 12: target = "Thrips_imaginis", lib = "1 73", pred = "1 73", try(lapply(X = S, FUN = FUN, ...), silent = TRUE) E = E, showPlot = TRUE)
24: 13: eval(expr, envir)
sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
Traceback:
25:
eval(expr, envir)14:
FUN(X[[i]], ...)26: 1:
Traceback:
withVisible(eval(expr, envir))RowCumsum(valid)
1: 15: 2: 27: RowCumsum(valid)withCallingHandlers(code, error = function (e)
rlang::entrace(e), message = function (cnd) FindNeighbors(embedding, lib_i, pred_i, knn, exclusionRadius = exclusionRadius, { validLib = validLib, libOverlap = idx$libOverlap, backend = backend, lapply(seq_len(cores), inner.do) 2:
FindNeighbors(embedding, lib_i, pred_i, knn, exclusionRadius = exclusionRadius, tieBreak = FALSE, verbose = verbose) watcher$capture_plot_and_output() validLib = validLib, libOverlap = idx$libOverlap, backend = backend, 16: tieBreak = FALSE, verbose = verbose)
if (on_message$capture) {parallel::mclapply(values, worker, mc.cores = cores, mc.preschedule = TRUE) watcher$push(cnd) 3: }
if (on_message$silence) {SMap(dataFrame, columns, target, lib, pred, E = E, Tp = Tp, knn = knn, 3: invokeRestart("muffleMessage") tau = tau, theta = th, exclusionRadius = exclusionRadius,
SMap(dataFrame, columns, target, lib, pred, E = E, Tp = Tp, knn = knn, embedded = embedded, validLib = validLib, noTime = noTime, 17: } ignoreNan = ignoreNan, backend = backend)}, warning = function (cnd) doTryCatch(return(expr), name, parentenv, handler) tau = tau, theta = th, exclusionRadius = exclusionRadius,
{18: 4: tryCatchOne(expr, names, parentenv, handlers[[1L]]) embedded = embedded, validLib = validLib, noTime = noTime, if (getOption("warn") >= 2 || getOption("warn") < 0) {ComputeError(predictions$Observations, predictions$Predictions)
return() 5: ignoreNan = ignoreNan, backend = backend)SweepRho(SMap(dataFrame, columns, target, lib, pred, E = E, Tp = Tp,
19: }tryCatchList(expr, classes, parentenv, handlers) 4: knn = knn, tau = tau, theta = th, exclusionRadius = exclusionRadius, watcher$capture_plot_and_output()ComputeError(predictions$Observations, predictions$Predictions)
embedded = embedded, validLib = validLib, noTime = noTime,
if (on_warning$capture) {20: 5: tryCatch(parallel::mclapply(values, worker, mc.cores = cores, ignoreNan = ignoreNan, backend = backend)$predictions) cnd <- sanitize_call(cnd)
SweepRho(SMap(dataFrame, columns, target, lib, pred, E = E, Tp = Tp, mc.preschedule = TRUE), error = function(e) NULL) knn = knn, tau = tau, theta = th, exclusionRadius = exclusionRadius,
6: watcher$push(cnd)21: embedded = embedded, validLib = validLib, noTime = noTime, SweepApply(theta, worker, numProcess)FUN(X[[i]], ...) } ignoreNan = ignoreNan, backend = backend)$predictions)
if (on_warning$silence) {
invokeRestart("muffleWarning") 7: 22:
}lapply(X = S, FUN = FUN, ...) 6:
FUN(X[[i]], ...) 8: unlist(SweepApply(theta, worker, numProcess))
}, error = function (cnd) doTryCatch(return(expr), name, parentenv, handler){
watcher$capture_plot_and_output()23: cnd <- sanitize_call(cnd)PredictNonlinear(dataFrame = Thrips, columns = "Thrips_imaginis", 9: target = "Thrips_imaginis", lib = "1 73", pred = "1 73", watcher$push(cnd) E = E, showPlot = TRUE) 7: switch(on_error, continue = invokeRestart("eval_continue"),
lapply(X = S, FUN = FUN, ...)tryCatchOne(expr, names, parentenv, handlers[[1L]])24:
stop = invokeRestart("eval_stop"), error = NULL)
})eval(expr, envir)10:
28: 8: 25: eval(call)doTryCatch(return(expr), name, parentenv, handler)eval(expr, envir)
tryCatchList(expr, classes, parentenv, handlers)
29: 26: eval(call)withVisible(eval(expr, envir))
27: 9: 11: tryCatchOne(expr, names, parentenv, handlers[[1L]])
tryCatch(expr, error = function(e) {10: withCallingHandlers(code, error = function (e) 30: rlang::entrace(e), message = function (cnd) with_handlers({tryCatchList(expr, classes, parentenv, handlers){ for (expr in tle$exprs) { watcher$capture_plot_and_output() if (on_message$capture) { call <- conditionCall(e)
ev <- withVisible(eval(expr, envir)) watcher$push(cnd) if (!is.null(call)) { }11: if (on_message$silence) { if (identical(call[[1L]], quote(doTryCatch))) invokeRestart("muffleMessage") watcher$capture_plot_and_output() } call <- sys.call(-4L)}, warning = function (cnd) watcher$print_value(ev$value, ev$visible, envir) }{tryCatch(expr, error = function(e) { TRUE if (getOption("warn") >= 2 || getOption("warn") < 0) { dcall <- deparse(call, nlines = 1L) return()}, handlers) call <- conditionCall(e) prefix <- paste("Error in", dcall, ": ") }
LONG <- 75L watcher$capture_plot_and_output() if (!is.null(call)) { sm <- strsplit(conditionMessage(e), "\n")[[1L]] if (on_warning$capture) { if (identical(call[[1L]], quote(doTryCatch))) cnd <- sanitize_call(cnd) call <- sys.call(-4L)31: watcher$push(cnd) dcall <- deparse(call, nlines = 1L) } prefix <- paste("Error in", dcall, ": ") w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w") if (on_warning$silence) { if (is.na(w)) invokeRestart("muffleWarning")doWithOneRestart(return(expr), restart) LONG <- 75L
}32: sm <- strsplit(conditionMessage(e), "\n")[[1L]] w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L], w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")withOneRestart(expr, restarts[[1L]])}, error = function (cnd) if (is.na(w)) type = "b") w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L],
if (w > LONG) 33: {withRestartList(expr, restarts[-nr]) prefix <- paste0(prefix, "\n ")
type = "b") } watcher$capture_plot_and_output() if (w > LONG) 34: else prefix <- "Error : " prefix <- paste0(prefix, "\n ") msg <- paste0(prefix, conditionMessage(e), "\n") }doWithOneRestart(return(expr), restart) .Internal(seterrmessage(msg[1L])) cnd <- sanitize_call(cnd) if (!silent && isTRUE(getOption("show.error.messages"))) { cat(msg, file = outFile) else prefix <- "Error : " .Internal(printDeferredWarnings()) watcher$push(cnd)
switch(on_error, continue = invokeRestart("eval_continue"), }35: msg <- paste0(prefix, conditionMessage(e), "\n") stop = invokeRestart("eval_stop"), error = NULL)withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])})
invisible(structure(msg, class = "try-error", condition = e))28: eval(call) .Internal(seterrmessage(msg[1L]))}) if (!silent && isTRUE(getOption("show.error.messages"))) {
12:
cat(msg, file = outFile)29: try(lapply(X = S, FUN = FUN, ...), silent = TRUE) .Internal(printDeferredWarnings())eval(call)
36: }withRestartList(expr, restarts) invisible(structure(msg, class = "try-error", condition = e))
13:
})30: 37: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
withRestarts(with_handlers({12:
with_handlers({ for (expr in tle$exprs) {try(lapply(X = S, FUN = FUN, ...), silent = TRUE) ev <- withVisible(eval(expr, envir))14: for (expr in tle$exprs) { watcher$capture_plot_and_output()
ev <- withVisible(eval(expr, envir)) watcher$print_value(ev$value, ev$visible, envir)13: }sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE)) watcher$capture_plot_and_output()FUN(X[[i]], ...)
watcher$print_value(ev$value, ev$visible, envir) TRUE
}14: TRUE15: }, handlers)lapply(seq_len(cores), inner.do)}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)
FUN(X[[i]], ...)16:
parallel::mclapply(values, worker, mc.cores = cores, mc.preschedule = TRUE)31:
15: 38: lapply(seq_len(cores), inner.do)doWithOneRestart(return(expr), restart)17:
evaluate::evaluate(...)doTryCatch(return(expr), name, parentenv, handler)32:
16: 39: 18: withOneRestart(expr, restarts[[1L]])tryCatchOne(expr, names, parentenv, handlers[[1L]])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, parallel::mclapply(values, worker, mc.cores = cores, mc.preschedule = TRUE) stop_on_error = if (is.numeric(options$error)) options$error else {33: 19: withRestartList(expr, restarts[-nr])
if (options$error && options$include) tryCatchList(expr, classes, parentenv, handlers)17: 34: doTryCatch(return(expr), name, parentenv, handler)
0L20: else 2L
}, output_handler = knit_handlers(options$render, options))18: doWithOneRestart(return(expr), restart)
tryCatchOne(expr, names, parentenv, handlers[[1L]])40:
tryCatch(parallel::mclapply(values, worker, mc.cores = cores, in_dir(input_dir(), expr)19: mc.preschedule = TRUE), error = function(e) NULL)35:
withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])tryCatchList(expr, classes, parentenv, handlers)
21:
SweepApply(theta, worker, numProcess)
20: 41: 36: 22: tryCatch(parallel::mclapply(values, worker, mc.cores = cores, unlist(SweepApply(theta, worker, numProcess)) mc.preschedule = TRUE), error = function(e) NULL)
in_input_dir(evaluate(code, envir = env, new_device = FALSE, withRestartList(expr, restarts) keep_warning = if (is.numeric(options$warning)) TRUE else options$warning,
23: 21: 37: PredictNonlinear(dataFrame = Thrips, columns = "Thrips_imaginis", SweepApply(theta, worker, numProcess) keep_message = if (is.numeric(options$message)) TRUE else options$message,
target = "Thrips_imaginis", lib = "1 73", pred = "1 73", withRestarts(with_handlers({ stop_on_error = if (is.numeric(options$error)) options$error else { E = E, showPlot = TRUE)22:
unlist(SweepApply(theta, worker, numProcess)) for (expr in tle$exprs) {
if (options$error && options$include) 24: ev <- withVisible(eval(expr, envir)) 0L23: watcher$capture_plot_and_output()PredictNonlinear(dataFrame = Thrips, columns = "Thrips_imaginis", eval(expr, envir) else 2L watcher$print_value(ev$value, ev$visible, envir)
}, output_handler = knit_handlers(options$render, options)))25: }eval(expr, envir) TRUE target = "Thrips_imaginis", lib = "1 73", pred = "1 73", }, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)
26: 38: 42: evaluate::evaluate(...)withVisible(eval(expr, envir))
eng_r(options)39:
evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning,
E = E, showPlot = TRUE)43: keep_message = if (is.numeric(options$message)) TRUE else options$message,
27: block_exec(params)withCallingHandlers(code, error = function (e) 24:
stop_on_error = if (is.numeric(options$error)) options$error else {eval(expr, envir)44:
rlang::entrace(e), message = function (cnd) call_block(x){25:
eval(expr, envir) if (options$error && options$include) 45: 0L
process_group(group)26: watcher$capture_plot_and_output()withVisible(eval(expr, envir)) if (on_message$capture) { else 2L
watcher$push(cnd)
} }, output_handler = knit_handlers(options$render, options))27:
46: withCallingHandlers(code, error = function (e) 40: rlang::entrace(e), message = function (cnd) { if (on_message$silence) {withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), watcher$capture_plot_and_output() error = function(e) { if (progress && is.function(pb$interrupt)) in_dir(input_dir(), expr) if (on_message$capture) { pb$interrupt() invokeRestart("muffleMessage") watcher$push(cnd)
if (is_R_CMD_build() || is_R_CMD_check()) 41: error <<- format(e) }in_input_dir(evaluate(code, envir = env, new_device = FALSE, if (on_message$silence) { keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, } keep_message = if (is.numeric(options$message)) TRUE else options$message, }) invokeRestart("muffleMessage")}, warning = function (cnd) stop_on_error = if (is.numeric(options$error)) options$error else { }{
if (getOption("warn") >= 2 || getOption("warn") < 0) { if (options$error && options$include) }, warning = function (cnd) 47: { 0Lwith_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), if (getOption("warn") >= 2 || getOption("warn") < 0) { return() error = function(e) { } else 2L if (progress && is.function(pb$interrupt)) return() pb$interrupt() }, output_handler = knit_handlers(options$render, options))) }
if (is_R_CMD_build() || is_R_CMD_check()) 42: watcher$capture_plot_and_output()eng_r(options) watcher$capture_plot_and_output() if (on_warning$capture) { error <<- format(e)
if (on_warning$capture) {43: }), list(rlang_trace_top_env = knit_global()))block_exec(params) cnd <- sanitize_call(cnd) cnd <- sanitize_call(cnd)
watcher$push(cnd) watcher$push(cnd) } }44: if (on_warning$silence) { if (on_warning$silence) { invokeRestart("muffleWarning")48: call_block(x) }xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),
error = function(e) {45: if (progress && is.function(pb$interrupt)) }, error = function (cnd) invokeRestart("muffleWarning") pb$interrupt(){process_group(group) if (is_R_CMD_build() || is_R_CMD_check()) watcher$capture_plot_and_output() } cnd <- sanitize_call(cnd)
error <<- format(e)46: watcher$push(cnd)}, error = function (cnd) switch(on_error, continue = invokeRestart("eval_continue"), { stop = invokeRestart("eval_stop"), error = NULL)withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), }) watcher$capture_plot_and_output() }), list(rlang_trace_top_env = knit_global())), function(loc) { cnd <- sanitize_call(cnd) error = function(e) { watcher$push(cnd) if (progress && is.function(pb$interrupt)) setwd(wd) pb$interrupt()
if (is_R_CMD_build() || is_R_CMD_check()) write_utf8(res, output %n% stdout()) switch(on_error, continue = invokeRestart("eval_continue"), 28: error <<- format(e) paste0("\nQuitting from ", loc, if (!is.null(error)) eval(call) paste0("\n", rule(), error, "\n", rule())) })}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc) stop = invokeRestart("eval_stop"), error = NULL)
})
29: 47: with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), eval(call)
30: 28: error = function(e) {eval(call)with_handlers({
if (progress && is.function(pb$interrupt)) 49: for (expr in tle$exprs) {29: process_file(text, output) ev <- withVisible(eval(expr, envir))eval(call) watcher$capture_plot_and_output()
watcher$print_value(ev$value, ev$visible, envir)30: with_handlers({ }
TRUE pb$interrupt() for (expr in tle$exprs) { if (is_R_CMD_build() || is_R_CMD_check()) 50: }, handlers)knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet) ev <- withVisible(eval(expr, envir))
watcher$capture_plot_and_output()51:
error <<- format(e) watcher$print_value(ev$value, ev$visible, envir)rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(), }31: TRUEdoWithOneRestart(return(expr), restart)}, handlers) output_dir = getwd(), ...)
31: }), list(rlang_trace_top_env = knit_global()))doWithOneRestart(return(expr), restart)32:
withOneRestart(expr, restarts[[1L]])
52:
48: vweave_rmarkdown(...)33: 32: withRestartList(expr, restarts[-nr])xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),
withOneRestart(expr, restarts[[1L]])53:
34: 33: error = function(e) {doWithOneRestart(return(expr), restart)engine$weave(file, quiet = quiet, encoding = enc)withRestartList(expr, restarts[-nr]) if (progress && is.function(pb$interrupt))
pb$interrupt()35:
if (is_R_CMD_build() || is_R_CMD_check()) 54: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])doTryCatch(return(expr), name, parentenv, handler) error <<- format(e)
34:
55: 36: doWithOneRestart(return(expr), restart) }), list(rlang_trace_top_env = knit_global())), function(loc) {tryCatchOne(expr, names, parentenv, handlers[[1L]])
setwd(wd)withRestartList(expr, restarts)35: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
36: write_utf8(res, output %n% stdout())withRestartList(expr, restarts)56: 37:
tryCatchList(expr, classes, parentenv, handlers) paste0("\nQuitting from ", loc, if (!is.null(error)) 37:
withRestarts(with_handlers({withRestarts(with_handlers({ for (expr in tle$exprs) {57: for (expr in tle$exprs) { paste0("\n", rule(), error, "\n", rule()))tryCatch({ ev <- withVisible(eval(expr, envir)) ev <- withVisible(eval(expr, envir)) watcher$capture_plot_and_output()}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc) watcher$print_value(ev$value, ev$visible, envir) watcher$capture_plot_and_output() engine$weave(file, quiet = quiet, encoding = enc) } watcher$print_value(ev$value, ev$visible, envir) setwd(startdir)
TRUE output <- find_vignette_product(name, by = "weave", engine = engine) }}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE) TRUE if (!have.makefile && vignette_is_tex(output)) {49: }, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE) texi2pdf(file = output, clean = FALSE, quiet = quiet)process_file(text, output) output <- find_vignette_product(name, by = "texi2pdf",
50: 38: engine = engine)evaluate::evaluate(...)knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)38:
}39:
evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, evaluate::evaluate(...) keep_message = if (is.numeric(options$message)) TRUE else options$message,
outputs <- c(outputs, output)51: 39: stop_on_error = if (is.numeric(options$error)) options$error else {evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(), if (options$error && options$include) }, error = function(e) { keep_message = if (is.numeric(options$message)) TRUE else options$message, output_dir = getwd(), ...) thisOK <<- FALSE stop_on_error = if (is.numeric(options$error)) options$error else { 0L fails <<- c(fails, file)
else 2L message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s", if (options$error && options$include) 52: }, output_handler = knit_handlers(options$render, options)) 0L
else 2L }, output_handler = knit_handlers(options$render, options))40: file, conditionMessage(e)))in_dir(input_dir(), expr)
vweave_rmarkdown(...)
})41: 40:
in_dir(input_dir(), expr)
in_input_dir(evaluate(code, envir = env, new_device = FALSE, 41:
keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, in_input_dir(evaluate(code, envir = env, new_device = FALSE, 58: keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, 53: tools::buildVignettes(dir = "/Volumes/Builds/packages/big-sur-arm64/results/4.5/rEDM.Rcheck/vign_test/rEDM", engine$weave(file, quiet = quiet, encoding = enc) skip = TRUE, ser_elibs = "/Volumes/Temp/tmp/Rtmp10qQZH/file9701b4c6771.rds") keep_message = if (is.numeric(options$message)) TRUE else options$message,
keep_message = if (is.numeric(options$message)) TRUE else options$message, 54:
stop_on_error = if (is.numeric(options$error)) options$error else {An irrecoverable exception occurred. R is aborting now ...
if (options$error && options$include) stop_on_error = if (is.numeric(options$error)) options$error else {doTryCatch(return(expr), name, parentenv, handler) if (options$error && options$include) 0L
else 2L 0L55: }, output_handler = knit_handlers(options$render, options)))tryCatchOne(expr, names, parentenv, handlers[[1L]])
42:
eng_r(options) else 2L56: }, output_handler = knit_handlers(options$render, options)))
tryCatchList(expr, classes, parentenv, handlers)43: block_exec(params)
42: 44: eng_r(options)57: call_block(x)tryCatch({
engine$weave(file, quiet = quiet, encoding = enc)
43: 45: setwd(startdir)process_group(group)block_exec(params) output <- find_vignette_product(name, by = "weave", engine = engine)
46: if (!have.makefile && vignette_is_tex(output)) {withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), 44: texi2pdf(file = output, clean = FALSE, quiet = quiet)call_block(x) output <- find_vignette_product(name, by = "texi2pdf",
engine = engine) } error = function(e) {45: if (progress && is.function(pb$interrupt)) outputs <- c(outputs, output) pb$interrupt()process_group(group) if (is_R_CMD_build() || is_R_CMD_check())
error <<- format(e)}, error = function(e) { })46:
withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), thisOK <<- FALSE47: with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), error = function(e) { error = function(e) { if (progress && is.function(pb$interrupt)) if (progress && is.function(pb$interrupt)) fails <<- c(fails, file) pb$interrupt() pb$interrupt() message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s", if (is_R_CMD_build() || is_R_CMD_check()) file, conditionMessage(e))) if (is_R_CMD_build() || is_R_CMD_check()) error <<- format(e)}) error <<- format(e)
})58: }), list(rlang_trace_top_env = knit_global()))
tools::buildVignettes(dir = "/Volumes/Builds/packages/big-sur-arm64/results/4.5/rEDM.Rcheck/vign_test/rEDM", 47: 48: with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), skip = TRUE, ser_elibs = "/Volumes/Temp/tmp/Rtmp10qQZH/file9701b4c6771.rds") error = function(e) {xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), if (progress && is.function(pb$interrupt)) error = function(e) { pb$interrupt() if (progress && is.function(pb$interrupt)) if (is_R_CMD_build() || is_R_CMD_check())
error <<- format(e)An irrecoverable exception occurred. R is aborting now ...
pb$interrupt() }), list(rlang_trace_top_env = knit_global())) if (is_R_CMD_build() || is_R_CMD_check()) error <<- format(e)
}), list(rlang_trace_top_env = knit_global())), function(loc) {48: setwd(wd)xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), write_utf8(res, output %n% stdout()) error = function(e) { paste0("\nQuitting from ", loc, if (!is.null(error)) if (progress && is.function(pb$interrupt)) paste0("\n", rule(), error, "\n", rule())) pb$interrupt()}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)
if (is_R_CMD_build() || is_R_CMD_check()) 49: error <<- format(e) }), list(rlang_trace_top_env = knit_global())), function(loc) {process_file(text, output) setwd(wd)
write_utf8(res, output %n% stdout())50: paste0("\nQuitting from ", loc, if (!is.null(error)) knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet) paste0("\n", rule(), error, "\n", rule()))
}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)51:
rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(), 49: process_file(text, output) output_dir = getwd(), ...)
50: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)52:
vweave_rmarkdown(...)51:
rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(), 53: output_dir = getwd(), ...)engine$weave(file, quiet = quiet, encoding = enc)
54: 52: doTryCatch(return(expr), name, parentenv, handler)vweave_rmarkdown(...)
55:
tryCatchOne(expr, names, parentenv, handlers[[1L]])53:
engine$weave(file, quiet = quiet, encoding = enc)56:
54: tryCatchList(expr, classes, parentenv, handlers)doTryCatch(return(expr), name, parentenv, handler)
57: 55: tryCatch({tryCatchOne(expr, names, parentenv, handlers[[1L]]) engine$weave(file, quiet = quiet, encoding = enc)
56: tryCatchList(expr, classes, parentenv, handlers) setwd(startdir)
output <- find_vignette_product(name, by = "weave", engine = engine)57: if (!have.makefile && vignette_is_tex(output)) {tryCatch({ texi2pdf(file = output, clean = FALSE, quiet = quiet) engine$weave(file, quiet = quiet, encoding = enc) output <- find_vignette_product(name, by = "texi2pdf", setwd(startdir) engine = engine) output <- find_vignette_product(name, by = "weave", engine = engine) } outputs <- c(outputs, output) if (!have.makefile && vignette_is_tex(output)) {}, error = function(e) { thisOK <<- FALSE fails <<- c(fails, file) texi2pdf(file = output, clean = FALSE, quiet = quiet) message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s", output <- find_vignette_product(name, by = "texi2pdf", file, conditionMessage(e))) engine = engine)}) }
outputs <- c(outputs, output)58: }, error = function(e) {tools::buildVignettes(dir = "/Volumes/Builds/packages/big-sur-arm64/results/4.5/rEDM.Rcheck/vign_test/rEDM", thisOK <<- FALSE skip = TRUE, ser_elibs = "/Volumes/Temp/tmp/Rtmp10qQZH/file9701b4c6771.rds") fails <<- c(fails, file)
message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s", An irrecoverable exception occurred. R is aborting now ...
file, conditionMessage(e)))})
58: tools::buildVignettes(dir = "/Volumes/Builds/packages/big-sur-arm64/results/4.5/rEDM.Rcheck/vign_test/rEDM", skip = TRUE, ser_elibs = "/Volumes/Temp/tmp/Rtmp10qQZH/file9701b4c6771.rds")
An irrecoverable exception occurred. R is aborting now ...
Quitting from rEDM-tutorial.Rmd:466-469 [smap_thrips]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
<error/rlang_error>
Error in `data.frame()`:
! arguments imply differing number of rows: 15, 0
---
Backtrace:
▆
1. └─rEDM::PredictNonlinear(...)
2. └─base::data.frame(Theta = theta, rho = rho)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Error: processing vignette 'rEDM-tutorial.Rmd' failed with diagnostics:
arguments imply differing number of rows: 15, 0
--- failed re-building ‘rEDM-tutorial.Rmd’
SUMMARY: processing the following file failed:
‘rEDM-tutorial.Rmd’
Error: Vignette re-building failed.
Execution halted
Flavor: r-oldrel-macos-arm64