Error(s) in re-building vignettes:
--- re-building ‘basic_usage.Rmd’ using rmarkdown

 *** caught segfault ***
address 0x110, cause 'invalid permissions'

Traceback:
 1: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)
 2: eval_f(x0, ...)
 3: nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     mi = mi, opts = mi$options)
 4: doTryCatch(return(expr), name, parentenv, handler)
 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
 6: tryCatchList(expr, classes, parentenv, handlers)
 7: tryCatch({    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,         mi = mi, opts = mi$options)}, error = function(e) {})
 8: system.time({    model <- mi$model    result <- NULL    tryCatch({        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,             mi = mi, opts = mi$options)    }, error = function(e) {    })    if (!is.null(result)) {        model$fail <- FALSE        model$coefficients <- result$solution        model$logLik <- as.numeric(-1 * result$objective)        model$iterations <- result$iterations        model$status <- result$status        model$message <- result$message    }})
 9: FUN(X[[i]], ...)
10: lapply(X = S, FUN = FUN, ...)
11: doTryCatch(return(expr), name, parentenv, handler)
12: tryCatchOne(expr, names, parentenv, handlers[[1L]])
13: tryCatchList(expr, classes, parentenv, handlers)
14: 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)             prefix <- paste0(prefix, "\n  ")    }    else prefix <- "Error : "    msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, file = outFile)        .Internal(printDeferredWarnings())    }    invisible(structure(msg, class = "try-error", condition = e))})
15: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
16: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
17: FUN(X[[i]], ...)
18: lapply(seq_len(cores), inner.do)
19: parallel::mclapply(miList, runModel, mc.cores = numCores)
20: withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))
21: suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))
22: withCallingHandlers(expr, message = function(c) if (inherits(c,     classes)) tryInvokeRestart("muffleMessage"))
23: suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))
24: runMultistart(modelInputs)
25: logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat",     "brand"), scalePar = "price", numMultiStarts = 10)
26: eval(expr, envir)
27: eval(expr, envir)
28: withVisible(eval(expr, envir))
29: withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) {    watcher$capture_plot_and_output()    if (on_message$capture) {        watcher$push(cnd)    }    if (on_message$silence) {        invokeRestart("muffleMessage")    }}, warning = function (cnd) {    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    }    watcher$capture_plot_and_output()    if (on_warning$capture) {        cnd <- sanitize_call(cnd)        watcher$push(cnd)    }    if (on_warning$silence) {        invokeRestart("muffleWarning")    }}, error = function (cnd) {    watcher$capture_plot_and_output()    cnd <- sanitize_call(cnd)    watcher$push(cnd)    switch(on_error, continue = invokeRestart("eval_continue"),         stop = invokeRestart("eval_stop"), error = NULL)})
30: eval(call)
31: eval(call)
32: with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers)
33: doWithOneRestart(return(expr), restart)
34: withOneRestart(expr, restarts[[1L]])
35: withRestartList(expr, restarts[-nr])
36: doWithOneRestart(return(expr), restart)
37: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
38: withRestartList(expr, restarts)
39: withRestarts(with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)
40: evaluate::evaluate(...)
41: 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,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options))
42: in_dir(input_dir(), expr)
43: in_input_dir(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,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options)))
44: eng_r(options)
45: block_exec(params)
46: call_block(x)
47: process_group(group)
48: 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)    })
49: 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()))
50: 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)
51: process_file(text, output)
52: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
53: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
54: vweave_rmarkdown(...)
55: engine$weave(file, quiet = quiet, encoding = enc)
56: doTryCatch(return(expr), name, parentenv, handler)
57: tryCatchOne(expr, names, parentenv, handlers[[1L]])
58: tryCatchList(expr, classes, parentenv, handlers)
59: 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)    }}, error = function(e) {    OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})
60: tools:::.buildOneVignette("basic_usage.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr",     TRUE, FALSE, "basic_usage", "UTF-8", "/Volumes/Temp/tmp/RtmpS24rW8/file1697365004785.rds")
An irrecoverable exception occurred. R is aborting now ...

 *** caught segfault ***
address 0x110, cause 'invalid permissions'

 *** caught segfault ***
address 0x110, cause 'invalid permissions'

 *** caught segfault ***
address 0x110, cause 'invalid permissions'

Traceback:
 1: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)
 2: eval_f(x0, ...)
 3: nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     mi = mi, opts = mi$options)
Traceback:

 4: doTryCatch(return(expr), name, parentenv, handler)
 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
 6: tryCatchList(expr, classes, parentenv, handlers)
 7: tryCatch({    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,         mi = mi, opts = mi$options)}, error = function(e) {})
 8: system.time({    model <- mi$model    result <- NULL    tryCatch({ 1: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)
 2: eval_f(x0, ...)
 3: nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     mi = mi, opts = mi$options)
 4: doTryCatch(return(expr), name, parentenv, handler)
 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
 6: tryCatchList(expr, classes, parentenv, handlers)
 7: tryCatch({    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,         mi = mi, opts = mi$options)}, error = function(e) {})
 8: system.time({    model <- mi$model    result <- NULL    tryCatch({        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,             mi = mi, opts = mi$options)    }, error = function(e) {    })    if (!is.null(result)) {        model$fail <- FALSE        model$coefficients <- result$solution        model$logLik <- as.numeric(-1 * result$objective)        model$iterations <- result$iterations        model$status <- result$status        model$message <- result$message    }        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,             mi = mi, opts = mi$options)    }, error = function(e) {    })    if (!is.null(result)) {        model$fail <- FALSE        model$coefficients <- result$solution        model$logLik <- as.numeric(-1 * result$objective)        model$iterations <- result$iterations        model$status <- result$status        model$message <- result$message    }})
 9: FUN(X[[i]], ...)
10: lapply(X = S, FUN = FUN, ...)
11: doTryCatch(return(expr), name, parentenv, handler)
12: tryCatchOne(expr, names, parentenv, handlers[[1L]])
13: tryCatchList(expr, classes, parentenv, handlers)
14: 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)             prefix <- paste0(prefix, "\n  ")    }    else prefix <- "Error : "    msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, file = outFile)        .Internal(printDeferredWarnings())    }    invisible(structure(msg, class = "try-error", condition = e))})
15: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
16: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
17: FUN(X[[i]], ...)
18: lapply(seq_len(cores), inner.do)
19: parallel::mclapply(miList, runModel, mc.cores = numCores)
20: withCallingHandlers(expr, warning = function(w) if (inherits(w, 
Traceback:
 1: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)
 2: eval_f(x0, ...)
 3: nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     mi = mi, opts = mi$options)
 4: doTryCatch(return(expr), name, parentenv, handler)
 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
 *** caught segfault ***
address 0x110, cause 'invalid permissions'
    classes)) tryInvokeRestart("muffleWarning"))})
 6: tryCatchList(expr, classes, parentenv, handlers)
21: suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))
22: withCallingHandlers(expr, message = function(c) if (inherits(c, 
 7: tryCatch({    classes)) tryInvokeRestart("muffleMessage"))
 9: FUN(X[[i]], ...)
10:     result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,         mi = mi, opts = mi$options)}, error = function(e) {})
 8: system.time({    model <- mi$model    result <- NULL    tryCatch({        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,             mi = mi, opts = mi$options)lapply(X = S, FUN = FUN, ...)
11: doTryCatch(return(expr), name, parentenv, handler)
12: tryCatchOne(expr, names, parentenv, handlers[[1L]])
13: tryCatchList(expr, classes, parentenv, handlers)
23: suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))
24: runMultistart(modelInputs)
25: logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat",     "brand"), scalePar = "price", numMultiStarts = 10)
26: eval(expr, envir)
27: eval(expr, envir)
    }, error = function(e) {    })    if (!is.null(result)) {        model$fail <- FALSE        model$coefficients <- result$solution28: withVisible(eval(expr, envir))
29: withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) {        model$logLik <- as.numeric(-1 * result$objective)        model$iterations <- result$iterations        model$status <- result$status        model$message <- result$message    }})
 9: FUN(X[[i]], ...)
10: lapply(X = S, FUN = FUN, ...)
14: 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, ": ")
11:     watcher$capture_plot_and_output()doTryCatch(return(expr), name, parentenv, handler)    if (on_message$capture) {        watcher$push(cnd)    }    if (on_message$silence) {        invokeRestart("muffleMessage")    }}, warning = function (cnd) 
12: tryCatchOne(expr, names, parentenv, handlers[[1L]]){
    if (getOption("warn") >= 2 || getOption("warn") < 0) {        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")13: tryCatchList(expr, classes, parentenv, handlers)
14:         if (w > LONG) tryCatch(expr, error = function(e) {            prefix <- paste0(prefix, "\n  ")    call <- conditionCall(e)    }    else prefix <- "Error : "    if (!is.null(call)) {    msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, file = outFile)        .Internal(printDeferredWarnings())    }        return()    invisible(structure(msg, class = "try-error", condition = e))})    }
15: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
16: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
17: FUN(X[[i]], ...)
18: lapply(seq_len(cores), inner.do)
19: parallel::mclapply(miList, runModel, mc.cores = numCores)
20: withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))
    watcher$capture_plot_and_output()    if (on_warning$capture) {        cnd <- sanitize_call(cnd)        watcher$push(cnd)    }    if (on_warning$silence) {        invokeRestart("muffleWarning")    }}, error = function (cnd) {        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)             prefix <- paste0(prefix, "\n  ")    }    else prefix <- "Error : "21:     msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, file = outFile)        .Internal(printDeferredWarnings())suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))    }
    watcher$capture_plot_and_output()22: withCallingHandlers(expr, message = function(c) if (inherits(c,     classes)) tryInvokeRestart("muffleMessage"))

Traceback:
 1: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)
23:  2:     cnd <- sanitize_call(cnd)eval_f(x0, ...)
 3: nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     mi = mi, opts = mi$options)
suppressMessages(suppressWarnings(parallel::mclapply(miList,     invisible(structure(msg, class = "try-error", condition = e)) 4:     watcher$push(cnd)})    switch(on_error, continue = invokeRestart("eval_continue"), 
        stop = invokeRestart("eval_stop"), error = NULL)    runModel, mc.cores = numCores)))15: 
24: runMultistart(modelInputs)try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
})doTryCatch(return(expr), name, parentenv, handler)
 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
 6: tryCatchList(expr, classes, parentenv, handlers)
 7: tryCatch({

16: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
25:     result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,         mi = mi, opts = mi$options)}, error = function(e) {})30: 
logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat", eval(call) 8: 17:     "brand"), scalePar = "price", numMultiStarts = 10)system.time({
FUN(X[[i]], ...)
18: lapply(seq_len(cores), inner.do)
19: parallel::mclapply(miList, runModel, mc.cores = numCores)
    model <- mi$model
20: withCallingHandlers(expr, warning = function(w) if (inherits(w, 31: 26:     result <- NULL    tryCatch({        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,             mi = mi, opts = mi$options)    }, error = function(e) {    })    if (!is.null(result)) {eval(call)
        model$fail <- FALSE32:         model$coefficients <- result$solutioneval(expr, envir)        model$logLik <- as.numeric(-1 * result$objective)    classes)) tryInvokeRestart("muffleWarning"))
        model$iterations <- result$iterations        model$status <- result$status        model$message <- result$messagewith_handlers({
27: eval(expr, envir)21:     }    for (expr in tle$exprs) {})
 9: FUN(X[[i]], ...)
10:         ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()
lapply(X = S, FUN = FUN, ...)
        watcher$print_value(ev$value, ev$visible, envir)suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))28:     }11: withVisible(eval(expr, envir))doTryCatch(return(expr), name, parentenv, handler)


    TRUE}, handlers)
33: 22: 
 *** caught segfault ***
29: withCallingHandlers(expr, message = function(c) if (inherits(c, 12: withCallingHandlers(code, error = function (e) doWithOneRestart(return(expr), restart)
34: withOneRestart(expr, restarts[[1L]])
35: withRestartList(expr, restarts[-nr])rlang::entrace(e), message = function (cnd) 
36: doWithOneRestart(return(expr), restart)
address 0x110, cause 'invalid permissions'
{37:     classes)) tryInvokeRestart("muffleMessage"))tryCatchOne(expr, names, parentenv, handlers[[1L]])    watcher$capture_plot_and_output()    if (on_message$capture) {        watcher$push(cnd)    }
    if (on_message$silence) {        invokeRestart("muffleMessage")    }}, warning = function (cnd) {    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    }
withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
    watcher$capture_plot_and_output()38:     if (on_warning$capture) {        cnd <- sanitize_call(cnd)        watcher$push(cnd)withRestartList(expr, restarts)    }
39: withRestarts(with_handlers({    for (expr in tle$exprs) {23: suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))
24: runMultistart(modelInputs)
25: 13: logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat",         ev <- withVisible(eval(expr, envir))    if (on_warning$silence) {tryCatchList(expr, classes, parentenv, handlers)    "brand"), scalePar = "price", numMultiStarts = 10)

26:         watcher$capture_plot_and_output()eval(expr, envir)
27: eval(expr, envir)
28: withVisible(eval(expr, envir))
14:         watcher$print_value(ev$value, ev$visible, envir)    }    TRUE29: 
 *** caught segfault ***
tryCatch(expr, error = function(e) {address 0x110, cause 'invalid permissions'
}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)
40: 
 *** caught segfault ***
evaluate::evaluate(...)address 0x110, cause 'invalid permissions'
    call <- conditionCall(e)
41: 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,         invokeRestart("muffleWarning")    if (!is.null(call)) {    stop_on_error = if (is.numeric(options$error)) options$error else {withCallingHandlers(code, error = function (e)         if (options$error && options$include)             0Lrlang::entrace(e), message = function (cnd)         else 2L{    }, output_handler = knit_handlers(options$render, options))
42: in_dir(input_dir(), expr)
43: in_input_dir(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,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options)))
44: eng_r(options)
45:     watcher$capture_plot_and_output()        if (identical(call[[1L]], quote(doTryCatch)))             call <- sys.call(-4L)    if (on_message$capture) {block_exec(params)
46:         watcher$push(cnd)    }        dcall <- deparse(call, nlines = 1L)call_block(x)    }    if (on_message$silence) {        invokeRestart("muffleMessage")    }
47:         prefix <- paste("Error in", dcall, ": ")        LONG <- 75Lprocess_group(group)
48: }, error = function (cnd) }, warning = function (cnd)         sm <- strsplit(conditionMessage(e), "\n")[[1L]]{        w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")        if (is.na(w))     if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    }    watcher$capture_plot_and_output(){            w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L],     watcher$capture_plot_and_output()    cnd <- sanitize_call(cnd)    watcher$push(cnd)    if (on_warning$capture) {                type = "b")        cnd <- sanitize_call(cnd)        if (w > LONG) 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)        watcher$push(cnd)    }    if (on_warning$silence) {        invokeRestart("muffleWarning")    }}, error = function (cnd) {    watcher$capture_plot_and_output()    cnd <- sanitize_call(cnd)    watcher$push(cnd)    switch(on_error, continue = invokeRestart("eval_continue"),         stop = invokeRestart("eval_stop"), error = NULL)})
30: eval(call)
31: eval(call)
    switch(on_error, continue = invokeRestart("eval_continue"), 32:         stop = invokeRestart("eval_stop"), error = NULL)
Traceback:
    })            prefix <- paste0(prefix, "\n  ")with_handlers({}) 1: 
    }    else prefix <- "Error : "    msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, file = outFile)        .Internal(printDeferredWarnings())    }    invisible(structure(msg, class = "try-error", condition = e))
    for (expr in tle$exprs) {30: })49: eval(call)

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())         ev <- withVisible(eval(expr, envir))31:             error <<- format(e)    }), list(rlang_trace_top_env = knit_global()))15: 
mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUEeval(call)
50: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)}, handlers)
 2: eval_f(x0, ...)
Traceback:


xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), 
Traceback:

 *** caught segfault ***
address 0x110, cause 'invalid permissions'

32: with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir)) 3:  1: 16: 
 *** caught segfault ***
mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)address 0x110, cause 'invalid permissions'
nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, 
 2: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
17: FUN(X[[i]], ...)
18:     mi = mi, opts = mi$options)lapply(seq_len(cores), inner.do)eval_f(x0, ...)    error = function(e) {        if (progress && is.function(pb$interrupt)) 
 4: doTryCatch(return(expr), name, parentenv, handler)
            pb$interrupt()        watcher$capture_plot_and_output()        if (is_R_CMD_build() || is_R_CMD_check())  5: 33: 
19: parallel::mclapply(miList, runModel, mc.cores = numCores)        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE
            error <<- format(e)}, handlers)20: withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))
 1: tryCatchOne(expr, names, parentenv, handlers[[1L]])
33: doWithOneRestart(return(expr), restart)
    }), list(rlang_trace_top_env = knit_global())), function(loc) {
doWithOneRestart(return(expr), restart)mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)
34: 
    setwd(wd)34: 21: withOneRestart(expr, restarts[[1L]])
35: withRestartList(expr, restarts[-nr])
36: doWithOneRestart(return(expr), restart)
Traceback:
withOneRestart(expr, restarts[[1L]]) 6:  3: suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))    write_utf8(res, output %n% stdout()) 1:     paste0("\nQuitting from ", loc, if (!is.null(error))         paste0("\n", rule(), error, "\n", rule()))}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)
51: tryCatchList(expr, classes, parentenv, handlers)nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, 


process_file(text, output)37: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
38: withRestartList(expr, restarts)
39: withRestarts(with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)
40: evaluate::evaluate(...)
41: 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,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options))
42: in_dir(input_dir(), expr)
43: in_input_dir(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,     mi = mi, opts = mi$options)mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)

 2: eval_f(x0, ...)
 3: nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     mi = mi, opts = mi$options)
 4: doTryCatch(return(expr), name, parentenv, handler)
 5: 

35: 
withRestartList(expr, restarts[-nr])
36: doWithOneRestart(return(expr), restart)
37: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
38: withRestartList(expr, restarts)
 2:     stop_on_error = if (is.numeric(options$error)) options$error else {tryCatchOne(expr, names, parentenv, handlers[[1L]])22: withCallingHandlers(expr, message = function(c) if (inherits(c,     classes)) tryInvokeRestart("muffleMessage"))
23: suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))
24: runMultistart(modelInputs)
25: logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat",     "brand"), scalePar = "price", numMultiStarts = 10)
26: eval(expr, envir)
27: eval(expr, envir)
28: withVisible(eval(expr, envir))
29: withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) {    watcher$capture_plot_and_output()    if (on_message$capture) { 4: doTryCatch(return(expr), name, parentenv, handler)
 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
52:         if (options$error && options$include) 
39:  6: tryCatchList(expr, classes, parentenv, handlers)
 7: tryCatch({
Traceback:
knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet) 6: 
53: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
54: vweave_rmarkdown(...)
55: withRestarts(with_handlers({ 7:  1: tryCatchList(expr, classes, parentenv, handlers)            0L    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,         watcher$push(cnd)        mi = mi, opts = mi$options)}, error = function(e) {})
 8: system.time({    model <- mi$model    result <- NULL    tryCatch({        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,             mi = mi, opts = mi$options)    }, error = function(e) {    })    if (!is.null(result)) {        model$fail <- FALSE        model$coefficients <- result$solution        model$logLik <- as.numeric(-1 * result$objective)        model$iterations <- result$iterations        model$status <- result$status        model$message <- result$message    }})
 9: FUN(X[[i]], ...)mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)    }    if (on_message$silence) {        invokeRestart("muffleMessage")    }}, warning = function (cnd) {    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    }    watcher$capture_plot_and_output()    if (on_warning$capture) {        cnd <- sanitize_call(cnd)        watcher$push(cnd)    }    if (on_warning$silence) {        invokeRestart("muffleWarning")    }}, error = function (cnd) {    watcher$capture_plot_and_output()    cnd <- sanitize_call(cnd)    watcher$push(cnd)    switch(on_error, continue = invokeRestart("eval_continue"),         stop = invokeRestart("eval_stop"), error = NULL)})
30: eval(call)
31: engine$weave(file, quiet = quiet, encoding = enc)
tryCatch({
eval(call)

 7: eval_f(x0, ...)10: 
 2:     result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, tryCatch({        mi = mi, opts = mi$options)}, error = function(e) {})
 8: system.time({    model <- mi$model    result <- NULL    tryCatch({        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,             mi = mi, opts = mi$options)    }, error = function(e) {    })    if (!is.null(result)) {        model$fail <- FALSE        model$coefficients <- result$solution        model$logLik <- as.numeric(-1 * result$objective)        model$iterations <- result$iterations        model$status <- result$status        model$message <- result$message    }})
 9: FUN(X[[i]], ...)
    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)
40: evaluate::evaluate(...)
41: 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,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options))
42: in_dir(input_dir(), expr)
43: in_input_dir(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,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)         else 2Leval_f(x0, ...)    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, 
10:             0L56: 32: doTryCatch(return(expr), name, parentenv, handler)
57: tryCatchOne(expr, names, parentenv, handlers[[1L]])
58: tryCatchList(expr, classes, parentenv, handlers)
59: 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)    }}, error = function(e) {    OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))lapply(X = S, FUN = FUN, ...) 3:     }, output_handler = knit_handlers(options$render, options)))        mi = mi, opts = mi$options)})lapply(X = S, FUN = FUN, ...)
        else 2L
    }, output_handler = knit_handlers(options$render, options)))
44: eng_r(options)
45: block_exec(params)
46: call_block(x)
47: process_group(group)
48: 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)    })
49: 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)
44: eng_r(options)
45: 60: nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, tools:::.buildOneVignette("basic_usage.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr",     TRUE, FALSE, "basic_usage", "UTF-8", "/Volumes/Temp/tmp/RtmpS24rW8/file1697365004785.rds")

with_handlers({
block_exec(params)11: doTryCatch(return(expr), name, parentenv, handler)
12: tryCatchOne(expr, names, parentenv, handlers[[1L]])
13: tryCatchList(expr, classes, parentenv, handlers)
14: 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)             prefix <- paste0(prefix, "\n  ")    }    }), list(rlang_trace_top_env = knit_global())) 3:     for (expr in tle$exprs) {    mi = mi, opts = mi$options)}, error = function(e) {    else prefix <- "Error : "
nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, 

    msg <- paste0(prefix, conditionMessage(e), "\n")11: 50:     mi = mi, opts = mi$options)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)
51: An irrecoverable exception occurred. R is aborting now ...
})doTryCatch(return(expr), name, parentenv, handler)
 8: system.time({    model <- mi$model    result <- NULL    tryCatch({        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,             mi = mi, opts = mi$options)    }, error = function(e) {    })    if (!is.null(result)) {        model$fail <- FALSE        model$coefficients <- result$solution        ev <- withVisible(eval(expr, envir))    .Internal(seterrmessage(msg[1L])) 4:     if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, file = outFile)        .Internal(printDeferredWarnings())    }    invisible(structure(msg, class = "try-error", condition = e))})
15: process_file(text, output)46:         model$logLik <- as.numeric(-1 * result$objective)        model$iterations <- result$iterations        model$status <- result$status        model$message <- result$message    }})
 9: FUN(X[[i]], ...)
10: lapply(X = S, FUN = FUN, ...)doTryCatch(return(expr), name, parentenv, handler)call_block(x)
try(lapply(X = S, FUN = FUN, ...), silent = TRUE)

16: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
17: FUN(X[[i]], ...)
18: lapply(seq_len(cores), inner.do)
19: parallel::mclapply(miList, runModel, mc.cores = numCores)
20: withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))
21: suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))
22: withCallingHandlers(expr, message = function(c) if (inherits(c,     classes)) tryInvokeRestart("muffleMessage"))
23: 


suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))
24:  5: 11: doTryCatch(return(expr), name, parentenv, handler)tryCatchOne(expr, names, parentenv, handlers[[1L]])
 6: tryCatchList(expr, classes, parentenv, handlers)

47: process_group(group)
48: 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)    })
49: 52: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
53: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)12: with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),  4: runMultistart(modelInputs)
25: logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat",     "brand"), scalePar = "price", numMultiStarts = 10)
26: eval(expr, envir)
27:  7: 
tryCatch({    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     error = function(e) {        mi = mi, opts = mi$options)}, error = function(e) {12:         if (progress && is.function(pb$interrupt))             pb$interrupt()})eval(expr, envir)
        if (is_R_CMD_build() || is_R_CMD_check()) doTryCatch(return(expr), name, parentenv, handler)tryCatchOne(expr, names, parentenv, handlers[[1L]])tryCatchOne(expr, names, parentenv, handlers[[1L]])
13: tryCatchList(expr, classes, parentenv, handlers)
54: 

vweave_rmarkdown(...)28: 
        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }14: 55: engine$weave(file, quiet = quiet, encoding = enc)
56: doTryCatch(return(expr), name, parentenv, handler)
57: tryCatchOne(expr, names, parentenv, handlers[[1L]])
58: tryCatchList(expr, classes, parentenv, handlers)
59: 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", 13: 
            engine = engine)tryCatch(expr, error = function(e) {    call <- conditionCall(e)
    TRUE 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
 6: tryCatchList(expr, classes, parentenv, handlers)
 7: tryCatch({    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,         mi = mi, opts = mi$options)}, error = function(e) {})
 8: system.time({    model <- mi$modelwithVisible(eval(expr, envir))}, handlers)
33: doWithOneRestart(return(expr), restart)
34: withOneRestart(expr, restarts[[1L]])
35: withRestartList(expr, restarts[-nr])
36: doWithOneRestart(return(expr), restart)
37: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
38: withRestartList(expr, restarts)
39: withRestarts(with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()    }tryCatchList(expr, classes, parentenv, handlers)    if (!is.null(call)) {        watcher$print_value(ev$value, ev$visible, envir)        if (identical(call[[1L]], quote(doTryCatch)))             error <<- format(e)}, error = function(e) {    }), list(rlang_trace_top_env = knit_global()))
50: 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)
51: process_file(text, output)    OK <<- FALSE    result <- NULL
    tryCatch({        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,             mi = mi, opts = mi$options)    }, error = function(e) {    })    if (!is.null(result)) {        model$fail <- FALSE        model$coefficients <- result$solution        model$logLik <- as.numeric(-1 * result$objective)        model$iterations <- result$iterations        model$status <- result$status        model$message <- result$message    }})
14: 
    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s", 29: withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) {    watcher$capture_plot_and_output()    if (on_message$capture) {        watcher$push(cnd)    }    if (on_message$silence) {        invokeRestart("muffleMessage")    }}, warning = function (cnd) {    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    }    watcher$capture_plot_and_output()    if (on_warning$capture) {        file, conditionMessage(e))) 8:     }system.time({    model <- mi$model    result <- NULL    tryCatch({        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,             mi = mi, opts = mi$options)    }, error = function(e) {    })    if (!is.null(result)) {        model$fail <- FALSE        model$coefficients <- result$solution    TRUE}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)
40: evaluate::evaluate(...)
        cnd <- sanitize_call(cnd)}) 9: 
        model$logLik <- as.numeric(-1 * result$objective)41:         watcher$push(cnd)
            call <- sys.call(-4L)60: tools:::.buildOneVignette("basic_usage.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr",     TRUE, FALSE, "basic_usage", "UTF-8", "/Volumes/Temp/tmp/RtmpS24rW8/file1697365004785.rds")
An irrecoverable exception occurred. R is aborting now ...
        model$iterations <- result$iterationstryCatch(expr, error = function(e) {        dcall <- deparse(call, nlines = 1L)        prefix <- paste("Error in", dcall, ": ")52:     }knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
53: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
54: vweave_rmarkdown(...)
55: engine$weave(file, quiet = quiet, encoding = enc)
56: doTryCatch(return(expr), name, parentenv, handler)
57: tryCatchOne(expr, names, parentenv, handlers[[1L]])
58: tryCatchList(expr, classes, parentenv, handlers)
59: 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)    if (on_warning$silence) {        invokeRestart("muffleWarning")    }}, error = function (cnd) {    watcher$capture_plot_and_output()    cnd <- sanitize_call(cnd)    watcher$push(cnd)    switch(on_error, continue = invokeRestart("eval_continue"),         stop = invokeRestart("eval_stop"), error = NULL)})
30: eval(call)
31: eval(call)
32: with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning,     call <- conditionCall(e)        LONG <- 75LFUN(X[[i]], ...)        watcher$print_value(ev$value, ev$visible, envir)        output <- find_vignette_product(name, by = "texi2pdf",     }    TRUE}, handlers)
33:     keep_message = if (is.numeric(options$message)) TRUE else options$message,         model$status <- result$status        model$message <- result$message    }})    stop_on_error = if (is.numeric(options$error)) options$error else {    if (!is.null(call)) {
        sm <- strsplit(conditionMessage(e), "\n")[[1L]]10: 
        if (options$error && options$include)         if (identical(call[[1L]], quote(doTryCatch)))             engine = engine)        w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")lapply(X = S, FUN = FUN, ...) 9:             0L            call <- sys.call(-4L)    }        if (is.na(w)) 
            w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L],                 type = "b")        if (w > LONG)             prefix <- paste0(prefix, "\n  ")    }    else prefix <- "Error : "    msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, file = outFile)        .Internal(printDeferredWarnings())    }    invisible(structure(msg, class = "try-error", condition = e))})
15: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
        else 2LdoWithOneRestart(return(expr), restart)        dcall <- deparse(call, nlines = 1L)}, error = function(e) {16: 11:     }, output_handler = knit_handlers(options$render, options))FUN(X[[i]], ...)
42: in_dir(input_dir(), expr)
43: in_input_dir(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,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options)))
44: eng_r(options)
45: block_exec(params)
46: call_block(x)
47: process_group(group)
    OK <<- FALSE
        prefix <- paste("Error in", dcall, ": ")doTryCatch(return(expr), name, parentenv, handler)        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)             prefix <- paste0(prefix, "\n  ")    }    else prefix <- "Error : "sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s", 10: 
lapply(X = S, FUN = FUN, ...)
11: doTryCatch(return(expr), name, parentenv, handler)
12: tryCatchOne(expr, names, parentenv, handlers[[1L]])
13: tryCatchList(expr, classes, parentenv, handlers)
14: 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)             prefix <- paste0(prefix, "\n  ")    }    else prefix <- "Error : "    msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, file = outFile)        .Internal(printDeferredWarnings())    }    msg <- paste0(prefix, conditionMessage(e), "\n")
        file, conditionMessage(e)))48: 12: 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)    })
49: 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()))
50: xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), tryCatchOne(expr, names, parentenv, handlers[[1L]])
13: tryCatchList(expr, classes, parentenv, handlers)
14: tryCatch(expr, error = function(e) {    call <- conditionCall(e)    if (!is.null(call)) {        if (identical(call[[1L]], quote(doTryCatch)))             call <- sys.call(-4L)34:     error = function(e) {withOneRestart(expr, restarts[[1L]])
        dcall <- deparse(call, nlines = 1L)})
        if (progress && is.function(pb$interrupt)) 35:             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)        prefix <- paste("Error in", dcall, ": ")    invisible(structure(msg, class = "try-error", condition = e))        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)             prefix <- paste0(prefix, "\n  ")    }    else prefix <- "Error : "    msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, file = outFile)        .Internal(printDeferredWarnings())    }17:     write_utf8(res, output %n% stdout())
FUN(X[[i]], ...)    .Internal(seterrmessage(msg[1L]))
})
    paste0("\nQuitting from ", loc, if (!is.null(error)) 15: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
    if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, file = outFile)        .Internal(printDeferredWarnings())    }    invisible(structure(msg, class = "try-error", condition = e))})
15:     invisible(structure(msg, class = "try-error", condition = e))withRestartList(expr, restarts[-nr])try(lapply(X = S, FUN = FUN, ...), silent = TRUE)18: lapply(seq_len(cores), inner.do)
19: parallel::mclapply(miList, runModel, mc.cores = numCores)
20: withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))
})16: 
36: doWithOneRestart(return(expr), restart)
37: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
38: withRestartList(expr, restarts)
60: tools:::.buildOneVignette("basic_usage.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr",     TRUE, FALSE, "basic_usage", "UTF-8", "/Volumes/Temp/tmp/RtmpS24rW8/file1697365004785.rds")21: suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))
22: withCallingHandlers(expr, message = function(c) if (inherits(c,     classes)) tryInvokeRestart("muffleMessage"))
23: suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))
24: runMultistart(modelInputs)
25: 39: logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat",     "brand"), scalePar = "price", numMultiStarts = 10)sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
withRestarts(with_handlers({        paste0("\n", rule(), error, "\n", rule()))    for (expr in tle$exprs) {}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)17: 
FUN(X[[i]], ...)
18: lapply(seq_len(cores), inner.do)
19: parallel::mclapply(miList, runModel, mc.cores = numCores)
20: withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))
21: suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))
22: withCallingHandlers(expr, message = function(c) if (inherits(c,     classes)) tryInvokeRestart("muffleMessage"))
23: suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))
24: runMultistart(modelInputs)
25: logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat",     "brand"), scalePar = "price", numMultiStarts = 10)
An irrecoverable exception occurred. R is aborting now ...
        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)
40: evaluate::evaluate(...)
41: 
26: eval(expr, envir)


15: 
evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, 27: 26: 51: process_file(text, output)
52: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
try(lapply(X = S, FUN = FUN, ...), silent = TRUE)    keep_message = if (is.numeric(options$message)) TRUE else options$message, eval(expr, envir)16:     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include) sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
28: withVisible(eval(expr, envir))
29: withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) {
            0L53: eval(expr, envir)rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
54: vweave_rmarkdown(...)
55: engine$weave(file, quiet = quiet, encoding = enc)
56: doTryCatch(return(expr), name, parentenv, handler)
57: tryCatchOne(expr, names, parentenv, handlers[[1L]])
58: tryCatchList(expr, classes, parentenv, handlers)

27: eval(expr, envir)
28: withVisible(eval(expr, envir))
29: withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) 17: 
        else 2L16: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
17: FUN(X[[i]], ...)
18: lapply(seq_len(cores), inner.do)
19: parallel::mclapply(miList, runModel, mc.cores = numCores)
20: withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))
21: 59:     watcher$capture_plot_and_output()FUN(X[[i]], ...){
suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))    if (on_message$capture) {        watcher$push(cnd)    }    if (on_message$silence) {18:     }, output_handler = knit_handlers(options$render, options))lapply(seq_len(cores), inner.do)    watcher$capture_plot_and_output()

42: in_dir(input_dir(), expr)
43: in_input_dir(evaluate(code, envir = env, new_device = FALSE,         invokeRestart("muffleMessage")tryCatch({    engine$weave(file, quiet = quiet, encoding = enc)19: parallel::mclapply(miList, runModel, mc.cores = numCores)
20: withCallingHandlers(expr, warning = function(w) if (inherits(w, 
    keep_warning = if (is.numeric(options$warning)) TRUE else options$warning,     }}, warning = function (cnd) {    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    keep_message = if (is.numeric(options$message)) TRUE else options$message,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options)))
    if (on_message$capture) {        watcher$push(cnd)    classes)) tryInvokeRestart("muffleWarning"))    }    watcher$capture_plot_and_output()    if (on_warning$capture) {44:     }    if (on_message$silence) {        invokeRestart("muffleMessage")    }}, warning = function (cnd) {    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    }    watcher$capture_plot_and_output()    setwd(startdir)    if (on_warning$capture) {        cnd <- sanitize_call(cnd)        watcher$push(cnd)    }
22:     if (on_warning$silence) {        cnd <- sanitize_call(cnd)    output <- find_vignette_product(name, by = "weave", engine = engine)        invokeRestart("muffleWarning")withCallingHandlers(expr, message = function(c) if (inherits(c,     if (!have.makefile && vignette_is_tex(output)) {        texi2pdf(file = output, clean = FALSE, quiet = quiet)    }eng_r(options)}, error = function (cnd)     classes)) tryInvokeRestart("muffleMessage"))
21:         watcher$push(cnd)45: 
suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores)){block_exec(params)
    }
23:     if (on_warning$silence) {suppressMessages(suppressWarnings(parallel::mclapply(miList, 22:         output <- find_vignette_product(name, by = "texi2pdf",             engine = engine)    }}, error = function(e) {    OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})    watcher$capture_plot_and_output()        invokeRestart("muffleWarning")    cnd <- sanitize_call(cnd)    watcher$push(cnd)    switch(on_error, continue = invokeRestart("eval_continue"),         stop = invokeRestart("eval_stop"), error = NULL)})
30: eval(call)
31: eval(call)
32: with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))    }}, error = function (cnd) {    watcher$capture_plot_and_output()    cnd <- sanitize_call(cnd)    watcher$push(cnd)    switch(on_error, continue = invokeRestart("eval_continue"),         stop = invokeRestart("eval_stop"), error = NULL)})
    runModel, mc.cores = numCores)))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers)
33: doWithOneRestart(return(expr), restart)
34: withOneRestart(expr, restarts[[1L]])
35: withRestartList(expr, restarts[-nr])
36: doWithOneRestart(return(expr), restart)
37: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
38: 
withCallingHandlers(expr, message = function(c) if (inherits(c, 60: tools:::.buildOneVignette("basic_usage.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr",     TRUE, FALSE, "basic_usage", "UTF-8", "/Volumes/Temp/tmp/RtmpS24rW8/file1697365004785.rds")
An irrecoverable exception occurred. R is aborting now ...
30: 
withRestartList(expr, restarts)eval(call)24: runMultistart(modelInputs)
25: logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat",     "brand"), scalePar = "price", numMultiStarts = 10)    classes)) tryInvokeRestart("muffleMessage"))
31: eval(call)

39: 46: 

23: call_block(x)suppressMessages(suppressWarnings(parallel::mclapply(miList, 
26: withRestarts(with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE32: with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()eval(expr, envir)        watcher$print_value(ev$value, ev$visible, envir)}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)
    runModel, mc.cores = numCores)))47: 
process_group(group)    }
    TRUE}, handlers)

24: 48: 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()) 27: 40:             error <<- format(e)33: eval(expr, envir)evaluate::evaluate(...)    })
41: evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, doWithOneRestart(return(expr), restart)runMultistart(modelInputs)

28: 

withVisible(eval(expr, envir))    keep_message = if (is.numeric(options$message)) TRUE else options$message,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L
34: 29:         else 2L25: withCallingHandlers(code, error = function (e)     }, output_handler = knit_handlers(options$render, options))
42: in_dir(input_dir(), expr)
rlang::entrace(e), message = function (cnd) withOneRestart(expr, restarts[[1L]])43: logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat", 
49: in_input_dir(evaluate(code, envir = env, new_device = FALSE,     "brand"), scalePar = "price", numMultiStarts = 10)
26: eval(expr, envir)
27:     keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, 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()))
50: xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), {    keep_message = if (is.numeric(options$message)) TRUE else options$message, 35:     error = function(e) {    stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)     watcher$capture_plot_and_output()    if (on_message$capture) {        watcher$push(cnd)    }    if (on_message$silence) {        invokeRestart("muffleMessage")withRestartList(expr, restarts[-nr])            0L        else 2L    }, output_handler = knit_handlers(options$render, options)))
44: eng_r(options)

    }45: }, warning = function (cnd) 36: doWithOneRestart(return(expr), restart)
        if (progress && is.function(pb$interrupt)) eval(expr, envir)            pb$interrupt()block_exec(params)
46: call_block(x)
47: process_group(group)
48: 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)    }){37: 
withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])28: 
withVisible(eval(expr, envir))

    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    }        if (is_R_CMD_build() || is_R_CMD_check()) 38:             error <<- format(e)    }), list(rlang_trace_top_env = knit_global())), function(loc) {withRestartList(expr, restarts)29: 
39: withRestarts(with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))withCallingHandlers(code, error = function (e)     watcher$capture_plot_and_output()    if (on_warning$capture) {        cnd <- sanitize_call(cnd)        watcher$push(cnd)    }    if (on_warning$silence) {        invokeRestart("muffleWarning")    }}, error = function (cnd) 49:     setwd(wd){    watcher$capture_plot_and_output()    write_utf8(res, output %n% stdout())rlang::entrace(e), message = function (cnd) {    cnd <- sanitize_call(cnd)        watcher$capture_plot_and_output()with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     paste0("\nQuitting from ", loc, if (!is.null(error))         watcher$print_value(ev$value, ev$visible, envir)    watcher$capture_plot_and_output()    watcher$push(cnd)    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()))
50: 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())     }    if (on_message$capture) {            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)
51: process_file(text, output)
52: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
53: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     switch(on_error, continue = invokeRestart("eval_continue"),         paste0("\n", rule(), error, "\n", rule()))}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)
51: process_file(text, output)    TRUE        stop = invokeRestart("eval_stop"), error = NULL)})
30: eval(call)
31: eval(call)
32: with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers)
        watcher$push(cnd)
}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)33:     output_dir = getwd(), ...)
    }    if (on_message$silence) {        invokeRestart("muffleMessage")    }52: 
54: 40: vweave_rmarkdown(...)evaluate::evaluate(...)doWithOneRestart(return(expr), restart)
34: withOneRestart(expr, restarts[[1L]])
35: withRestartList(expr, restarts[-nr])
36: 
}, warning = function (cnd) {doWithOneRestart(return(expr), restart)knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)


41: 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,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options))
55: 37: 53: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    }    watcher$capture_plot_and_output()42: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(), in_dir(input_dir(), expr)    if (on_warning$capture) {
38: withRestartList(expr, restarts)engine$weave(file, quiet = quiet, encoding = enc)        cnd <- sanitize_call(cnd)        watcher$push(cnd)
    }    if (on_warning$silence) {        invokeRestart("muffleWarning")    }
    output_dir = getwd(), ...)
54: vweave_rmarkdown(...)43: 
39: withRestarts(with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)56: 
in_input_dir(evaluate(code, envir = env, new_device = FALSE,     keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, doTryCatch(return(expr), name, parentenv, handler)
}, error = function (cnd)     keep_message = if (is.numeric(options$message)) TRUE else options$message, 57:     stop_on_error = if (is.numeric(options$error)) options$error else {{        if (options$error && options$include) tryCatchOne(expr, names, parentenv, handlers[[1L]])
58: tryCatchList(expr, classes, parentenv, handlers)
59: 40: 
    watcher$capture_plot_and_output()    cnd <- sanitize_call(cnd)    watcher$push(cnd)    switch(on_error, continue = invokeRestart("eval_continue"), tryCatch({        stop = invokeRestart("eval_stop"), error = NULL)})
evaluate::evaluate(...)55: engine$weave(file, quiet = quiet, encoding = enc)
56: doTryCatch(return(expr), name, parentenv, handler)            0L    engine$weave(file, quiet = quiet, encoding = enc)
30: 57:     setwd(startdir)eval(call)
31: eval(call)
32: tryCatchOne(expr, names, parentenv, handlers[[1L]])
58:         else 2Lwith_handlers({    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", 
    }, output_handler = knit_handlers(options$render, options)))
44: eng_r(options)
tryCatchList(expr, classes, parentenv, handlers)            engine = engine)45:     for (expr in tle$exprs) {block_exec(params)
46:         ev <- withVisible(eval(expr, envir))    }
call_block(x)        watcher$capture_plot_and_output()
41: 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,     stop_on_error = if (is.numeric(options$error)) options$error else {59: }, error = function(e) {        if (options$error && options$include)     OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})        watcher$print_value(ev$value, ev$visible, envir)            0L47: tryCatch({    }process_group(group)    engine$weave(file, quiet = quiet, encoding = enc)
60: tools:::.buildOneVignette("basic_usage.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr",     TRUE, FALSE, "basic_usage", "UTF-8", "/Volumes/Temp/tmp/RtmpS24rW8/file1697365004785.rds")

    TRUE48:     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)        else 2L}, handlers)
withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     }, output_handler = knit_handlers(options$render, options))        output <- find_vignette_product(name, by = "texi2pdf",             engine = engine)33: doWithOneRestart(return(expr), restart)
An irrecoverable exception occurred. R is aborting now ...
    }}, error = function(e) {    OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})34: 
withOneRestart(expr, restarts[[1L]])

60: tools:::.buildOneVignette("basic_usage.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr",     TRUE, FALSE, "basic_usage", "UTF-8", "/Volumes/Temp/tmp/RtmpS24rW8/file1697365004785.rds")42: in_dir(input_dir(), expr)
43: in_input_dir(evaluate(code, envir = env, new_device = FALSE, 35: withRestartList(expr, restarts[-nr])
36: doWithOneRestart(return(expr), restart)
37: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
38: withRestartList(expr, restarts)
39: withRestarts(with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)
    error = function(e) {    keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, 40: 
    keep_message = if (is.numeric(options$message)) TRUE else options$message, An irrecoverable exception occurred. R is aborting now ...
    stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options)))
44: eng_r(options)
45: block_exec(params)
46: evaluate::evaluate(...)call_block(x)        if (progress && is.function(pb$interrupt))             pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)
    })
49: with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), 47:     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()))
50: xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     error = function(e) {
41: 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,     stop_on_error = if (is.numeric(options$error)) options$error else {process_group(group)
48: withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     error = function(e) {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options))        if (progress && is.function(pb$interrupt))             pb$interrupt()        if (progress && is.function(pb$interrupt))             pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)
        if (is_R_CMD_build() || is_R_CMD_check()) 42:     })            error <<- format(e)    }), list(rlang_trace_top_env = knit_global())), function(loc) {    setwd(wd)in_dir(input_dir(), expr)    write_utf8(res, output %n% stdout())

49: with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     error = function(e) {        if (progress && is.function(pb$interrupt)) 43: in_input_dir(evaluate(code, envir = env, new_device = FALSE,             pb$interrupt()    paste0("\nQuitting from ", loc, if (!is.null(error))         paste0("\n", rule(), error, "\n", rule()))}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)
    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 {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options)))
44: eng_r(options)
45: block_exec(params)
        if (is_R_CMD_build() || is_R_CMD_check()) 51: process_file(text, output)
            error <<- format(e)46: call_block(x)
47: process_group(group)
48: withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     error = function(e) {        if (progress && is.function(pb$interrupt))     }), list(rlang_trace_top_env = knit_global()))
50: 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()))            pb$interrupt()}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)52: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
53: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),         if (is_R_CMD_build() || is_R_CMD_check())     output_dir = getwd(), ...)
51: process_file(text, output)
52: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)            error <<- format(e)    })

53: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
54: vweave_rmarkdown(...)
55: engine$weave(file, quiet = quiet, encoding = enc)
56: doTryCatch(return(expr), name, parentenv, handler)
57: tryCatchOne(expr, names, parentenv, handlers[[1L]])
58: tryCatchList(expr, classes, parentenv, handlers)
59: 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)
54: vweave_rmarkdown(...)
55: engine$weave(file, quiet = quiet, encoding = enc)
56:     }}, error = function(e) {    OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})49: 
60: tools:::.buildOneVignette("basic_usage.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr",     TRUE, FALSE, "basic_usage", "UTF-8", "/Volumes/Temp/tmp/RtmpS24rW8/file1697365004785.rds")doTryCatch(return(expr), name, parentenv, handler)
An irrecoverable exception occurred. R is aborting now ...
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()))
50: xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     error = function(e) {
57: tryCatchOne(expr, names, parentenv, handlers[[1L]])
        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()))58: tryCatchList(expr, classes, parentenv, handlers)
}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)59: 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)    }}, error = function(e) {    OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})
60: tools:::.buildOneVignette("basic_usage.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr",     TRUE, FALSE, "basic_usage", "UTF-8", "/Volumes/Temp/tmp/RtmpS24rW8/file1697365004785.rds")
An irrecoverable exception occurred. R is aborting now ...

51: process_file(text, output)
52: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
53: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
54: vweave_rmarkdown(...)
55: engine$weave(file, quiet = quiet, encoding = enc)
56: doTryCatch(return(expr), name, parentenv, handler)
57: tryCatchOne(expr, names, parentenv, handlers[[1L]])
58: tryCatchList(expr, classes, parentenv, handlers)
59: 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)    }}, error = function(e) {    OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})
60: tools:::.buildOneVignette("basic_usage.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr",     TRUE, FALSE, "basic_usage", "UTF-8", "/Volumes/Temp/tmp/RtmpS24rW8/file1697365004785.rds")
An irrecoverable exception occurred. R is aborting now ...

Quitting from basic_usage.Rmd:82-91 [unnamed-chunk-7]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
<error/rlang_error>
Error in `names(x) <- value`:
! 'names' attribute [3] must be the same length as the vector [0]
---
Backtrace:
    ▆
 1. └─logitr::logitr(...)
 2.   └─logitr:::getMultistartSummary(allModels)
 3.     └─base::`colnames<-`(...)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Error: processing vignette 'basic_usage.Rmd' failed with diagnostics:
'names' attribute [3] must be the same length as the vector [0]
--- failed re-building ‘basic_usage.Rmd’

--- re-building ‘benchmark.Rmd’ using rmarkdown
--- finished re-building ‘benchmark.Rmd’

--- re-building ‘convergence.Rmd’ using rmarkdown
--- finished re-building ‘convergence.Rmd’

--- re-building ‘data_formatting.Rmd’ using rmarkdown
--- finished re-building ‘data_formatting.Rmd’

--- re-building ‘interactions.Rmd’ using rmarkdown
--- finished re-building ‘interactions.Rmd’

--- re-building ‘mnl_models.Rmd’ using rmarkdown

 *** caught segfault ***
address 0x110, cause 'invalid permissions'

Traceback:
 1: 
 *** caught segfault ***
address 0x110, cause 'invalid permissions'
mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)
 2: eval_f(x0, ...)
 3: nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     mi = mi, opts = mi$options)
 4: doTryCatch(return(expr), name, parentenv, handler)
 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
 6: tryCatchList(expr, classes, parentenv, handlers)
 7: tryCatch({    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,         mi = mi, opts = mi$options)}, error = function(e) {})
 8: system.time({    model <- mi$model    result <- NULL    tryCatch({        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,             mi = mi, opts = mi$options)    }, error = function(e) {    })    if (!is.null(result)) {        model$fail <- FALSE        model$coefficients <- result$solution        model$logLik <- as.numeric(-1 * result$objective)        model$iterations <- result$iterations        model$status <- result$status        model$message <- result$message    }})
 9: FUN(X[[i]], ...)
10: lapply(X = S, FUN = FUN, ...)
11: doTryCatch(return(expr), name, parentenv, handler)
12: tryCatchOne(expr, names, parentenv, handlers[[1L]])
13: tryCatchList(expr, classes, parentenv, handlers)
14: 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)             prefix <- paste0(prefix, "\n  ")    }    else prefix <- "Error : "    msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, file = outFile)        .Internal(printDeferredWarnings())    }    invisible(structure(msg, class = "try-error", condition = e))})
15: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
16: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
17: FUN(X[[i]], ...)
18: lapply(seq_len(cores), inner.do)
19: parallel::mclapply(miList, runModel, mc.cores = numCores)
20: withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))
21: suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))
22: withCallingHandlers(expr, message = function(c) if (inherits(c,     classes)) tryInvokeRestart("muffleMessage"))
23: suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))
24: runMultistart(modelInputs)
25: logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat",     "brand"), scalePar = "price", numMultiStarts = 10, startVals = wtp_mnl_pref$Estimate)
26: eval(expr, envir)
27: eval(expr, envir)
28: withVisible(eval(expr, envir))
29: withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) {    watcher$capture_plot_and_output()    if (on_message$capture) {        watcher$push(cnd)    }    if (on_message$silence) {        invokeRestart("muffleMessage")    }}, warning = function (cnd) {    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    }    watcher$capture_plot_and_output()    if (on_warning$capture) {        cnd <- sanitize_call(cnd)        watcher$push(cnd)    }    if (on_warning$silence) {        invokeRestart("muffleWarning")    }}, error = function (cnd) {    watcher$capture_plot_and_output()    cnd <- sanitize_call(cnd)    watcher$push(cnd)    switch(on_error, continue = invokeRestart("eval_continue"),         stop = invokeRestart("eval_stop"), error = NULL)})
30: eval(call)
31: eval(call)
32: with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers)
33: doWithOneRestart(return(expr), restart)
34: withOneRestart(expr, restarts[[1L]])
35: withRestartList(expr, restarts[-nr])
36: doWithOneRestart(return(expr), restart)
37: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
38: withRestartList(expr, restarts)
39: withRestarts(with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)
40: evaluate::evaluate(...)
41: 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,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options))
42: in_dir(input_dir(), expr)
43: in_input_dir(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,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options)))
44: eng_r(options)
45: block_exec(params)
46: call_block(x)
47: process_group(group)
48: 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)    })
49: 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()))
50: 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)
51: process_file(text, output)
52: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
53: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
54: vweave_rmarkdown(...)
55: engine$weave(file, quiet = quiet, encoding = enc)
56: doTryCatch(return(expr), name, parentenv, handler)
57: tryCatchOne(expr, names, parentenv, handlers[[1L]])
58: tryCatchList(expr, classes, parentenv, handlers)
59: 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)    }}, error = function(e) {    OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})
60: tools:::.buildOneVignette("mnl_models.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr",     TRUE, FALSE, "mnl_models", "UTF-8", "/Volumes/Temp/tmp/RtmpS24rW8/file16973e8577a7.rds")
An irrecoverable exception occurred. R is aborting now ...

Traceback:
 1: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)
 2: eval_f(x0, ...)
 3: nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     mi = mi, opts = mi$options)
 4: doTryCatch(return(expr), name, parentenv, handler)
 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
 6: tryCatchList(expr, classes, parentenv, handlers)
 7: tryCatch({    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,         mi = mi, opts = mi$options)}, error = function(e) {})
 8: system.time({    model <- mi$model    result <- NULL    tryCatch({        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,             mi = mi, opts = mi$options)    }, error = function(e) {    })    if (!is.null(result)) {        model$fail <- FALSE        model$coefficients <- result$solution        model$logLik <- as.numeric(-1 * result$objective)        model$iterations <- result$iterations        model$status <- result$status        model$message <- result$message    }})
 9: FUN(X[[i]], ...)
10: lapply(X = S, FUN = FUN, ...)
11: doTryCatch(return(expr), name, parentenv, handler)
12: tryCatchOne(expr, names, parentenv, handlers[[1L]])
13: tryCatchList(expr, classes, parentenv, handlers)
14: 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)             prefix <- paste0(prefix, "\n  ")    }    else prefix <- "Error : "    msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, file = outFile)        .Internal(printDeferredWarnings())    }    invisible(structure(msg, class = "try-error", condition = e))})
15: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
16: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
17: FUN(X[[i]], ...)
18: lapply(seq_len(cores), inner.do)
19: parallel::mclapply(miList, runModel, mc.cores = numCores)
20: withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))
21: suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))
22: withCallingHandlers(expr, message = function(c) if (inherits(c,     classes)) tryInvokeRestart("muffleMessage"))
23: suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))
24: runMultistart(modelInputs)
25: logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat",     "brand"), scalePar = "price", numMultiStarts = 10, startVals = wtp_mnl_pref$Estimate)
26: eval(expr, envir)
27: eval(expr, envir)
28: withVisible(eval(expr, envir))
29: withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) {    watcher$capture_plot_and_output()    if (on_message$capture) {        watcher$push(cnd)    }    if (on_message$silence) {        invokeRestart("muffleMessage")    }}, warning = function (cnd) {    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    }    watcher$capture_plot_and_output()    if (on_warning$capture) {        cnd <- sanitize_call(cnd)        watcher$push(cnd)    }    if (on_warning$silence) {        invokeRestart("muffleWarning")    }}, error = function (cnd) {    watcher$capture_plot_and_output()    cnd <- sanitize_call(cnd)    watcher$push(cnd)    switch(on_error, continue = invokeRestart("eval_continue"),         stop = invokeRestart("eval_stop"), error = NULL)})
30: eval(call)
31: eval(call)
32: with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers)
33: doWithOneRestart(return(expr), restart)
34: withOneRestart(expr, restarts[[1L]])
35: withRestartList(expr, restarts[-nr])
36: doWithOneRestart(return(expr), restart)
37: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
38: withRestartList(expr, restarts)
39: withRestarts(with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)
40: evaluate::evaluate(...)
41: 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,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options))
42: in_dir(input_dir(), expr)
43: in_input_dir(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,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options)))
44: eng_r(options)
45: block_exec(params)
46: call_block(x)
47: process_group(group)
48: 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)    })
49: 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()))
50: 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)
51: process_file(text, output)
52: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
53: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
54: vweave_rmarkdown(...)
55: engine$weave(file, quiet = quiet, encoding = enc)
56: doTryCatch(return(expr), name, parentenv, handler)
57: tryCatchOne(expr, names, parentenv, handlers[[1L]])
58: tryCatchList(expr, classes, parentenv, handlers)
59: 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)    }}, error = function(e) {    OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})
60: tools:::.buildOneVignette("mnl_models.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr",     TRUE, FALSE, "mnl_models", "UTF-8", "/Volumes/Temp/tmp/RtmpS24rW8/file16973e8577a7.rds")
An irrecoverable exception occurred. R is aborting now ...

 *** caught segfault ***
address 0x110, cause 'invalid permissions'

 *** caught segfault ***
address 0x110, cause 'invalid permissions'

 *** caught segfault ***
address 0x110, cause 'invalid permissions'

Traceback:
 1: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)
 2: eval_f(x0, ...)
 3: nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     mi = mi, opts = mi$options)
 4: doTryCatch(return(expr), name, parentenv, handler)
 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
 6: tryCatchList(expr, classes, parentenv, handlers)
 7: tryCatch({    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,         mi = mi, opts = mi$options)}, error = function(e) {})
 8: system.time({    model <- mi$model    result <- NULL    tryCatch({        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,             mi = mi, opts = mi$options)    }, error = function(e) {    })    if (!is.null(result)) {        model$fail <- FALSE        model$coefficients <- result$solution        model$logLik <- as.numeric(-1 * result$objective)        model$iterations <- result$iterations        model$status <- result$status        model$message <- result$message    }})
 9: FUN(X[[i]], ...)
10: lapply(X = S, FUN = FUN, ...)
11: doTryCatch(return(expr), name, parentenv, handler)
12: tryCatchOne(expr, names, parentenv, handlers[[1L]])
13: tryCatchList(expr, classes, parentenv, handlers)
14: 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)             prefix <- paste0(prefix, "\n  ")    }    else prefix <- "Error : "    msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, file = outFile)        .Internal(printDeferredWarnings())    }    invisible(structure(msg, class = "try-error", condition = e))})
15: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
16: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
17: FUN(X[[i]], ...)
18: lapply(seq_len(cores), inner.do)
19: parallel::mclapply(miList, runModel, mc.cores = numCores)
20: withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))
21: suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))
22: withCallingHandlers(expr, message = function(c) if (inherits(c,     classes)) tryInvokeRestart("muffleMessage"))
23: suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))
24: runMultistart(modelInputs)
25: logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat",     "brand"), scalePar = "price", numMultiStarts = 10, startVals = wtp_mnl_pref$Estimate)
26: eval(expr, envir)
27: eval(expr, envir)
28: withVisible(eval(expr, envir))
29: withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) {    watcher$capture_plot_and_output()    if (on_message$capture) {        watcher$push(cnd)    }    if (on_message$silence) {        invokeRestart("muffleMessage")    }}, warning = function (cnd) {    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    }    watcher$capture_plot_and_output()    if (on_warning$capture) {        cnd <- sanitize_call(cnd)        watcher$push(cnd)    }    if (on_warning$silence) {        invokeRestart("muffleWarning")    }}, error = function (cnd) {    watcher$capture_plot_and_output()    cnd <- sanitize_call(cnd)    watcher$push(cnd)    switch(on_error, continue = invokeRestart("eval_continue"),         stop = invokeRestart("eval_stop"), error = NULL)})
30: eval(call)
31: eval(call)
32: with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers)
33: doWithOneRestart(return(expr), restart)
34: withOneRestart(expr, restarts[[1L]])
35: withRestartList(expr, restarts[-nr])
36: doWithOneRestart(return(expr), restart)
37: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])

 *** caught segfault ***
address 0x110, cause 'invalid permissions'
38: withRestartList(expr, restarts)
39: withRestarts(with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)
40: evaluate::evaluate(...)
41: 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,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options))
42: in_dir(input_dir(), expr)
43: in_input_dir(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,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options)))
44: eng_r(options)
45: block_exec(params)
46: call_block(x)
47: process_group(group)
48: 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)    })
49: 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()))
50: 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)
51: process_file(text, output)
52: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
53: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
54: vweave_rmarkdown(...)
55: engine$weave(file, quiet = quiet, encoding = enc)
56: doTryCatch(return(expr), name, parentenv, handler)
57: tryCatchOne(expr, names, parentenv, handlers[[1L]])
58: tryCatchList(expr, classes, parentenv, handlers)
 *** caught segfault ***
address 0x110, cause 'invalid permissions'

59: 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)    }}, error = function(e) {    OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})
60: tools:::.buildOneVignette("mnl_models.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr",     TRUE, FALSE, "mnl_models", "UTF-8", "/Volumes/Temp/tmp/RtmpS24rW8/file16973e8577a7.rds")
An irrecoverable exception occurred. R is aborting now ...

Traceback:
 1: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)
 2: eval_f(x0, ...)
 3: nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     mi = mi, opts = mi$options)
 4: doTryCatch(return(expr), name, parentenv, handler)
 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
 6: tryCatchList(expr, classes, parentenv, handlers)
 7: tryCatch({    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,         mi = mi, opts = mi$options)}, error = function(e) {})
 8: system.time({    model <- mi$model    result <- NULL    tryCatch({
Traceback:
 1: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)
 2: eval_f(x0, ...)        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,             mi = mi, opts = mi$options)    }, error = function(e) {    })    if (!is.null(result)) {        model$fail <- FALSE        model$coefficients <- result$solution        model$logLik <- as.numeric(-1 * result$objective)        model$iterations <- result$iterations        model$status <- result$status        model$message <- result$message    }})

 3: nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     mi = mi, opts = mi$options)
 4: doTryCatch(return(expr), name, parentenv, handler)
 5:  9: FUN(X[[i]], ...)
10: lapply(X = S, FUN = FUN, ...)
11: doTryCatch(return(expr), name, parentenv, handler)
12: tryCatchOne(expr, names, parentenv, handlers[[1L]])
13: tryCatchList(expr, classes, parentenv, handlers)
tryCatchOne(expr, names, parentenv, handlers[[1L]])14: 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") 6: tryCatchList(expr, classes, parentenv, handlers)
 7: tryCatch({    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,         if (w > LONG)             prefix <- paste0(prefix, "\n  ")    }    else prefix <- "Error : "    msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, file = outFile)        .Internal(printDeferredWarnings())    }    invisible(structure(msg, class = "try-error", condition = e))})        mi = mi, opts = mi$options)}, error = function(e) {})
 8: system.time({
15: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
16: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
17: FUN(X[[i]], ...)
18: lapply(seq_len(cores), inner.do)    model <- mi$model    result <- NULL    tryCatch({        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,             mi = mi, opts = mi$options)    }, error = function(e) {    })
19: parallel::mclapply(miList, runModel, mc.cores = numCores)
20: withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))    if (!is.null(result)) {        model$fail <- FALSE        model$coefficients <- result$solution        model$logLik <- as.numeric(-1 * result$objective)        model$iterations <- result$iterations        model$status <- result$status        model$message <- result$message    }})
 9: FUN(X[[i]], ...)

21: suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))
22: withCallingHandlers(expr, message = function(c) if (inherits(c,     classes)) tryInvokeRestart("muffleMessage"))
23: suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))
24: runMultistart(modelInputs)
25: logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat", 10: lapply(X = S, FUN = FUN, ...)
11: doTryCatch(return(expr), name, parentenv, handler)
12: tryCatchOne(expr, names, parentenv, handlers[[1L]])
13: tryCatchList(expr, classes, parentenv, handlers)
    "brand"), scalePar = "price", numMultiStarts = 10, startVals = wtp_mnl_pref$Estimate)
26: eval(expr, envir)
27: eval(expr, envir)
28: withVisible(eval(expr, envir))
29: withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) {
 *** caught segfault ***
address 0x110, cause 'invalid permissions'
    watcher$capture_plot_and_output()14:     if (on_message$capture) {        watcher$push(cnd)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)    }    if (on_message$silence) {        prefix <- paste("Error in", dcall, ": ")        LONG <- 75L        sm <- strsplit(conditionMessage(e), "\n")[[1L]]        w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")        invokeRestart("muffleMessage")    }}, warning = function (cnd) {
Traceback:
    if (getOption("warn") >= 2 || getOption("warn") < 0) {
Traceback:
 1: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)
 2: eval_f(x0, ...)
 3:  1:         if (is.na(w))         return()mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)
 2: nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     mi = mi, opts = mi$options)
 4: doTryCatch(return(expr), name, parentenv, handler)
 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
 6: tryCatchList(expr, classes, parentenv, handlers)            w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L], 
eval_f(x0, ...)
 3: nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,                 type = "b")    mi = mi, opts = mi$options) 7: 
tryCatch({    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,         mi = mi, opts = mi$options)}, error = function(e) {    } 4:         if (w > LONG)             prefix <- paste0(prefix, "\n  ")    }    else prefix <- "Error : "    msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L]))doTryCatch(return(expr), name, parentenv, handler)    watcher$capture_plot_and_output()})    if (!silent && isTRUE(getOption("show.error.messages"))) {    if (on_warning$capture) {        cnd <- sanitize_call(cnd)        cat(msg, file = outFile)
        .Internal(printDeferredWarnings()) 8: system.time({    model <- mi$model
    }    result <- NULL 5:     invisible(structure(msg, class = "try-error", condition = e))        watcher$push(cnd)
 *** caught segfault ***
})
15: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
16: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
17: FUN(X[[i]], ...)
18: lapply(seq_len(cores), inner.do)
19:     }parallel::mclapply(miList, runModel, mc.cores = numCores)
20: withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))
21: address 0x110, cause 'invalid permissions'
    tryCatch({tryCatchOne(expr, names, parentenv, handlers[[1L]])        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,             mi = mi, opts = mi$options)suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))    if (on_warning$silence) {

    }, error = function(e) {    })    if (!is.null(result)) {        model$fail <- FALSE        model$coefficients <- result$solution        model$logLik <- as.numeric(-1 * result$objective)22: withCallingHandlers(expr, message = function(c) if (inherits(c,     classes)) tryInvokeRestart("muffleMessage"))
        invokeRestart("muffleWarning") 6:     }        model$iterations <- result$iterationstryCatchList(expr, classes, parentenv, handlers)}, error = function (cnd) 23: suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))
24: runMultistart(modelInputs){    watcher$capture_plot_and_output()    cnd <- sanitize_call(cnd)    watcher$push(cnd)    switch(on_error, continue = invokeRestart("eval_continue"),         model$status <- result$status
        stop = invokeRestart("eval_stop"), error = NULL)
 7: })tryCatch({25:     result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, 
30: eval(call)

Traceback:
logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat",     "brand"), scalePar = "price", numMultiStarts = 10, startVals = wtp_mnl_pref$Estimate)        model$message <- result$message        mi = mi, opts = mi$options)
 1:     }26: }, error = function(e) {31: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)})})
eval(expr, envir)
eval(call) 8: 

32: with_handlers({ 2:     for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir) 9:     }eval_f(x0, ...)    TRUE
 *** caught segfault ***

}, handlers)
33: doWithOneRestart(return(expr), restart)
34: withOneRestart(expr, restarts[[1L]])
35: withRestartList(expr, restarts[-nr])
FUN(X[[i]], ...) 3: 
27: eval(expr, envir)
28: system.time({withVisible(eval(expr, envir))nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     mi = mi, opts = mi$options)
 4: doTryCatch(return(expr), name, parentenv, handler)
 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])

10: lapply(X = S, FUN = FUN, ...) 6: 
tryCatchList(expr, classes, parentenv, handlers)
 7: tryCatch({
11: 29: withCallingHandlers(code, error = function (e)     result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, address 0x110, cause 'invalid permissions'
36: rlang::entrace(e), message = function (cnd) {doTryCatch(return(expr), name, parentenv, handler)doWithOneRestart(return(expr), restart)
    watcher$capture_plot_and_output()    model <- mi$model

Traceback:
    result <- NULL12:  1:     tryCatch({        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,             mi = mi, opts = mi$options)    }, error = function(e) {    })    if (!is.null(result)) {        model$fail <- FALSE        model$coefficients <- result$solution        model$logLik <- as.numeric(-1 * result$objective)        model$iterations <- result$iterations        mi = mi, opts = mi$options)37: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)        model$status <- result$status
withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
38: withRestartList(expr, restarts)        model$message <- result$message
    if (on_message$capture) {}, error = function(e) {tryCatchOne(expr, names, parentenv, handlers[[1L]])})        watcher$push(cnd)    }    if (on_message$silence) {        invokeRestart("muffleMessage")    }
 2: }, warning = function (cnd) 13: eval_f(x0, ...)
 3: nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     mi = mi, opts = mi$options){    }39: 
})
 9:  4: withRestarts(with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()FUN(X[[i]], ...)tryCatchList(expr, classes, parentenv, handlers)    if (getOption("warn") >= 2 || getOption("warn") < 0) {

        return()        watcher$print_value(ev$value, ev$visible, envir)
 8:     }    }    TRUEdoTryCatch(return(expr), name, parentenv, handler)10: system.time({    model <- mi$model    result <- NULL    tryCatch({        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,             mi = mi, opts = mi$options)    }, error = function(e) {    })    if (!is.null(result)) {        model$fail <- FALSE        model$coefficients <- result$solution        model$logLik <- as.numeric(-1 * result$objective)        model$iterations <- result$iterations    watcher$capture_plot_and_output()}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)
14: lapply(X = S, FUN = FUN, ...)
    if (on_warning$capture) {tryCatch(expr, error = function(e) {    call <- conditionCall(e)    if (!is.null(call)) {40:         model$status <- result$status 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
 6: tryCatchList(expr, classes, parentenv, handlers)
 7: tryCatch({    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,         cnd <- sanitize_call(cnd)        watcher$push(cnd)    }
        model$message <- result$message    if (on_warning$silence) {11: evaluate::evaluate(...)        if (identical(call[[1L]], quote(doTryCatch)))         mi = mi, opts = mi$options)
    }        invokeRestart("muffleWarning")    }}, error = function (cnd) {    watcher$capture_plot_and_output()41: }, error = function(e) {
Traceback:
})doTryCatch(return(expr), name, parentenv, handler)            call <- sys.call(-4L)
12:  1: })        dcall <- deparse(call, nlines = 1L)evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning,     keep_message = if (is.numeric(options$message)) TRUE else options$message,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include) tryCatchOne(expr, names, parentenv, handlers[[1L]])
 8: system.time({    model <- mi$modelmi$logitFuncs$getMnlV(pars, d$X, d$scalePar)

    cnd <- sanitize_call(cnd)    result <- NULL 9: FUN(X[[i]], ...)
10: lapply(X = S, FUN = FUN, ...)
11: doTryCatch(return(expr), name, parentenv, handler)
12: tryCatchOne(expr, names, parentenv, handlers[[1L]])    watcher$push(cnd)
        prefix <- paste("Error in", dcall, ": ")            0L 2: 
13:         LONG <- 75L    switch(on_error, continue = invokeRestart("eval_continue"),         stop = invokeRestart("eval_stop"), error = NULL)})
30: eval(call)
31: eval(call)
32: with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers)
33: doWithOneRestart(return(expr), restart)
34: withOneRestart(expr, restarts[[1L]])
35: withRestartList(expr, restarts[-nr])
36: doWithOneRestart(return(expr), restart)
37: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
38: withRestartList(expr, restarts)
39: withRestarts(with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)
40: evaluate::evaluate(...)
41: 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,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options))
42: in_dir(input_dir(), expr)
43: in_input_dir(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,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options)))
44: eng_r(options)
45: block_exec(params)
46: call_block(x)
47: process_group(group)
48: 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)    })
49: 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()))
50: 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)
51: process_file(text, output)
52: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
53: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
54: vweave_rmarkdown(...)
55: engine$weave(file, quiet = quiet, encoding = enc)
56: doTryCatch(return(expr), name, parentenv, handler)
57: tryCatchOne(expr, names, parentenv, handlers[[1L]])
58: tryCatchList(expr, classes, parentenv, handlers)
59: 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)    }}, error = function(e) {    OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})
60: tools:::.buildOneVignette("mnl_models.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr",     TRUE, FALSE, "mnl_models", "UTF-8", "/Volumes/Temp/tmp/RtmpS24rW8/file16973e8577a7.rds")
An irrecoverable exception occurred. R is aborting now ...
        else 2L    }, output_handler = knit_handlers(options$render, options))        sm <- strsplit(conditionMessage(e), "\n")[[1L]]eval_f(x0, ...)    tryCatch({
        w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")13:         result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, tryCatchList(expr, classes, parentenv, handlers)        if (is.na(w))             mi = mi, opts = mi$options)    }, error = function(e) {    })    if (!is.null(result)) {        model$fail <- FALSE        model$coefficients <- result$solution        model$logLik <- as.numeric(-1 * result$objective)        model$iterations <- result$iterations        model$status <- result$status        model$message <- result$message    }            w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L], 

 3: 14: tryCatch(expr, error = function(e) {42: })    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)             prefix <- paste0(prefix, "\n  ")nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, tryCatchList(expr, classes, parentenv, handlers)    }in_dir(input_dir(), expr)                type = "b")
43: in_input_dir(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,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options)))
44: eng_r(options)
45: block_exec(params)
 9: FUN(X[[i]], ...)
10: lapply(X = S, FUN = FUN, ...)
11: doTryCatch(return(expr), name, parentenv, handler)
12: tryCatchOne(expr, names, parentenv, handlers[[1L]])
13: tryCatchList(expr, classes, parentenv, handlers)
14: 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")
    else prefix <- "Error : "    msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, file = outFile)        .Internal(printDeferredWarnings())    }    mi = mi, opts = mi$options)
 4: doTryCatch(return(expr), name, parentenv, handler)
 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
 6: tryCatchList(expr, classes, parentenv, handlers)
 7: tryCatch({    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,         if (w > LONG)     invisible(structure(msg, class = "try-error", condition = e))})
15: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
16: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
17: FUN(X[[i]], ...)
18: lapply(seq_len(cores), inner.do)
19: parallel::mclapply(miList, runModel, mc.cores = numCores)
20: withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))
            prefix <- paste0(prefix, "\n  ")        if (is.na(w)) 
46:         mi = mi, opts = mi$options)21: call_block(x)            w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L], }, error = function(e) {suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))})

47: 
                type = "b")        if (w > LONG)             prefix <- paste0(prefix, "\n  ")    }    else prefix <- "Error : "    } 8: system.time({    model <- mi$model    result <- NULL22:     tryCatch({        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     msg <- paste0(prefix, conditionMessage(e), "\n")            mi = mi, opts = mi$options)    }, error = function(e) {    })    if (!is.null(result)) {        model$fail <- FALSE        model$coefficients <- result$solution        model$logLik <- as.numeric(-1 * result$objective)        model$iterations <- result$iterations        model$status <- result$status        model$message <- result$message    }})
 9: FUN(X[[i]], ...)
10: lapply(X = S, FUN = FUN, ...)
11: doTryCatch(return(expr), name, parentenv, handler)
    else prefix <- "Error : "    .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, file = outFile)        .Internal(printDeferredWarnings())process_group(group)withCallingHandlers(expr, message = function(c) if (inherits(c,     classes)) tryInvokeRestart("muffleMessage"))
12:     msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, file = outFile)        .Internal(printDeferredWarnings())    }    invisible(structure(msg, class = "try-error", condition = e))tryCatchOne(expr, names, parentenv, handlers[[1L]])})

13: tryCatchList(expr, classes, parentenv, handlers)
14: tryCatch(expr, error = function(e) {23: 
    }    call <- conditionCall(e)48: withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     if (!is.null(call)) {        if (identical(call[[1L]], quote(doTryCatch)))             call <- sys.call(-4L)        dcall <- deparse(call, nlines = 1L)suppressMessages(suppressWarnings(parallel::mclapply(miList,     error = function(e) {        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")14: 15: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
    runModel, mc.cores = numCores)))        if (w > LONG) tryCatch(expr, error = function(e) {
24: runMultistart(modelInputs)
            prefix <- paste0(prefix, "\n  ")        if (progress && is.function(pb$interrupt)) 25:     }            pb$interrupt()logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat",     "brand"), scalePar = "price", numMultiStarts = 10, startVals = wtp_mnl_pref$Estimate)    invisible(structure(msg, class = "try-error", condition = e))    else prefix <- "Error : "    msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L]))})

    if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, file = outFile)        .Internal(printDeferredWarnings())    }    invisible(structure(msg, class = "try-error", condition = e))})
26: eval(expr, envir)
27: eval(expr, envir)
28: withVisible(eval(expr, envir))
29: withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) {15:         if (is_R_CMD_build() || is_R_CMD_check()) 15:             error <<- format(e)    })
49:     watcher$capture_plot_and_output()16: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
    if (on_message$capture) {with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), 16: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))    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")

17: FUN(X[[i]], ...)
18: lapply(seq_len(cores), inner.do)try(lapply(X = S, FUN = FUN, ...), silent = TRUE)17:         if (is.na(w))             w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L],                 type = "b")        if (w > LONG)             prefix <- paste0(prefix, "\n  ")    }    else prefix <- "Error : "    msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {        watcher$push(cnd)
    error = function(e) {    }FUN(X[[i]], ...)
19: parallel::mclapply(miList, runModel, mc.cores = numCores)
20: withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))
    if (on_message$silence) {
        cat(msg, file = outFile)        .Internal(printDeferredWarnings())        if (progress && is.function(pb$interrupt)) 16: 21: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))            pb$interrupt()suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))
17: FUN(X[[i]], ...)
18: lapply(seq_len(cores), inner.do)
18:     }lapply(seq_len(cores), inner.do)        if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)    }), list(rlang_trace_top_env = knit_global()))
50: 
19: parallel::mclapply(miList, runModel, mc.cores = numCores)
20: withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))
21: suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))        invokeRestart("muffleMessage")22: 
    }
19: parallel::mclapply(miList, runModel, mc.cores = numCores)
20: withCallingHandlers(expr, message = function(c) if (inherits(c, 22: withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))}, warning = function (cnd) xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), 
    invisible(structure(msg, class = "try-error", condition = e)){    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    }    watcher$capture_plot_and_output()    if (on_warning$capture) {})    classes)) tryInvokeRestart("muffleMessage"))        cnd <- sanitize_call(cnd)    error = function(e) {21: 
withCallingHandlers(expr, message = function(c) if (inherits(c, 
suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))
        watcher$push(cnd)15: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
    classes)) tryInvokeRestart("muffleMessage"))    }    if (on_warning$silence) {        if (progress && is.function(pb$interrupt)) 
23: 22: 16: suppressMessages(suppressWarnings(parallel::mclapply(miList, withCallingHandlers(expr, message = function(c) if (inherits(c, 23: suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))
24: runMultistart(modelInputs)
25:     classes)) tryInvokeRestart("muffleMessage"))
23: suppressMessages(suppressWarnings(parallel::mclapply(miList,             pb$interrupt()sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
17: FUN(X[[i]], ...)
18: lapply(seq_len(cores), inner.do)
19: parallel::mclapply(miList, runModel, mc.cores = numCores)
20: withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))
21: suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))
22:     runModel, mc.cores = numCores)))logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat",     "brand"), scalePar = "price", numMultiStarts = 10, startVals = wtp_mnl_pref$Estimate)
        invokeRestart("muffleWarning")    }}, error = function (cnd) {    watcher$capture_plot_and_output()    cnd <- sanitize_call(cnd)    runModel, mc.cores = numCores)))26:     watcher$push(cnd)withCallingHandlers(expr, message = function(c) if (inherits(c,         if (is_R_CMD_build() || is_R_CMD_check()) 

    classes)) tryInvokeRestart("muffleMessage"))            error <<- format(e)    }), list(rlang_trace_top_env = knit_global())), function(loc) {    setwd(wd)    write_utf8(res, output %n% stdout())    switch(on_error, continue = invokeRestart("eval_continue"), eval(expr, envir)
27: eval(expr, envir)
28: withVisible(eval(expr, envir))
24: 
29: withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) {    watcher$capture_plot_and_output()    if (on_message$capture) {    paste0("\nQuitting from ", loc, if (!is.null(error)) runMultistart(modelInputs)24:         watcher$push(cnd)23: 
25: suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))
24: runMultistart(modelInputs)
runMultistart(modelInputs)        stop = invokeRestart("eval_stop"), error = NULL)})logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat",         paste0("\n", rule(), error, "\n", rule()))}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)
51: process_file(text, output)    "brand"), scalePar = "price", numMultiStarts = 10, startVals = wtp_mnl_pref$Estimate)    }    if (on_message$silence) {        invokeRestart("muffleMessage")


25: 52: 25: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat", 30: logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat", 

26: eval(expr, envir)    "brand"), scalePar = "price", numMultiStarts = 10, startVals = wtp_mnl_pref$Estimate)    }    "brand"), scalePar = "price", numMultiStarts = 10, startVals = wtp_mnl_pref$Estimate)}, warning = function (cnd) {    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    }    watcher$capture_plot_and_output()    if (on_warning$capture) {
53: 26: 

        cnd <- sanitize_call(cnd)        watcher$push(cnd)    }    if (on_warning$silence) {eval(expr, envir)eval(call)rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(), 
27: eval(expr, envir)
28: withVisible(eval(expr, envir))26: 
29: withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) {27:     output_dir = getwd(), ...)
54: vweave_rmarkdown(...)
55: engine$weave(file, quiet = quiet, encoding = enc)        invokeRestart("muffleWarning")eval(expr, envir)    watcher$capture_plot_and_output()
    }
    if (on_message$capture) {        watcher$push(cnd)    }}, error = function (cnd) eval(expr, envir)56: 28:     if (on_message$silence) {{
31: eval(call)
32: with_handlers({    for (expr in tle$exprs) {    watcher$capture_plot_and_output()    cnd <- sanitize_call(cnd)
        invokeRestart("muffleMessage")        ev <- withVisible(eval(expr, envir))27:     watcher$push(cnd)    switch(on_error, continue = invokeRestart("eval_continue"),     }eval(expr, envir)
28:         watcher$capture_plot_and_output()}, warning = function (cnd) withVisible(eval(expr, envir))        stop = invokeRestart("eval_stop"), error = NULL)})
withVisible(eval(expr, envir)){    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    }    watcher$capture_plot_and_output()doTryCatch(return(expr), name, parentenv, handler)29: 

    if (on_warning$capture) {29: withCallingHandlers(code, error = function (e) withCallingHandlers(code, error = function (e)         watcher$print_value(ev$value, ev$visible, envir)    }rlang::entrace(e), message = function (cnd)         cnd <- sanitize_call(cnd)    TRUE30:         watcher$push(cnd)rlang::entrace(e), message = function (cnd) }, handlers)
    }    if (on_warning$silence) {
{eval(call){        invokeRestart("muffleWarning")    watcher$capture_plot_and_output()    if (on_message$capture) {        watcher$push(cnd)57: 33: 
31: eval(call)
doWithOneRestart(return(expr), restart)    }tryCatchOne(expr, names, parentenv, handlers[[1L]])32: with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()    }}, error = function (cnd) {    watcher$capture_plot_and_output()    cnd <- sanitize_call(cnd)    watcher$push(cnd)    if (on_message$silence) {
    watcher$capture_plot_and_output()
    if (on_message$capture) {        watcher$push(cnd)    }    if (on_message$silence) {        invokeRestart("muffleMessage")    }}, warning = function (cnd) {    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    }58: tryCatchList(expr, classes, parentenv, handlers)
59: tryCatch({34:     watcher$capture_plot_and_output()    engine$weave(file, quiet = quiet, encoding = enc)        invokeRestart("muffleMessage")    if (on_warning$capture) {    }    switch(on_error, continue = invokeRestart("eval_continue"),         cnd <- sanitize_call(cnd)        watcher$print_value(ev$value, ev$visible, envir)    }        stop = invokeRestart("eval_stop"), error = NULL)})}, warning = function (cnd)     TRUE
withOneRestart(expr, restarts[[1L]]){
35: 30: eval(call)}, handlers)        watcher$push(cnd)    }    if (on_warning$silence) {    setwd(startdir)withRestartList(expr, restarts[-nr])
33:     if (getOption("warn") >= 2 || getOption("warn") < 0) {    output <- find_vignette_product(name, by = "weave", engine = engine)        invokeRestart("muffleWarning")    if (!have.makefile && vignette_is_tex(output)) {doWithOneRestart(return(expr), restart)        return()    }    watcher$capture_plot_and_output()    if (on_warning$capture) {
34: withOneRestart(expr, restarts[[1L]])
        cnd <- sanitize_call(cnd)
        watcher$push(cnd)35: 31: withRestartList(expr, restarts[-nr])        texi2pdf(file = output, clean = FALSE, quiet = quiet)
    }
    }eval(call)
32: with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)36: doWithOneRestart(return(expr), restart)
    if (on_warning$silence) {36: 37:         output <- find_vignette_product(name, by = "texi2pdf",     }    TRUE}, handlers)
33: doWithOneRestart(return(expr), restart)
        invokeRestart("muffleWarning")withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])}, error = function (cnd) doWithOneRestart(return(expr), restart)34: withOneRestart(expr, restarts[[1L]])
35: withRestartList(expr, restarts[-nr])
36: doWithOneRestart(return(expr), restart)
37: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])            engine = engine){    watcher$capture_plot_and_output()    cnd <- sanitize_call(cnd)    watcher$push(cnd)    switch(on_error, continue = invokeRestart("eval_continue"), 
    }        stop = invokeRestart("eval_stop"), error = NULL)})
38: 

    }37: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
30: withRestartList(expr, restarts)}, error = function (cnd) eval(call)38: {    watcher$capture_plot_and_output()    cnd <- sanitize_call(cnd)    watcher$push(cnd)    switch(on_error, continue = invokeRestart("eval_continue"),         stop = invokeRestart("eval_stop"), error = NULL)})
30: eval(call)

38: 31: eval(call)
32: with_handlers({    for (expr in tle$exprs) {
39: withRestartList(expr, restarts)        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers)
}, error = function(e) {withRestartList(expr, restarts)
39: withRestarts(with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()    OK <<- FALSE33: withRestarts(with_handlers({31: eval(call)
32: with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers)
33: doWithOneRestart(return(expr), restart)doWithOneRestart(return(expr), restart)    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})
60: 
    for (expr in tle$exprs) {        watcher$print_value(ev$value, ev$visible, envir)tools:::.buildOneVignette("mnl_models.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr", 
    TRUE, FALSE, "mnl_models", "UTF-8", "/Volumes/Temp/tmp/RtmpS24rW8/file16973e8577a7.rds")39: 

withRestarts(with_handlers({34: An irrecoverable exception occurred. R is aborting now ...
34:         ev <- withVisible(eval(expr, envir))    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)withOneRestart(expr, restarts[[1L]])    }    TRUE}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)
        watcher$capture_plot_and_output()40: evaluate::evaluate(...)
    }        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)    TRUEwithOneRestart(expr, restarts[[1L]])}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)

41: 
35: withRestartList(expr, restarts[-nr])
36: doWithOneRestart(return(expr), restart)40: evaluate::evaluate(...)
41: 35: 
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, evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2LwithRestartList(expr, restarts[-nr])
40: 
    }, output_handler = knit_handlers(options$render, options))    keep_message = if (is.numeric(options$message)) TRUE else options$message, 37: 
withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])36: 42:     stop_on_error = if (is.numeric(options$error)) options$error else {in_dir(input_dir(), expr)evaluate::evaluate(...)

41: doWithOneRestart(return(expr), restart)
43: in_input_dir(evaluate(code, envir = env, new_device = FALSE, 
38: evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning,     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 {        if (options$error && options$include) 37:             0L        else 2L    }, output_handler = knit_handlers(options$render, options))
42: in_dir(input_dir(), expr)        if (options$error && options$include)     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) withRestartList(expr, restarts)

38:             0LwithRestartList(expr, restarts)
39: withRestarts(with_handlers({    for (expr in tle$exprs) {            0L43:         else 2L        else 2L    }, output_handler = knit_handlers(options$render, options))
42:     }, output_handler = knit_handlers(options$render, options)))in_dir(input_dir(), expr)

        ev <- withVisible(eval(expr, envir))39: 44: in_input_dir(evaluate(code, envir = env, new_device = FALSE, 
eng_r(options)43:         watcher$capture_plot_and_output()    keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, in_input_dir(evaluate(code, envir = env, new_device = FALSE, 
45: block_exec(params)
46: call_block(x)
47: process_group(group)
48: withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),         watcher$print_value(ev$value, ev$visible, envir)    keep_warning = if (is.numeric(options$warning)) TRUE else options$warning,     }    keep_message = if (is.numeric(options$message)) TRUE else options$message,     TRUEwithRestarts(with_handlers({}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)    error = function(e) {    stop_on_error = if (is.numeric(options$error)) options$error else {    for (expr in tle$exprs) {
40: evaluate::evaluate(...)    keep_message = if (is.numeric(options$message)) TRUE else options$message,         if (options$error && options$include)     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L
        else 2L        if (progress && is.function(pb$interrupt))     }, output_handler = knit_handlers(options$render, options)))
            0L        ev <- withVisible(eval(expr, envir))        else 2L    }, output_handler = knit_handlers(options$render, options)))44: 41: 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,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L            pb$interrupt()    }, output_handler = knit_handlers(options$render, options))
        watcher$capture_plot_and_output()eng_r(options)        if (is_R_CMD_build() || is_R_CMD_check()) 
            error <<- format(e)    })
49:         watcher$print_value(ev$value, ev$visible, envir)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())     }42: in_dir(input_dir(), expr)
43: in_input_dir(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,     stop_on_error = if (is.numeric(options$error)) options$error else {            error <<- format(e)    }), list(rlang_trace_top_env = knit_global()))
        if (options$error && options$include)             0L    TRUE
50: 44: }, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), 
40: evaluate::evaluate(...)
45: 41: 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,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L
        else 2L45:     }, output_handler = knit_handlers(options$render, options))
42: in_dir(input_dir(), expr)    error = function(e) {block_exec(params)        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)    }, output_handler = knit_handlers(options$render, options)))
    write_utf8(res, output %n% stdout())    paste0("\nQuitting from ", loc, if (!is.null(error)) 

44: eng_r(options)
45: block_exec(params)
46: block_exec(params)46: call_block(x)call_block(x)        paste0("\n", rule(), error, "\n", rule()))}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)
51: process_file(text, output)

47: process_group(group)
48: withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), 43: 
52: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
53: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
54: in_input_dir(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,     stop_on_error = if (is.numeric(options$error)) options$error else {    error = function(e) {
vweave_rmarkdown(...)
47: process_group(group)55: 46: 
        if (options$error && options$include)         if (progress && is.function(pb$interrupt))             0Lcall_block(x)48: 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())             pb$interrupt()        else 2L    }, output_handler = knit_handlers(options$render, options)))
44: eng_r(options)
45: block_exec(params)
46: call_block(x)
47: process_group(group)
48: 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)engine$weave(file, quiet = quiet, encoding = enc)
56: doTryCatch(return(expr), name, parentenv, handler)
57:         if (is_R_CMD_build() || is_R_CMD_check()) 
47: process_group(group)
48: withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     error = function(e) {tryCatchOne(expr, names, parentenv, handlers[[1L]])
        if (progress && is.function(pb$interrupt))             pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)    })
49: with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     error = function(e) {        if (progress && is.function(pb$interrupt))     })58:             pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)            error <<- format(e)
    })49: tryCatchList(expr, classes, parentenv, handlers)
59:             error <<- format(e)    }), list(rlang_trace_top_env = knit_global()))    })

with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), 49: with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), tryCatch({    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()))
49:     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()))
50: xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), 
    engine$weave(file, quiet = quiet, encoding = enc)50:     error = function(e) {        if (progress && is.function(pb$interrupt)) 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()))
50: 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())             pb$interrupt()50:             error <<- format(e)        if (is_R_CMD_build() || is_R_CMD_check())     setwd(startdir)    }), list(rlang_trace_top_env = knit_global())), function(loc) {xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     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)    }}, error = function(e) {    OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})
60: tools:::.buildOneVignette("mnl_models.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr",             error <<- format(e)xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     setwd(wd)    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)    }), 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)
51: process_file(text, output)
    TRUE, FALSE, "mnl_models", "UTF-8", "/Volumes/Temp/tmp/RtmpS24rW8/file16973e8577a7.rds")    error = function(e) {    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)
51: process_file(text, output)
52: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)52:     write_utf8(res, output %n% stdout())        if (progress && is.function(pb$interrupt)) 
53: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(), 
    paste0("\nQuitting from ", loc, if (!is.null(error)) An irrecoverable exception occurred. R is aborting now ...
    output_dir = getwd(), ...)
54: vweave_rmarkdown(...)
55: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)            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)) engine$weave(file, quiet = quiet, encoding = enc)
56: doTryCatch(return(expr), name, parentenv, handler)        paste0("\n", rule(), error, "\n", rule()))
        paste0("\n", rule(), error, "\n", rule()))}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)
53: }, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)57: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
54: vweave_rmarkdown(...)
55: engine$weave(file, quiet = quiet, encoding = enc)
56: doTryCatch(return(expr), name, parentenv, handler)
51: tryCatchOne(expr, names, parentenv, handlers[[1L]])
process_file(text, output)51: 


58: 57: 52: tryCatchList(expr, classes, parentenv, handlers)knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
53: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)process_file(text, output)
tryCatchOne(expr, names, parentenv, handlers[[1L]])54: vweave_rmarkdown(...)
58: tryCatchList(expr, classes, parentenv, handlers)

59: 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)    }}, error = function(e) {    OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})
52: 
59: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
53: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
54: vweave_rmarkdown(...)
55: engine$weave(file, quiet = quiet, encoding = enc)
55: tryCatch({engine$weave(file, quiet = quiet, encoding = enc)
56: doTryCatch(return(expr), name, parentenv, handler)
57: tryCatchOne(expr, names, parentenv, handlers[[1L]])
58: tryCatchList(expr, classes, parentenv, handlers)
59: 
60:     engine$weave(file, quiet = quiet, encoding = enc)56: doTryCatch(return(expr), name, parentenv, handler)
57: tryCatchOne(expr, names, parentenv, handlers[[1L]])
58: tryCatchList(expr, classes, parentenv, handlers)
59: tryCatch({    engine$weave(file, quiet = quiet, encoding = enc)    setwd(startdir)tools:::.buildOneVignette("mnl_models.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr", tryCatch({    TRUE, FALSE, "mnl_models", "UTF-8", "/Volumes/Temp/tmp/RtmpS24rW8/file16973e8577a7.rds")    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)    }}, error = function(e) {    OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})
60:     engine$weave(file, quiet = quiet, encoding = enc)    setwd(startdir)    output <- find_vignette_product(name, by = "weave", engine = engine)    setwd(startdir)    if (!have.makefile && vignette_is_tex(output)) {        texi2pdf(file = output, clean = FALSE, quiet = quiet)        output <- find_vignette_product(name, by = "texi2pdf",             engine = engine)    }}, error = function(e) {    OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})

60: An irrecoverable exception occurred. R is aborting now ...
    output <- find_vignette_product(name, by = "weave", engine = engine)tools:::.buildOneVignette("mnl_models.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr", tools:::.buildOneVignette("mnl_models.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr",     TRUE, FALSE, "mnl_models", "UTF-8", "/Volumes/Temp/tmp/RtmpS24rW8/file16973e8577a7.rds")    if (!have.makefile && vignette_is_tex(output)) {    TRUE, FALSE, "mnl_models", "UTF-8", "/Volumes/Temp/tmp/RtmpS24rW8/file16973e8577a7.rds")        texi2pdf(file = output, clean = FALSE, quiet = quiet)        output <- find_vignette_product(name, by = "texi2pdf",             engine = engine)    }}, error = function(e) {
    OK <<- FALSEAn irrecoverable exception occurred. R is aborting now ...

An irrecoverable exception occurred. R is aborting now ...
    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})
60: tools:::.buildOneVignette("mnl_models.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr",     TRUE, FALSE, "mnl_models", "UTF-8", "/Volumes/Temp/tmp/RtmpS24rW8/file16973e8577a7.rds")
An irrecoverable exception occurred. R is aborting now ...

Quitting from mnl_models.Rmd:85-98 [unnamed-chunk-9]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
<error/rlang_error>
Error in `names(x) <- value`:
! 'names' attribute [3] must be the same length as the vector [0]
---
Backtrace:
    ▆
 1. └─logitr::logitr(...)
 2.   └─logitr:::getMultistartSummary(allModels)
 3.     └─base::`colnames<-`(...)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Error: processing vignette 'mnl_models.Rmd' failed with diagnostics:
'names' attribute [3] must be the same length as the vector [0]
--- failed re-building ‘mnl_models.Rmd’

--- re-building ‘mnl_models_weighted.Rmd’ using rmarkdown

 *** caught segfault ***
address 0x110, cause 'invalid permissions'

Traceback:
 1: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)
 2: eval_f(x0, ...)
 3: nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     mi = mi, opts = mi$options)
 4: doTryCatch(return(expr), name, parentenv, handler)
 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
 6: tryCatchList(expr, classes, parentenv, handlers)
 7: tryCatch({    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,         mi = mi, opts = mi$options)}, error = function(e) {})
 8: system.time({    model <- mi$model    result <- NULL    tryCatch({        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,             mi = mi, opts = mi$options)    }, error = function(e) {    })    if (!is.null(result)) {        model$fail <- FALSE        model$coefficients <- result$solution        model$logLik <- as.numeric(-1 * result$objective)        model$iterations <- result$iterations        model$status <- result$status        model$message <- result$message    }})
 9: FUN(X[[i]], ...)
10: lapply(X = S, FUN = FUN, ...)
11: doTryCatch(return(expr), name, parentenv, handler)
12: tryCatchOne(expr, names, parentenv, handlers[[1L]])
13: tryCatchList(expr, classes, parentenv, handlers)
14: 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)             prefix <- paste0(prefix, "\n  ")    }    else prefix <- "Error : "    msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, file = outFile)        .Internal(printDeferredWarnings())    }    invisible(structure(msg, class = "try-error", condition = e))})
15: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
16: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
17: FUN(X[[i]], ...)
18: lapply(seq_len(cores), inner.do)
19: parallel::mclapply(miList, runModel, mc.cores = numCores)
20: withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))
21: suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))
22: withCallingHandlers(expr, message = function(c) if (inherits(c,     classes)) tryInvokeRestart("muffleMessage"))
23: suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))
24: runMultistart(modelInputs)
25: logitr(data = cars_us, outcome = "choice", obsID = "obsnum",     pars = c("hev", "phev10", "phev20", "phev40", "bev75", "bev100",         "bev150", "american", "japanese", "chinese", "skorean",         "phevFastcharge", "bevFastcharge", "opCost", "accelTime"),     scalePar = "price", robust = TRUE, numMultiStarts = 10)
26: eval(expr, envir)
27: eval(expr, envir)
28: withVisible(eval(expr, envir))
29: withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) {    watcher$capture_plot_and_output()    if (on_message$capture) {        watcher$push(cnd)    }    if (on_message$silence) {        invokeRestart("muffleMessage")    }}, warning = function (cnd) {    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    }    watcher$capture_plot_and_output()    if (on_warning$capture) {        cnd <- sanitize_call(cnd)        watcher$push(cnd)    }    if (on_warning$silence) {        invokeRestart("muffleWarning")    }}, error = function (cnd) {    watcher$capture_plot_and_output()    cnd <- sanitize_call(cnd)    watcher$push(cnd)    switch(on_error, continue = invokeRestart("eval_continue"),         stop = invokeRestart("eval_stop"), error = NULL)})
30: eval(call)
31: eval(call)
32: with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers)
33: doWithOneRestart(return(expr), restart)
34: withOneRestart(expr, restarts[[1L]])
35: withRestartList(expr, restarts[-nr])
36: doWithOneRestart(return(expr), restart)
37: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
38: withRestartList(expr, restarts)
39: withRestarts(with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)
40: evaluate::evaluate(...)
41: 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,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options))
42: in_dir(input_dir(), expr)
43: in_input_dir(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,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options)))
44: eng_r(options)
45: block_exec(params)
46: call_block(x)
47: process_group(group)
48: 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)    })
49: 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()))
50: 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)
51: process_file(text, output)
52: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
53: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
54: vweave_rmarkdown(...)
55: engine$weave(file, quiet = quiet, encoding = enc)
56: doTryCatch(return(expr), name, parentenv, handler)
57: tryCatchOne(expr, names, parentenv, handlers[[1L]])
58: tryCatchList(expr, classes, parentenv, handlers)
59: 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)    }}, error = function(e) {    OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})
60: tools:::.buildOneVignette("mnl_models_weighted.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr",     TRUE, FALSE, "mnl_models_weighted", "UTF-8", "/Volumes/Temp/tmp/RtmpS24rW8/file169732ee090b9.rds")
An irrecoverable exception occurred. R is aborting now ...

 *** 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: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)
 2: eval_f(x0, ...)
 3: nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     mi = mi, opts = mi$options)
 4: doTryCatch(return(expr), name, parentenv, handler)
 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
 6: tryCatchList(expr, classes, parentenv, handlers)
 7: tryCatch({    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,         mi = mi, opts = mi$options)}, error = function(e) {})
 8: system.time({    model <- mi$model    result <- NULL    tryCatch({        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,             mi = mi, opts = mi$options)    }, error = function(e) {    })    if (!is.null(result)) {        model$fail <- FALSE        model$coefficients <- result$solution        model$logLik <- as.numeric(-1 * result$objective)        model$iterations <- result$iterations        model$status <- result$status        model$message <- result$message    }})
 9: FUN(X[[i]], ...)
10: lapply(X = S, FUN = FUN, ...)
11: doTryCatch(return(expr), name, parentenv, handler)
12: tryCatchOne(expr, names, parentenv, handlers[[1L]])
13: tryCatchList(expr, classes, parentenv, handlers)
14: 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)             prefix <- paste0(prefix, "\n  ")    }    else prefix <- "Error : "    msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, file = outFile)        .Internal(printDeferredWarnings())    }    invisible(structure(msg, class = "try-error", condition = e))})
15: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
16: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
17: FUN(X[[i]], ...)
18: lapply(seq_len(cores), inner.do)
19: parallel::mclapply(miList, runModel, mc.cores = numCores)
20: withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))
21: suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))
22: withCallingHandlers(expr, message = function(c) if (inherits(c,     classes)) tryInvokeRestart("muffleMessage"))
23: suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))
24: runMultistart(modelInputs)
25: logitr(data = cars_us, outcome = "choice", obsID = "obsnum",     pars = c("hev", "phev10", "phev20", "phev40", "bev75", "bev100",         "bev150", "american", "japanese", "chinese", "skorean",         "phevFastcharge", "bevFastcharge", "opCost", "accelTime"),     scalePar = "price", robust = TRUE, numMultiStarts = 10)
26: eval(expr, envir)
27: eval(expr, envir)
28: withVisible(eval(expr, envir))
29: withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) {    watcher$capture_plot_and_output()    if (on_message$capture) {        watcher$push(cnd)    }    if (on_message$silence) {        invokeRestart("muffleMessage")    }}, warning = function (cnd) {    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    }    watcher$capture_plot_and_output()    if (on_warning$capture) {        cnd <- sanitize_call(cnd)        watcher$push(cnd)    }    if (on_warning$silence) {        invokeRestart("muffleWarning")
Traceback:
 1: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)
 2: eval_f(x0, ...)
 3: nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     mi = mi, opts = mi$options)
 4: doTryCatch(return(expr), name, parentenv, handler)
 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
 6:     }}, error = function (cnd) {    watcher$capture_plot_and_output()tryCatchList(expr, classes, parentenv, handlers)
 7: tryCatch({    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     cnd <- sanitize_call(cnd)    watcher$push(cnd)    switch(on_error, continue = invokeRestart("eval_continue"),         stop = invokeRestart("eval_stop"), error = NULL)})
30: eval(call)
31:         mi = mi, opts = mi$options)}, error = function(e) {})
 8: system.time({eval(call)
32: with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    model <- mi$model    result <- NULL    tryCatch({        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,             mi = mi, opts = mi$options)    }, error = function(e) {    }    TRUE}, handlers)
33: doWithOneRestart(return(expr), restart)
34: withOneRestart(expr, restarts[[1L]])    })    if (!is.null(result)) {        model$fail <- FALSE        model$coefficients <- result$solution        model$logLik <- as.numeric(-1 * result$objective)        model$iterations <- result$iterations        model$status <- result$status        model$message <- result$message    }})
 9: FUN(X[[i]], ...)
10: lapply(X = S, FUN = FUN, ...)
11: doTryCatch(return(expr), name, parentenv, handler)
12: tryCatchOne(expr, names, parentenv, handlers[[1L]])
13: tryCatchList(expr, classes, parentenv, handlers)
14: tryCatch(expr, error = function(e) {
35: withRestartList(expr, restarts[-nr])
36: doWithOneRestart(return(expr), restart)
37: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])    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
38: withRestartList(expr, restarts)
39: withRestarts(with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)
40: evaluate::evaluate(...)
41: 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,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        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],         else 2L    }, output_handler = knit_handlers(options$render, options))
42: in_dir(input_dir(), expr)

 *** caught segfault ***
address 0x110, cause 'invalid permissions'
43: in_input_dir(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,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options)))
44: eng_r(options)
45: block_exec(params)                type = "b")
46: call_block(x)        if (w > LONG) 
Traceback:
            prefix <- paste0(prefix, "\n  ")    }
47: process_group(group)
48:     else prefix <- "Error : " 1: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)
withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), 
Traceback:
 1:  2: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)    error = function(e) {eval_f(x0, ...)
    msg <- paste0(prefix, conditionMessage(e), "\n")
 2: eval_f(x0, ...)
 3: nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     mi = mi, opts = mi$options)
 4: doTryCatch(return(expr), name, parentenv, handler)    .Internal(seterrmessage(msg[1L]))
        if (progress && is.function(pb$interrupt))  3:             pb$interrupt()nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,         if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)    })    mi = mi, opts = mi$options)
 4: doTryCatch(return(expr), name, parentenv, handler)
49: with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     error = function(e) {
 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
        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()))
    if (!silent && isTRUE(getOption("show.error.messages"))) { 6: tryCatchList(expr, classes, parentenv, handlers)
 7: 50: tryCatch({ 5:         cat(msg, file = outFile)        .Internal(printDeferredWarnings())xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     }    error = function(e) {    invisible(structure(msg, class = "try-error", condition = e))})    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,         mi = mi, opts = mi$options)}, error = function(e) {tryCatchOne(expr, names, parentenv, handlers[[1L]])})
        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)
51: process_file(text, output)
52: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
53: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
54: vweave_rmarkdown(...)
55: 
 6: tryCatchList(expr, classes, parentenv, handlers)
engine$weave(file, quiet = quiet, encoding = enc) 7: 
Traceback:
 1: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)tryCatch({
 8: system.time({    model <- mi$model    result <- NULL15: 
try(lapply(X = S, FUN = FUN, ...), silent = TRUE)56: doTryCatch(return(expr), name, parentenv, handler)
57: tryCatchOne(expr, names, parentenv, handlers[[1L]])    tryCatch({

    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,         mi = mi, opts = mi$options)16: 
58: tryCatchList(expr, classes, parentenv, handlers)
59: tryCatch({    engine$weave(file, quiet = quiet, encoding = enc)    setwd(startdir)    output <- find_vignette_product(name, by = "weave", engine = engine)}, error = function(e) { 2: eval_f(x0, ...)
 3: nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     mi = mi, opts = mi$options)
 4: doTryCatch(return(expr), name, parentenv, handler)sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))    if (!have.makefile && vignette_is_tex(output)) {        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, 
17: FUN(X[[i]], ...)
18:         texi2pdf(file = output, clean = FALSE, quiet = quiet)            mi = mi, opts = mi$options)    }, error = function(e) {    })    if (!is.null(result)) {        model$fail <- FALSElapply(seq_len(cores), inner.do)
})
        model$coefficients <- result$solution
 8:  5: tryCatchOne(expr, names, parentenv, handlers[[1L]])        model$logLik <- as.numeric(-1 * result$objective)19: 
        model$iterations <- result$iterations        model$status <- result$status        model$message <- result$messageparallel::mclapply(miList, runModel, mc.cores = numCores)        output <- find_vignette_product(name, by = "texi2pdf",             engine = engine)    }
    }})
 9: FUN(X[[i]], ...) 6: 
system.time({tryCatchList(expr, classes, parentenv, handlers)
 7: }, error = function(e) {20: withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))
21: suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))    OK <<- FALSEtryCatch({10:     message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",     result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, lapply(X = S, FUN = FUN, ...)        file, conditionMessage(e)))

22: withCallingHandlers(expr, message = function(c) if (inherits(c,     classes)) tryInvokeRestart("muffleMessage"))
23: suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))
        mi = mi, opts = mi$options)11: doTryCatch(return(expr), name, parentenv, handler)
12: }, error = function(e) {})
 8: system.time({    model <- mi$model    result <- NULL    tryCatch({        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,             mi = mi, opts = mi$options)})    model <- mi$model
60: tools:::.buildOneVignette("mnl_models_weighted.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr",     TRUE, FALSE, "mnl_models_weighted", "UTF-8", "/Volumes/Temp/tmp/RtmpS24rW8/file169732ee090b9.rds")
An irrecoverable exception occurred. R is aborting now ...
    result <- NULL    tryCatch({        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,             mi = mi, opts = mi$options)    }, error = function(e) {tryCatchOne(expr, names, parentenv, handlers[[1L]])    })    if (!is.null(result)) {        model$fail <- FALSE        model$coefficients <- result$solution        model$logLik <- as.numeric(-1 * result$objective)        model$iterations <- result$iterations        model$status <- result$status24:     }, error = function(e) {
13: tryCatchList(expr, classes, parentenv, handlers)
14: 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")    })runMultistart(modelInputs)
25:         if (is.na(w))             w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L],                 type = "b")        if (w > LONG)             prefix <- paste0(prefix, "\n  ")        model$message <- result$message    }    }})
 9: FUN(X[[i]], ...)    if (!is.null(result)) {    else prefix <- "Error : "    msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, file = outFile)        .Internal(printDeferredWarnings())    }    invisible(structure(msg, class = "try-error", condition = e))})
15: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
16: 
sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
17: FUN(X[[i]], ...)
18: lapply(seq_len(cores), inner.do)
10: 
 *** caught segfault ***
logitr(data = cars_us, outcome = "choice", obsID = "obsnum",         model$fail <- FALSElapply(X = S, FUN = FUN, ...)19: address 0x110, cause 'invalid permissions'
    pars = c("hev", "phev10", "phev20", "phev40", "bev75", "bev100",         model$coefficients <- result$solutionparallel::mclapply(miList, runModel, mc.cores = numCores)
 *** caught segfault ***

address 0x110, cause 'invalid permissions'
        model$logLik <- as.numeric(-1 * result$objective)20:         "bev150", "american", "japanese", "chinese", "skorean",         model$iterations <- result$iterations        "phevFastcharge", "bevFastcharge", "opCost", "accelTime"),     scalePar = "price", robust = TRUE, numMultiStarts = 10)
26: eval(expr, envir)
27: withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))
21: suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))
22: withCallingHandlers(expr, message = function(c) if (inherits(c,     classes)) tryInvokeRestart("muffleMessage"))

eval(expr, envir)23: suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))
        model$status <- result$status24: 
28: withVisible(eval(expr, envir))
29: withCallingHandlers(code, error = function (e) runMultistart(modelInputs)
25: logitr(data = cars_us, outcome = "choice", obsID = "obsnum",     pars = c("hev", "phev10", "phev20", "phev40", "bev75", "bev100",         "bev150", "american", "japanese", "chinese", "skorean",         "phevFastcharge", "bevFastcharge", "opCost", "accelTime"),     scalePar = "price", robust = TRUE, numMultiStarts = 10)
26: rlang::entrace(e), message = function (cnd) eval(expr, envir)11:         model$message <- result$message    }})
 9: FUN(X[[i]], ...)
10: lapply(X = S, FUN = FUN, ...)
11: doTryCatch(return(expr), name, parentenv, handler)
12: tryCatchOne(expr, names, parentenv, handlers[[1L]])

{27:     watcher$capture_plot_and_output()eval(expr, envir)
28:     if (on_message$capture) {13: tryCatchList(expr, classes, parentenv, handlers)
14: tryCatch(expr, error = function(e) {        watcher$push(cnd)    }    if (on_message$silence) {    call <- conditionCall(e)doTryCatch(return(expr), name, parentenv, handler)    if (!is.null(call)) {        invokeRestart("muffleMessage")
withVisible(eval(expr, envir))    }}, warning = function (cnd) {
        if (identical(call[[1L]], quote(doTryCatch)))             call <- sys.call(-4L)        dcall <- deparse(call, nlines = 1L)    if (getOption("warn") >= 2 || getOption("warn") < 0) {        prefix <- paste("Error in", dcall, ": ")        LONG <- 75L        return()29: withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd)         sm <- strsplit(conditionMessage(e), "\n")[[1L]]{        w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")    watcher$capture_plot_and_output()12: tryCatchOne(expr, names, parentenv, handlers[[1L]])
    if (on_message$capture) {        watcher$push(cnd)        if (is.na(w))     }    if (on_message$silence) {        invokeRestart("muffleMessage")    }    }}, warning = function (cnd)     watcher$capture_plot_and_output()13: tryCatchList(expr, classes, parentenv, handlers)
14: tryCatch(expr, error = function(e) {{            w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L],                 type = "b")        if (w > LONG)             prefix <- paste0(prefix, "\n  ")    }    else prefix <- "Error : "    msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, file = outFile)        .Internal(printDeferredWarnings())    }    invisible(structure(msg, class = "try-error", condition = e))
Traceback:
    call <- conditionCall(e)    if (on_warning$capture) {        cnd <- sanitize_call(cnd)        watcher$push(cnd)    }    if (on_warning$silence) { 1:     if (!is.null(call)) {        invokeRestart("muffleWarning")    }}, error = function (cnd)     if (getOption("warn") >= 2 || getOption("warn") < 0) {})mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)        if (identical(call[[1L]], quote(doTryCatch))) 
Traceback:
 1: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)
 2: eval_f(x0, ...)
 3: nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     mi = mi, opts = mi$options)
 4: doTryCatch(return(expr), name, parentenv, handler)
 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
 6: tryCatchList(expr, classes, parentenv, handlers)
 7: tryCatch({    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,         mi = mi, opts = mi$options)}, error = function(e) {})
 8: system.time({    model <- mi$model    result <- NULL    tryCatch({        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,             mi = mi, opts = mi$options)    }, error = function(e) {    })    if (!is.null(result)) {        model$fail <- FALSE        model$coefficients <- result$solution        model$logLik <- as.numeric(-1 * result$objective)        model$iterations <- result$iterations        model$status <- result$status        model$message <- result$message

        return(){    } 2:     }15: })    watcher$capture_plot_and_output()    cnd <- sanitize_call(cnd)    watcher$push(cnd)    switch(on_error, continue = invokeRestart("eval_continue"),     watcher$capture_plot_and_output()            call <- sys.call(-4L)        stop = invokeRestart("eval_stop"), error = NULL)})

30:     if (on_warning$capture) {eval(call)        cnd <- sanitize_call(cnd)try(lapply(X = S, FUN = FUN, ...), silent = TRUE)eval_f(x0, ...) 9:         watcher$push(cnd)FUN(X[[i]], ...)
31: eval(call)

        dcall <- deparse(call, nlines = 1L)
 3: 16: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     }    mi = mi, opts = mi$options)


    if (on_warning$silence) {17:         invokeRestart("muffleWarning")10:     } 4: doTryCatch(return(expr), name, parentenv, handler)lapply(X = S, FUN = FUN, ...)
11: doTryCatch(return(expr), name, parentenv, handler)FUN(X[[i]], ...)
 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])

        prefix <- paste("Error in", dcall, ": ")12: }, error = function (cnd)         LONG <- 75L32: {tryCatchOne(expr, names, parentenv, handlers[[1L]])
    watcher$capture_plot_and_output()with_handlers({        sm <- strsplit(conditionMessage(e), "\n")[[1L]]    cnd <- sanitize_call(cnd)
        w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")18:  6: lapply(seq_len(cores), inner.do)        if (is.na(w))     watcher$push(cnd)    for (expr in tle$exprs) {    switch(on_error, continue = invokeRestart("eval_continue"),         stop = invokeRestart("eval_stop"), error = NULL)13: tryCatchList(expr, classes, parentenv, handlers)})tryCatchList(expr, classes, parentenv, handlers)        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE
            w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L],                 type = "b")        if (w > LONG)             prefix <- paste0(prefix, "\n  ")    }    else prefix <- "Error : "    msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, file = outFile)        .Internal(printDeferredWarnings())    }14: 
 7: tryCatch(expr, error = function(e) {}, handlers)
30: eval(call)
tryCatch({    invisible(structure(msg, class = "try-error", condition = e))    call <- conditionCall(e)    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, 31: 
        mi = mi, opts = mi$options)
}, error = function(e) {})19: parallel::mclapply(miList, runModel, mc.cores = numCores)

})    if (!is.null(call)) { 8: system.time({    model <- mi$model
    result <- NULL20: withCallingHandlers(expr, warning = function(w) if (inherits(w, eval(call)    classes)) tryInvokeRestart("muffleWarning"))33:         if (identical(call[[1L]], quote(doTryCatch))) 15: 
21: doWithOneRestart(return(expr), restart)
32: with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()    tryCatch({            call <- sys.call(-4L)try(lapply(X = S, FUN = FUN, ...), silent = TRUE)suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))
        dcall <- deparse(call, nlines = 1L)        watcher$print_value(ev$value, ev$visible, envir)

 *** caught segfault ***
        prefix <- paste("Error in", dcall, ": ")
address 0x110, cause 'invalid permissions'
        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, 34: 22: withOneRestart(expr, restarts[[1L]])            mi = mi, opts = mi$options)    }    }, error = function(e) {    })    if (!is.null(result)) {        model$fail <- FALSE        model$coefficients <- result$solution        model$logLik <- as.numeric(-1 * result$objective)
        LONG <- 75L        sm <- strsplit(conditionMessage(e), "\n")[[1L]]withCallingHandlers(expr, message = function(c) if (inherits(c, 16:     classes)) tryInvokeRestart("muffleMessage"))    TRUE        model$iterations <- result$iterations        w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")        if (is.na(w)) 35: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))

            w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L], withRestartList(expr, restarts[-nr])        model$status <- result$status17: }, handlers)23: 
33: doWithOneRestart(return(expr), restart)
34: withOneRestart(expr, restarts[[1L]])suppressMessages(suppressWarnings(parallel::mclapply(miList, FUN(X[[i]], ...)        model$message <- result$message
35: withRestartList(expr, restarts[-nr])
36: doWithOneRestart(return(expr), restart)
37:     runModel, mc.cores = numCores)))    }
withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
18: lapply(seq_len(cores), inner.do)})
 *** caught segfault ***
address 0x110, cause 'invalid permissions'


24: runMultistart(modelInputs)
25: logitr(data = cars_us, outcome = "choice", obsID = "obsnum",     pars = c("hev", "phev10", "phev20", "phev40", "bev75", "bev100",         "bev150", "american", "japanese", "chinese", "skorean",         "phevFastcharge", "bevFastcharge", "opCost", "accelTime"),     scalePar = "price", robust = TRUE, numMultiStarts = 10)                type = "b")
36: doWithOneRestart(return(expr), restart)
38:         if (w > LONG) 
            prefix <- paste0(prefix, "\n  ")
19: withRestartList(expr, restarts)37: 
26: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])39: eval(expr, envir)    } 9: 
27: 
FUN(X[[i]], ...)
10: parallel::mclapply(miList, runModel, mc.cores = numCores)38: lapply(X = S, FUN = FUN, ...)
    else prefix <- "Error : "withRestartList(expr, restarts)
withRestarts(with_handlers({    msg <- paste0(prefix, conditionMessage(e), "\n")39: 
Traceback:
eval(expr, envir)
    .Internal(seterrmessage(msg[1L]))withRestarts(with_handlers({    for (expr in tle$exprs) {20: withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))
        ev <- withVisible(eval(expr, envir)) 1: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)
 2: eval_f(x0, ...)
11:         watcher$capture_plot_and_output()21:     for (expr in tle$exprs) { 3: nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     mi = mi, opts = mi$options)
        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE    if (!silent && isTRUE(getOption("show.error.messages"))) {suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))
22: }, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)withCallingHandlers(expr, message = function(c) if (inherits(c, doTryCatch(return(expr), name, parentenv, handler)
12: tryCatchOne(expr, names, parentenv, handlers[[1L]])
 4:         cat(msg, file = outFile)13:     classes)) tryInvokeRestart("muffleMessage"))        .Internal(printDeferredWarnings())    }    invisible(structure(msg, class = "try-error", condition = e))})
15: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
16: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
17: FUN(X[[i]], ...)
18: lapply(seq_len(cores), inner.do)
19: parallel::mclapply(miList, runModel, mc.cores = numCores)
20: withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))
21: suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))
22: withCallingHandlers(expr, message = function(c) if (inherits(c,     classes)) tryInvokeRestart("muffleMessage"))
23: suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))
24: runMultistart(modelInputs)
25: logitr(data = cars_us, outcome = "choice", obsID = "obsnum",     pars = c("hev", "phev10", "phev20", "phev40", "bev75", "bev100",         "bev150", "american", "japanese", "chinese", "skorean",         "phevFastcharge", "bevFastcharge", "opCost", "accelTime"),     scalePar = "price", robust = TRUE, numMultiStarts = 10)
26: eval(expr, envir)
27: eval(expr, envir)
28: withVisible(eval(expr, envir))
29: withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) {    watcher$capture_plot_and_output()    if (on_message$capture) {        watcher$push(cnd)    }    if (on_message$silence) {        invokeRestart("muffleMessage")    }}, warning = function (cnd) {


23: suppressMessages(suppressWarnings(parallel::mclapply(miList, 28:         ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE    if (getOption("warn") >= 2 || getOption("warn") < 0) {40: doTryCatch(return(expr), name, parentenv, handler)evaluate::evaluate(...)
41: 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,     stop_on_error = if (is.numeric(options$error)) options$error else {
 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
 6:     runModel, mc.cores = numCores)))
Traceback:

24: runMultistart(modelInputs)
25: logitr(data = cars_us, outcome = "choice", obsID = "obsnum",     pars = c("hev", "phev10", "phev20", "phev40", "bev75", "bev100",         "bev150", "american", "japanese", "chinese", "skorean",         "phevFastcharge", "bevFastcharge", "opCost", "accelTime"),     scalePar = "price", robust = TRUE, numMultiStarts = 10)
26: eval(expr, envir)
27: eval(expr, envir)}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE) 1: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)
 2: eval_f(x0, ...)
 3: tryCatchList(expr, classes, parentenv, handlers)        return()
nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, 
28: withVisible(eval(expr, envir))
29: withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) {    watcher$capture_plot_and_output()    if (on_message$capture) {        watcher$push(cnd)    }    if (on_message$silence) {        invokeRestart("muffleMessage")    }40: withVisible(eval(expr, envir))}, warning = function (cnd) {    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    }    watcher$capture_plot_and_output()    if (on_warning$capture) {        cnd <- sanitize_call(cnd)        watcher$push(cnd)    }
29: evaluate::evaluate(...)    if (on_warning$silence) {
        invokeRestart("muffleWarning")
41: withCallingHandlers(code, error = function (e)         if (options$error && options$include) rlang::entrace(e), message = function (cnd)     }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,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options))
42: in_dir(input_dir(), expr)
43: in_input_dir(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,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options)))
44: eng_r(options)
45: block_exec(params)
46: call_block(x)
47: process_group(group)
48: tryCatchList(expr, classes, parentenv, handlers)
 7: tryCatch({    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     watcher$capture_plot_and_output()14: withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),         mi = mi, opts = mi$options)}, error = function(e) {})
 8: system.time({            0L    }    error = function(e) {    if (on_warning$capture) {    mi = mi, opts = mi$options)        cnd <- sanitize_call(cnd)}, error = function (cnd) tryCatch(expr, error = function(e) {{    call <- conditionCall(e)    watcher$capture_plot_and_output()    model <- mi$model
{    watcher$capture_plot_and_output()    cnd <- sanitize_call(cnd)    watcher$push(cnd)    switch(on_error, continue = invokeRestart("eval_continue"),         stop = invokeRestart("eval_stop"), error = NULL)})
30: eval(call)
31: eval(call)
32: with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers)
33: doWithOneRestart(return(expr), restart)
34: withOneRestart(expr, restarts[[1L]])
35: withRestartList(expr, restarts[-nr])
36: doWithOneRestart(return(expr), restart)
37: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
38: withRestartList(expr, restarts)
39: withRestarts(with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)        else 2L    }, output_handler = knit_handlers(options$render, options))
42: in_dir(input_dir(), expr)
    }        if (progress && is.function(pb$interrupt))             pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)    })
49: with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),         watcher$push(cnd)    if (on_message$capture) {    }    if (on_warning$silence) {        invokeRestart("muffleWarning")    }}, error = function (cnd) {    watcher$capture_plot_and_output()    cnd <- sanitize_call(cnd)    watcher$push(cnd)    switch(on_error, continue = invokeRestart("eval_continue"),         stop = invokeRestart("eval_stop"), error = NULL)})
30: eval(call)
31: eval(call)
32: with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE        watcher$push(cnd)    TRUE    error = function(e) {    result <- NULL        if (progress && is.function(pb$interrupt))             pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e) 4: }, handlers)    }    tryCatch({        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,             mi = mi, opts = mi$options)    }, error = function(e) {43:     if (on_message$silence) {}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)in_input_dir(evaluate(code, envir = env, new_device = FALSE,         invokeRestart("muffleMessage")
40:     keep_warning = if (is.numeric(options$warning)) TRUE else options$warning,     keep_message = if (is.numeric(options$message)) TRUE else options$message, 
doTryCatch(return(expr), name, parentenv, handler)
33:     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options)))
doWithOneRestart(return(expr), restart)    }) 5:     if (!is.null(result)) {        model$fail <- FALSE        model$coefficients <- result$solution        model$logLik <- as.numeric(-1 * result$objective)        model$iterations <- result$iterations        model$status <- result$status        model$message <- result$message    }    }), list(rlang_trace_top_env = knit_global()))tryCatchOne(expr, names, parentenv, handlers[[1L]])
 6: tryCatchList(expr, classes, parentenv, handlers)
 7: tryCatch({44: evaluate::evaluate(...)    }
    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, 
}, warning = function (cnd) {    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    }    watcher$capture_plot_and_output()    if (on_warning$capture) {        cnd <- sanitize_call(cnd)        watcher$push(cnd)    if (!is.null(call)) {        mi = mi, opts = mi$options)41:     }}, error = function(e) {evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning,     if (on_warning$silence) {
})eng_r(options)        invokeRestart("muffleWarning")50: 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())
    }34:     paste0("\nQuitting from ", loc, if (!is.null(error))     keep_message = if (is.numeric(options$message)) TRUE else options$message,     stop_on_error = if (is.numeric(options$error)) options$error else {45: withOneRestart(expr, restarts[[1L]])

})}, error = function (cnd) block_exec(params)        if (identical(call[[1L]], quote(doTryCatch))) 35:         if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options))
42: in_dir(input_dir(), expr)
43: in_input_dir(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,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L
46: call_block(x)
47: process_group(group)
48: 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)    })
{withRestartList(expr, restarts[-nr])            call <- sys.call(-4L)        paste0("\n", rule(), error, "\n", rule()))49: }, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)    watcher$capture_plot_and_output()with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),         dcall <- deparse(call, nlines = 1L)
    cnd <- sanitize_call(cnd)    watcher$push(cnd)    switch(on_error, continue = invokeRestart("eval_continue"), 
        prefix <- paste("Error in", dcall, ": ")        LONG <- 75L        sm <- strsplit(conditionMessage(e), "\n")[[1L]]        stop = invokeRestart("eval_stop"), error = NULL)        w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")
 9:     }, output_handler = knit_handlers(options$render, options)))})
30: FUN(X[[i]], ...)    error = function(e) {

51:         if (progress && is.function(pb$interrupt))             pb$interrupt() 8: 44:         if (is.na(w)) eng_r(options)
process_file(text, output)10: system.time({eval(call)36:             w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L],                 type = "b")    model <- mi$model
31: eval(call)
32: with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))
lapply(X = S, FUN = FUN, ...)45: doWithOneRestart(return(expr), restart)
11: block_exec(params)
37: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
38: withRestartList(expr, restarts)
        if (w > LONG) doTryCatch(return(expr), name, parentenv, handler)

    result <- NULL    tryCatch({        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,         if (is_R_CMD_build() || is_R_CMD_check()) 39:         watcher$capture_plot_and_output()12: tryCatchOne(expr, names, parentenv, handlers[[1L]])
13: tryCatchList(expr, classes, parentenv, handlers)
14: 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)             prefix <- paste0(prefix, "\n  ")    }    else prefix <- "Error : "    msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, file = outFile)        .Internal(printDeferredWarnings())    }    invisible(structure(msg, class = "try-error", condition = e))})
15: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
16: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
17: FUN(X[[i]], ...)
18: lapply(seq_len(cores), inner.do)
19: parallel::mclapply(miList, runModel, mc.cores = numCores)
20: withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))
21: suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))
22: withCallingHandlers(expr, message = function(c) if (inherits(c,     classes)) tryInvokeRestart("muffleMessage"))
23: suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))
24: runMultistart(modelInputs)
25: logitr(data = cars_us, outcome = "choice", obsID = "obsnum",     pars = c("hev", "phev10", "phev20", "phev40", "bev75", "bev100",         "bev150", "american", "japanese", "chinese", "skorean",         "phevFastcharge", "bevFastcharge", "opCost", "accelTime"),     scalePar = "price", robust = TRUE, numMultiStarts = 10)
26: eval(expr, envir)
27: eval(expr, envir)
28: withVisible(eval(expr, envir))
29: withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) {    watcher$capture_plot_and_output()    if (on_message$capture) {        watcher$push(cnd)    }    if (on_message$silence) {        invokeRestart("muffleMessage")    }}, warning = function (cnd) {    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()            error <<- format(e)withRestarts(with_handlers({    for (expr in tle$exprs) {            mi = mi, opts = mi$options)    }    }, error = function(e) {    })    if (!is.null(result)) {        model$fail <- FALSE        model$coefficients <- result$solution        model$logLik <- as.numeric(-1 * result$objective)        model$iterations <- result$iterations        model$status <- result$status        model$message <- result$message    }})
 9: FUN(X[[i]], ...)
10: lapply(X = S, FUN = FUN, ...)
11: doTryCatch(return(expr), name, parentenv, handler)
12: tryCatchOne(expr, names, parentenv, handlers[[1L]])    watcher$capture_plot_and_output()52: 46: call_block(x)
47: process_group(group)
48: 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)    })
49: 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()))
50: 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)
51: process_file(text, output)knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE
53: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
54: vweave_rmarkdown(...)
55: engine$weave(file, quiet = quiet, encoding = enc)
            prefix <- paste0(prefix, "\n  ")
    }), list(rlang_trace_top_env = knit_global()))52:         watcher$print_value(ev$value, ev$visible, envir)13: 
    }    else prefix <- "Error : "    msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, file = outFile)    if (on_warning$capture) {}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)
40: evaluate::evaluate(...)
tryCatchList(expr, classes, parentenv, handlers)    }        .Internal(printDeferredWarnings())knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)41:         cnd <- sanitize_call(cnd)56: evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, 
50: 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())         watcher$push(cnd)doTryCatch(return(expr), name, parentenv, handler)
    TRUE}, handlers)
33: doWithOneRestart(return(expr), restart)
34: withOneRestart(expr, restarts[[1L]])
35: withRestartList(expr, restarts[-nr])
    }
    keep_message = if (is.numeric(options$message)) TRUE else options$message, 
53: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
54: vweave_rmarkdown(...)
55: engine$weave(file, quiet = quiet, encoding = enc)
56: doTryCatch(return(expr), name, parentenv, handler)
57: tryCatchOne(expr, names, parentenv, handlers[[1L]])
58: tryCatchList(expr, classes, parentenv, handlers)
59: 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)    }}, error = function(e) {    OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})
60: tools:::.buildOneVignette("mnl_models_weighted.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr",     TRUE, FALSE, "mnl_models_weighted", "UTF-8", "/Volumes/Temp/tmp/RtmpS24rW8/file169732ee090b9.rds")
An irrecoverable exception occurred. R is aborting now ...
36: 14:     }    invisible(structure(msg, class = "try-error", condition = e))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")})doWithOneRestart(return(expr), restart)57:     stop_on_error = if (is.numeric(options$error)) options$error else {tryCatchOne(expr, names, parentenv, handlers[[1L]])
58: tryCatchList(expr, classes, parentenv, handlers)
59: 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)    }            error <<- format(e)
    if (on_warning$silence) {
15: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)    }), list(rlang_trace_top_env = knit_global())), function(loc) {        invokeRestart("muffleWarning")    }}, error = function (cnd) {
    setwd(wd)        if (options$error && options$include)     watcher$capture_plot_and_output()    cnd <- sanitize_call(cnd)}, error = function(e) {    OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         if (is.na(w))     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)
51: process_file(text, output)
37: 16:             w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L],     watcher$push(cnd)sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))            0L        else 2L    }, output_handler = knit_handlers(options$render, options))
                type = "b")52: 42:         file, conditionMessage(e)))
17: FUN(X[[i]], ...)
18: lapply(seq_len(cores), inner.do)
19: parallel::mclapply(miList, runModel, mc.cores = numCores)
20: withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))
21: suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))
22: withCallingHandlers(expr, message = function(c) if (inherits(c,     classes)) tryInvokeRestart("muffleMessage"))
23: suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))
withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])24: runMultistart(modelInputs)
25: logitr(data = cars_us, outcome = "choice", obsID = "obsnum", })
in_dir(input_dir(), expr)    switch(on_error, continue = invokeRestart("eval_continue"), knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
53: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)60:         stop = invokeRestart("eval_stop"), error = NULL)})
    pars = c("hev", "phev10", "phev20", "phev40", "bev75", "bev100", 
54: vweave_rmarkdown(...)
        if (w > LONG)             prefix <- paste0(prefix, "\n  ")        "bev150", "american", "japanese", "chinese", "skorean", 
30: tools:::.buildOneVignette("mnl_models_weighted.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr",     TRUE, FALSE, "mnl_models_weighted", "UTF-8", "/Volumes/Temp/tmp/RtmpS24rW8/file169732ee090b9.rds")43:         "phevFastcharge", "bevFastcharge", "opCost", "accelTime"), in_input_dir(evaluate(code, envir = env, new_device = FALSE, 55:     }    else prefix <- "Error : "

38: withRestartList(expr, restarts)
39: withRestarts(with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUEengine$weave(file, quiet = quiet, encoding = enc)eval(call)    msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, file = outFile)}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)    scalePar = "price", robust = TRUE, numMultiStarts = 10)
    keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, 
56: 
26: eval(expr, envir)
27: eval(expr, envir)
An irrecoverable exception occurred. R is aborting now ...
40: evaluate::evaluate(...)    keep_message = if (is.numeric(options$message)) TRUE else options$message, 
41:         .Internal(printDeferredWarnings())28:     }    invisible(structure(msg, class = "try-error", condition = e))doTryCatch(return(expr), name, parentenv, handler)withVisible(eval(expr, envir))


31: evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, 57:     stop_on_error = if (is.numeric(options$error)) options$error else {})tryCatchOne(expr, names, parentenv, handlers[[1L]])
58: tryCatchList(expr, classes, parentenv, handlers)
59: 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", 
eval(call)
32: with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers)
33: doWithOneRestart(return(expr), restart)
15:     keep_message = if (is.numeric(options$message)) TRUE else options$message, 29:         if (options$error && options$include)             engine = engine)34:     stop_on_error = if (is.numeric(options$error)) options$error else {try(lapply(X = S, FUN = FUN, ...), silent = TRUE)        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options))
42: in_dir(input_dir(), expr)
43: in_input_dir(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,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options)))
44: eng_r(options)
            0L
        else 2LwithCallingHandlers(code, error = function (e) 45: block_exec(params)
withOneRestart(expr, restarts[[1L]])    }, output_handler = knit_handlers(options$render, options)))16: 46:     }}, error = function(e) {    OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})
60: call_block(x)sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))

17: 44: rlang::entrace(e), message = function (cnd) 
eng_r(options)
45: block_exec(params)35: FUN(X[[i]], ...)tools:::.buildOneVignette("mnl_models_weighted.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr", {

withRestartList(expr, restarts[-nr])    TRUE, FALSE, "mnl_models_weighted", "UTF-8", "/Volumes/Temp/tmp/RtmpS24rW8/file169732ee090b9.rds")18:     watcher$capture_plot_and_output()
    if (on_message$capture) {47:         watcher$push(cnd)lapply(seq_len(cores), inner.do)process_group(group)
19: 


48: withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), An irrecoverable exception occurred. R is aborting now ...
46:     error = function(e) {    }36:     if (on_message$silence) {        invokeRestart("muffleMessage")call_block(x)
47:         if (progress && is.function(pb$interrupt))     }process_group(group)doWithOneRestart(return(expr), restart)}, warning = function (cnd)             pb$interrupt()
        if (is_R_CMD_build() || is_R_CMD_check()) {            error <<- format(e)    })
49: with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), 37: parallel::mclapply(miList, runModel, mc.cores = numCores)
    error = function(e) {        if (progress && is.function(pb$interrupt)) 
            pb$interrupt()48: 20:     if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    }    watcher$capture_plot_and_output()        if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)    }), list(rlang_trace_top_env = knit_global()))
50: 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)    if (on_warning$capture) {withCallingHandlers(expr, warning = function(w) if (inherits(w,     write_utf8(res, output %n% stdout())    classes)) tryInvokeRestart("muffleWarning"))
21: suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))
22: withCallingHandlers(expr, message = function(c) if (inherits(c,     paste0("\nQuitting from ", loc, if (!is.null(error))     classes)) tryInvokeRestart("muffleMessage"))
23:         cnd <- sanitize_call(cnd)withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])        paste0("\n", rule(), error, "\n", rule()))
        watcher$push(cnd)withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), }, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)38: withRestartList(expr, restarts)
39: withRestarts(with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)
40: evaluate::evaluate(...)
41: 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,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L    error = function(e) {        if (progress && is.function(pb$interrupt))             pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)    })
49: with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     error = function(e) {        else 2LsuppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))    }
        if (progress && is.function(pb$interrupt))     }, output_handler = knit_handlers(options$render, options))
42:     if (on_warning$silence) {in_dir(input_dir(), expr)
43: 
        invokeRestart("muffleWarning")            pb$interrupt()51:     }in_input_dir(evaluate(code, envir = env, new_device = FALSE, 24:     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 {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options)))runMultistart(modelInputs)        if (is_R_CMD_build() || is_R_CMD_check()) process_file(text, output)}, error = function (cnd) {    watcher$capture_plot_and_output()    cnd <- sanitize_call(cnd)            error <<- format(e)

52: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
53: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(), 25: 
    watcher$push(cnd)logitr(data = cars_us, outcome = "choice", obsID = "obsnum",     pars = c("hev", "phev10", "phev20", "phev40", "bev75", "bev100",         "bev150", "american", "japanese", "chinese", "skorean",     }), list(rlang_trace_top_env = knit_global()))    output_dir = getwd(), ...)        "phevFastcharge", "bevFastcharge", "opCost", "accelTime"), 
    scalePar = "price", robust = TRUE, numMultiStarts = 10)44: 
50: 54: eng_r(options)    switch(on_error, continue = invokeRestart("eval_continue"), xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),         stop = invokeRestart("eval_stop"), error = NULL)})

    error = function(e) {26: eval(expr, envir)
27: eval(expr, envir)
28: withVisible(eval(expr, envir))
29: 45: 
30: block_exec(params)        if (progress && is.function(pb$interrupt)) withCallingHandlers(code, error = function (e)             pb$interrupt()rlang::entrace(e), message = function (cnd)         if (is_R_CMD_build() || is_R_CMD_check()) eval(call)            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()))46: }, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc){call_block(x)    watcher$capture_plot_and_output()    if (on_message$capture) {vweave_rmarkdown(...)
31:         watcher$push(cnd)
51:     }
eval(call)
32: with_handlers({process_file(text, output)55:     if (on_message$silence) {    for (expr in tle$exprs) {
52: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)        invokeRestart("muffleMessage")
        ev <- withVisible(eval(expr, envir))53: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)engine$weave(file, quiet = quiet, encoding = enc)        watcher$capture_plot_and_output()    }
56: }, warning = function (cnd) 47: process_group(group)        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers)

54: doTryCatch(return(expr), name, parentenv, handler)vweave_rmarkdown(...)
55: 

48: 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)    })engine$weave(file, quiet = quiet, encoding = enc)33: 
{57: doWithOneRestart(return(expr), restart)    if (getOption("warn") >= 2 || getOption("warn") < 0) {
34: withOneRestart(expr, restarts[[1L]])
35: 49:         return()    }tryCatchOne(expr, names, parentenv, handlers[[1L]])withRestartList(expr, restarts[-nr])with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     watcher$capture_plot_and_output()    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()))
50: 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)
    if (on_warning$capture) {        cnd <- sanitize_call(cnd)        watcher$push(cnd)    }    if (on_warning$silence) {36:     }), list(rlang_trace_top_env = knit_global())), function(loc) {doWithOneRestart(return(expr), restart)        invokeRestart("muffleWarning")    }
37: 58:     setwd(wd)    write_utf8(res, output %n% stdout())56:     paste0("\nQuitting from ", loc, if (!is.null(error)) tryCatchList(expr, classes, parentenv, handlers)doTryCatch(return(expr), name, parentenv, handler)
57: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
59: tryCatch({tryCatchOne(expr, names, parentenv, handlers[[1L]])        paste0("\n", rule(), error, "\n", rule()))}, error = function (cnd) 

38: withRestartList(expr, restarts)58:     engine$weave(file, quiet = quiet, encoding = enc){    watcher$capture_plot_and_output()    cnd <- sanitize_call(cnd)
    watcher$push(cnd)    switch(on_error, continue = invokeRestart("eval_continue"),         stop = invokeRestart("eval_stop"), error = NULL)})
30: eval(call)
}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)
51: process_file(text, output)
39: 31: eval(call)
32: with_handlers({    for (expr in tle$exprs) {tryCatchList(expr, classes, parentenv, handlers)        ev <- withVisible(eval(expr, envir))
    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)        watcher$capture_plot_and_output()59:         output <- find_vignette_product(name, by = "texi2pdf",             engine = engine)    }}, error = function(e) {    OK <<- FALSEwithRestarts(with_handlers({tryCatch({    engine$weave(file, quiet = quiet, encoding = enc)        watcher$print_value(ev$value, ev$visible, envir)    setwd(startdir)    }    for (expr in tle$exprs) {    TRUE}, handlers)
        ev <- withVisible(eval(expr, envir))33:         watcher$capture_plot_and_output()    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         watcher$print_value(ev$value, ev$visible, envir)    }    output <- find_vignette_product(name, by = "weave", engine = engine)    TRUE}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)
    if (!have.makefile && vignette_is_tex(output)) {doWithOneRestart(return(expr), restart)40:         file, conditionMessage(e)))evaluate::evaluate(...)
})        texi2pdf(file = output, clean = FALSE, quiet = quiet)52: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
53: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),         output <- find_vignette_product(name, by = "texi2pdf", 34: withOneRestart(expr, restarts[[1L]])
35: withRestartList(expr, restarts[-nr])
36: 
    output_dir = getwd(), ...)
41: 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, 60:             engine = engine)    stop_on_error = if (is.numeric(options$error)) options$error else {
54: vweave_rmarkdown(...)
55:         if (options$error && options$include) doWithOneRestart(return(expr), restart)
engine$weave(file, quiet = quiet, encoding = enc)            0L37: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
38: 
56: tools:::.buildOneVignette("mnl_models_weighted.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr", withRestartList(expr, restarts)    }doTryCatch(return(expr), name, parentenv, handler)    TRUE, FALSE, "mnl_models_weighted", "UTF-8", "/Volumes/Temp/tmp/RtmpS24rW8/file169732ee090b9.rds")
An irrecoverable exception occurred. R is aborting now ...

39: 
withRestarts(with_handlers({57:     for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)
40: evaluate::evaluate(...)
41: 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,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options))
42: tryCatchOne(expr, names, parentenv, handlers[[1L]])}, error = function(e) {in_dir(input_dir(), expr)    OK <<- FALSE        else 2L
    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s", 43:         file, conditionMessage(e)))    }, output_handler = knit_handlers(options$render, options))
})
58: tryCatchList(expr, classes, parentenv, handlers)
in_input_dir(evaluate(code, envir = env, new_device = FALSE, 42: 
60: in_dir(input_dir(), expr)59: 
43:     keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, in_input_dir(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,     stop_on_error = if (is.numeric(options$error)) options$error else {    keep_message = if (is.numeric(options$message)) TRUE else options$message,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include) tryCatch({tools:::.buildOneVignette("mnl_models_weighted.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr",         if (options$error && options$include)     engine$weave(file, quiet = quiet, encoding = enc)            0L        else 2L    }, output_handler = knit_handlers(options$render, options)))    setwd(startdir)
44: eng_r(options)    output <- find_vignette_product(name, by = "weave", engine = engine)    if (!have.makefile && vignette_is_tex(output)) {    TRUE, FALSE, "mnl_models_weighted", "UTF-8", "/Volumes/Temp/tmp/RtmpS24rW8/file169732ee090b9.rds")
        texi2pdf(file = output, clean = FALSE, quiet = quiet)
        output <- find_vignette_product(name, by = "texi2pdf", An irrecoverable exception occurred. R is aborting now ...
            0L            engine = engine)    }}, error = function(e) {    OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})
60: tools:::.buildOneVignette("mnl_models_weighted.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr",     TRUE, FALSE, "mnl_models_weighted", "UTF-8", "/Volumes/Temp/tmp/RtmpS24rW8/file169732ee090b9.rds")
An irrecoverable exception occurred. R is aborting now ...
        else 2L45: block_exec(params)
    }, output_handler = knit_handlers(options$render, options)))46: call_block(x)
47: process_group(group)
48: withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), 
44: eng_r(options)
45: block_exec(params)
46: call_block(x)
47: process_group(group)
48: 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)    })
49: 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()))
50: 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()))    error = function(e) {        if (progress && is.function(pb$interrupt))             pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)    })}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)
51: 
49: 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()))
process_file(text, output)
52: 50: 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())knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
53: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     paste0("\nQuitting from ", loc, if (!is.null(error))         paste0("\n", rule(), error, "\n", rule()))}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)
51: process_file(text, output)
52:     output_dir = getwd(), ...)
54: vweave_rmarkdown(...)
55: engine$weave(file, quiet = quiet, encoding = enc)knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
53: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
54: vweave_rmarkdown(...)
55: engine$weave(file, quiet = quiet, encoding = enc)
56: doTryCatch(return(expr), name, parentenv, handler)
57: 
56: doTryCatch(return(expr), name, parentenv, handler)
57: tryCatchOne(expr, names, parentenv, handlers[[1L]])
58: tryCatchList(expr, classes, parentenv, handlers)tryCatchOne(expr, names, parentenv, handlers[[1L]])
58: tryCatchList(expr, classes, parentenv, handlers)

59: 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)) {59: 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)    }}, error = function(e) {        texi2pdf(file = output, clean = FALSE, quiet = quiet)        output <- find_vignette_product(name, by = "texi2pdf",             engine = engine)    }}, error = function(e) {    OK <<- FALSE    OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})
60: tools:::.buildOneVignette("mnl_models_weighted.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr",     TRUE, FALSE, "mnl_models_weighted", "UTF-8", "/Volumes/Temp/tmp/RtmpS24rW8/file169732ee090b9.rds")
    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})
60: An irrecoverable exception occurred. R is aborting now ...
tools:::.buildOneVignette("mnl_models_weighted.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr",     TRUE, FALSE, "mnl_models_weighted", "UTF-8", "/Volumes/Temp/tmp/RtmpS24rW8/file169732ee090b9.rds")
An irrecoverable exception occurred. R is aborting now ...

Quitting from mnl_models_weighted.Rmd:64-80 [unnamed-chunk-3]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
<error/rlang_error>
Error in `names(x) <- value`:
! 'names' attribute [3] must be the same length as the vector [0]
---
Backtrace:
    ▆
 1. └─logitr::logitr(...)
 2.   └─logitr:::getMultistartSummary(allModels)
 3.     └─base::`colnames<-`(...)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Error: processing vignette 'mnl_models_weighted.Rmd' failed with diagnostics:
'names' attribute [3] must be the same length as the vector [0]
--- failed re-building ‘mnl_models_weighted.Rmd’

--- re-building ‘mxl_models.Rmd’ using rmarkdown
--- finished re-building ‘mxl_models.Rmd’

--- re-building ‘predict.Rmd’ using rmarkdown

 *** caught segfault ***
address 0x110, cause 'invalid permissions'

 *** caught segfault ***
address 0x110, cause 'invalid permissions'

 *** caught segfault ***
address 0x110, cause 'invalid permissions'

Traceback:
 1: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)
 *** caught segfault ***

 *** caught segfault ***

 *** caught segfault ***
address 0x110, cause 'invalid permissions'
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'

 2: eval_f(x0, ...)
 3: nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     mi = mi, opts = mi$options)
 4: doTryCatch(return(expr), name, parentenv, handler)
 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
 6: tryCatchList(expr, classes, parentenv, handlers)
 7: tryCatch({    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,         mi = mi, opts = mi$options)}, error = function(e) {})
 8: system.time({    model <- mi$model    result <- NULL    tryCatch({        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, address 0x110, cause 'invalid permissions'
            mi = mi, opts = mi$options)    }, error = function(e) {    })    if (!is.null(result)) {        model$fail <- FALSE
Traceback:
 1: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)
 *** caught segfault ***
address 0x110, cause 'invalid permissions'

 2: eval_f(x0, ...)
 3:         model$coefficients <- result$solution        model$logLik <- as.numeric(-1 * result$objective)        model$iterations <- result$iterations        model$status <- result$status        model$message <- result$message    }})nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     mi = mi, opts = mi$options)
 4: doTryCatch(return(expr), name, parentenv, handler)
 9: FUN(X[[i]], ...)
10: lapply(X = S, FUN = FUN, ...)

 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
 6: tryCatchList(expr, classes, parentenv, handlers)
11: doTryCatch(return(expr), name, parentenv, handler)
12: tryCatchOne(expr, names, parentenv, handlers[[1L]])
13:  7: tryCatch({    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,         mi = mi, opts = mi$options)}, error = function(e) {})
 8: tryCatchList(expr, classes, parentenv, handlers)
14: tryCatch(expr, error = function(e) {    call <- conditionCall(e)    if (!is.null(call)) {        if (identical(call[[1L]], quote(doTryCatch))) system.time({    model <- mi$model    result <- NULL            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")    tryCatch({        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,             mi = mi, opts = mi$options)    }, error = function(e) {    })    if (!is.null(result)) {        model$fail <- FALSE        model$coefficients <- result$solution        model$logLik <- as.numeric(-1 * result$objective)        model$iterations <- result$iterations        model$status <- result$status
Traceback:
        model$message <- result$message        if (is.na(w))     }})
 9: FUN(X[[i]], ...)
10: lapply(X = S, FUN = FUN, ...)
11: doTryCatch(return(expr), name, parentenv, handler) 1: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)
 2: eval_f(x0, ...)
 3:             w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L], 
12: tryCatchOne(expr, names, parentenv, handlers[[1L]])
13: tryCatchList(expr, classes, parentenv, handlers)
nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     mi = mi, opts = mi$options)
 4: doTryCatch(return(expr), name, parentenv, handler)
 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])14: 
 6: tryCatchList(expr, classes, parentenv, handlers)                type = "b")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],         if (w > LONG)             prefix <- paste0(prefix, "\n  ")    }    else prefix <- "Error : "    msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, file = outFile)        .Internal(printDeferredWarnings())    }                type = "b")
Traceback:
 1: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)
Traceback:
 1: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)

 2:  7:         if (w > LONG) eval_f(x0, ...)
Traceback:
    invisible(structure(msg, class = "try-error", condition = e)) 1: 
Traceback:
            prefix <- paste0(prefix, "\n  ")})
mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)    } 1: tryCatch({
15:     result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, 
 2: eval_f(x0, ...)
 3: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)
 2:     else prefix <- "Error : "
eval_f(x0, ...)
 3:     msg <- paste0(prefix, conditionMessage(e), "\n")
Traceback:
nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,  3:     mi = mi, opts = mi$options)
 4: nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, file = outFile)        mi = mi, opts = mi$options)    mi = mi, opts = mi$options)
 4: 16: 
}, error = function(e) {
Traceback:
doTryCatch(return(expr), name, parentenv, handler)    mi = mi, opts = mi$options)
 4: doTryCatch(return(expr), name, parentenv, handler) 2: eval_f(x0, ...)
 3: nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     mi = mi, opts = mi$options)
 4: doTryCatch(return(expr), name, parentenv, handler)
 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
 6: tryCatchList(expr, classes, parentenv, handlers)
 7: tryCatch({    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,         mi = mi, opts = mi$options)}, error = function(e) {})
 8: system.time({    model <- mi$model    result <- NULL        .Internal(printDeferredWarnings())sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))    }    invisible(structure(msg, class = "try-error", condition = e))})
15: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)

17: FUN(X[[i]], ...)
18: lapply(seq_len(cores), inner.do)
19: parallel::mclapply(miList, runModel, mc.cores = numCores)
Traceback:

 1:  5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
 6: tryCatchList(expr, classes, parentenv, handlers)
 7: tryCatch({    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,         mi = mi, opts = mi$options)
doTryCatch(return(expr), name, parentenv, handler)16: })sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
17: FUN(X[[i]], ...)
18: lapply(seq_len(cores), inner.do)
19: parallel::mclapply(miList, runModel, mc.cores = numCores)
20: withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))

    tryCatch({
}, error = function(e) {})
 8: system.time({    model <- mi$model    result <- NULL    tryCatch({        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,             mi = mi, opts = mi$options)    }, error = function(e) {    })    if (!is.null(result)) {        model$fail <- FALSE        model$coefficients <- result$solution        model$logLik <- as.numeric(-1 * result$objective)        model$iterations <- result$iterations        model$status <- result$status        model$message <- result$message    }})        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,  1: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)
 2: eval_f(x0, ...) 8: 20: system.time({    model <- mi$modelwithCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning")) 5: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar) 5: 
 2: eval_f(x0, ...)
 3: nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     mi = mi, opts = mi$options)
 4: doTryCatch(return(expr), name, parentenv, handler)
    result <- NULL
 1: tryCatchOne(expr, names, parentenv, handlers[[1L]])
 9: FUN(X[[i]], ...)
10: lapply(X = S, FUN = FUN, ...)
11: doTryCatch(return(expr), name, parentenv, handler)
12: tryCatchOne(expr, names, parentenv, handlers[[1L]])
13: tryCatchList(expr, classes, parentenv, handlers)            mi = mi, opts = mi$options)    }, error = function(e) {    tryCatch({tryCatchOne(expr, names, parentenv, handlers[[1L]])
    })
 3: nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, 
 6: 
21: suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))
22: withCallingHandlers(expr, message = function(c) if (inherits(c,     classes)) tryInvokeRestart("muffleMessage"))
23: suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))21:     if (!is.null(result)) {        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,  6: tryCatchList(expr, classes, parentenv, handlers)
 5: 
suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))
22: withCallingHandlers(expr, message = function(c) if (inherits(c,     classes)) tryInvokeRestart("muffleMessage"))
mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)
 7: tryCatch({    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, 
        mi = mi, opts = mi$options)        model$fail <- FALSEtryCatchList(expr, classes, parentenv, handlers)23:  2: suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))
24: runMultistart(modelInputs)
25: logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat",     "brand"), scalePar = "price", numMultiStarts = 10)
14:         model$coefficients <- result$solution    mi = mi, opts = mi$options)
 4: doTryCatch(return(expr), name, parentenv, handler)
 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
 6: tryCatchList(expr, classes, parentenv, handlers)
 7: tryCatch({    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,         mi = mi, opts = mi$options)}, error = function(e) {})
 8: system.time({    model <- mi$model    result <- NULL    tryCatch({        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,             mi = mi, opts = mi$options)    }, error = function(e) {    })    if (!is.null(result)) {        model$fail <- FALSE        model$coefficients <- result$solution        model$logLik <- as.numeric(-1 * result$objective)        model$iterations <- result$iterations        model$status <- result$status        model$message <- result$message    }})
 9: FUN(X[[i]], ...)
10: lapply(X = S, FUN = FUN, ...)
11: doTryCatch(return(expr), name, parentenv, handler)
12: 24: tryCatch(expr, error = function(e) {        model$logLik <- as.numeric(-1 * result$objective)26:         model$iterations <- result$iterations        model$status <- result$status        model$message <- result$message    }})
 9: FUN(X[[i]], ...)
10: lapply(X = S, FUN = FUN, ...)eval_f(x0, ...)
    call <- conditionCall(e) 7: tryCatch({    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,         mi = mi, opts = mi$options)}, error = function(e) {})
 8: system.time({    model <- mi$model    result <- NULLeval(expr, envir)}, error = function(e) {tryCatchOne(expr, names, parentenv, handlers[[1L]])
13: tryCatchList(expr, classes, parentenv, handlers)
runMultistart(modelInputs)
tryCatchOne(expr, names, parentenv, handlers[[1L]])            mi = mi, opts = mi$options)})
 8: system.time({    model <- mi$model    result <- NULL    tryCatch({        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,             mi = mi, opts = mi$options)    }, error = function(e) {    })    if (!is.null(result)) {        model$fail <- FALSE        model$coefficients <- result$solution        model$logLik <- as.numeric(-1 * result$objective)        model$iterations <- result$iterations        model$status <- result$status        model$message <- result$message    }})
 9: FUN(X[[i]], ...)
10: lapply(X = S, FUN = FUN, ...)
11: doTryCatch(return(expr), name, parentenv, handler)
12: tryCatchOne(expr, names, parentenv, handlers[[1L]])
13: tryCatchList(expr, classes, parentenv, handlers)


14:     tryCatch({tryCatch(expr, error = function(e) {    call <- conditionCall(e)    if (!is.null(call)) {        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,             mi = mi, opts = mi$options)    }, error = function(e) {    })    if (!is.null(result)) {        model$fail <- FALSE    if (!is.null(call)) {    }, error = function(e) {27:         model$coefficients <- result$solution        model$logLik <- as.numeric(-1 * result$objective)    })14: 25: 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)             prefix <- paste0(prefix, "\n  ")    }    else prefix <- "Error : "    msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, file = outFile)        .Internal(printDeferredWarnings())    }    invisible(structure(msg, class = "try-error", condition = e))})
15: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
16: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
17: FUN(X[[i]], ...)
18: lapply(seq_len(cores), inner.do)
        if (identical(call[[1L]], quote(doTryCatch))) 
    if (!is.null(result)) {logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat",         if (identical(call[[1L]], quote(doTryCatch))) 11:             call <- sys.call(-4L)        model$iterations <- result$iterations        model$fail <- FALSEeval(expr, envir)    "brand"), scalePar = "price", numMultiStarts = 10)
28: withVisible(eval(expr, envir))
29: withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) {    watcher$capture_plot_and_output()    if (on_message$capture) {        watcher$push(cnd)    }    if (on_message$silence) {        invokeRestart("muffleMessage")19:  6:         model$coefficients <- result$solutiontryCatchList(expr, classes, parentenv, handlers)
 7: tryCatch({    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,         mi = mi, opts = mi$options)}, error = function(e) {})
 8: system.time({    model <- mi$model    result <- NULL
doTryCatch(return(expr), name, parentenv, handler)parallel::mclapply(miList, runModel, mc.cores = numCores)
12: tryCatchOne(expr, names, parentenv, handlers[[1L]])
13: tryCatchList(expr, classes, parentenv, handlers)
14: tryCatch(expr, error = function(e) {    call <- conditionCall(e)    if (!is.null(call)) {        model$logLik <- as.numeric(-1 * result$objective)
26:  3: nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     mi = mi, opts = mi$options)
 4: doTryCatch(return(expr), name, parentenv, handler)
 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
        dcall <- deparse(call, nlines = 1L)    }}, warning = function (cnd) {    if (getOption("warn") >= 2 || getOption("warn") < 0) {eval(expr, envir)    tryCatch({        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,             mi = mi, opts = mi$options)    }, error = function(e) {    })    if (!is.null(result)) {        model$fail <- FALSE        model$coefficients <- result$solution
27: eval(expr, envir)
28: withVisible(eval(expr, envir))
29: withCallingHandlers(code, error = function (e)             call <- sys.call(-4L)20:         return()        if (identical(call[[1L]], quote(doTryCatch)))     }    watcher$capture_plot_and_output()    if (on_warning$capture) {        cnd <- sanitize_call(cnd)        watcher$push(cnd)    }        model$iterations <- result$iterations        dcall <- deparse(call, nlines = 1L)        model$logLik <- as.numeric(-1 * result$objective)        model$iterations <- result$iterations        model$status <- result$status        model$message <- result$message    }})
 9: FUN(X[[i]], ...)
10: lapply(X = S, FUN = FUN, ...)
11: doTryCatch(return(expr), name, parentenv, handler)            call <- sys.call(-4L)        model$status <- result$status
rlang::entrace(e), message = function (cnd)         model$status <- result$status
        model$message <- result$message    }})
 9: FUN(X[[i]], ...)
10: lapply(X = S, FUN = FUN, ...)
11: doTryCatch(return(expr), name, parentenv, handler)
        prefix <- paste("Error in", dcall, ": ")    if (on_warning$silence) {        prefix <- paste("Error in", dcall, ": ")        LONG <- 75L{    watcher$capture_plot_and_output()    if (on_message$capture) {        watcher$push(cnd)    }    if (on_message$silence) {        invokeRestart("muffleMessage")12:  6: withCallingHandlers(expr, warning = function(w) if (inherits(w,         model$message <- result$message    }})
 9: FUN(X[[i]], ...)
10: lapply(X = S, FUN = FUN, ...)
11: doTryCatch(return(expr), name, parentenv, handler)
12: tryCatchOne(expr, names, parentenv, handlers[[1L]])
13: tryCatchList(expr, classes, parentenv, handlers)
14: tryCatch(expr, error = function(e) {    call <- conditionCall(e)    if (!is.null(call)) {        sm <- strsplit(conditionMessage(e), "\n")[[1L]]12: tryCatchOne(expr, names, parentenv, handlers[[1L]])
13: tryCatchList(expr, classes, parentenv, handlers)    classes)) tryInvokeRestart("muffleWarning"))tryCatchList(expr, classes, parentenv, handlers)        if (identical(call[[1L]], quote(doTryCatch))) 
 7: tryCatch({    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,         mi = mi, opts = mi$options)}, error = function(e) {})
 8: system.time({    model <- mi$model        w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")    }
            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)             prefix <- paste0(prefix, "\n  ")    }    else prefix <- "Error : "    msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, file = outFile)        .Internal(printDeferredWarnings())    }    invisible(structure(msg, class = "try-error", condition = e))})
        invokeRestart("muffleWarning")    }}, error = function (cnd) {    watcher$capture_plot_and_output()    cnd <- sanitize_call(cnd)    watcher$push(cnd)    switch(on_error, continue = invokeRestart("eval_continue"),         stop = invokeRestart("eval_stop"), error = NULL)})}, warning = function (cnd)         dcall <- deparse(call, nlines = 1L)
14: 21: suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))
22: withCallingHandlers(expr, message = function(c) if (inherits(c,     classes)) tryInvokeRestart("muffleMessage"))
23: suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))
24: runMultistart(modelInputs)
25: logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat",     "brand"), scalePar = "price", numMultiStarts = 10)
26: eval(expr, envir)
27: eval(expr, envir)
28: withVisible(eval(expr, envir))
29: withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) {    watcher$capture_plot_and_output()    if (on_message$capture) {        watcher$push(cnd)    }    if (on_message$silence) {        invokeRestart("muffleMessage")    }}, warning = function (cnd) {    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    }    watcher$capture_plot_and_output()    if (on_warning$capture) {        cnd <- sanitize_call(cnd)        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)             prefix <- paste0(prefix, "\n  ")    }    else prefix <- "Error : "    msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, file = outFile)        .Internal(printDeferredWarnings())    }    invisible(structure(msg, class = "try-error", condition = e))    result <- NULL        if (is.na(w)) tryCatchOne(expr, names, parentenv, handlers[[1L]])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) 
        prefix <- paste("Error in", dcall, ": ")            w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L], })        watcher$push(cnd)    }    if (on_warning$silence) {        invokeRestart("muffleWarning")    }}, error = function (cnd) {    watcher$capture_plot_and_output()    cnd <- sanitize_call(cnd)    watcher$push(cnd)    switch(on_error, continue = invokeRestart("eval_continue"),         stop = invokeRestart("eval_stop"), error = NULL)})
30: eval(call)
31: eval(call)
32: with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers)

        LONG <- 75L15: 13: {    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()30: 15: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)        sm <- strsplit(conditionMessage(e), "\n")[[1L]]tryCatchList(expr, classes, parentenv, handlers)
    tryCatch({        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)             prefix <- paste0(prefix, "\n  ")    }        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,             mi = mi, opts = mi$options)try(lapply(X = S, FUN = FUN, ...), silent = TRUE)                type = "b")
        if (w > LONG)             prefix <- paste0(prefix, "\n  ")    }    else prefix <- "Error : "    msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, file = outFile)        .Internal(printDeferredWarnings())    }    invisible(structure(msg, class = "try-error", condition = e))})
15: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
16: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))16:     }, error = function(e) {    })    if (!is.null(result)) {        model$fail <- FALSE        model$coefficients <- result$solution        model$logLik <- as.numeric(-1 * result$objective)        model$iterations <- result$iterations        model$status <- result$status        model$message <- result$message14:     else prefix <- "Error : "            prefix <- paste0(prefix, "\n  ")    msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, file = outFile)        .Internal(printDeferredWarnings())    }    invisible(structure(msg, class = "try-error", condition = e))})    }    }sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))

15: 
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, ": ")33: eval(call)    else prefix <- "Error : "
31: eval(call)
32: with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers)
33: doWithOneRestart(return(expr), restart)
34: withOneRestart(expr, restarts[[1L]])
35: withRestartList(expr, restarts[-nr])
36: doWithOneRestart(return(expr), restart)
37: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
38: withRestartList(expr, restarts)
39: withRestarts(with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)
40: evaluate::evaluate(...)
41: 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,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options))
42: in_dir(input_dir(), expr)
43: in_input_dir(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,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options)))    msg <- paste0(prefix, conditionMessage(e), "\n")16: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
17: FUN(X[[i]], ...)try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
doWithOneRestart(return(expr), restart)    .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, file = outFile)        .Internal(printDeferredWarnings())    }    invisible(structure(msg, class = "try-error", condition = e))})
15: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
16: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
17: FUN(X[[i]], ...)
18: lapply(seq_len(cores), inner.do)
19: parallel::mclapply(miList, runModel, mc.cores = numCores)
20: withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))
21: suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))

 9: FUN(X[[i]], ...)
10: lapply(X = S, FUN = FUN, ...)
11: doTryCatch(return(expr), name, parentenv, handler)
12: tryCatchOne(expr, names, parentenv, handlers[[1L]])
13: tryCatchList(expr, classes, parentenv, handlers)
14: tryCatch(expr, error = function(e) {    call <- conditionCall(e)    if (!is.null(call)) {        if (identical(call[[1L]], quote(doTryCatch))) 

17: 17: FUN(X[[i]], ...)
18: lapply(seq_len(cores), inner.do)
19: 
        LONG <- 75L18:             call <- sys.call(-4L)        dcall <- deparse(call, nlines = 1L)FUN(X[[i]], ...)parallel::mclapply(miList, runModel, mc.cores = numCores)
20: withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))
21: suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))
22: withCallingHandlers(expr, message = function(c) if (inherits(c,     classes)) tryInvokeRestart("muffleMessage"))
23: suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))

22: 
34: lapply(seq_len(cores), inner.do)withOneRestart(expr, restarts[[1L]])18:     }lapply(seq_len(cores), inner.do)
19: parallel::mclapply(miList, runModel, mc.cores = numCores)16: 
20: withCallingHandlers(expr, warning = function(w) if (inherits(w, 44:         prefix <- paste("Error in", dcall, ": ")        sm <- strsplit(conditionMessage(e), "\n")[[1L]]
sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))        LONG <- 75L24: 
    watcher$capture_plot_and_output()17: FUN(X[[i]], ...)
18: lapply(seq_len(cores), inner.do)
19: parallel::mclapply(miList, runModel, mc.cores = numCores)
20: withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))
21: suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))
22: withCallingHandlers(expr, message = function(c) if (inherits(c,     classes)) tryInvokeRestart("muffleMessage"))
eng_r(options)        sm <- strsplit(conditionMessage(e), "\n")[[1L]]runMultistart(modelInputs)withCallingHandlers(expr, message = function(c) if (inherits(c,     classes)) tryInvokeRestart("muffleMessage"))
23: suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))
24: runMultistart(modelInputs)
25: logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat",     "brand"), scalePar = "price", numMultiStarts = 10)
26: eval(expr, envir)
27: eval(expr, envir)
        w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")
19: parallel::mclapply(miList, runModel, mc.cores = numCores)
20: withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))
21: suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))        if (is.na(w)) 35: 28: 

25: logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat", 
withVisible(eval(expr, envir))    classes)) tryInvokeRestart("muffleWarning"))
29: withCallingHandlers(code, error = function (e) 
21: suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))
22: withCallingHandlers(expr, message = function(c) if (inherits(c,     classes)) tryInvokeRestart("muffleMessage"))
23: suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))
24: runMultistart(modelInputs)
45:         w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")23: suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))
24: runMultistart(modelInputs)
25: logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat",     "brand"), scalePar = "price", numMultiStarts = 10)
26: eval(expr, envir)
27: eval(expr, envir)
28: withVisible(eval(expr, envir))
29: withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) {    watcher$capture_plot_and_output()    if (on_message$capture) {        watcher$push(cnd)    }    if (on_message$silence) {        invokeRestart("muffleMessage")    }}, warning = function (cnd) {    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()block_exec(params)22: rlang::entrace(e), message = function (cnd)         if (is.na(w)) {    watcher$capture_plot_and_output()    if (on_message$capture) {        watcher$push(cnd)    }    if (on_message$silence) {        invokeRestart("muffleMessage")
            w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L],                 type = "b")        if (w > LONG)             prefix <- paste0(prefix, "\n  ")    }    else prefix <- "Error : "    msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, file = outFile)        .Internal(printDeferredWarnings())    }    invisible(structure(msg, class = "try-error", condition = e))25:     if (on_warning$capture) {    }}, warning = function (cnd) {            w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L], })
logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat",     "brand"), scalePar = "price", numMultiStarts = 10)withCallingHandlers(expr, message = function(c) if (inherits(c,     if (getOption("warn") >= 2 || getOption("warn") < 0) {46:     "brand"), scalePar = "price", numMultiStarts = 10)        cnd <- sanitize_call(cnd)                type = "b")        if (w > LONG)             prefix <- paste0(prefix, "\n  ")    }    else prefix <- "Error : "    msg <- paste0(prefix, conditionMessage(e), "\n")        watcher$push(cnd)withRestartList(expr, restarts[-nr])        return()
36: doWithOneRestart(return(expr), restart)
    }
    }
26: eval(expr, envir)
27: eval(expr, envir)
28: withVisible(eval(expr, envir))
29: withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) {    watcher$capture_plot_and_output()    if (on_message$capture) {        watcher$push(cnd)    }    if (on_message$silence) {        invokeRestart("muffleMessage")    }}, warning = function (cnd) {    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    }    watcher$capture_plot_and_output()    if (on_warning$capture) {        cnd <- sanitize_call(cnd)    classes)) tryInvokeRestart("muffleMessage"))37: 15: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])        watcher$push(cnd)    }
    .Internal(seterrmessage(msg[1L]))26: call_block(x)
47:     if (on_warning$silence) {        invokeRestart("muffleWarning")    }}, error = function (cnd)     watcher$capture_plot_and_output()    watcher$capture_plot_and_output()38: withRestartList(expr, restarts)
    }{    if (!silent && isTRUE(getOption("show.error.messages"))) {    if (on_warning$silence) {        invokeRestart("muffleWarning")    }try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
eval(expr, envir)    watcher$capture_plot_and_output()
27: eval(expr, envir)
28: withVisible(eval(expr, envir))
29: withCallingHandlers(code, error = function (e)         cat(msg, file = outFile)    if (on_warning$capture) {    if (on_warning$capture) {23:         cnd <- sanitize_call(cnd)        watcher$push(cnd)    }    if (on_warning$silence) {        invokeRestart("muffleWarning")    }}, error = function (cnd) {    watcher$capture_plot_and_output()    cnd <- sanitize_call(cnd)    watcher$push(cnd)    switch(on_error, continue = invokeRestart("eval_continue"),         stop = invokeRestart("eval_stop"), error = NULL)})
process_group(group)suppressMessages(suppressWarnings(parallel::mclapply(miList,         .Internal(printDeferredWarnings())rlang::entrace(e), message = function (cnd)     }    invisible(structure(msg, class = "try-error", condition = e))})
15: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
16: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
17: FUN(X[[i]], ...)
18: lapply(seq_len(cores), inner.do)
19: parallel::mclapply(miList, runModel, mc.cores = numCores)
20: withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))
}, error = function (cnd)     cnd <- sanitize_call(cnd)
30: 21: eval(call)39:     runModel, mc.cores = numCores)))suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))
{    watcher$capture_plot_and_output()withRestarts(with_handlers({        cnd <- sanitize_call(cnd)
        watcher$push(cnd)    }    if (on_warning$silence) {        invokeRestart("muffleWarning")    }}, error = function (cnd) {31: {    for (expr in tle$exprs) {    watcher$capture_plot_and_output()    if (on_message$capture) {        watcher$push(cnd)    }    if (on_message$silence) {        invokeRestart("muffleMessage")    }}, warning = function (cnd) {    if (getOption("warn") >= 2 || getOption("warn") < 0) {    watcher$push(cnd)    cnd <- sanitize_call(cnd)
    watcher$push(cnd)    switch(on_error, continue = invokeRestart("eval_continue"),         stop = invokeRestart("eval_stop"), error = NULL)})
30: eval(call)
31: eval(call)
eval(call)16: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
17: FUN(X[[i]], ...)
18: lapply(seq_len(cores), inner.do)
19: parallel::mclapply(miList, runModel, mc.cores = numCores)
20: withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))
21: suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))
22: withCallingHandlers(expr, message = function(c) if (inherits(c,     classes)) tryInvokeRestart("muffleMessage"))
23: suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))
24: runMultistart(modelInputs)    watcher$capture_plot_and_output()    cnd <- sanitize_call(cnd)    watcher$push(cnd)
        ev <- withVisible(eval(expr, envir))22: withCallingHandlers(expr, message = function(c) if (inherits(c,     classes)) tryInvokeRestart("muffleMessage"))
23: suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))
24: runMultistart(modelInputs)
25: logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat",     "brand"), scalePar = "price", numMultiStarts = 10)
26: eval(expr, envir)
27: eval(expr, envir)
28: withVisible(eval(expr, envir))
29: withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) {    watcher$capture_plot_and_output()    if (on_message$capture) {24: 32: with_handlers({    switch(on_error, continue = invokeRestart("eval_continue"), 48: 
runMultistart(modelInputs)
25: logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat",     "brand"), scalePar = "price", numMultiStarts = 10)
26: eval(expr, envir)
27: eval(expr, envir)
28: withVisible(eval(expr, envir))
29: withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) {    watcher$capture_plot_and_output()    if (on_message$capture) {        watcher$push(cnd)    }    if (on_message$silence) {        invokeRestart("muffleMessage")    }}, warning = function (cnd)         stop = invokeRestart("eval_stop"), error = NULL)        return()
    switch(on_error, continue = invokeRestart("eval_continue"), {    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    }    watcher$capture_plot_and_output()    if (on_warning$capture) {        cnd <- sanitize_call(cnd)        watcher$push(cnd)    }    if (on_warning$silence) {        watcher$capture_plot_and_output()})
30: eval(call)
31: eval(call)
32: with_handlers({    for (expr in tle$exprs) {        watcher$push(cnd)        stop = invokeRestart("eval_stop"), error = NULL)    }    if (on_message$silence) {        invokeRestart("muffleMessage")    }}, warning = function (cnd) {    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()})
30: eval(call)
31: eval(call)
32:         watcher$print_value(ev$value, ev$visible, envir)withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),         invokeRestart("muffleWarning")    }32: with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers)
33: doWithOneRestart(return(expr), restart)
34: withOneRestart(expr, restarts[[1L]])
35: withRestartList(expr, restarts[-nr])
36: with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))    error = function(e) {        ev <- withVisible(eval(expr, envir))    for (expr in tle$exprs) {    }    watcher$capture_plot_and_output()    if (on_warning$capture) {        cnd <- sanitize_call(cnd)        watcher$push(cnd)    }    if (on_warning$silence) {        invokeRestart("muffleWarning")    }}, error = function (cnd) {    watcher$capture_plot_and_output()    cnd <- sanitize_call(cnd)    watcher$push(cnd)    switch(on_error, continue = invokeRestart("eval_continue"),         stop = invokeRestart("eval_stop"), error = NULL)})
30: eval(call)
31: eval(call)
32: with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers)
33: doWithOneRestart(return(expr), restart)
34: withOneRestart(expr, restarts[[1L]])
35: withRestartList(expr, restarts[-nr])
36: doWithOneRestart(return(expr), restart)
37:     }        watcher$capture_plot_and_output()        ev <- withVisible(eval(expr, envir))25:         watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers)
33: doWithOneRestart(return(expr), restart)        watcher$capture_plot_and_output()
37: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
38: withRestartList(expr, restarts)
39: withRestarts(with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers)
33: doWithOneRestart(return(expr), restart)
34: withOneRestart(expr, restarts[[1L]])
35: withRestartList(expr, restarts[-nr])
    watcher$capture_plot_and_output()    }    if (on_warning$capture) {        cnd <- sanitize_call(cnd)        watcher$push(cnd)    }    if (on_warning$silence) {        invokeRestart("muffleWarning")    }}, error = function (cnd) {    watcher$capture_plot_and_output()    cnd <- sanitize_call(cnd)    watcher$push(cnd)    switch(on_error, continue = invokeRestart("eval_continue"),         watcher$print_value(ev$value, ev$visible, envir)}, error = function (cnd) {    watcher$capture_plot_and_output()    cnd <- sanitize_call(cnd)    watcher$push(cnd)    switch(on_error, continue = invokeRestart("eval_continue"),         stop = invokeRestart("eval_stop"), error = NULL)})
30: eval(call)doWithOneRestart(return(expr), restart)36:         stop = invokeRestart("eval_stop"), error = NULL)    TRUE    }logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat",         watcher$print_value(ev$value, ev$visible, envir)doWithOneRestart(return(expr), restart)    }
    TRUE    "brand"), scalePar = "price", numMultiStarts = 10)}, handlers)
})        if (progress && is.function(pb$interrupt)) 
withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)
38: withRestartList(expr, restarts)
39: withRestarts(with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)
40: evaluate::evaluate(...)
41: evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, 
40: 31: 
eval(call)
32: with_handlers({    for (expr in tle$exprs) {37:             pb$interrupt()    TRUE        if (is_R_CMD_build() || is_R_CMD_check()) evaluate::evaluate(...)
41: 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,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        ev <- withVisible(eval(expr, envir))            error <<- format(e)
        else 2L    })        watcher$capture_plot_and_output()withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])34: 33: withOneRestart(expr, restarts[[1L]])
35: withRestartList(expr, restarts[-nr])
36: doWithOneRestart(return(expr), restart)
}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)30:     keep_message = if (is.numeric(options$message)) TRUE else options$message, 
    stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options))
42: in_dir(input_dir(), expr)
43: in_input_dir(evaluate(code, envir = env, new_device = FALSE, doWithOneRestart(return(expr), restart)    }, output_handler = knit_handlers(options$render, options))eval(call)
42: in_dir(input_dir(), expr)
43: in_input_dir(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,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options)))
44: eng_r(options)        watcher$print_value(ev$value, ev$visible, envir)38: 37: withRestartList(expr, restarts)


    }

34: withOneRestart(expr, restarts[[1L]])
35: withRestartList(expr, restarts[-nr])    TRUE45: block_exec(params)
46: call_block(x)
47: process_group(group)
48: 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)    })
withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])40: }, handlers)
33: doWithOneRestart(return(expr), restart)
    keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, 
31: 49: evaluate::evaluate(...)34: with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     keep_message = if (is.numeric(options$message)) TRUE else options$message, 
39: eval(call)withRestarts(with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)
    error = function(e) {49: 38: 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()) 

40:         if (progress && is.function(pb$interrupt)) evaluate::evaluate(...)
41: 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,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2LwithRestartList(expr, restarts)    stop_on_error = if (is.numeric(options$error)) options$error else {32: withOneRestart(expr, restarts[[1L]])
35: withRestartList(expr, restarts[-nr])
36: doWithOneRestart(return(expr), restart)
37: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
38: withRestartList(expr, restarts)
39: withRestarts(with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)
40: evaluate::evaluate(...)
41: 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,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options))
42: in_dir(input_dir(), expr)
43: in_input_dir(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,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options)))
44: eng_r(options)            pb$interrupt()26: 
with_handlers({        if (options$error && options$include) 

            error <<- format(e)39:     for (expr in tle$exprs) {        if (is_R_CMD_build() || is_R_CMD_check()) 
45: block_exec(params)
46: call_block(x)
47: process_group(group)
48: 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)    })
49: 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()))
50: 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())eval(expr, envir)
27: withRestarts(with_handlers({36:         ev <- withVisible(eval(expr, envir))41: eval(expr, envir)evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning,             0L    }, output_handler = knit_handlers(options$render, options))    paste0("\nQuitting from ", loc, if (!is.null(error)) 
42: in_dir(input_dir(), expr)
43: in_input_dir(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,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L
        watcher$capture_plot_and_output()    keep_message = if (is.numeric(options$message)) TRUE else options$message,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options))
42: in_dir(input_dir(), expr)
43: in_input_dir(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,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options)))
44: eng_r(options)
45: block_exec(params)
46: call_block(x)
47: process_group(group)
48: 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)    })
49: 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()))
50: 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)28: withVisible(eval(expr, envir))
29: withCallingHandlers(code, error = function (e)             error <<- format(e)    }), list(rlang_trace_top_env = knit_global()))doWithOneRestart(return(expr), restart)        else 2Lrlang::entrace(e), message = function (cnd)         paste0("\n", rule(), error, "\n", rule()))    }), list(rlang_trace_top_env = knit_global()))}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)

50: 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)
51: process_file(text, output)
52: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
{51: process_file(text, output)
    }, output_handler = knit_handlers(options$render, options)))51: process_file(text, output)
    for (expr in tle$exprs) {
52: 52:         watcher$print_value(ev$value, ev$visible, envir)44: eng_r(options)
45: block_exec(params)
46: call_block(x)
47: process_group(group)
48: 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)    })
49: 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()))
50: 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)knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
53: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
54: vweave_rmarkdown(...)
55: engine$weave(file, quiet = quiet, encoding = enc)
56: doTryCatch(return(expr), name, parentenv, handler)
57: tryCatchOne(expr, names, parentenv, handlers[[1L]])
58: tryCatchList(expr, classes, parentenv, handlers)
59: tryCatch({    engine$weave(file, quiet = quiet, encoding = enc)    watcher$capture_plot_and_output()        else 2L        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)
40: evaluate::evaluate(...)
41: evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, 
50: xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     keep_message = if (is.numeric(options$message)) TRUE else options$message,     if (on_message$capture) {

53: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
54: vweave_rmarkdown(...)
55: engine$weave(file, quiet = quiet, encoding = enc)
56: doTryCatch(return(expr), name, parentenv, handler)    }
    stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options))
42: in_dir(input_dir(), expr)
43: in_input_dir(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,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options)))
44: eng_r(options)
45: block_exec(params)
46: call_block(x)
47: process_group(group)
48: withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     error = function(e) {
57:         if (progress && is.function(pb$interrupt))     setwd(startdir)            pb$interrupt()tryCatchOne(expr, names, parentenv, handlers[[1L]])        if (is_R_CMD_build() || is_R_CMD_check())     output <- find_vignette_product(name, by = "weave", engine = engine)    TRUE
37: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
38: withRestartList(expr, restarts)
39: withRestarts(with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)
40: evaluate::evaluate(...)
41: 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,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options))
42: in_dir(input_dir(), expr)
43: in_input_dir(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,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options)))
44: eng_r(options)
45: block_exec(params)
46: call_block(x)
47: process_group(group)
48: withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     if (!have.makefile && vignette_is_tex(output)) {    }, output_handler = knit_handlers(options$render, options)))53: 
    error = function(e) {        if (progress && is.function(pb$interrupt))             pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check())         watcher$push(cnd)    error = function(e) {51: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(), process_file(text, output)
52: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
53: 58: }, handlers)            error <<- format(e)        if (progress && is.function(pb$interrupt))     }    if (on_message$silence) {        invokeRestart("muffleMessage")    }}, warning = function (cnd) {    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    }    watcher$capture_plot_and_output()    if (on_warning$capture) {        cnd <- sanitize_call(cnd)        watcher$push(cnd)tryCatchList(expr, classes, parentenv, handlers)rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(), 
    })44: eng_r(options)
45: block_exec(params)

49: with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     error = function(e) {        if (progress && is.function(pb$interrupt))             pb$interrupt()        texi2pdf(file = output, clean = FALSE, quiet = quiet)    output_dir = getwd(), ...)            pb$interrupt()
    }
    if (on_warning$silence) {        invokeRestart("muffleWarning")    }}, error = function (cnd) {    watcher$capture_plot_and_output()    cnd <- sanitize_call(cnd)    watcher$push(cnd)59: 
        if (is_R_CMD_build() || is_R_CMD_check())         if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)    })
49: 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()))
50: 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)
51: process_file(text, output)
52: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
53: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
54: vweave_rmarkdown(...)
55: engine$weave(file, quiet = quiet, encoding = enc)
56: doTryCatch(return(expr), name, parentenv, handler)
57: tryCatchOne(expr, names, parentenv, handlers[[1L]])
58: tryCatchList(expr, classes, parentenv, handlers)
59: 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)    }}, error = function(e) {    OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})
54:     switch(on_error, continue = invokeRestart("eval_continue"),     output_dir = getwd(), ...)33:             error <<- format(e)doWithOneRestart(return(expr), restart)
34: withOneRestart(expr, restarts[[1L]])
35: withRestartList(expr, restarts[-nr])
46: 60:             error <<- format(e)
call_block(x)
47: process_group(group)
48: 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)    })
49: 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()))
50: 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)
51: process_file(text, output)
52: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
53: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
54: vweave_rmarkdown(...)
55: engine$weave(file, quiet = quiet, encoding = enc)
56: 54: vweave_rmarkdown(...)
55: engine$weave(file, quiet = quiet, encoding = enc)
56: 36: doTryCatch(return(expr), name, parentenv, handler)    }), list(rlang_trace_top_env = knit_global())), function(loc) {doWithOneRestart(return(expr), restart)
37: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
38: vweave_rmarkdown(...)doTryCatch(return(expr), name, parentenv, handler)
57: tryCatchOne(expr, names, parentenv, handlers[[1L]])
58: tryCatchList(expr, classes, parentenv, handlers)
59: tryCatch({tools:::.buildOneVignette("predict.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr",         stop = invokeRestart("eval_stop"), error = NULL)    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)
51: process_file(text, output)
52: tryCatch({    engine$weave(file, quiet = quiet, encoding = enc)    }), list(rlang_trace_top_env = knit_global()))knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
50: 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()

withRestartList(expr, restarts)
55: 30:         output <- find_vignette_product(name, by = "texi2pdf",             engine = engine)    }}, error = function(e) {    OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})
60: tools:::.buildOneVignette("predict.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr",     TRUE, FALSE, "predict", "UTF-8", "/Volumes/Temp/tmp/RtmpS24rW8/file169735483cd7.rds")
An irrecoverable exception occurred. R is aborting now ...
eval(call)
31: eval(call)    setwd(startdir)

        if (is_R_CMD_build() || is_R_CMD_check()) 
    output <- find_vignette_product(name, by = "weave", engine = engine)    engine$weave(file, quiet = quiet, encoding = enc)    TRUE, FALSE, "predict", "UTF-8", "/Volumes/Temp/tmp/RtmpS24rW8/file169735483cd7.rds")    setwd(startdir)    output <- find_vignette_product(name, by = "weave", engine = engine)
An irrecoverable exception occurred. R is aborting now ...
engine$weave(file, quiet = quiet, encoding = enc)
39:     if (!have.makefile && vignette_is_tex(output)) {withRestarts(with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE32:         texi2pdf(file = output, clean = FALSE, quiet = quiet)        output <- find_vignette_product(name, by = "texi2pdf",             engine = engine)    }}, error = function(e) {    OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))53: 56: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
54: vweave_rmarkdown(...)
55: engine$weave(file, quiet = quiet, encoding = enc)
56: doTryCatch(return(expr), name, parentenv, handler)57: with_handlers({})    if (!have.makefile && vignette_is_tex(output)) {
60: tools:::.buildOneVignette("predict.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr",     TRUE, FALSE, "predict", "UTF-8", "/Volumes/Temp/tmp/RtmpS24rW8/file169735483cd7.rds")
An irrecoverable exception occurred. R is aborting now ...

doTryCatch(return(expr), name, parentenv, handler)    for (expr in tle$exprs) {
        texi2pdf(file = output, clean = FALSE, quiet = quiet)            error <<- format(e)57: }, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)        ev <- withVisible(eval(expr, envir))        output <- find_vignette_product(name, by = "texi2pdf",         watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers)
33: doWithOneRestart(return(expr), restart)    }), list(rlang_trace_top_env = knit_global())), function(loc) {tryCatchOne(expr, names, parentenv, handlers[[1L]])
34: withOneRestart(expr, restarts[[1L]])
35: withRestartList(expr, restarts[-nr])
36: doWithOneRestart(return(expr), restart)
37: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
38: withRestartList(expr, restarts)
39: withRestarts(with_handlers({tryCatchOne(expr, names, parentenv, handlers[[1L]])
58: tryCatchList(expr, classes, parentenv, handlers)

40: evaluate::evaluate(...)
57: 58: tryCatchList(expr, classes, parentenv, handlers)
59: 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)    }}, error = function(e) {    OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})
60: tools:::.buildOneVignette("predict.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr",     TRUE, FALSE, "predict", "UTF-8", "/Volumes/Temp/tmp/RtmpS24rW8/file169735483cd7.rds")
59: 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)    }}, error = function(e) {    OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})An irrecoverable exception occurred. R is aborting now ...

41: evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, tryCatchOne(expr, names, parentenv, handlers[[1L]])            engine = engine)    setwd(wd)    for (expr in tle$exprs) {    keep_message = if (is.numeric(options$message)) TRUE else options$message, 
        ev <- withVisible(eval(expr, envir))
    }    write_utf8(res, output %n% stdout())60: tools:::.buildOneVignette("predict.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr",     TRUE, FALSE, "predict", "UTF-8", "/Volumes/Temp/tmp/RtmpS24rW8/file169735483cd7.rds")    stop_on_error = if (is.numeric(options$error)) options$error else {58:     paste0("\nQuitting from ", loc, if (!is.null(error))         if (options$error && options$include)             0LtryCatchList(expr, classes, parentenv, handlers)        paste0("\n", rule(), error, "\n", rule()))}, error = function(e) {}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)
    OK <<- FALSE        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }
        else 2L    }, output_handler = knit_handlers(options$render, options))
42: 59: 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)) {    TRUE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s", 
51: process_file(text, output)
52: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)        file, conditionMessage(e)))
})
60: tools:::.buildOneVignette("predict.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr", in_dir(input_dir(), expr)        texi2pdf(file = output, clean = FALSE, quiet = quiet)
43: in_input_dir(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,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options)))
44: eng_r(options)
45: block_exec(params)
46: call_block(x)
47:         output <- find_vignette_product(name, by = "texi2pdf",     TRUE, FALSE, "predict", "UTF-8", "/Volumes/Temp/tmp/RtmpS24rW8/file169735483cd7.rds")
An irrecoverable exception occurred. R is aborting now ...
process_group(group)53:             engine = engine)
48: withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     error = function(e) {    }}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)}, error = function(e) {rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(), 
    OK <<- FALSE    output_dir = getwd(), ...)        if (progress && is.function(pb$interrupt))     message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",             pb$interrupt()        file, conditionMessage(e)))})
60: tools:::.buildOneVignette("predict.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr",     TRUE, FALSE, "predict", "UTF-8", "/Volumes/Temp/tmp/RtmpS24rW8/file169735483cd7.rds")40:         if (is_R_CMD_build() || is_R_CMD_check()) An irrecoverable exception occurred. R is aborting now ...
evaluate::evaluate(...)            error <<- format(e)    })
49: with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     error = function(e) {        if (progress && is.function(pb$interrupt))             pb$interrupt()


54: vweave_rmarkdown(...)
55: engine$weave(file, quiet = quiet, encoding = enc)
56: doTryCatch(return(expr), name, parentenv, handler)
57: tryCatchOne(expr, names, parentenv, handlers[[1L]])
58: 41: tryCatchList(expr, classes, parentenv, handlers)evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, 
        if (is_R_CMD_build() || is_R_CMD_check()) 59: An irrecoverable exception occurred. R is aborting now ...
tryCatch({    engine$weave(file, quiet = quiet, encoding = enc)            error <<- format(e)    setwd(startdir)    }), list(rlang_trace_top_env = knit_global()))
50: xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     error = function(e) {    keep_message = if (is.numeric(options$message)) TRUE else options$message,     output <- find_vignette_product(name, by = "weave", engine = engine)        if (progress && is.function(pb$interrupt))     if (!have.makefile && vignette_is_tex(output)) {        texi2pdf(file = output, clean = FALSE, quiet = quiet)        output <- find_vignette_product(name, by = "texi2pdf",             engine = engine)    }    stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options))            pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)
    }), list(rlang_trace_top_env = knit_global())), function(loc) {42: }, error = function(e) {    OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})
60: tools:::.buildOneVignette("predict.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr",     TRUE, FALSE, "predict", "UTF-8", "/Volumes/Temp/tmp/RtmpS24rW8/file169735483cd7.rds")in_dir(input_dir(), expr)
    setwd(wd)
An irrecoverable exception occurred. R is aborting now ...
    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)43: in_input_dir(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, 
51: process_file(text, output)    stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options)))

44: eng_r(options)
52: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
53: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
54: 45: block_exec(params)
46: call_block(x)
47: process_group(group)vweave_rmarkdown(...)
55: engine$weave(file, quiet = quiet, encoding = enc)
56: doTryCatch(return(expr), name, parentenv, handler)
57: tryCatchOne(expr, names, parentenv, handlers[[1L]])
58: tryCatchList(expr, classes, parentenv, handlers)
59: tryCatch({
48: withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     error = function(e) {        if (progress && is.function(pb$interrupt))     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)    }}, error = function(e) {    OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))            pb$interrupt()})
60:         if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)    })
49: 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()))tools:::.buildOneVignette("predict.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr",     TRUE, FALSE, "predict", "UTF-8", "/Volumes/Temp/tmp/RtmpS24rW8/file169735483cd7.rds")
An irrecoverable exception occurred. R is aborting now ...

50: 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)
51: process_file(text, output)
52: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
53: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
54: vweave_rmarkdown(...)
55: engine$weave(file, quiet = quiet, encoding = enc)
56: doTryCatch(return(expr), name, parentenv, handler)
57: tryCatchOne(expr, names, parentenv, handlers[[1L]])
58: tryCatchList(expr, classes, parentenv, handlers)
59: 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)    }}, error = function(e) {    OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})
60: tools:::.buildOneVignette("predict.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr",     TRUE, FALSE, "predict", "UTF-8", "/Volumes/Temp/tmp/RtmpS24rW8/file169735483cd7.rds")
An irrecoverable exception occurred. R is aborting now ...

Quitting from predict.Rmd:91-109 [unnamed-chunk-5]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
<error/rlang_error>
Error in `names(x) <- value`:
! 'names' attribute [3] must be the same length as the vector [0]
---
Backtrace:
    ▆
 1. └─logitr::logitr(...)
 2.   └─logitr:::getMultistartSummary(allModels)
 3.     └─base::`colnames<-`(...)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Error: processing vignette 'predict.Rmd' failed with diagnostics:
'names' attribute [3] must be the same length as the vector [0]
--- failed re-building ‘predict.Rmd’

--- re-building ‘summarizing_results.Rmd’ using rmarkdown
--- finished re-building ‘summarizing_results.Rmd’

--- re-building ‘utility_models.Rmd’ using rmarkdown
--- finished re-building ‘utility_models.Rmd’

SUMMARY: processing the following files failed:
  ‘basic_usage.Rmd’ ‘mnl_models.Rmd’ ‘mnl_models_weighted.Rmd’
  ‘predict.Rmd’

Error: Vignette re-building failed.
Execution halted