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/RtmpuwPC9a/file25497e9a492b.rds")
An irrecoverable exception occurred. R is aborting now ...

 *** 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/RtmpuwPC9a/file25497e9a492b.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'

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

Traceback:

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:  1: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)
 2: 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$iterationseval_f(x0, ...)
        model$status <- result$status        model$message <- result$message    }})
 9: FUN(X[[i]], ...)
 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({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:     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]])
Traceback:
 1: tryCatch(expr, error = function(e) {
13: tryCatchList(expr, classes, parentenv, handlers)
14: tryCatch(expr, error = function(e) {    call <- conditionCall(e)    if (!is.null(call)) {    call <- conditionCall(e)    if (!is.null(call)) {        if (identical(call[[1L]], quote(doTryCatch)))             call <- sys.call(-4L)        dcall <- deparse(call, nlines = 1L)        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]]        prefix <- paste("Error in", dcall, ": ")        LONG <- 75L        sm <- strsplit(conditionMessage(e), "\n")[[1L]]        w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)        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)        if (is.na(w))             w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L], 
                type = "b")        if (w > LONG)             prefix <- paste0(prefix, "\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)
 5:     }    else prefix <- "Error : "    msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {

Traceback:
        cat(msg, file = outFile)16: tryCatchOne(expr, names, parentenv, handlers[[1L]])
 1: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE)) 6: 
        .Internal(printDeferredWarnings())    }    invisible(structure(msg, class = "try-error", condition = e))tryCatchList(expr, classes, parentenv, handlers)

 7: tryCatch({    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,  2:         mi = mi, opts = mi$options)}, error = function(e) {17: FUN(X[[i]], ...)})})eval_f(x0, ...)

18: lapply(seq_len(cores), inner.do)

19: 

Traceback:
 3:  1: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)
 2: 15: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,  8: 
system.time({16: eval_f(x0, ...)    model <- mi$modelparallel::mclapply(miList, runModel, mc.cores = numCores)sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))    mi = mi, opts = mi$options)

17: FUN(X[[i]], ...)
18: lapply(seq_len(cores), inner.do)
19:     result <- NULL20: 
    tryCatch({withCallingHandlers(expr, warning = function(w) if (inherits(w, 
 3: nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, parallel::mclapply(miList, runModel, mc.cores = numCores)    classes)) tryInvokeRestart("muffleWarning"))

        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, 21:     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({            mi = mi, opts = mi$options)    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     }, error = function(e) {        mi = mi, opts = mi$options)
 *** caught segfault ***
 4:     })20:     if (!is.null(result)) {doTryCatch(return(expr), name, parentenv, handler)
 *** caught segfault ***
withCallingHandlers(expr, warning = function(w) if (inherits(w, suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))}, error = function(e) {        model$fail <- FALSE})address 0x110, cause 'invalid permissions'
    classes)) tryInvokeRestart("muffleWarning"))
21: suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))

22: withCallingHandlers(expr, message = function(c) if (inherits(c, 22: 
address 0x110, cause 'invalid permissions'

    classes)) tryInvokeRestart("muffleMessage")) 5: 
23: tryCatchOne(expr, names, parentenv, handlers[[1L]])        model$coefficients <- result$solution        model$logLik <- as.numeric(-1 * result$objective)        model$iterations <- result$iterations        model$status <- result$status        model$message <- result$messagesuppressMessages(suppressWarnings(parallel::mclapply(miList,     }withCallingHandlers(expr, message = function(c) if (inherits(c,     runModel, mc.cores = numCores)))
 6:  8:     classes)) tryInvokeRestart("muffleMessage"))tryCatchList(expr, classes, parentenv, handlers)

23:  7: tryCatch({
suppressMessages(suppressWarnings(parallel::mclapply(miList, })    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,         mi = mi, opts = mi$options)}, error = function(e) {})24: 
 8: system.time({
    runModel, mc.cores = numCores)))runMultistart(modelInputs)
25: 
 9: logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat", system.time({    model <- mi$model    model <- mi$model    result <- NULLFUN(X[[i]], ...)    result <- NULL    tryCatch({24:     "brand"), scalePar = "price", numMultiStarts = 10)    tryCatch({        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, runMultistart(modelInputs)        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, 

            mi = mi, opts = mi$options)
10: lapply(X = S, FUN = FUN, ...)25:     }, 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$status26: 
eval(expr, envir)            mi = mi, opts = mi$options)logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat", 
    "brand"), scalePar = "price", numMultiStarts = 10)    }, error = function(e) {11:         model$message <- result$messagedoTryCatch(return(expr), name, parentenv, handler)
    }
    })26: eval(expr, envir)
27:     if (!is.null(result)) {})eval(expr, envir)        model$fail <- FALSE
12: tryCatchOne(expr, names, parentenv, handlers[[1L]])
13: tryCatchList(expr, classes, parentenv, handlers)

        model$coefficients <- result$solution27: 14: 28:  9: 
Traceback:
        model$logLik <- as.numeric(-1 * result$objective)tryCatch(expr, error = function(e) {withVisible(eval(expr, envir))    call <- conditionCall(e)    if (!is.null(call)) {        if (identical(call[[1L]], quote(doTryCatch))) eval(expr, envir)        model$iterations <- result$iterations            call <- sys.call(-4L)FUN(X[[i]], ...)        model$status <- result$status
10: lapply(X = S, FUN = FUN, ...)        dcall <- deparse(call, nlines = 1L)
 1: 

mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)
Traceback:
        model$message <- result$message28: 
 2: eval_f(x0, ...)
        prefix <- paste("Error in", dcall, ": ")11: withVisible(eval(expr, envir))
    } 1: doTryCatch(return(expr), name, parentenv, handler) 3: })
 9: FUN(X[[i]], ...)
10: 
29: 12:         LONG <- 75Llapply(X = S, FUN = FUN, ...)withCallingHandlers(code, error = function (e) nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, tryCatchOne(expr, names, parentenv, handlers[[1L]])mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)        sm <- strsplit(conditionMessage(e), "\n")[[1L]]
    mi = mi, opts = mi$options)
        w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")
29: 11:         if (is.na(w))             w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L],  4:  2:                 type = "b")withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) 
doTryCatch(return(expr), name, parentenv, handler){rlang::entrace(e), message = function (cnd)     watcher$capture_plot_and_output()
12: tryCatchOne(expr, names, parentenv, handlers[[1L]])
13: tryCatchList(expr, classes, parentenv, handlers)
    if (on_message$capture) {        if (w > LONG) 13: doTryCatch(return(expr), name, parentenv, handler)eval_f(x0, ...)        watcher$push(cnd){
tryCatchList(expr, classes, parentenv, handlers)            prefix <- paste0(prefix, "\n  ")    }    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")
    }
 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])14:     else prefix <- "Error : "14:  3: nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, 
tryCatch(expr, error = function(e) {tryCatch(expr, error = function(e) {    call <- conditionCall(e)    if (!is.null(call)) { 6:     watcher$capture_plot_and_output()    }}, error = function (cnd) {    msg <- paste0(prefix, conditionMessage(e), "\n")    mi = mi, opts = mi$options)    if (on_message$capture) {
    call <- conditionCall(e)    if (!is.null(call)) {        if (identical(call[[1L]], quote(doTryCatch)))             call <- sys.call(-4L)    .Internal(seterrmessage(msg[1L]))        watcher$push(cnd)    if (!silent && isTRUE(getOption("show.error.messages"))) {    }        if (identical(call[[1L]], quote(doTryCatch)))     if (on_message$silence) { 4: doTryCatch(return(expr), name, parentenv, handler)
 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
        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")tryCatchList(expr, classes, parentenv, handlers) 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) {})    watcher$capture_plot_and_output()            call <- sys.call(-4L)        dcall <- deparse(call, nlines = 1L)    }
        prefix <- paste("Error in", dcall, ": ")    cnd <- sanitize_call(cnd) 7: tryCatch({}, 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)
        cat(msg, file = outFile)        LONG <- 75L
 *** caught segfault ***
    watcher$push(cnd)        .Internal(printDeferredWarnings())    }    switch(on_error, continue = invokeRestart("eval_continue"),     invisible(structure(msg, class = "try-error", condition = e)) 8:     result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,         mi = mi, opts = mi$options)}, error = function(e) {address 0x110, cause 'invalid permissions'
        dcall <- deparse(call, nlines = 1L)        sm <- strsplit(conditionMessage(e), "\n")[[1L]]        stop = invokeRestart("eval_stop"), error = NULL)})})
30: eval(call)
31: eval(call)
32: with_handlers({
15: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
16:         prefix <- paste("Error in", dcall, ": ")system.time({})        w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")    for (expr in tle$exprs) {sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))})
17: 

30: eval(call)
31:     model <- mi$modelFUN(X[[i]], ...)    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 <- FALSEeval(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)    }
 8:         ev <- withVisible(eval(expr, envir))        if (is.na(w)) 18: lapply(seq_len(cores), inner.do)        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)

Traceback:
            w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L],  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:     TRUE        LONG <- 75L}, handlers)
        sm <- strsplit(conditionMessage(e), "\n")[[1L]]    }tryCatchList(expr, classes, parentenv, handlers)system.time({                type = "b")        model$coefficients <- result$solution        model$logLik <- as.numeric(-1 * result$objective)        if (w > LONG) 33: 19:     TRUEparallel::mclapply(miList, runModel, mc.cores = numCores)
20: withCallingHandlers(expr, warning = function(w) if (inherits(w,         w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")    model <- mi$model    classes)) tryInvokeRestart("muffleWarning"))        model$iterations <- result$iterations
21: suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))
22: withCallingHandlers(expr, message = function(c) if (inherits(c,             prefix <- paste0(prefix, "\n  ")        model$status <- result$status
    result <- NULL}, handlers)    tryCatch({
33: doWithOneRestart(return(expr), restart)
34: withOneRestart(expr, restarts[[1L]])        if (is.na(w))     classes)) tryInvokeRestart("muffleMessage"))doWithOneRestart(return(expr), restart)
23:         result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,             mi = mi, opts = mi$options)    }, error = function(e) {    })    if (!is.null(result)) {    }suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))
24: runMultistart(modelInputs)
            w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L], 25: logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat",     "brand"), scalePar = "price", numMultiStarts = 10)        model$fail <- FALSE 7:     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: 
                type = "b")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) {
34:         model$coefficients <- result$solutionlapply(seq_len(cores), inner.do)        model$message <- result$message        invokeRestart("muffleMessage")35: tryCatch({        if (w > LONG) 
    }19: 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:     result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, withOneRestart(expr, restarts[[1L]])        model$logLik <- as.numeric(-1 * result$objective)
35: withRestartList(expr, restarts[-nr])
36: doWithOneRestart(return(expr), restart)
37: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])    }            prefix <- paste0(prefix, "\n  ")withRestartList(expr, restarts[-nr])tryCatchList(expr, classes, parentenv, handlers)}, warning = function (cnd) {    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()        model$iterations <- result$iterations
    }    }38:     watcher$capture_plot_and_output()    else prefix <- "Error : "        model$status <- result$status        model$message <- result$message    }})
 9: 
FUN(X[[i]], ...)withRestartList(expr, restarts)
36: 
    msg <- paste0(prefix, conditionMessage(e), "\n")        mi = mi, opts = mi$options)    if (on_warning$capture) {
20: 14:         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: 10: 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, ": ")lapply(X = S, FUN = FUN, ...)doWithOneRestart(return(expr), restart)}, error = function(e) {with_handlers({
        LONG <- 75L
withCallingHandlers(expr, warning = function(w) if (inherits(w, })11: doTryCatch(return(expr), name, parentenv, handler)
12:     .Internal(seterrmessage(msg[1L]))tryCatchOne(expr, names, parentenv, handlers[[1L]])    classes)) tryInvokeRestart("muffleWarning"))

    if (!silent && isTRUE(getOption("show.error.messages"))) {
        sm <- strsplit(conditionMessage(e), "\n")[[1L]] 8: system.time({    model <- mi$model    result <- NULL    for (expr in tle$exprs) {13: 37: 
    tryCatch({        ev <- withVisible(eval(expr, envir))        w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")21:         result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,         watcher$capture_plot_and_output()        if (is.na(w)) suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])tryCatchList(expr, classes, parentenv, handlers)
38: withRestartList(expr, restarts)
39: withRestarts(with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))39: 

        cat(msg, file = outFile)        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)            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    }withRestarts(with_handlers({    }    TRUE}, handlers)
33: doWithOneRestart(return(expr), restart)
34: withOneRestart(expr, restarts[[1L]])
35: withRestartList(expr, restarts[-nr])
36: doWithOneRestart(return(expr), restart)        watcher$print_value(ev$value, ev$visible, envir)    for (expr in tle$exprs) {14:         ev <- withVisible(eval(expr, envir))})        watcher$capture_plot_and_output()            w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L], 
tryCatch(expr, error = function(e) {37:     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))})    }        .Internal(printDeferredWarnings())

15: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
16:     }                type = "b")        watcher$print_value(ev$value, ev$visible, envir)withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])    invisible(structure(msg, class = "try-error", condition = e))    TRUE 9: 22: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
withCallingHandlers(expr, message = function(c) if (inherits(c,     classes)) tryInvokeRestart("muffleMessage"))
23: suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))

})
15: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
16: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))        if (w > LONG)             prefix <- paste0(prefix, "\n  ")FUN(X[[i]], ...)    }
    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)))24:     }17: 10: FUN(X[[i]], ...)38: runMultistart(modelInputs)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
}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)
40: evaluate::evaluate(...)    else prefix <- "Error : "
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:     msg <- paste0(prefix, conditionMessage(e), "\n")

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)44: 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) 17: FUN(X[[i]], ...)
18: lapply(seq_len(cores), inner.do)
19: in_input_dir(evaluate(code, envir = env, new_device = FALSE, parallel::mclapply(miList, runModel, mc.cores = numCores)    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)     .Internal(seterrmessage(msg[1L]))
20: 
eng_r(options)25: 
45: block_exec(params)
46: call_block(x)
logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat",     "brand"), scalePar = "price", numMultiStarts = 10)            prefix <- paste0(prefix, "\n  ")            0L47: process_group(group)
48: withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), 
        else 2L    }, output_handler = knit_handlers(options$render, options))
    if (!silent && isTRUE(getOption("show.error.messages"))) {    error = function(e) {    }25: 26: 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) {        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: 42:     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))
eval(expr, envir)
27:         invokeRestart("muffleMessage")        if (progress && is.function(pb$interrupt)) lapply(seq_len(cores), inner.do)in_dir(input_dir(), expr)eval(expr, envir)22:     }withCallingHandlers(expr, message = function(c) if (inherits(c, 
withCallingHandlers(expr, warning = function(w) if (inherits(w,         else 2L            pb$interrupt()    }, 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))     classes)) tryInvokeRestart("muffleMessage"))
}, warning = function (cnd) 28: withVisible(eval(expr, envir))
29: withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) {    watcher$capture_plot_and_output()19:         if (is_R_CMD_build() || is_R_CMD_check())             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()))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) {parallel::mclapply(miList, runModel, mc.cores = numCores)            error <<- format(e)    if (on_message$capture) {        watcher$push(cnd)    }    if (on_message$silence) {        invokeRestart("muffleMessage")    }}, warning = function (cnd) 
{    watcher$capture_plot_and_output()    if (on_message$capture) {        watcher$push(cnd)43:     })in_input_dir(evaluate(code, envir = env, new_device = FALSE, 

    classes)) tryInvokeRestart("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())    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(), ...)
20:     if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    }    keep_warning = if (is.numeric(options$warning)) TRUE else options$warning,     if (getOption("warn") >= 2 || getOption("warn") < 0) {    watcher$capture_plot_and_output()54:     }    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: 
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")    }    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)     if (on_message$silence) {49: }, warning = function (cnd) {    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    }    watcher$capture_plot_and_output()    if (on_warning$capture) {eval(call)            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)) with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),         return()21:         cnd <- sanitize_call(cnd)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: vweave_rmarkdown(...)    error = function(e) {    }        watcher$push(cnd)    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()            pb$interrupt()
        invokeRestart("muffleMessage")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)
    cnd <- sanitize_call(cnd)    }}, 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)    }        if (is_R_CMD_build() || is_R_CMD_check())         if (progress && is.function(pb$interrupt))             error <<- format(e)    })
    watcher$push(cnd)

    if (on_warning$silence) {49:             pb$interrupt()with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), 59: 32:         invokeRestart("muffleWarning")32:         if (is_R_CMD_build() || is_R_CMD_check()) withVisible(eval(expr, envir))tryCatch({
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")    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/RtmpuwPC9a/file25497e9a492b.rds")
An irrecoverable exception occurred. R is aborting now ...
    error = function(e) {with_handlers({    }            error <<- format(e)    }with_handlers({}, 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])
}, error = function (cnd)         if (progress && is.function(pb$interrupt))     }), list(rlang_trace_top_env = knit_global()))    switch(on_error, continue = invokeRestart("eval_continue"),     for (expr in tle$exprs) {        stop = invokeRestart("eval_stop"), error = NULL)})
30: eval(call)
31: eval(call)
{            pb$interrupt()    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)
        ev <- withVisible(eval(expr, envir))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()))36:         watcher$capture_plot_and_output()32: 33: }, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)        if (is_R_CMD_build() || is_R_CMD_check()) doWithOneRestart(return(expr), restart)    watcher$capture_plot_and_output()doWithOneRestart(return(expr), restart)            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)with_handlers({    for (expr in tle$exprs) {
57: tryCatchOne(expr, names, parentenv, handlers[[1L]])
58: tryCatchList(expr, classes, parentenv, handlers)
59: 
        watcher$print_value(ev$value, ev$visible, envir)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:     }    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: 37: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
38: withRestartList(expr, restarts)    cnd <- sanitize_call(cnd)        ev <- withVisible(eval(expr, envir))
        watcher$capture_plot_and_output()withRestartList(expr, restarts)        watcher$print_value(ev$value, ev$visible, envir)tryCatch({
34:     }    engine$weave(file, quiet = quiet, encoding = enc)39: withOneRestart(expr, restarts[[1L]])
35: withRestartList(expr, restarts[-nr])
    TRUE36: engine$weave(file, quiet = quiet, encoding = enc)
56: doWithOneRestart(return(expr), restart)
    setwd(startdir)    output <- find_vignette_product(name, by = "weave", engine = engine)doTryCatch(return(expr), name, parentenv, handler)

39:     watcher$push(cnd)57: 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)withRestarts(with_handlers({    for (expr in tle$exprs) {tryCatchOne(expr, names, parentenv, handlers[[1L]])37: }, handlers)    }    TRUE}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)        ev <- withVisible(eval(expr, envir))withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])    switch(on_error, continue = invokeRestart("eval_continue"),     if (!have.makefile && vignette_is_tex(output)) {        stop = invokeRestart("eval_stop"), error = NULL)        texi2pdf(file = output, clean = FALSE, quiet = quiet)        output <- find_vignette_product(name, by = "texi2pdf",             engine = engine)    }

58: })
30: eval(call)
31: eval(call)        watcher$capture_plot_and_output()
tryCatchList(expr, classes, parentenv, handlers)
33: 38: withRestartList(expr, restarts)}, error = function(e) {
        watcher$print_value(ev$value, ev$visible, envir)    OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",     }    TRUE}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)
40: 40:         file, conditionMessage(e)))
59: evaluate::evaluate(...)doWithOneRestart(return(expr), restart)evaluate::evaluate(...)})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", 
60: tools:::.buildOneVignette("basic_usage.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr", 
32: 
with_handlers({
    TRUE, FALSE, "basic_usage", "UTF-8", "/Volumes/Temp/tmp/RtmpuwPC9a/file25497e9a492b.rds")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))
        file, conditionMessage(e)))
An irrecoverable exception occurred. R is aborting now ...
34: withOneRestart(expr, restarts[[1L]])
35: withRestartList(expr, restarts[-nr])
36: doWithOneRestart(return(expr), restart)
37: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
38:     for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)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))
60: tools:::.buildOneVignette("basic_usage.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr", withRestartList(expr, restarts)    }
39: withRestarts(with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()    TRUE}, handlers)
33: doWithOneRestart(return(expr), restart)
34: withOneRestart(expr, restarts[[1L]])
35: withRestartList(expr, restarts[-nr])
36: 

    TRUE, FALSE, "basic_usage", "UTF-8", "/Volumes/Temp/tmp/RtmpuwPC9a/file25497e9a492b.rds")42: doWithOneRestart(return(expr), restart)        watcher$print_value(ev$value, ev$visible, envir)42: 39: 

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, withRestarts(with_handlers({An irrecoverable exception occurred. R is aborting now ...
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)    }    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 {
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)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()))
        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,     for (expr in tle$exprs) {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)    stop_on_error = if (is.numeric(options$error)) options$error else {        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)         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:     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L    }    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    }, output_handler = knit_handlers(options$render, options)))            0L        else 2L    }, output_handler = knit_handlers(options$render, options)))
44: eng_r(options)
45: block_exec(params)
46: 
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)    })
call_block(x)
53: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
54: vweave_rmarkdown(...)
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()) 
55:             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) {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)    setwd(wd)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()    write_utf8(res, output %n% stdout())        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) 
59: tryCatch({            0L        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))         else 2L    paste0("\nQuitting from ", loc, if (!is.null(error))         paste0("\n", rule(), error, "\n", rule()))}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)
    }, output_handler = knit_handlers(options$render, options)))
44:     engine$weave(file, quiet = quiet, encoding = enc)51: process_file(text, output)
        paste0("\n", rule(), error, "\n", rule()))    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/RtmpuwPC9a/file25497e9a492b.rds")
An irrecoverable exception occurred. R is aborting now ...
}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), eng_r(options)    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: 
52: 
knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
53: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)45: block_exec(params)

54: vweave_rmarkdown(...)
55: engine$weave(file, quiet = quiet, encoding = enc)
56: doTryCatch(return(expr), name, parentenv, handler)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()rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),         if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)51:     }), list(rlang_trace_top_env = knit_global())), function(loc) {
process_file(text, output)    output_dir = getwd(), ...)

57:     setwd(wd)tryCatchOne(expr, names, parentenv, handlers[[1L]])    write_utf8(res, output %n% stdout())54:     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: 58: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)52: 
vweave_rmarkdown(...)53: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
54: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
55: engine$weave(file, quiet = quiet, encoding = enc)tryCatchList(expr, classes, parentenv, handlers)
vweave_rmarkdown(...)

55: 
engine$weave(file, quiet = quiet, encoding = enc)
56: doTryCatch(return(expr), name, parentenv, handler)
57: 53: 59: tryCatch({    engine$weave(file, quiet = quiet, encoding = enc)56: tryCatchOne(expr, names, parentenv, handlers[[1L]])    setwd(startdir)
58: doTryCatch(return(expr), name, parentenv, handler)    output <- find_vignette_product(name, by = "weave", engine = engine)rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     if (!have.makefile && vignette_is_tex(output)) {    output_dir = getwd(), ...)
57: tryCatchOne(expr, names, parentenv, handlers[[1L]])
58: tryCatchList(expr, classes, parentenv, handlers)tryCatchList(expr, classes, parentenv, handlers)

59:         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/RtmpuwPC9a/file25497e9a492b.rds")
An irrecoverable exception occurred. R is aborting now ...
54: 
vweave_rmarkdown(...)tryCatch({59: 
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)    engine$weave(file, quiet = quiet, encoding = enc)    setwd(startdir)    output <- find_vignette_product(name, by = "weave", engine = engine)tryCatch({    if (!have.makefile && vignette_is_tex(output)) {    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",         texi2pdf(file = output, clean = FALSE, quiet = quiet)        output <- find_vignette_product(name, by = "texi2pdf",             engine = engine)    }}, error = function(e) {            engine = engine)    }}, error = function(e) {    OK <<- FALSE
    OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))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)
60:         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/RtmpuwPC9a/file25497e9a492b.rds")
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/RtmpuwPC9a/file25497e9a492b.rds")
An 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("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/RtmpuwPC9a/file25497e9a492b.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: 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/RtmpuwPC9a/file2549465a7a06.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()
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  ")    }
 *** caught segfault ***
address 0x110, cause 'invalid permissions'
    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"))
    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({21: suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))
22: withCallingHandlers(expr, message = function(c) if (inherits(c,     classes)) tryInvokeRestart("muffleMessage"))
23: 
Traceback:
 1: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)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)
 2: eval_f(x0, ...)
 3: nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     mi = mi, opts = mi$options)
    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output() 4: 
        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))doTryCatch(return(expr), name, parentenv, handler)
42: in_dir(input_dir(), expr)
43: in_input_dir(evaluate(code, envir = env, new_device = FALSE, 27: eval(expr, envir)
28: 
 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)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")    }}, error = function(e) {})
 8: system.time({}, warning = function (cnd) {    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    model <- mi$model    result <- NULL    }    watcher$capture_plot_and_output()    if (on_warning$capture) {        cnd <- sanitize_call(cnd)        watcher$push(cnd)    }    tryCatch({        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,             mi = mi, opts = mi$options)    }, error = function(e) {    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    })    if (!is.null(result)) {        model$fail <- FALSE        model$coefficients <- result$solution        model$logLik <- as.numeric(-1 * result$objective)        model$iterations <- result$iterations    }, output_handler = knit_handlers(options$render, options)))
44:         model$status <- result$status        model$message <- result$message    }})
 9: FUN(X[[i]], ...)
10: lapply(X = S, FUN = FUN, ...)
    if (on_warning$silence) {        invokeRestart("muffleWarning")    }}, error = function (cnd) {    watcher$capture_plot_and_output()    cnd <- sanitize_call(cnd)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) {
Traceback:
 1: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)
        if (progress && is.function(pb$interrupt))  2: 11: eval_f(x0, ...)            pb$interrupt()doTryCatch(return(expr), name, parentenv, handler)        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)) 

12:             pb$interrupt()tryCatchOne(expr, names, parentenv, handlers[[1L]])        if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)
    }), list(rlang_trace_top_env = knit_global()))13: tryCatchList(expr, classes, parentenv, handlers)
14:     watcher$push(cnd)
50:     switch(on_error, continue = invokeRestart("eval_continue"),         stop = invokeRestart("eval_stop"), error = NULL)})
xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     error = function(e) {        if (progress && is.function(pb$interrupt))  3: 30: eval(call)
tryCatch(expr, error = function(e) {
 *** caught segfault ***
31: nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, address 0x110, cause 'invalid permissions'
eval(call)    mi = mi, opts = mi$options)    call <- conditionCall(e)
            pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check())     if (!is.null(call)) {        if (identical(call[[1L]], quote(doTryCatch)))             call <- sys.call(-4L)        dcall <- deparse(call, nlines = 1L)32:             error <<- format(e)    }), list(rlang_trace_top_env = knit_global())), function(loc) {    setwd(wd)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)    write_utf8(res, output %n% stdout())    }    TRUE}, handlers)

 4: 33: doWithOneRestart(return(expr), restart)
34: withOneRestart(expr, restarts[[1L]])
35: doTryCatch(return(expr), name, parentenv, handler)withRestartList(expr, restarts[-nr])
        prefix <- paste("Error in", dcall, ": ")        LONG <- 75L        sm <- strsplit(conditionMessage(e), "\n")[[1L]]        w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")    paste0("\nQuitting from ", loc, if (!is.null(error))         if (is.na(w))         paste0("\n", rule(), error, "\n", rule()))
36:  5:             w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L], doWithOneRestart(return(expr), restart)
37:                 type = "b")withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])        if (w > LONG) }, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)
51: 
process_file(text, output)            prefix <- paste0(prefix, "\n  ")38: withRestartList(expr, restarts)
39: tryCatchOne(expr, names, parentenv, handlers[[1L]])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)
52: 
 6: 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(), ...)
54: vweave_rmarkdown(...)
55:     }
 *** caught segfault ***
engine$weave(file, quiet = quiet, encoding = enc)address 0x110, cause 'invalid permissions'

    else prefix <- "Error : "    msg <- paste0(prefix, conditionMessage(e), "\n") 7: 
56: doTryCatch(return(expr), name, parentenv, handler)
57: tryCatchOne(expr, names, parentenv, handlers[[1L]])
58: tryCatchList(expr, classes, parentenv, handlers)    .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))})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 <- NULL40: 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    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
15: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
16: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
17: FUN(X[[i]], ...)
        model$coefficients <- result$solution
59:         else 2L    }, output_handler = knit_handlers(options$render, options))
42: in_dir(input_dir(), expr)
        model$logLik <- as.numeric(-1 * result$objective)        model$iterations <- result$iterations        model$status <- result$status        model$message <- result$message    }43: })18: lapply(seq_len(cores), inner.do)
19: 
parallel::mclapply(miList, runModel, mc.cores = numCores)in_input_dir(evaluate(code, envir = env, new_device = FALSE,     keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, tryCatch({    engine$weave(file, quiet = quiet, encoding = enc)    setwd(startdir)
    keep_message = if (is.numeric(options$message)) TRUE else options$message,     stop_on_error = if (is.numeric(options$error)) options$error else {    output <- find_vignette_product(name, by = "weave", engine = engine)    if (!have.makefile && vignette_is_tex(output)) {20: 
Traceback:
 9: withCallingHandlers(expr, warning = function(w) if (inherits(w, FUN(X[[i]], ...)    classes)) tryInvokeRestart("muffleWarning"))
21: suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))
22: withCallingHandlers(expr, message = function(c) if (inherits(c,     classes)) tryInvokeRestart("muffleMessage"))        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)))
        if (options$error && options$include) })
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/RtmpuwPC9a/file2549465a7a06.rds")10: 
            0L 1: lapply(X = S, FUN = FUN, ...)mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)        else 2L    }, output_handler = knit_handlers(options$render, options)))

 2: 11: 

Traceback:
44:  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)eval_f(x0, ...)23: 
eng_r(options)doTryCatch(return(expr), name, parentenv, handler)
suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))
24: runMultistart(modelInputs)
25:  3: 
logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat",     "brand"), scalePar = "price", numMultiStarts = 10, startVals = wtp_mnl_pref$Estimate)nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, 
    mi = mi, opts = mi$options) 4: 
doTryCatch(return(expr), name, parentenv, handler)

45: An irrecoverable exception occurred. R is aborting now ...
block_exec(params)
12: 
46:  4: doTryCatch(return(expr), name, parentenv, handler)
 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
 6:  5: 26: call_block(x)eval(expr, envir)
tryCatchOne(expr, names, parentenv, handlers[[1L]])tryCatchList(expr, classes, parentenv, handlers)
13: tryCatchList(expr, classes, parentenv, handlers)47: 
27: 

process_group(group)
48: withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),  7:     error = function(e) {tryCatchOne(expr, names, parentenv, handlers[[1L]])
tryCatch({        if (progress && is.function(pb$interrupt))             pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,         mi = mi, opts = mi$options)}, error = function(e) {    }) 6: 
})49: eval(expr, envir)
with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),  8: tryCatchList(expr, classes, parentenv, handlers)14: 
    error = function(e) {
28:  7: system.time({tryCatch(expr, error = function(e) {withVisible(eval(expr, envir))tryCatch({
        if (progress && is.function(pb$interrupt)) 29:     result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) {        mi = mi, opts = mi$options)            pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)    }), list(rlang_trace_top_env = knit_global()))
    call <- conditionCall(e)    watcher$capture_plot_and_output()    if (on_message$capture) {        watcher$push(cnd)    }    if (!is.null(call)) {        if (identical(call[[1L]], quote(doTryCatch)))             call <- sys.call(-4L)}, error = function(e) {})    if (on_message$silence) {        dcall <- deparse(call, nlines = 1L)    model <- mi$model    result <- NULL    tryCatch({        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, 
        invokeRestart("muffleMessage") 8: 50:             mi = mi, opts = mi$options)    }system.time({    }, error = function(e) {    })    if (!is.null(result)) {xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     model <- mi$model    result <- NULL    tryCatch({        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,         model$fail <- FALSE            mi = mi, opts = mi$options)    }, error = function(e) {    error = function(e) {}, warning = function (cnd) {    if (getOption("warn") >= 2 || getOption("warn") < 0) {        if (progress && is.function(pb$interrupt))         prefix <- paste("Error in", dcall, ": ")        return()        model$coefficients <- result$solution        model$logLik <- as.numeric(-1 * result$objective)    })    }        LONG <- 75L    if (!is.null(result)) {    watcher$capture_plot_and_output()        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    }        model$iterations <- result$iterations        sm <- strsplit(conditionMessage(e), "\n")[[1L]]})        model$status <- result$status        w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")
 9: FUN(X[[i]], ...)
10: lapply(X = S, FUN = FUN, ...)        if (is.na(w))             w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L], 
                type = "b")            pb$interrupt()        model$message <- result$message11: 
 *** caught segfault ***
    if (on_warning$capture) {doTryCatch(return(expr), name, parentenv, handler)        if (is_R_CMD_build() || is_R_CMD_check()) address 0x110, cause 'invalid permissions'
            error <<- format(e)        if (w > LONG)             prefix <- paste0(prefix, "\n  ")    }), list(rlang_trace_top_env = knit_global())), function(loc) {
12: tryCatchOne(expr, names, parentenv, handlers[[1L]])
13:     setwd(wd)tryCatchList(expr, classes, parentenv, handlers)    write_utf8(res, output %n% stdout())    }    else prefix <- "Error : "    msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L]))        cnd <- sanitize_call(cnd)    if (!silent && isTRUE(getOption("show.error.messages"))) {
        watcher$push(cnd)        cat(msg, file = outFile)        .Internal(printDeferredWarnings())    }    invisible(structure(msg, class = "try-error", condition = e))    }14: tryCatch(expr, error = function(e) {    call <- conditionCall(e)    if (!is.null(call)) {    if (on_warning$silence) {    }})    paste0("\nQuitting from ", loc, if (!is.null(error))         paste0("\n", rule(), error, "\n", rule()))        if (identical(call[[1L]], quote(doTryCatch)))             call <- sys.call(-4L)        dcall <- deparse(call, nlines = 1L)
}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)        prefix <- paste("Error in", dcall, ": ")        invokeRestart("muffleWarning")    }}, error = function (cnd) {})
 9:         LONG <- 75L
        sm <- strsplit(conditionMessage(e), "\n")[[1L]]    watcher$capture_plot_and_output()        w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")51: process_file(text, output)    cnd <- sanitize_call(cnd)15: 
    watcher$push(cnd)try(lapply(X = S, FUN = FUN, ...), silent = TRUE)        if (is.na(w))             w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L],                 type = "b")        if (w > LONG) 
52: 16: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
17:             prefix <- paste0(prefix, "\n  ")    }knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
    else prefix <- "Error : "    switch(on_error, continue = invokeRestart("eval_continue"),         stop = invokeRestart("eval_stop"), error = NULL)53: FUN(X[[i]], ...)
})18:     msg <- paste0(prefix, conditionMessage(e), "\n")lapply(seq_len(cores), inner.do)
rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(), 19:     .Internal(seterrmessage(msg[1L]))
30: FUN(X[[i]], ...)parallel::mclapply(miList, runModel, mc.cores = numCores)    if (!silent && isTRUE(getOption("show.error.messages"))) {
        cat(msg, file = outFile)
    output_dir = getwd(), ...)
54: eval(call)10: 
20: lapply(X = S, FUN = FUN, ...)31: vweave_rmarkdown(...)

withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))
21: suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))55: 
eval(call)22: 11: engine$weave(file, quiet = quiet, encoding = enc)
Traceback:
withCallingHandlers(expr, message = function(c) if (inherits(c,         .Internal(printDeferredWarnings()) 1: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)
 2: eval_f(x0, ...)doTryCatch(return(expr), name, parentenv, handler)


    }32: 12: 
with_handlers({ 3:     invisible(structure(msg, class = "try-error", condition = e))    for (expr in tle$exprs) {})
tryCatchOne(expr, names, parentenv, handlers[[1L]])15: 
13: tryCatchList(expr, classes, parentenv, handlers)
nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,         ev <- withVisible(eval(expr, envir))try(lapply(X = S, FUN = FUN, ...), silent = TRUE)    mi = mi, opts = mi$options)
56:         watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)
    }    TRUE 4: }, handlers)doTryCatch(return(expr), name, parentenv, handler)
 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])16:     classes)) tryInvokeRestart("muffleMessage"))doTryCatch(return(expr), name, parentenv, handler)
14: 

33: tryCatch(expr, error = function(e) {doWithOneRestart(return(expr), restart)
34: withOneRestart(expr, restarts[[1L]])
35: withRestartList(expr, restarts[-nr]) 6: 
57:     call <- conditionCall(e)tryCatchList(expr, classes, parentenv, handlers)
 7: tryCatch({sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))    if (!is.null(call)) {
    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, 23:         if (identical(call[[1L]], quote(doTryCatch)))         mi = mi, opts = mi$options)}, error = function(e) {suppressMessages(suppressWarnings(parallel::mclapply(miList, 36:             call <- sys.call(-4L)        dcall <- deparse(call, nlines = 1L)tryCatchOne(expr, names, parentenv, handlers[[1L]])

doWithOneRestart(return(expr), restart)58:     runModel, mc.cores = numCores)))
tryCatchList(expr, classes, parentenv, handlers)})


17:         prefix <- paste("Error in", dcall, ": ")37:         LONG <- 75L24:         sm <- strsplit(conditionMessage(e), "\n")[[1L]]FUN(X[[i]], ...)
        w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")59:         if (is.na(w)) 18: lapply(seq_len(cores), inner.do)
19: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])            w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L],                 type = "b")        if (w > LONG) tryCatch({runMultistart(modelInputs)
    engine$weave(file, quiet = quiet, encoding = enc)    setwd(startdir)    output <- find_vignette_product(name, by = "weave", engine = engine)            prefix <- paste0(prefix, "\n  ")25:     }parallel::mclapply(miList, runModel, mc.cores = numCores) 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) {20: withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat",     else prefix <- "Error : "    "brand"), scalePar = "price", numMultiStarts = 10, startVals = wtp_mnl_pref$Estimate)
    if (!have.makefile && vignette_is_tex(output)) {    msg <- paste0(prefix, conditionMessage(e), "\n")        texi2pdf(file = output, clean = FALSE, quiet = quiet)
        output <- find_vignette_product(name, by = "texi2pdf", 21: 
suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))            engine = engine)26: 
22:     .Internal(seterrmessage(msg[1L]))    }eval(expr, envir)withCallingHandlers(expr, message = function(c) if (inherits(c, 
    })27:     classes)) tryInvokeRestart("muffleMessage"))    if (!is.null(result)) {    if (!silent && isTRUE(getOption("show.error.messages"))) {
        cat(msg, file = outFile)38:         .Internal(printDeferredWarnings())}, error = function(e) {eval(expr, envir)    }23: suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))    OK <<- FALSEwithRestartList(expr, restarts)    invisible(structure(msg, class = "try-error", condition = e))    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         model$fail <- FALSE})
        file, conditionMessage(e)))

39: })24: 

withRestarts(with_handlers({        model$coefficients <- result$solution    for (expr in tle$exprs) {runMultistart(modelInputs)15: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)60:         model$logLik <- as.numeric(-1 * result$objective)28:         model$iterations <- result$iterations        model$status <- result$status        model$message <- result$message    }})
 9: FUN(X[[i]], ...)withVisible(eval(expr, envir))        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()

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/RtmpuwPC9a/file2549465a7a06.rds")        watcher$print_value(ev$value, ev$visible, envir)25: 

16: logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat", sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))An irrecoverable exception occurred. R is aborting now ...
    "brand"), scalePar = "price", numMultiStarts = 10, startVals = wtp_mnl_pref$Estimate)
29: 
17: 26: eval(expr, envir)
27: eval(expr, envir)
FUN(X[[i]], ...)
 *** caught segfault ***
28:     }withVisible(eval(expr, envir))
address 0x110, cause 'invalid permissions'

withCallingHandlers(code, error = function (e)     TRUErlang::entrace(e), message = function (cnd) 
10: 18: lapply(X = S, FUN = FUN, ...)
11: doTryCatch(return(expr), name, parentenv, handler)
12: tryCatchOne(expr, names, parentenv, handlers[[1L]])
13: lapply(seq_len(cores), inner.do)}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)

{29: withCallingHandlers(code, error = function (e) tryCatchList(expr, classes, parentenv, handlers)    watcher$capture_plot_and_output()
40:     if (on_message$capture) {        watcher$push(cnd)    }19:     if (on_message$silence) {        invokeRestart("muffleMessage")    }parallel::mclapply(miList, runModel, mc.cores = numCores)
20: withCallingHandlers(expr, warning = function(w) if (inherits(w, rlang::entrace(e), message = function (cnd) evaluate::evaluate(...)}, warning = function (cnd) 14: {{    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    }    classes)) tryInvokeRestart("muffleWarning"))    watcher$capture_plot_and_output()tryCatch(expr, error = function(e) {    watcher$capture_plot_and_output()    if (on_warning$capture) {

    call <- conditionCall(e)21: suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))
        cnd <- sanitize_call(cnd)22:     if (!is.null(call)) {withCallingHandlers(expr, message = function(c) if (inherits(c,     if (on_message$capture) {    classes)) tryInvokeRestart("muffleMessage"))        if (identical(call[[1L]], quote(doTryCatch))) 
23:         watcher$push(cnd)        watcher$push(cnd)    }    if (on_message$silence) {        invokeRestart("muffleMessage")    }}, warning = function (cnd) {    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    }41:             call <- sys.call(-4L)suppressMessages(suppressWarnings(parallel::mclapply(miList, evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning,     runModel, mc.cores = numCores)))
24: runMultistart(modelInputs)
    }    watcher$capture_plot_and_output()    keep_message = if (is.numeric(options$message)) TRUE else options$message,     if (on_warning$silence) {    stop_on_error = if (is.numeric(options$error)) options$error else {25:         if (options$error && options$include)         dcall <- deparse(call, nlines = 1L)logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat",         prefix <- paste("Error in", dcall, ": ")    "brand"), scalePar = "price", numMultiStarts = 10, startVals = wtp_mnl_pref$Estimate)    if (on_warning$capture) {
            0L        cnd <- sanitize_call(cnd)        invokeRestart("muffleWarning")26:         LONG <- 75Leval(expr, envir)
27: eval(expr, envir)        else 2L        sm <- strsplit(conditionMessage(e), "\n")[[1L]]    }    }, output_handler = knit_handlers(options$render, options))
        w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")        watcher$push(cnd)    }    if (on_warning$silence) {        invokeRestart("muffleWarning")    }42: }, error = function (cnd) in_dir(input_dir(), expr)

 *** caught segfault ***
address 0x110, cause 'invalid permissions'
28: 
        if (is.na(w))             w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L],                 type = "b")43:         if (w > LONG)             prefix <- paste0(prefix, "\n  ")}, error = function (cnd) {    watcher$capture_plot_and_output()    cnd <- sanitize_call(cnd)    watcher$push(cnd)in_input_dir(evaluate(code, envir = env, new_device = FALSE,     switch(on_error, continue = invokeRestart("eval_continue"),         stop = invokeRestart("eval_stop"), error = NULL){    keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, 
Traceback:
 1: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)
    } 2: })    keep_message = if (is.numeric(options$message)) TRUE else options$message,     else prefix <- "Error : "    msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {
    stop_on_error = if (is.numeric(options$error)) options$error else {    watcher$capture_plot_and_output()withVisible(eval(expr, envir))30:         if (options$error && options$include) eval_f(x0, ...)eval(call)
 3:     cnd <- sanitize_call(cnd)

            0L31:     watcher$push(cnd)    switch(on_error, continue = invokeRestart("eval_continue"),         stop = invokeRestart("eval_stop"), error = NULL)})eval(call)29:         cat(msg, file = outFile)
32:         else 2L    }, output_handler = knit_handlers(options$render, options)))
44: eng_r(options)        .Internal(printDeferredWarnings())
45: block_exec(params)nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     }withCallingHandlers(code, error = function (e) 
46: call_block(x)with_handlers({rlang::entrace(e), message = function (cnd)     invisible(structure(msg, class = "try-error", condition = e))    for (expr in tle$exprs) {{        ev <- withVisible(eval(expr, envir))
        watcher$capture_plot_and_output()    watcher$capture_plot_and_output()    if (on_message$capture) {        watcher$push(cnd)    }    if (on_message$silence) {        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE        invokeRestart("muffleMessage")}, handlers)
})47:     }
30:     mi = mi, opts = mi$options)

15: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)process_group(group) 4: 
doTryCatch(return(expr), name, parentenv, handler)48: }, warning = function (cnd) eval(call){
    if (getOption("warn") >= 2 || getOption("warn") < 0) {withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), 

        return()31: eval(call)33: doWithOneRestart(return(expr), restart)
34: 
Traceback:
16:     }sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))withOneRestart(expr, restarts[[1L]]) 1: 
35: withRestartList(expr, restarts[-nr])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
36: doWithOneRestart(return(expr), restart)
37:     result <- NULL 5: 
tryCatchOne(expr, names, parentenv, handlers[[1L]])    tryCatch({    error = function(e) {        if (progress && is.function(pb$interrupt))             pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)    watcher$capture_plot_and_output()    if (on_warning$capture) {        cnd <- sanitize_call(cnd)        watcher$push(cnd)        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, 
 6:             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$status32:     }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)    }    })    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: 

tryCatchList(expr, classes, parentenv, handlers)
 7: tryCatch({17:     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))FUN(X[[i]], ...)
18: 49:     result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, eval(call)
withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])lapply(seq_len(cores), inner.do)with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),         model$message <- result$message        mi = mi, opts = mi$options)42: 

38: 
19:     }}, error = function(e) {parallel::mclapply(miList, runModel, mc.cores = numCores)in_dir(input_dir(), expr)31: })


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, 20: withRestartList(expr, restarts) 9: FUN(X[[i]], ...)    stop_on_error = if (is.numeric(options$error)) options$error else {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)
})
        if (options$error && options$include) eval(call)

 8: 
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)            0L        else 2L    }, output_handler = knit_handlers(options$render, options)))    error = function(e) {10: 26: system.time({

        if (progress && is.function(pb$interrupt)) 44: eng_r(options)
45: block_exec(params)eval(expr, envir)    model <- mi$modellapply(X = S, FUN = FUN, ...)39: 
            pb$interrupt()37: 46:         if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)
27: eval(expr, envir)
    }), list(rlang_trace_top_env = knit_global()))    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$solutionwithRestarts(with_handlers({withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
call_block(x)        model$logLik <- as.numeric(-1 * result$objective)        model$iterations <- result$iterations    for (expr in tle$exprs) {

47:         ev <- withVisible(eval(expr, envir))38: 50:         watcher$capture_plot_and_output()        model$status <- result$status        model$message <- result$message    }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) {})xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),         watcher$print_value(ev$value, ev$visible, envir)28: withRestartList(expr, restarts)        if (progress && is.function(pb$interrupt)) 


11:     }    TRUE}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)
40: evaluate::evaluate(...) 9:     error = function(e) {withVisible(eval(expr, envir))        if (progress && is.function(pb$interrupt)) 
            pb$interrupt()41: evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, doTryCatch(return(expr), name, parentenv, handler)
39: 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)})
withRestarts(with_handlers({            pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check())     keep_message = if (is.numeric(options$message)) TRUE else options$message,     for (expr in tle$exprs) {FUN(X[[i]], ...)        ev <- withVisible(eval(expr, envir))            error <<- format(e)        if (is_R_CMD_build() || is_R_CMD_check())     stop_on_error = if (is.numeric(options$error)) options$error else {30: 
eval(call)
        if (options$error && options$include)             error <<- format(e)
        watcher$capture_plot_and_output()    }), list(rlang_trace_top_env = knit_global())), function(loc) {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)        watcher$print_value(ev$value, ev$visible, envir)    }), list(rlang_trace_top_env = knit_global()))31: 12:     setwd(wd)        dcall <- deparse(call, nlines = 1L)    }
eval(call)            0L        else 2L
        prefix <- paste("Error in", dcall, ": ")tryCatchOne(expr, names, parentenv, handlers[[1L]])32:     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)
50:         LONG <- 75L    TRUE    }, output_handler = knit_handlers(options$render, options))51: 
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 <- 75Lprocess_file(text, output)xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),         sm <- strsplit(conditionMessage(e), "\n")[[1L]]        sm <- strsplit(conditionMessage(e), "\n")[[1L]]with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))    error = function(e) {
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:         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) }, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)
        watcher$capture_plot_and_output()call_block(x)
            prefix <- paste0(prefix, "\n  ")
40: evaluate::evaluate(...)
    }        w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")    else prefix <- "Error : "    msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L]))52:         if (progress && is.function(pb$interrupt))             pb$interrupt()knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)47:     if (!silent && isTRUE(getOption("show.error.messages"))) {        if (is_R_CMD_build() || is_R_CMD_check()) 41: evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, 
        cat(msg, file = outFile)    keep_message = if (is.numeric(options$message)) TRUE else options$message,             error <<- format(e)53:         .Internal(printDeferredWarnings())rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),         watcher$print_value(ev$value, ev$visible, envir)    output_dir = getwd(), ...)    }), list(rlang_trace_top_env = knit_global())), function(loc) {    setwd(wd)    stop_on_error = if (is.numeric(options$error)) options$error else {    }    write_utf8(res, output %n% stdout())    invisible(structure(msg, class = "try-error", condition = e))
54: vweave_rmarkdown(...)
})        if (is.na(w)) 
    }        if (options$error && options$include)             w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L],                 type = "b")        if (w > LONG)             prefix <- paste0(prefix, "\n  ")    }            0Lprocess_group(group)
    else prefix <- "Error : "        else 2L    paste0("\nQuitting from ", loc, if (!is.null(error))         paste0("\n", rule(), error, "\n", rule()))15: 55:     TRUE    msg <- paste0(prefix, conditionMessage(e), "\n")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()))    .Internal(seterrmessage(msg[1L]))}, handlers)engine$weave(file, quiet = quiet, encoding = enc)
}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)33: doWithOneRestart(return(expr), restart)
34: withOneRestart(expr, restarts[[1L]])
35: withRestartList(expr, restarts[-nr])
36: doWithOneRestart(return(expr), restart)
37: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
38: withRestartList(expr, restarts)
39:     if (!silent && isTRUE(getOption("show.error.messages"))) {
    }, 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: withRestarts(with_handlers({56:     for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUEdoTryCatch(return(expr), name, parentenv, handler)
57: tryCatchOne(expr, names, parentenv, handlers[[1L]])
58: tryCatchList(expr, classes, parentenv, handlers)
59: tryCatch({
}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)call_block(x)50: 16: 
sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))        cat(msg, file = outFile)    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) {        .Internal(printDeferredWarnings())

    OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))
xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), 51: process_file(text, output)40:     }})17: FUN(X[[i]], ...)
18: lapply(seq_len(cores), inner.do)evaluate::evaluate(...)
60:     invisible(structure(msg, class = "try-error", condition = e))})


19: tools:::.buildOneVignette("mnl_models.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr",     error = function(e) {15: parallel::mclapply(miList, runModel, mc.cores = numCores)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)47: process_group(group)


48: 41: 
19: withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), 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))
parallel::mclapply(miList, runModel, mc.cores = numCores)42: 52: in_dir(input_dir(), expr)knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
20: withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))    TRUE, FALSE, "mnl_models", "UTF-8", "/Volumes/Temp/tmp/RtmpuwPC9a/file2549465a7a06.rds")
53: 
An irrecoverable exception occurred. R is aborting now ...
    error = function(e) {        if (progress && is.function(pb$interrupt))             pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)    })
49:         if (progress && is.function(pb$interrupt)) 
rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(), 
43:             pb$interrupt()in_input_dir(evaluate(code, envir = env, new_device = FALSE, 21: suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))20:     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()))
with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))
21: suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))
    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()))    output_dir = getwd(), ...)        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: 
54: vweave_rmarkdown(...)
55: engine$weave(file, quiet = quiet, encoding = enc)
56: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(), 
22: withCallingHandlers(expr, message = function(c) if (inherits(c,     classes)) tryInvokeRestart("muffleMessage"))
23: 22:     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)50: withCallingHandlers(expr, message = function(c) if (inherits(c,     classes)) tryInvokeRestart("muffleMessage"))
23: suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), suppressMessages(suppressWarnings(parallel::mclapply(miList,     if (!have.makefile && vignette_is_tex(output)) {doTryCatch(return(expr), name, parentenv, handler)}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)    runModel, mc.cores = numCores)))
24: runMultistart(modelInputs)

57: tryCatchOne(expr, names, parentenv, handlers[[1L]])
        texi2pdf(file = output, clean = FALSE, quiet = quiet)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: 

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) {58: 24: runMultistart(modelInputs)
25: logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat",     "brand"), scalePar = "price", numMultiStarts = 10, startVals = wtp_mnl_pref$Estimate)
vweave_rmarkdown(...)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/RtmpuwPC9a/file2549465a7a06.rds")
An irrecoverable exception occurred. R is aborting now ...

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)    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)
        invokeRestart("muffleMessage")    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/RtmpuwPC9a/file2549465a7a06.rds")
An irrecoverable exception occurred. R is aborting now ...
26: eval(expr, envir)
27:     }        output <- find_vignette_product(name, by = "texi2pdf", 51: eval(expr, envir)
28: withVisible(eval(expr, envir))
29: withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) {}, 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)            engine = engine)    }}, error = function(e) {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:     OK <<- FALSE    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)    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/RtmpuwPC9a/file2549465a7a06.rds")
An irrecoverable exception occurred. R is aborting now ...
    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])    watcher$push(cnd)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/RtmpuwPC9a/file2549465a7a06.rds")
An irrecoverable exception occurred. R is aborting now ...

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/RtmpuwPC9a/file2549465a7a06.rds")
An irrecoverable exception occurred. R is aborting now ...
    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/RtmpuwPC9a/file2549465a7a06.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/RtmpuwPC9a/file25491c2046f6.rds")
An irrecoverable exception occurred. R is aborting now ...

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

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

Traceback:
 1: 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)
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:     })
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)
 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({doTryCatch(return(expr), name, parentenv, handler)
57: tryCatchOne(expr, names, parentenv, handlers[[1L]])
58: tryCatchList(expr, classes, parentenv, handlers)
59:         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    }})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)
 9: FUN(X[[i]], ...)
        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", 10: lapply(X = S, FUN = FUN, ...)        file, conditionMessage(e)))})

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) 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/RtmpuwPC9a/file25491c2046f6.rds")
An irrecoverable exception occurred. R is aborting now ...
            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/RtmpuwPC9a/file25491c2046f6.rds")
An irrecoverable exception occurred. R is aborting now ...

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

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

Traceback:
 1: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)
 2: 
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)
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) { 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({})
 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    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)) {    }, error = function(e) {    })    if (!is.null(result)) {        model$fail <- FALSE        model$coefficients <- result$solution        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]], ...)        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: 
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  ")tryCatchList(expr, classes, parentenv, handlers)
14: tryCatch(expr, error = function(e) {    call <- conditionCall(e)    if (!is.null(call)) {    }    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))})        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  ")
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)
    }    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))})19: parallel::mclapply(miList, runModel, mc.cores = numCores)
20: withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))
21: 
15: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
16: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
17: FUN(X[[i]], ...)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: 
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"))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: 
21: suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))
22: withCallingHandlers(expr, message = function(c) if (inherits(c,     classes)) tryInvokeRestart("muffleMessage"))
23: 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)suppressMessages(suppressWarnings(parallel::mclapply(miList,     }    runModel, mc.cores = numCores)))
24: runMultistart(modelInputs)
25: logitr(data = cars_us, outcome = "choice", obsID = "obsnum", 
 *** caught segfault ***
    if (on_warning$silence) {    pars = c("hev", "phev10", "phev20", "phev40", "bev75", "bev100", address 0x110, cause 'invalid permissions'
        invokeRestart("muffleWarning")        "bev150", "american", "japanese", "chinese", "skorean",     }}, 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)        "phevFastcharge", "bevFastcharge", "opCost", "accelTime"), 
    scalePar = "price", robust = TRUE, numMultiStarts = 10)32: 
with_handlers({26: eval(expr, envir)
27: eval(expr, envir)
28: withVisible(eval(expr, envir))
29: withCallingHandlers(code, error = function (e)     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: 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()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]])    }    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)
38: withRestartList(expr, restarts)
39: withRestarts(with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()    }    TRUE}, handlers)
33: doWithOneRestart(return(expr), restart)
34: withOneRestart(expr, restarts[[1L]])
        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, 35: withRestartList(expr, restarts[-nr])
36: doWithOneRestart(return(expr), restart)
37:     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: 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)    }    TRUEeng_r(options)
45: block_exec(params)}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)

 *** caught segfault ***

 *** caught segfault ***

address 0x110, cause 'invalid permissions'
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, 46: 
 *** caught segfault ***
address 0x110, cause 'invalid permissions'
    stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include) call_block(x)            0Laddress 0x110, cause 'invalid permissions'
        else 2L    }, output_handler = knit_handlers(options$render, options))
42: 
47: 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) 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),             0L        else 2L    }, output_handler = knit_handlers(options$render, options)))
44: eng_r(options)
45:     error = function(e) {        if (progress && is.function(pb$interrupt)) 
Traceback:
            pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)    }), list(rlang_trace_top_env = knit_global())) 1: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)
 2: block_exec(params)
46: call_block(x)
47: process_group(group)
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]])
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)
 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) {48: 
52: withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), })
knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet) 8: 
system.time({    error = function(e) {53: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
54:     model <- mi$model        if (progress && is.function(pb$interrupt))     result <- NULL            pb$interrupt()vweave_rmarkdown(...)        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()

 *** caught segfault ***
55:     tryCatch({        if (is_R_CMD_build() || is_R_CMD_check()) engine$weave(file, quiet = quiet, encoding = enc)            error <<- format(e)    }), list(rlang_trace_top_env = knit_global()))
50: 
address 0x110, cause 'invalid permissions'
56: doTryCatch(return(expr), name, parentenv, handler)
xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), 57:     error = function(e) {        if (progress && is.function(pb$interrupt))             pb$interrupt()        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_R_CMD_build() || is_R_CMD_check())             error <<- format(e)    }), list(rlang_trace_top_env = knit_global())), function(loc) {        model$coefficients <- result$solution    setwd(wd)    write_utf8(res, output %n% stdout())        model$logLik <- as.numeric(-1 * result$objective)tryCatchOne(expr, names, parentenv, handlers[[1L]])        model$iterations <- result$iterations
Traceback:
        model$status <- result$status
Traceback:
        model$message <- result$message    paste0("\nQuitting from ", loc, if (!is.null(error))  1:         paste0("\n", rule(), error, "\n", rule()))
    }
Traceback:
 1: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)
 2: eval_f(x0, ...)
58:  1:  3: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     mi = mi, opts = mi$options)})


tryCatchList(expr, classes, parentenv, handlers) 9: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)FUN(X[[i]], ...)
10: }, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc) 2: lapply(X = S, FUN = FUN, ...)
51:  4: eval_f(x0, ...)process_file(text, output)doTryCatch(return(expr), name, parentenv, handler)
 2: eval_f(x0, ...)
 3: 
52: 

11:  3: nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, 
nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, doTryCatch(return(expr), name, parentenv, handler)    mi = mi, opts = mi$options)    mi = mi, opts = mi$options)
59: 

 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
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))) knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)            call <- sys.call(-4L)
 4: doTryCatch(return(expr), name, parentenv, handler)
 4: tryCatch({ 5:  6:     engine$weave(file, quiet = quiet, encoding = enc)doTryCatch(return(expr), name, parentenv, handler)
53: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(), tryCatchOne(expr, names, parentenv, handlers[[1L]])        dcall <- deparse(call, nlines = 1L)tryCatchList(expr, classes, parentenv, handlers)    setwd(startdir)
    output_dir = getwd(), ...)

    output <- find_vignette_product(name, by = "weave", engine = engine)        prefix <- paste("Error in", dcall, ": ") 5:  6: tryCatchList(expr, classes, parentenv, handlers)
 7:     if (!have.makefile && vignette_is_tex(output)) { 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        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))})
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$iterations54: 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:     result <- NULL        texi2pdf(file = output, clean = FALSE, quiet = quiet)15: tryCatchOne(expr, names, parentenv, handlers[[1L]])try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
Traceback:

        output <- find_vignette_product(name, by = "texi2pdf", tryCatch({        model$status <- result$status    tryCatch({        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)            engine = engine)
    engine$weave(file, quiet = quiet, encoding = enc) 1:     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:         dcall <- deparse(call, nlines = 1L)    } 6:         result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)tools:::.buildOneVignette("mnl_models_weighted.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr",         prefix <- paste("Error in", dcall, ": ")    TRUE, FALSE, "mnl_models_weighted", "UTF-8", "/Volumes/Temp/tmp/RtmpuwPC9a/file25491c2046f6.rds")
16:             mi = mi, opts = mi$options)}, error = function(e) {tryCatchList(expr, classes, parentenv, handlers)        LONG <- 75L
sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))    }, error = function(e) {
An irrecoverable exception occurred. R is aborting now ...
17:     OK <<- FALSEFUN(X[[i]], ...)
18:     }) 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) {}) 7:         sm <- strsplit(conditionMessage(e), "\n")[[1L]]    if (!is.null(result)) {    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s", lapply(seq_len(cores), inner.do)
tryCatch({ 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]])    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]], ...)
        file, conditionMessage(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)))         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))        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 : "        model$fail <- FALSE})    msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {
        model$coefficients <- result$solution        model$logLik <- as.numeric(-1 * result$objective)        model$iterations <- result$iterations        cat(msg, file = outFile)
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)
        model$status <- result$status10: 25: 60:         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)
15: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
        .Internal(printDeferredWarnings())16:     }    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(X = S, FUN = FUN, ...)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, logitr(data = cars_us, outcome = "choice", obsID = "obsnum", 
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:     pars = c("hev", "phev10", "phev20", "phev40", "bev75", "bev100",         "bev150", "american", "japanese", "chinese", "skorean",         "phevFastcharge", "bevFastcharge", "opCost", "accelTime"), parallel::mclapply(miList, runModel, mc.cores = numCores)
    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()sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))    if (on_message$capture) {        watcher$push(cnd)    }    if (on_message$silence) {        invokeRestart("muffleMessage")    }}, warning = function (cnd) {
    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    }
tools:::.buildOneVignette("mnl_models_weighted.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr",     watcher$capture_plot_and_output()    if (on_warning$capture) {        cnd <- sanitize_call(cnd)        watcher$push(cnd)    }    if (on_warning$silence) {        invokeRestart("muffleWarning")    }    runModel, mc.cores = numCores)))
    TRUE, FALSE, "mnl_models_weighted", "UTF-8", "/Volumes/Temp/tmp/RtmpuwPC9a/file25491c2046f6.rds")24: }, error = function (cnd) 17: 16: runMultistart(modelInputs)
25: FUN(X[[i]], ...)
An irrecoverable exception occurred. R is aborting now ...
logitr(data = cars_us, outcome = "choice", obsID = "obsnum", 20: 
{    pars = c("hev", "phev10", "phev20", "phev40", "bev75", "bev100", withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))    watcher$capture_plot_and_output()18:         "bev150", "american", "japanese", "chinese", "skorean",         "phevFastcharge", "bevFastcharge", "opCost", "accelTime"),     scalePar = "price", robust = TRUE, numMultiStarts = 10)
26: eval(expr, envir)
27: eval(expr, envir)lapply(seq_len(cores), inner.do)

21: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))19: 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)
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) {    cnd <- sanitize_call(cnd)        invokeRestart("muffleMessage")    }}, warning = function (cnd) {27: 
    watcher$push(cnd)eval(expr, envir)    if (getOption("warn") >= 2 || getOption("warn") < 0) {    switch(on_error, continue = invokeRestart("eval_continue"), 17: parallel::mclapply(miList, runModel, mc.cores = numCores)        return()
20: FUN(X[[i]], ...)    }        stop = invokeRestart("eval_stop"), error = NULL)    watcher$capture_plot_and_output()
28: })withCallingHandlers(expr, warning = function(w) if (inherits(w, 
30: 
withVisible(eval(expr, envir))eval(call)
31: eval(call)
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()    if (on_warning$capture) {    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)        cnd <- sanitize_call(cnd)        watcher$push(cnd)    }    if (on_warning$silence) {    }    TRUE}, handlers)    classes)) tryInvokeRestart("muffleWarning"))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"), 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)    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)})        invokeRestart("muffleWarning")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)
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)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)
    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)    }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,     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:     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), 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)    })
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: 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 = function(e) {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/RtmpuwPC9a/file25491c2046f6.rds")
An irrecoverable exception occurred. R is aborting now ...
46:         if (progress && is.function(pb$interrupt)) }, error = function (cnd)             pb$interrupt()    watcher$capture_plot_and_output()call_block(x)
{    watcher$capture_plot_and_output()    cnd <- sanitize_call(cnd)    watcher$push(cnd)47:         if (is_R_CMD_build() || is_R_CMD_check()) process_group(group)    if (on_warning$capture) {
    switch(on_error, continue = invokeRestart("eval_continue"),         stop = invokeRestart("eval_stop"), error = NULL)48:             error <<- format(e)    }), list(rlang_trace_top_env = knit_global())), function(loc) {    setwd(wd)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)})
        cnd <- sanitize_call(cnd)56:     write_utf8(res, output %n% stdout())doTryCatch(return(expr), name, parentenv, handler)

30:         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)    paste0("\nQuitting from ", loc, if (!is.null(error)) 
57: eval(call)
        paste0("\n", rule(), error, "\n", rule()))31: eval(call)tryCatchOne(expr, names, parentenv, handlers[[1L]])
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)32: }, 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,     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()) with_handlers({
            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)51: 58:     for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))
process_file(text, output)53: 
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/RtmpuwPC9a/file25491c2046f6.rds")
An irrecoverable exception occurred. R is aborting now ...
        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]])rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(), 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:     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]])
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: engine$weave(file, quiet = quiet, encoding = enc)
56: doTryCatch(return(expr), name, parentenv, handler)
eng_r(options)
57: 58: tryCatchOne(expr, names, parentenv, handlers[[1L]])
tryCatchList(expr, classes, parentenv, handlers)58: 
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)
45:     }}, error = function(e) {tryCatchList(expr, classes, parentenv, handlers)    OK <<- FALSE
59: tryCatch({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)    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/RtmpuwPC9a/file25491c2046f6.rds")
An irrecoverable exception occurred. R is aborting now ...
    engine$weave(file, quiet = quiet, encoding = enc)    })
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)    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/RtmpuwPC9a/file25491c2046f6.rds")
An irrecoverable exception occurred. R is aborting now ...
    }), 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/RtmpuwPC9a/file25491c2046f6.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'

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, ...)
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, 
11:     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$modeldoTryCatch(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)) {    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        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)        model$status <- result$status
        model$message <- result$message    }})
 9: FUN(X[[i]], ...)
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, 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")    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:         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))

 *** caught segfault ***
address 0x110, cause 'invalid permissions'
29: withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) {    watcher$capture_plot_and_output()    if (on_message$capture) {eval(expr, envir)
27: eval(expr, envir)
28: withVisible(eval(expr, envir))
        watcher$push(cnd)    }    if (on_message$silence) {        invokeRestart("muffleMessage")    }29: withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) {    watcher$capture_plot_and_output()}, warning = function (cnd) {    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    if (on_message$capture) {        watcher$push(cnd)    }    if (on_message$silence) {    }    watcher$capture_plot_and_output()    if (on_warning$capture) {        cnd <- sanitize_call(cnd)        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()        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)})
    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: })
30: 
 *** caught segfault ***
address 0x110, cause 'invalid permissions'
eval(call)
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)

Traceback:
 1: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)
 2: 34: withOneRestart(expr, restarts[[1L]])
35: withRestartList(expr, restarts[-nr])
36: doWithOneRestart(return(expr), restart)
eval_f(x0, ...)
 3: nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     mi = mi, opts = mi$options)
 4: 37: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
38: withRestartList(expr, restarts)
39: withRestarts(with_handlers({doTryCatch(return(expr), name, parentenv, handler)
 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
 6: tryCatchList(expr, classes, parentenv, handlers)
 7: 31: eval(call)
32: with_handlers({    for (expr in tle$exprs) {        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)    }    TRUE}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)
40:         watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers)
tryCatch({33: doWithOneRestart(return(expr), restart)    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, evaluate::evaluate(...)        mi = mi, opts = mi$options)
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)
34: withOneRestart(expr, restarts[[1L]])
35: withRestartList(expr, restarts[-nr])
36: 
43: in_input_dir(evaluate(code, envir = env, new_device = FALSE, 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)    }}, 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)    keep_warning = if (is.numeric(options$warning)) TRUE else options$warning,     keep_message = if (is.numeric(options$message)) TRUE else options$message,         model$iterations <- result$iterations        model$status <- result$status        model$message <- result$message    stop_on_error = if (is.numeric(options$error)) options$error else {
Traceback:
    TRUE 1:         if (options$error && options$include) mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)
 2: eval_f(x0, ...)
}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)
40: evaluate::evaluate(...)            0L        else 2L    }, output_handler = knit_handlers(options$render, options)))
44: eng_r(options)    }
 3: 45: block_exec(params)
46: call_block(x)
})
47: process_group(group)nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, 41: evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, 
    mi = mi, opts = mi$options) 9: FUN(X[[i]], ...)
10: lapply(X = S, FUN = FUN, ...)
11: 
    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: 48: doTryCatch(return(expr), name, parentenv, handler)withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), 
12: tryCatchOne(expr, names, parentenv, handlers[[1L]])

13:  4: doTryCatch(return(expr), name, parentenv, handler)
 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
 6: tryCatchList(expr, classes, parentenv, handlers)
 7: tryCatchList(expr, classes, parentenv, handlers)
Traceback:

 1:     error = function(e) {        if (progress && is.function(pb$interrupt)) 14:             pb$interrupt()tryCatch(expr, error = function(e) {        if (is_R_CMD_build() || is_R_CMD_check()) mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)in_dir(input_dir(), expr)tryCatch({    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,         mi = mi, opts = mi$options)    call <- conditionCall(e)    if (!is.null(call)) {        if (identical(call[[1L]], quote(doTryCatch))) 
            call <- sys.call(-4L) 2: }, error = function(e) {
eval_f(x0, ...)            error <<- format(e)43: })        dcall <- deparse(call, nlines = 1L)        prefix <- paste("Error in", dcall, ": ")        LONG <- 75L        sm <- strsplit(conditionMessage(e), "\n")[[1L]]in_input_dir(evaluate(code, envir = env, new_device = FALSE, 
        w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")    keep_warning = if (is.numeric(options$warning)) TRUE else options$warning,     }) 3:     keep_message = if (is.numeric(options$message)) TRUE else options$message, 

nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,  8:     mi = mi, opts = mi$options)
 4: doTryCatch(return(expr), name, parentenv, handler)
    stop_on_error = if (is.numeric(options$error)) options$error else {
 *** caught segfault ***
 5:         if (options$error && options$include) address 0x110, cause 'invalid permissions'
49:             0Lsystem.time({with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),         if (is.na(w))         else 2L    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"))) {
 *** caught segfault ***
    }, output_handler = knit_handlers(options$render, options)))address 0x110, cause 'invalid permissions'
        cat(msg, file = outFile)
        .Internal(printDeferredWarnings())tryCatchOne(expr, names, parentenv, handlers[[1L]])
44: eng_r(options)
    }    invisible(structure(msg, class = "try-error", condition = e))})
15: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
 6:     model <- mi$model        if (progress && is.function(pb$interrupt)) tryCatchList(expr, classes, parentenv, handlers)16:     result <- NULL            pb$interrupt()    tryCatch({45: block_exec(params)
46:         result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,         if (is_R_CMD_build() || is_R_CMD_check()) call_block(x)sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
17:             mi = mi, opts = mi$options)FUN(X[[i]], ...)    }, error = function(e) {


    })47:     if (!is.null(result)) {            error <<- format(e)    }), list(rlang_trace_top_env = knit_global()))
18: 50: process_group(group)lapply(seq_len(cores), inner.do) 7: tryCatch({    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,         mi = mi, opts = mi$options)
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()) 
 *** caught segfault ***
        model$fail <- FALSE        model$coefficients <- result$solution        model$logLik <- as.numeric(-1 * result$objective)        model$iterations <- result$iterations        model$status <- result$statusaddress 0x110, cause 'invalid permissions'
        model$message <- result$message
}, error = function(e) {})
19: parallel::mclapply(miList, runModel, mc.cores = numCores)
            error <<- format(e)    })
xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     }})49:     error = function(e) { 8: system.time({
20:         if (progress && is.function(pb$interrupt))  9: withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))FUN(X[[i]], ...)
    model <- mi$model
10: with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     result <- NULL    tryCatch({        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,             mi = mi, opts = mi$options)    }, 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)))            pb$interrupt()    error = function(e) {lapply(X = S, FUN = FUN, ...)    })    if (!is.null(result)) {        model$fail <- FALSE
        if (is_R_CMD_build() || is_R_CMD_check()) 24:         model$coefficients <- result$solution        if (progress && is.function(pb$interrupt)) 
Traceback:
 1: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)


Traceback:
 1: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)runMultistart(modelInputs) 2: eval_f(x0, ...)
        model$logLik <- as.numeric(-1 * result$objective) 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)            pb$interrupt()
            error <<- format(e)25: logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat",     "brand"), scalePar = "price", numMultiStarts = 10)
26: eval(expr, envir)
        model$iterations <- result$iterations27: eval(expr, envir)
28: withVisible(eval(expr, envir))
        if (is_R_CMD_build() || is_R_CMD_check())         model$status <- result$status        model$message <- result$message11:             error <<- format(e)    }), list(rlang_trace_top_env = knit_global()))

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

 2: eval_f(x0, ...)
 3: nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, 50: }, error = function(e) {})
 8: system.time({51: 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()    model <- mi$model    }    mi = mi, opts = mi$options)process_file(text, output)
})
52: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)        if (is_R_CMD_build() || is_R_CMD_check()) 
53: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
54: vweave_rmarkdown(...)
55: engine$weave(file, quiet = quiet, encoding = enc)
doTryCatch(return(expr), name, parentenv, handler)    result <- NULL    tryCatch({        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, 
 *** caught segfault ***
 4: 
            error <<- format(e)doTryCatch(return(expr), name, parentenv, handler)
Traceback:
56: doTryCatch(return(expr), name, parentenv, handler)
57:  1: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)
 2: eval_f(x0, ...)    }), list(rlang_trace_top_env = knit_global())), function(loc) {
29:  9:     setwd(wd)FUN(X[[i]], ...)    write_utf8(res, output %n% stdout())withCallingHandlers(code, error = function (e) tryCatchOne(expr, names, parentenv, handlers[[1L]])
58: tryCatchList(expr, classes, parentenv, handlers)

    paste0("\nQuitting from ", loc, if (!is.null(error)) 
59: tryCatch({            mi = mi, opts = mi$options)10: 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)))         paste0("\n", rule(), error, "\n", rule()))            call <- sys.call(-4L)        dcall <- deparse(call, nlines = 1L)lapply(X = S, FUN = FUN, ...)    engine$weave(file, quiet = quiet, encoding = enc)}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)
    }, error = function(e) {51: process_file(text, output)    })
rlang::entrace(e), message = function (cnd) 
 5: {    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) {        prefix <- paste("Error in", dcall, ": ")
    if (!is.null(result)) {    watcher$capture_plot_and_output()11:     setwd(startdir)    output <- find_vignette_product(name, by = "weave", engine = engine) 3: 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())        LONG <- 75L
Traceback:
    cnd <- sanitize_call(cnd)    if (!have.makefile && vignette_is_tex(output)) {52: nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, address 0x110, cause 'invalid permissions'
    }    watcher$push(cnd)    switch(on_error, continue = invokeRestart("eval_continue"),         stop = invokeRestart("eval_stop"), error = NULL)})
30: eval(call)
31: eval(call)
        texi2pdf(file = output, clean = FALSE, quiet = quiet)tryCatchOne(expr, names, parentenv, handlers[[1L]])    mi = mi, opts = mi$options)
 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)        sm <- strsplit(conditionMessage(e), "\n")[[1L]] 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,         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  ")    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) {})
    }        model$fail <- FALSE    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:         model$coefficients <- result$solution        output <- find_vignette_product(name, by = "texi2pdf",             engine = engine)
Traceback:
    invisible(structure(msg, class = "try-error", condition = e))withCallingHandlers(expr, message = function(c) if (inherits(c,     }, error = function(e) {
 8:  1:         model$logLik <- as.numeric(-1 * result$objective)mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet) 4:     })    classes)) tryInvokeRestart("muffleMessage"))        model$iterations <- result$iterations32: doTryCatch(return(expr), name, parentenv, handler)    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)})
15: system.time({
    }}, 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/RtmpuwPC9a/file2549d917d4c.rds")
An irrecoverable exception occurred. R is aborting now ...
        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  ")try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
16: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
17: FUN(X[[i]], ...)
18: with_handlers({
    model <- mi$model 5:     }lapply(seq_len(cores), inner.do)

tryCatchOne(expr, names, parentenv, handlers[[1L]])    else prefix <- "Error : "    result <- NULL 2:     tryCatch({    msg <- paste0(prefix, conditionMessage(e), "\n")        model$status <- result$status53:     .Internal(seterrmessage(msg[1L]))        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))) 
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:             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")        model$message <- result$messagermarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     for (expr in tle$exprs) {    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:         if (is.na(w))         ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()
    }    if (!silent && isTRUE(getOption("show.error.messages"))) {})            w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L], 
 6: 19:         watcher$print_value(ev$value, ev$visible, envir)eval(expr, envir)tryCatchList(expr, classes, parentenv, handlers) 9: tryCatchList(expr, classes, parentenv, handlers)parallel::mclapply(miList, runModel, mc.cores = numCores)    }FUN(X[[i]], ...)

        cat(msg, file = outFile)28: 59: 

                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))        .Internal(printDeferredWarnings())eval_f(x0, ...)    TRUE}, handlers)
 7: withVisible(eval(expr, envir))
33: 29: tryCatch({
tryCatch({10:     engine$weave(file, quiet = quiet, encoding = enc)    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, 
20:         mi = mi, opts = mi$options)lapply(X = S, FUN = FUN, ...)}, error = function(e) {})
 8: system.time({    model <- mi$model    result <- NULL    tryCatch({        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     }    invisible(structure(msg, class = "try-error", condition = e))})
            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    }15: doWithOneRestart(return(expr), restart)
34: withOneRestart(expr, restarts[[1L]])
35: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
17: withRestartList(expr, restarts[-nr])})
36: doWithOneRestart(return(expr), restart)
37: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))
withCallingHandlers(code, error = function (e) 
11:     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)))}) 3: 
21:  9: FUN(X[[i]], ...)
10: FUN(X[[i]], ...)suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))
22: withCallingHandlers(expr, message = function(c) if (inherits(c, 
16: 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)    }rlang::entrace(e), message = function (cnd) sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     TRUE    classes)) tryInvokeRestart("muffleMessage"))
doTryCatch(return(expr), name, parentenv, handler)
lapply(X = S, FUN = FUN, ...)23:     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, {
}, 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, suppressMessages(suppressWarnings(parallel::mclapply(miList, 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: 
18: lapply(seq_len(cores), inner.do)
19: parallel::mclapply(miList, runModel, mc.cores = numCores)11: 
20: withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))
21:             mi = mi, opts = mi$options)    }, error = function(e) {    })    if (!is.null(result)) {        model$fail <- FALSE        model$coefficients <- result$solution    runModel, mc.cores = numCores)))12: 
tryCatchOne(expr, names, parentenv, handlers[[1L]])
13: tryCatchList(expr, classes, parentenv, handlers)
        model$logLik <- as.numeric(-1 * result$objective)doTryCatch(return(expr), name, parentenv, handler)    stop_on_error = if (is.numeric(options$error)) options$error else {
suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))14:     watcher$capture_plot_and_output()withCallingHandlers(expr, message = function(c) if (inherits(c,     if (on_message$capture) {
        model$iterations <- result$iterationstryCatch(expr, error = function(e) {12:     classes)) tryInvokeRestart("muffleMessage"))        if (options$error && options$include) 
23: suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))
24:         model$status <- result$status60:         watcher$push(cnd)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/RtmpuwPC9a/file2549d917d4c.rds")
An irrecoverable exception occurred. R is aborting now ...
    }    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) {    call <- conditionCall(e)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) 
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)24:     if (!is.null(call)) {            0L        cnd <- sanitize_call(cnd)        model$message <- result$messagetryCatchOne(expr, names, parentenv, handlers[[1L]])    }})
{        else 2L
    }, output_handler = knit_handlers(options$render, options))
42:         if (identical(call[[1L]], quote(doTryCatch)))  9: runMultistart(modelInputs)
25:         watcher$push(cnd)    watcher$capture_plot_and_output()FUN(X[[i]], ...)in_dir(input_dir(), expr)13:             call <- sys.call(-4L)    }        dcall <- deparse(call, nlines = 1L)

tryCatchList(expr, classes, parentenv, handlers)    if (on_message$capture) {logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat", 
        prefix <- paste("Error in", dcall, ": ")    if (on_warning$silence) {25: logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat",     "brand"), scalePar = "price", numMultiStarts = 10)
        invokeRestart("muffleWarning")        LONG <- 75L10:         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)     "brand"), scalePar = "price", numMultiStarts = 10)}, error = function (cnd) 26: 14: lapply(X = S, FUN = FUN, ...)
tryCatch(expr, error = function(e) {26: eval(expr, envir)
27:         watcher$push(cnd){43:             prefix <- paste0(prefix, "\n  ")
    }eval(expr, envir)    if (on_message$silence) {        invokeRestart("muffleMessage")    }}, warning = function (cnd) {    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    }
28: withVisible(eval(expr, envir))
29: withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) eval(expr, envir)    call <- conditionCall(e)    watcher$capture_plot_and_output()    cnd <- sanitize_call(cnd)    watcher$push(cnd)    }    watcher$capture_plot_and_output()in_input_dir(evaluate(code, envir = env, new_device = FALSE,     if (on_warning$capture) {        cnd <- sanitize_call(cnd)        watcher$push(cnd)    }    if (on_warning$silence) {{    switch(on_error, continue = invokeRestart("eval_continue"),     else prefix <- "Error : "        invokeRestart("muffleWarning")
    if (!is.null(call)) {    }}, error = function (cnd) {    watcher$capture_plot_and_output()    cnd <- sanitize_call(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 : "    msg <- paste0(prefix, conditionMessage(e), "\n")    keep_warning = if (is.numeric(options$warning)) TRUE else options$warning,     watcher$capture_plot_and_output()27:     .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()11: 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 (on_message$capture) {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options)))
    watcher$push(cnd)    if (on_message$capture) {doTryCatch(return(expr), name, parentenv, handler)    msg <- paste0(prefix, conditionMessage(e), "\n")        stop = invokeRestart("eval_stop"), error = NULL)44: 28:         watcher$push(cnd)
    switch(on_error, continue = invokeRestart("eval_continue"), 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]]eng_r(options)    .Internal(seterrmessage(msg[1L]))
        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()45: block_exec(params)withVisible(eval(expr, envir))    if (!silent && isTRUE(getOption("show.error.messages"))) {
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) {})    }        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$push(cnd)        cat(msg, file = outFile)        w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")        invokeRestart("muffleWarning")
withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])    }    if (on_message$silence) {30:     }46:         .Internal(printDeferredWarnings())    if (on_message$silence) {        invokeRestart("muffleMessage")eval(call)}, error = function (cnd) 
31: eval(call)
32: with_handlers({call_block(x)

        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)    }47: {38:         .Internal(printDeferredWarnings())        invokeRestart("muffleMessage")    invisible(structure(msg, class = "try-error", condition = e))process_group(group)    }    watcher$capture_plot_and_output()    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)
withRestartList(expr, restarts)}, warning = function (cnd)     cnd <- sanitize_call(cnd)

48: 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)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
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))
        else 2LwithCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     }    watcher$push(cnd)}, 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: 22: 33: 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)    }    }, output_handler = knit_handlers(options$render, options))
    if (on_warning$silence) {        invokeRestart("muffleWarning")    }}, error = function (cnd) {    watcher$capture_plot_and_output()    cnd <- sanitize_call(cnd)    invisible(structure(msg, class = "try-error", condition = e))doWithOneRestart(return(expr), restart)    switch(on_error, continue = invokeRestart("eval_continue"), 
34: withOneRestart(expr, restarts[[1L]])
35: withRestartList(expr, restarts[-nr])
36: doWithOneRestart(return(expr), restart)
37: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
38: eval(call)withRestartList(expr, restarts)})
15: {
42: 
try(lapply(X = S, FUN = FUN, ...), silent = TRUE)    watcher$push(cnd)        stop = invokeRestart("eval_stop"), error = NULL)    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    }    watcher$capture_plot_and_output()    if (on_warning$capture) {        cnd <- sanitize_call(cnd)        watcher$push(cnd)
    error = function(e) {16: 39: 31:         if (progress && is.function(pb$interrupt))     switch(on_error, continue = invokeRestart("eval_continue"),         stop = invokeRestart("eval_stop"), error = NULL)in_dir(input_dir(), expr)withRestarts(with_handlers({})            pb$interrupt()
    }eval(call)
43: in_input_dir(evaluate(code, envir = env, new_device = FALSE, })        if (is_R_CMD_build() || is_R_CMD_check())     keep_warning = if (is.numeric(options$warning)) TRUE else options$warning,     if (on_warning$silence) {
32: with_handlers({    keep_message = if (is.numeric(options$message)) TRUE else options$message,             error <<- format(e)sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
17: FUN(X[[i]], ...)
18: lapply(seq_len(cores), inner.do)
19:         invokeRestart("muffleWarning")    for (expr in tle$exprs) {    for (expr in tle$exprs) {    stop_on_error = if (is.numeric(options$error)) options$error else {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]])parallel::mclapply(miList, runModel, mc.cores = numCores)
20: 
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))         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)withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("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: 
        paste0("\n", rule(), error, "\n", rule()))
        ev <- withVisible(eval(expr, envir))        if (options$error && options$include)     })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])
30: }, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)    TRUE            0L21:         else 2L    }, output_handler = knit_handlers(options$render, options)))

        watcher$capture_plot_and_output()}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)eval(call)suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))44: 51: 
31: 
process_file(text, output)
eng_r(options)
45: 22: 
        watcher$print_value(ev$value, ev$visible, envir)36: block_exec(params)eval(call)withCallingHandlers(expr, message = function(c) if (inherits(c, 52:     }40: doWithOneRestart(return(expr), restart)
    classes)) tryInvokeRestart("muffleMessage"))
23: suppressMessages(suppressWarnings(parallel::mclapply(miList, knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)

evaluate::evaluate(...)
32:     runModel, mc.cores = numCores)))
24: 
runMultistart(modelInputs)

37: 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)withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])25: logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat",     "brand"), scalePar = "price", numMultiStarts = 10)
26:     TRUE
eval(expr, envir)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), 38:     error = function(e) {        if (progress && is.function(pb$interrupt)) withRestartList(expr, restarts)
39:     }
49: 41: 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), 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: withRestarts(with_handlers({    TRUE27: 53: in_dir(input_dir(), expr)    error = function(e) {
}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)eval(expr, envir)    for (expr in tle$exprs) {}, handlers)        if (progress && is.function(pb$interrupt)) 43:             pb$interrupt()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)        if (is_R_CMD_build() || is_R_CMD_check()) 
            pb$interrupt()        ev <- withVisible(eval(expr, envir))
rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(), 33: doWithOneRestart(return(expr), restart)
34: withOneRestart(expr, restarts[[1L]])
35: withRestartList(expr, restarts[-nr])
36:     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({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 <<- 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()))        if (is_R_CMD_build() || is_R_CMD_check())         watcher$capture_plot_and_output()
40: 
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)) 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,             error <<- format(e)40: 28: evaluate::evaluate(...)    engine$weave(file, quiet = quiet, encoding = enc)        paste0("\n", rule(), error, "\n", rule()))    stop_on_error = if (is.numeric(options$error)) options$error else {}, 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)
        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), withVisible(eval(expr, envir))    setwd(startdir)
    }), list(rlang_trace_top_env = knit_global())), function(loc) {    }), list(rlang_trace_top_env = knit_global())), function(loc) {    error = function(e) {
    output <- find_vignette_product(name, by = "weave", engine = engine)41: 59:     setwd(wd)        if (progress && is.function(pb$interrupt))     setwd(wd)evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning,         watcher$print_value(ev$value, ev$visible, envir)tryCatch({    engine$weave(file, quiet = quiet, encoding = enc)    keep_message = if (is.numeric(options$message)) TRUE else options$message,     }    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/RtmpuwPC9a/file2549d917d4c.rds")    TRUE29: withCallingHandlers(code, error = function (e) }, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)            pb$interrupt()

    if (!have.makefile && vignette_is_tex(output)) {    write_utf8(res, output %n% stdout())An irrecoverable exception occurred. R is aborting now ...
        if (is_R_CMD_build() || is_R_CMD_check()) 40:             error <<- format(e)    stop_on_error = if (is.numeric(options$error)) options$error else {    paste0("\nQuitting from ", loc, if (!is.null(error)) rlang::entrace(e), message = function (cnd)         texi2pdf(file = output, clean = FALSE, quiet = quiet)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)     })        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/RtmpuwPC9a/file2549d917d4c.rds")
An irrecoverable exception occurred. R is aborting now ...
{    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:     write_utf8(res, output %n% stdout())        paste0("\n", rule(), error, "\n", rule()))            0L        if (options$error && options$include)         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), withRestartList(expr, restarts)            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()) 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(), }, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)            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()))    output_dir = getwd(), ...)    error = function(e) {
    paste0("\nQuitting from ", loc, if (!is.null(error))         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: }, 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]])39: 
54: 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: 51:         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)
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)    }
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)))})}, 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", process_file(text, output)    TRUE, FALSE, "predict", "UTF-8", "/Volumes/Temp/tmp/RtmpuwPC9a/file2549d917d4c.rds")
An irrecoverable exception occurred. R is aborting now ...
knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
53: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
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/RtmpuwPC9a/file2549d917d4c.rds")
An irrecoverable exception occurred. R is aborting now ...
evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, 
60: tools:::.buildOneVignette("predict.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr", 
52: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
53: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
    TRUE, FALSE, "predict", "UTF-8", "/Volumes/Temp/tmp/RtmpuwPC9a/file2549d917d4c.rds")54: vweave_rmarkdown(...)    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)

55: engine$weave(file, quiet = quiet, encoding = enc)
56: doTryCatch(return(expr), name, parentenv, handler)
57: tryCatchOne(expr, names, parentenv, handlers[[1L]])
58: 
An irrecoverable exception occurred. R is aborting now ...
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) {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({tryCatchList(expr, classes, parentenv, handlers)
59: tryCatch({    engine$weave(file, quiet = quiet, encoding = enc)    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/RtmpuwPC9a/file2549d917d4c.rds")
An irrecoverable exception occurred. R is aborting now ...
    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)    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/RtmpuwPC9a/file2549d917d4c.rds")
    }}, 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/RtmpuwPC9a/file2549d917d4c.rds")An irrecoverable exception occurred. R is aborting now ...

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