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