Last updated on 2026-09-30 01:55:57 CEST.
| Flavor | Version | Tinstall | Tcheck | Ttotal | Status | Flags |
|---|---|---|---|---|---|---|
| r-devel-linux-x86_64-debian-clang | 2.0.2 | 3.83 | 223.64 | 227.47 | OK | |
| r-devel-linux-x86_64-debian-gcc | 2.0.2 | 2.24 | 228.17 | 230.41 | OK | |
| r-devel-linux-x86_64-fedora-clang | 2.0.2 | 175.82 | OK | |||
| r-devel-linux-x86_64-fedora-gcc | 2.0.2 | 189.12 | 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.72 | 205.17 | 208.89 | OK | |
| r-release-linux-x86_64 | 2.0.2 | 3.56 | 209.84 | 213.40 | 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 | 6.00 | 130.00 | 136.00 | OK | |
| r-oldrel-macos-arm64 | 2.0.2 | 2.00 | 50.00 | 52.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 | 8.00 | 158.00 | 166.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-09-30 00:01:18.772 R[38942:59823] 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]], ...)
Traceback:
1: 7: lapply(X = S, FUN = FUN, ...)RowCumsum(valid)
2: 8: FindNeighbors(embedding, lib_i, pred_i, knn, exclusionRadius = exclusionRadius, doTryCatch(return(expr), name, parentenv, handler) validLib = validLib, libOverlap = idx$libOverlap, backend = backend,
9: tieBreak = FALSE, verbose = verbose)tryCatchOne(expr, names, parentenv, handlers[[1L]])
3:
SMap(dataFrame, columns, target, lib, pred, E = E, Tp = Tp, knn = knn, 10: tau = tau, theta = th, exclusionRadius = exclusionRadius, tryCatchList(expr, classes, parentenv, handlers)
embedded = embedded, validLib = validLib, noTime = noTime, ignoreNan = ignoreNan, backend = backend)11:
tryCatch(expr, error = function(e) { 4: call <- conditionCall(e) if (!is.null(call)) { if (identical(call[[1L]], quote(doTryCatch))) call <- sys.call(-4L)ComputeError(predictions$Observations, predictions$Predictions) dcall <- deparse(call, nlines = 1L)
prefix <- paste("Error in", dcall, ": ") 5: SweepRho(SMap(dataFrame, columns, target, lib, pred, E = E, Tp = Tp, LONG <- 75L knn = knn, tau = tau, theta = th, exclusionRadius = exclusionRadius, sm <- strsplit(conditionMessage(e), "\n")[[1L]] embedded = embedded, validLib = validLib, noTime = noTime, w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w") ignoreNan = ignoreNan, backend = backend)$predictions) if (is.na(w)) w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L],
type = "b") 6: if (w > LONG) FUN(X[[i]], ...) prefix <- paste0(prefix, "\n ")
7: lapply(X = S, FUN = FUN, ...)
} 8: else prefix <- "Error : "doTryCatch(return(expr), name, parentenv, handler) msg <- paste0(prefix, conditionMessage(e), "\n")
.Internal(seterrmessage(msg[1L])) 9: if (!silent && isTRUE(getOption("show.error.messages"))) {tryCatchOne(expr, names, parentenv, handlers[[1L]]) cat(msg, file = outFile)
.Internal(printDeferredWarnings())10: }tryCatchList(expr, classes, parentenv, handlers) invisible(structure(msg, class = "try-error", condition = e))
})11:
12: tryCatch(expr, error = function(e) { call <- conditionCall(e)try(lapply(X = S, FUN = FUN, ...), silent = TRUE) if (!is.null(call)) {
if (identical(call[[1L]], quote(doTryCatch))) 13: call <- sys.call(-4L) dcall <- deparse(call, nlines = 1L)sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE)) prefix <- paste("Error in", dcall, ": ")
Traceback:
LONG <- 75L sm <- strsplit(conditionMessage(e), "\n")[[1L]] 1: w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")
RowCumsum(valid) if (is.na(w)) 14:
2: w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L], FUN(X[[i]], ...)FindNeighbors(embedding, lib_i, pred_i, knn, exclusionRadius = exclusionRadius,
validLib = validLib, libOverlap = idx$libOverlap, backend = backend, type = "b")15: tieBreak = FALSE, verbose = verbose) if (w > LONG) lapply(seq_len(cores), inner.do) prefix <- paste0(prefix, "\n ")
} 3: 16: SMap(dataFrame, columns, target, lib, pred, E = E, Tp = Tp, knn = knn, else prefix <- "Error : " msg <- paste0(prefix, conditionMessage(e), "\n")parallel::mclapply(values, worker, mc.cores = cores, mc.preschedule = TRUE) .Internal(seterrmessage(msg[1L]))
tau = tau, theta = th, exclusionRadius = exclusionRadius, if (!silent && isTRUE(getOption("show.error.messages"))) {17: cat(msg, file = outFile) embedded = embedded, validLib = validLib, noTime = noTime, doTryCatch(return(expr), name, parentenv, handler) .Internal(printDeferredWarnings())
ignoreNan = ignoreNan, backend = backend) }18:
tryCatchOne(expr, names, parentenv, handlers[[1L]]) invisible(structure(msg, class = "try-error", condition = e))
}) 4:
ComputeError(predictions$Observations, predictions$Predictions)12: 19: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)tryCatchList(expr, classes, parentenv, handlers)
13:
sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE)) 5: 20:
tryCatch(parallel::mclapply(values, worker, mc.cores = cores, 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,
embedded = embedded, validLib = validLib, noTime = noTime, ignoreNan = ignoreNan, backend = backend)$predictions)14:
6: FUN(X[[i]], ...)
FUN(X[[i]], ...)15:
lapply(seq_len(cores), inner.do)21: 7:
SweepApply(theta, worker, numProcess)16:
Traceback:
lapply(X = S, FUN = FUN, ...)
parallel::mclapply(values, worker, mc.cores = cores, mc.preschedule = TRUE)
1:
RowCumsum(valid) 8: 22: 17: unlist(SweepApply(theta, worker, numProcess))
doTryCatch(return(expr), name, parentenv, handler)
doTryCatch(return(expr), name, parentenv, handler)
23: 18: PredictNonlinear(dataFrame = Thrips, columns = "Thrips_imaginis", 2: tryCatchOne(expr, names, parentenv, handlers[[1L]]) target = "Thrips_imaginis", lib = "1 73", pred = "1 73", E = E, showPlot = TRUE)
FindNeighbors(embedding, lib_i, pred_i, knn, exclusionRadius = exclusionRadius,
validLib = validLib, libOverlap = idx$libOverlap, backend = backend, 19: 24: tieBreak = FALSE, verbose = verbose)tryCatchList(expr, classes, parentenv, handlers)eval(expr, envir)
9: 20: 3: SMap(dataFrame, columns, target, lib, pred, E = E, Tp = Tp, knn = knn, tryCatch(parallel::mclapply(values, worker, mc.cores = cores, tryCatchOne(expr, names, parentenv, handlers[[1L]]) tau = tau, theta = th, exclusionRadius = exclusionRadius, 25:
mc.preschedule = TRUE), error = function(e) NULL) embedded = embedded, validLib = validLib, noTime = noTime,
10: tryCatchList(expr, classes, parentenv, handlers)eval(expr, envir) ignoreNan = ignoreNan, backend = backend)
21: 11:
SweepApply(theta, worker, numProcess)tryCatch(expr, error = function(e) { 4:
26: call <- conditionCall(e)ComputeError(predictions$Observations, predictions$Predictions)withVisible(eval(expr, envir)) if (!is.null(call)) {
22: if (identical(call[[1L]], quote(doTryCatch)))
unlist(SweepApply(theta, worker, numProcess)) 5: call <- sys.call(-4L)
23: dcall <- deparse(call, nlines = 1L)27: PredictNonlinear(dataFrame = Thrips, columns = "Thrips_imaginis", prefix <- paste("Error in", dcall, ": ")withCallingHandlers(code, error = function (e) SweepRho(SMap(dataFrame, columns, target, lib, pred, E = E, Tp = Tp, rlang::entrace(e), message = function (cnd) LONG <- 75L target = "Thrips_imaginis", lib = "1 73", pred = "1 73", sm <- strsplit(conditionMessage(e), "\n")[[1L]] knn = knn, tau = tau, theta = th, exclusionRadius = exclusionRadius, w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w") embedded = embedded, validLib = validLib, noTime = noTime, { ignoreNan = ignoreNan, backend = backend)$predictions) watcher$capture_plot_and_output()
E = E, showPlot = TRUE) if (is.na(w)) 6: if (on_message$capture) { w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L], FUN(X[[i]], ...) type = "b")
if (w > LONG) 24:
eval(expr, envir) 7: prefix <- paste0(prefix, "\n ") watcher$push(cnd)lapply(X = S, FUN = FUN, ...) } } if (on_message$silence) {
invokeRestart("muffleMessage") 8: else prefix <- "Error : "25: doTryCatch(return(expr), name, parentenv, handler) } msg <- paste0(prefix, conditionMessage(e), "\n")
eval(expr, envir)}, warning = function (cnd) 9:
.Internal(seterrmessage(msg[1L]))tryCatchOne(expr, names, parentenv, handlers[[1L]])26: {withVisible(eval(expr, envir)) if (!silent && isTRUE(getOption("show.error.messages"))) { if (getOption("warn") >= 2 || getOption("warn") < 0) {
return() cat(msg, file = outFile) .Internal(printDeferredWarnings())10: }
}27: tryCatchList(expr, classes, parentenv, handlers) invisible(structure(msg, class = "try-error", condition = e)) watcher$capture_plot_and_output()})
12: withCallingHandlers(code, error = function (e) 11: if (on_warning$capture) {rlang::entrace(e), message = function (cnd) try(lapply(X = S, FUN = FUN, ...), silent = TRUE) cnd <- sanitize_call(cnd){ watcher$push(cnd) } watcher$capture_plot_and_output()
if (on_warning$silence) { if (on_message$capture) {tryCatch(expr, error = function(e) { invokeRestart("muffleWarning") watcher$push(cnd) }13: }}, error = function (cnd) if (on_message$silence) {{sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE)) invokeRestart("muffleMessage") watcher$capture_plot_and_output()
}14: cnd <- sanitize_call(cnd)}, warning = function (cnd) watcher$push(cnd)FUN(X[[i]], ...){
switch(on_error, continue = invokeRestart("eval_continue"), if (getOption("warn") >= 2 || getOption("warn") < 0) { call <- conditionCall(e)15: stop = invokeRestart("eval_stop"), error = NULL) return() if (!is.null(call)) {lapply(seq_len(cores), inner.do) } if (identical(call[[1L]], quote(doTryCatch))) watcher$capture_plot_and_output()}) if (on_warning$capture) {
call <- sys.call(-4L) cnd <- sanitize_call(cnd)
16: 28: parallel::mclapply(values, worker, mc.cores = cores, mc.preschedule = TRUE) dcall <- deparse(call, nlines = 1L) watcher$push(cnd)eval(call) }
if (on_warning$silence) {
prefix <- paste("Error in", dcall, ": ")29: eval(call)17: invokeRestart("muffleWarning")doTryCatch(return(expr), name, parentenv, handler) LONG <- 75L
}30:
sm <- strsplit(conditionMessage(e), "\n")[[1L]]}, error = function (cnd) w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")with_handlers({18: tryCatchOne(expr, names, parentenv, handlers[[1L]]) for (expr in tle$exprs) {
19: {tryCatchList(expr, classes, parentenv, handlers) watcher$capture_plot_and_output() if (is.na(w)) cnd <- sanitize_call(cnd) ev <- withVisible(eval(expr, envir)) watcher$push(cnd) w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L], switch(on_error, continue = invokeRestart("eval_continue"),
stop = invokeRestart("eval_stop"), error = NULL) watcher$capture_plot_and_output() type = "b")}) watcher$print_value(ev$value, ev$visible, envir)20:
}tryCatch(parallel::mclapply(values, worker, mc.cores = cores, TRUE if (w > LONG) 28: mc.preschedule = TRUE), error = function(e) NULL) prefix <- paste0(prefix, "\n ")}, handlers)
}31: 21: eval(call)SweepApply(theta, worker, numProcess)doWithOneRestart(return(expr), restart) else prefix <- "Error : "
29: 32: eval(call) msg <- paste0(prefix, conditionMessage(e), "\n")22: .Internal(seterrmessage(msg[1L]))
unlist(SweepApply(theta, worker, numProcess))withOneRestart(expr, restarts[[1L]])
30: 23: with_handlers({
for (expr in tle$exprs) {33: PredictNonlinear(dataFrame = Thrips, columns = "Thrips_imaginis", withRestartList(expr, restarts[-nr])
if (!silent && isTRUE(getOption("show.error.messages"))) {34: cat(msg, file = outFile) target = "Thrips_imaginis", lib = "1 73", pred = "1 73", doWithOneRestart(return(expr), restart) .Internal(printDeferredWarnings()) ev <- withVisible(eval(expr, envir))
watcher$capture_plot_and_output() }35: E = E, showPlot = TRUE) watcher$print_value(ev$value, ev$visible, envir)withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]]) } invisible(structure(msg, class = "try-error", condition = e))})
TRUE36: 12: }, handlers)withRestartList(expr, restarts)24: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
eval(expr, envir)
37: 13: withRestarts(with_handlers({
for (expr in tle$exprs) {25:
sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE)) ev <- withVisible(eval(expr, envir))eval(expr, envir)
watcher$capture_plot_and_output()31:
14: doWithOneRestart(return(expr), restart) watcher$print_value(ev$value, ev$visible, envir)FUN(X[[i]], ...)
}32: 26: 15: TRUEwithOneRestart(expr, restarts[[1L]])withVisible(eval(expr, envir))
33: }, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)lapply(seq_len(cores), inner.do)
withRestartList(expr, restarts[-nr])27:
38:
evaluate::evaluate(...)withCallingHandlers(code, error = function (e) 34: 16: rlang::entrace(e), message = function (cnd) doWithOneRestart(return(expr), restart)
parallel::mclapply(values, worker, mc.cores = cores, mc.preschedule = TRUE){39:
evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, watcher$capture_plot_and_output()
if (on_message$capture) {35: keep_message = if (is.numeric(options$message)) TRUE else options$message, 17: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]]) watcher$push(cnd) stop_on_error = if (is.numeric(options$error)) options$error else { } if (options$error && options$include)
doTryCatch(return(expr), name, parentenv, handler) 0L36: else 2L
withRestartList(expr, restarts) if (on_message$silence) { }, output_handler = knit_handlers(options$render, options))18:
invokeRestart("muffleMessage")tryCatchOne(expr, names, parentenv, handlers[[1L]])37: }
}, warning = function (cnd) 40: 19: withRestarts(with_handlers({{in_dir(input_dir(), expr) if (getOption("warn") >= 2 || getOption("warn") < 0) { for (expr in tle$exprs) {tryCatchList(expr, classes, parentenv, handlers) return() ev <- withVisible(eval(expr, envir))
}
watcher$capture_plot_and_output()20: watcher$capture_plot_and_output()41: if (on_warning$capture) {tryCatch(parallel::mclapply(values, worker, mc.cores = cores, in_input_dir(evaluate(code, envir = env, new_device = FALSE, cnd <- sanitize_call(cnd) watcher$print_value(ev$value, ev$visible, envir) keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, watcher$push(cnd) mc.preschedule = TRUE), error = function(e) NULL) keep_message = if (is.numeric(options$message)) TRUE else options$message, } } TRUE
stop_on_error = if (is.numeric(options$error)) options$error else { if (on_warning$silence) {}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)
invokeRestart("muffleWarning")21: if (options$error && options$include) }SweepApply(theta, worker, numProcess)38: }, error = function (cnd) 0L{evaluate::evaluate(...) watcher$capture_plot_and_output()
cnd <- sanitize_call(cnd)
else 2L watcher$push(cnd)22: }, output_handler = knit_handlers(options$render, options))) switch(on_error, continue = invokeRestart("eval_continue"), 39: unlist(SweepApply(theta, worker, numProcess)) stop = invokeRestart("eval_stop"), error = NULL)
})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,
23:
42: stop_on_error = if (is.numeric(options$error)) options$error else {PredictNonlinear(dataFrame = Thrips, columns = "Thrips_imaginis", if (options$error && options$include) eng_r(options)28:
target = "Thrips_imaginis", lib = "1 73", pred = "1 73", 0Leval(call)43: else 2L
block_exec(params) E = E, showPlot = TRUE) }, output_handler = knit_handlers(options$render, options))
29:
44: 40: eval(call)
24: call_block(x)in_dir(input_dir(), expr)
eval(expr, envir)
41: 45:
process_group(group)25:
in_input_dir(evaluate(code, envir = env, new_device = FALSE, 46: eval(expr, envir)withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, 30: keep_message = if (is.numeric(options$message)) TRUE else options$message,
error = function(e) {26: if (progress && is.function(pb$interrupt)) stop_on_error = if (is.numeric(options$error)) options$error else {with_handlers({withVisible(eval(expr, envir)) pb$interrupt() for (expr in tle$exprs) { if (options$error && options$include) ev <- withVisible(eval(expr, envir))
0L if (is_R_CMD_build() || is_R_CMD_check()) watcher$capture_plot_and_output() else 2L }, output_handler = knit_handlers(options$render, options))) watcher$print_value(ev$value, ev$visible, envir)27: error <<- format(e)
})withCallingHandlers(code, error = function (e) }42: rlang::entrace(e), message = function (cnd) eng_r(options){
TRUE43: }, handlers)47: watcher$capture_plot_and_output()block_exec(params)
with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), if (on_message$capture) { error = function(e) {
31: if (progress && is.function(pb$interrupt)) doWithOneRestart(return(expr), restart)44: watcher$push(cnd)
pb$interrupt()call_block(x)32: }withOneRestart(expr, restarts[[1L]]) if (is_R_CMD_build() || is_R_CMD_check())
if (on_message$silence) {45:
error <<- format(e) invokeRestart("muffleMessage")33: process_group(group)withRestartList(expr, restarts[-nr])
}), list(rlang_trace_top_env = knit_global())) }
}, warning = function (cnd) 46:
34: {doWithOneRestart(return(expr), restart)48:
xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), if (getOption("warn") >= 2 || getOption("warn") < 0) {35: error = function(e) {withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), return() if (progress && is.function(pb$interrupt)) error = function(e) {withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]]) } if (progress && is.function(pb$interrupt)) watcher$capture_plot_and_output() pb$interrupt()
pb$interrupt() if (on_warning$capture) {36: if (is_R_CMD_build() || is_R_CMD_check()) if (is_R_CMD_build() || is_R_CMD_check()) cnd <- sanitize_call(cnd)withRestartList(expr, restarts) error <<- format(e) error <<- format(e) }), list(rlang_trace_top_env = knit_global())), function(loc) { watcher$push(cnd) })
} if (on_warning$silence) {37:
invokeRestart("muffleWarning") }}, error = function (cnd) 47: withRestarts(with_handlers({{ for (expr in tle$exprs) {with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), watcher$capture_plot_and_output() ev <- withVisible(eval(expr, envir)) error = function(e) { cnd <- sanitize_call(cnd) watcher$capture_plot_and_output() watcher$push(cnd) if (progress && is.function(pb$interrupt)) setwd(wd) watcher$print_value(ev$value, ev$visible, envir) write_utf8(res, output %n% stdout()) pb$interrupt() } if (is_R_CMD_build() || is_R_CMD_check()) paste0("\nQuitting from ", loc, if (!is.null(error)) switch(on_error, continue = invokeRestart("eval_continue"), stop = invokeRestart("eval_stop"), error = NULL) TRUE paste0("\n", rule(), error, "\n", rule())) error <<- format(e)}) }), list(rlang_trace_top_env = knit_global()))}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)
28:
38: eval(call)48: 49: evaluate::evaluate(...)
process_file(text, output)xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), 39: 29: error = function(e) {evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, if (progress && is.function(pb$interrupt)) eval(call) keep_message = if (is.numeric(options$message)) TRUE else options$message,
pb$interrupt()
if (is_R_CMD_build() || is_R_CMD_check()) 50: stop_on_error = if (is.numeric(options$error)) options$error else {knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet) error <<- format(e)
if (options$error && options$include) 30: 0L51: }), list(rlang_trace_top_env = knit_global())), function(loc) { else 2Lwith_handlers({rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(), }, output_handler = knit_handlers(options$render, options)) output_dir = getwd(), ...)
for (expr in tle$exprs) { setwd(wd)40:
in_dir(input_dir(), expr) ev <- withVisible(eval(expr, envir)) write_utf8(res, output %n% stdout())
52: watcher$capture_plot_and_output() paste0("\nQuitting from ", loc, if (!is.null(error)) 41: vweave_rmarkdown(...) watcher$print_value(ev$value, ev$visible, envir) paste0("\n", rule(), error, "\n", rule()))}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)in_input_dir(evaluate(code, envir = env, new_device = FALSE,
}49: keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, process_file(text, output) TRUE53:
keep_message = if (is.numeric(options$message)) TRUE else options$message, }, handlers)engine$weave(file, quiet = quiet, encoding = enc)
50: stop_on_error = if (is.numeric(options$error)) options$error else {31: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
if (options$error && options$include)
0LdoWithOneRestart(return(expr), restart)54: else 2L51: }, output_handler = knit_handlers(options$render, options)))doTryCatch(return(expr), name, parentenv, handler)
rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(), 42:
output_dir = getwd(), ...)
eng_r(options)
32: 52: 55: vweave_rmarkdown(...)tryCatchOne(expr, names, parentenv, handlers[[1L]])
withOneRestart(expr, restarts[[1L]])43:
56: tryCatchList(expr, classes, parentenv, handlers)33: block_exec(params)
withRestartList(expr, restarts[-nr])53: 57:
engine$weave(file, quiet = quiet, encoding = enc)
tryCatch({44:
engine$weave(file, quiet = quiet, encoding = enc)54: setwd(startdir)call_block(x)34: output <- find_vignette_product(name, by = "weave", engine = engine)doTryCatch(return(expr), name, parentenv, handler)
if (!have.makefile && vignette_is_tex(output)) {45: texi2pdf(file = output, clean = FALSE, quiet = quiet)doWithOneRestart(return(expr), restart)
process_group(group) output <- find_vignette_product(name, by = "texi2pdf", 55:
engine = engine)tryCatchOne(expr, names, parentenv, handlers[[1L]])46: withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),
error = function(e) {56: } if (progress && is.function(pb$interrupt)) outputs <- c(outputs, output)tryCatchList(expr, classes, parentenv, handlers)35: }, error = function(e) {withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
thisOK <<- FALSE pb$interrupt() fails <<- c(fails, file)
57: message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s", if (is_R_CMD_build() || is_R_CMD_check()) 36: tryCatch({ error <<- format(e) file, conditionMessage(e)))withRestartList(expr, restarts) })})
engine$weave(file, quiet = quiet, encoding = enc)
47: setwd(startdir)58: with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), 37: output <- find_vignette_product(name, by = "weave", engine = engine)tools::buildVignettes(dir = "/Volumes/Builds/packages/big-sur-arm64/results/4.5/rEDM.Rcheck/vign_test/rEDM", if (!have.makefile && vignette_is_tex(output)) { skip = TRUE, ser_elibs = "/Volumes/Temp/tmp/Rtmp8T3RQs/file88ef7dde0f6e.rds") error = function(e) {withRestarts(with_handlers({
for (expr in tle$exprs) { texi2pdf(file = output, clean = FALSE, quiet = quiet) if (progress && is.function(pb$interrupt)) output <- find_vignette_product(name, by = "texi2pdf", pb$interrupt() engine = engine) ev <- withVisible(eval(expr, envir))An irrecoverable exception occurred. R is aborting now ...
if (is_R_CMD_build() || is_R_CMD_check()) } error <<- format(e) }), list(rlang_trace_top_env = knit_global())) watcher$capture_plot_and_output() outputs <- c(outputs, output)
48: }, error = function(e) { watcher$print_value(ev$value, ev$visible, envir)xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), } thisOK <<- FALSE error = function(e) { TRUE if (progress && is.function(pb$interrupt)) fails <<- c(fails, file)}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE) message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s", file, conditionMessage(e))) pb$interrupt()}) if (is_R_CMD_build() || is_R_CMD_check())
38: error <<- format(e)58: }), list(rlang_trace_top_env = knit_global())), function(loc) { setwd(wd)tools::buildVignettes(dir = "/Volumes/Builds/packages/big-sur-arm64/results/4.5/rEDM.Rcheck/vign_test/rEDM", evaluate::evaluate(...) write_utf8(res, output %n% stdout()) skip = TRUE, ser_elibs = "/Volumes/Temp/tmp/Rtmp8T3RQs/file88ef7dde0f6e.rds") paste0("\nQuitting from ", loc, if (!is.null(error))
paste0("\n", rule(), error, "\n", rule()))
39: }, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning,
49: An irrecoverable exception occurred. R is aborting now ...
keep_message = if (is.numeric(options$message)) TRUE else options$message, process_file(text, output) stop_on_error = if (is.numeric(options$error)) options$error else {
if (options$error && options$include) 50: 0L else 2Lknitr::knit(knit_input, knit_output, envir = envir, quiet = quiet) }, output_handler = knit_handlers(options$render, options))
51: 40: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(), output_dir = getwd(), ...)in_dir(input_dir(), expr)
41: in_input_dir(evaluate(code, envir = env, new_device = FALSE, 52: keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, vweave_rmarkdown(...) keep_message = if (is.numeric(options$message)) TRUE else options$message,
stop_on_error = if (is.numeric(options$error)) options$error else {53: if (options$error && options$include) engine$weave(file, quiet = quiet, encoding = enc) 0L
else 2L }, output_handler = knit_handlers(options$render, options)))54: doTryCatch(return(expr), name, parentenv, handler)
42: 55: tryCatchOne(expr, names, parentenv, handlers[[1L]])eng_r(options)
56: tryCatchList(expr, classes, parentenv, handlers)43:
block_exec(params)57:
tryCatch({44: call_block(x) engine$weave(file, quiet = quiet, encoding = enc)
setwd(startdir)45: output <- find_vignette_product(name, by = "weave", engine = engine)process_group(group) if (!have.makefile && vignette_is_tex(output)) { texi2pdf(file = output, clean = FALSE, quiet = quiet) output <- find_vignette_product(name, by = "texi2pdf",
engine = engine)46: } outputs <- c(outputs, output)withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), }, error = function(e) { thisOK <<- FALSE error = function(e) { fails <<- c(fails, file) if (progress && is.function(pb$interrupt)) message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s", pb$interrupt() file, conditionMessage(e))) if (is_R_CMD_build() || is_R_CMD_check()) }) error <<- format(e)
})58:
47: tools::buildVignettes(dir = "/Volumes/Builds/packages/big-sur-arm64/results/4.5/rEDM.Rcheck/vign_test/rEDM", with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), skip = TRUE, ser_elibs = "/Volumes/Temp/tmp/Rtmp8T3RQs/file88ef7dde0f6e.rds") error = function(e) {
if (progress && is.function(pb$interrupt)) pb$interrupt()An irrecoverable exception occurred. R is aborting now ...
if (is_R_CMD_build() || is_R_CMD_check()) error <<- format(e) }), list(rlang_trace_top_env = knit_global()))
48: xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), error = function(e) { if (progress && is.function(pb$interrupt)) pb$interrupt() if (is_R_CMD_build() || is_R_CMD_check()) error <<- format(e) }), list(rlang_trace_top_env = knit_global())), function(loc) { setwd(wd) write_utf8(res, output %n% stdout()) paste0("\nQuitting from ", loc, if (!is.null(error)) paste0("\n", rule(), error, "\n", rule()))}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)
49: process_file(text, output)
50: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
51: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(), output_dir = getwd(), ...)
52: vweave_rmarkdown(...)
53: engine$weave(file, quiet = quiet, encoding = enc)
54: doTryCatch(return(expr), name, parentenv, handler)
55: tryCatchOne(expr, names, parentenv, handlers[[1L]])
56: tryCatchList(expr, classes, parentenv, handlers)
57: 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)))})
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/Rtmp8T3RQs/file88ef7dde0f6e.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