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