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