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

 *** 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,  1:     mi = mi, opts = mi$options)
 4: doTryCatch(return(expr), name, parentenv, handler)
 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])

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

13: tryCatchList(expr, classes, parentenv, handlers)

Traceback:
lapply(X = S, FUN = FUN, ...)
 1: 14: tryCatch(expr, error = function(e) {    call <- conditionCall(e)    if (!is.null(call)) {11: 
11:         if (identical(call[[1L]], quote(doTryCatch)))  1: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)
 2: eval_f(x0, ...)doTryCatch(return(expr), name, parentenv, handler)
            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")doTryCatch(return(expr), name, parentenv, handler)        if (is.na(w))             w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L],  3:                 type = "b")        if (w > LONG)             prefix <- paste0(prefix, "\n  ")nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)    }    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)
    else prefix <- "Error : "

 7:     msg <- paste0(prefix, conditionMessage(e), "\n") 2:     .Internal(seterrmessage(msg[1L]))
eval_f(x0, ...)
 3: nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     mi = mi, opts = mi$options)12: 12: tryCatchOne(expr, names, parentenv, handlers[[1L]])
tryCatch({13:     if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, file = outFile)        .Internal(printDeferredWarnings())    }    invisible(structure(msg, class = "try-error", condition = e))    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, 
tryCatchList(expr, classes, parentenv, handlers) 4: 
doTryCatch(return(expr), name, parentenv, handler)14: 
 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
 6: tryCatchList(expr, classes, parentenv, handlers)
 7: tryCatchOne(expr, names, parentenv, handlers[[1L]])})tryCatch(expr, error = function(e) {tryCatch({
    call <- conditionCall(e)    if (!is.null(call)) {        if (identical(call[[1L]], quote(doTryCatch)))     result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, 15: 
try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
16: 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: parallel::mclapply(miList, runModel, mc.cores = numCores)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, ": ")
            call <- sys.call(-4L)}, error = function(e) {20:         dcall <- deparse(call, nlines = 1L)})        LONG <- 75L        mi = mi, opts = mi$options)        sm <- strsplit(conditionMessage(e), "\n")[[1L]]        w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")        if (is.na(w))             w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L],                 type = "b")        if (w > LONG)         prefix <- paste("Error in", dcall, ": ")
            prefix <- paste0(prefix, "\n  ")    }    else prefix <- "Error : "    msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L])) 8: }, error = function(e) {withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))
21: suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))
22:         LONG <- 75L        sm <- strsplit(conditionMessage(e), "\n")[[1L]]        w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")})system.time({    model <- mi$model    result <- NULL    tryCatch({        if (is.na(w)) 
 8: system.time({            w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L],     if (!silent && isTRUE(getOption("show.error.messages"))) {        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     model <- mi$model    result <- NULL    tryCatch({        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,             mi = mi, opts = mi$options)            mi = mi, opts = mi$options)                type = "b")        if (w > LONG)     }, error = function(e) {        cat(msg, file = outFile)    }, error = function(e) {withCallingHandlers(expr, message = function(c) if (inherits(c,         .Internal(printDeferredWarnings())    }            prefix <- paste0(prefix, "\n  ")    })    })    invisible(structure(msg, class = "try-error", condition = e))})
15: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)    classes)) tryInvokeRestart("muffleMessage"))    if (!is.null(result)) {    }
        model$fail <- FALSE    if (!is.null(result)) {23: suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))
24: runMultistart(modelInputs)
25:         model$fail <- FALSE    else prefix <- "Error : "
        model$coefficients <- result$solutionlogitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat",     "brand"), scalePar = "price", numMultiStarts = 10)
    msg <- paste0(prefix, conditionMessage(e), "\n")        model$logLik <- as.numeric(-1 * result$objective)26:     .Internal(seterrmessage(msg[1L]))eval(expr, envir)    if (!silent && isTRUE(getOption("show.error.messages"))) {        model$coefficients <- result$solution        cat(msg, file = outFile)16:         model$iterations <- result$iterations        model$status <- result$status        model$message <- result$message        .Internal(printDeferredWarnings())        model$logLik <- as.numeric(-1 * result$objective)sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
17: FUN(X[[i]], ...)        model$iterations <- result$iterations
 *** caught segfault ***
    }    invisible(structure(msg, class = "try-error", condition = e))address 0x110, cause 'invalid permissions'

})

18: lapply(seq_len(cores), inner.do)
19: parallel::mclapply(miList, runModel, mc.cores = numCores)15: 27:     }})
eval(expr, envir)
28: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
withVisible(eval(expr, envir))
29: withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd)         model$status <- result$status        model$message <- result$message    }})
 9: { 9: FUN(X[[i]], ...)
    watcher$capture_plot_and_output()    if (on_message$capture) {        watcher$push(cnd)FUN(X[[i]], ...)    }
20: 10: withCallingHandlers(expr, warning = function(w) if (inherits(w, 16:     classes)) tryInvokeRestart("muffleWarning"))

 *** caught segfault ***

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)10: lapply(X = S, FUN = FUN, ...)lapply(X = S, FUN = FUN, ...)
11: doTryCatch(return(expr), name, parentenv, handler)
12: tryCatchOne(expr, names, parentenv, handlers[[1L]])

 *** caught segfault ***
address 0x110, cause 'invalid permissions'
sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))

11: doTryCatch(return(expr), name, parentenv, handler)
    if (on_message$silence) {address 0x110, cause 'invalid permissions'

13: 12: tryCatchOne(expr, names, parentenv, handlers[[1L]])
13: tryCatchList(expr, classes, parentenv, handlers)
14: 17: 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) tryCatchList(expr, classes, parentenv, handlers)            prefix <- paste0(prefix, "\n  ")
27: FUN(X[[i]], ...)eval(expr, envir)
14:         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")    }18: tryCatch(expr, error = function(e) {    call <- conditionCall(e)    if (!is.null(call)) {        if (identical(call[[1L]], quote(doTryCatch)))             call <- sys.call(-4L)lapply(seq_len(cores), inner.do)        dcall <- deparse(call, nlines = 1L)

19: }, error = function (cnd)     }{28:         prefix <- paste("Error in", dcall, ": ")withVisible(eval(expr, envir))        LONG <- 75L    else prefix <- "Error : "parallel::mclapply(miList, runModel, mc.cores = numCores)    watcher$capture_plot_and_output()    msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L]))        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],     cnd <- sanitize_call(cnd)    if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, file = outFile)        .Internal(printDeferredWarnings())    }    watcher$push(cnd)
    switch(on_error, continue = invokeRestart("eval_continue"), 20:         stop = invokeRestart("eval_stop"), error = NULL)    invisible(structure(msg, class = "try-error", condition = e))})
withCallingHandlers(expr, warning = function(w) if (inherits(w, 
                type = "b")    classes)) tryInvokeRestart("muffleWarning"))29: 15:         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))withCallingHandlers(code, error = function (e) })
Traceback:
try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
})

 1: 
rlang::entrace(e), message = function (cnd) 15: 21: suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))
22: withCallingHandlers(expr, message = function(c) if (inherits(c, 30: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
16: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
17: FUN(X[[i]], ...)
18: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)eval(call)
 2: {    classes)) tryInvokeRestart("muffleMessage"))
lapply(seq_len(cores), inner.do)
19: parallel::mclapply(miList, runModel, mc.cores = numCores)eval_f(x0, ...)31: 
    watcher$capture_plot_and_output()    if (on_message$capture) {
 3: nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     mi = mi, opts = mi$options)        watcher$push(cnd)    }    if (on_message$silence) {        invokeRestart("muffleMessage")    }
 4: eval(call)
16: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
17: FUN(X[[i]], ...)
18: lapply(seq_len(cores), inner.do)
19: parallel::mclapply(miList, runModel, mc.cores = numCores)}, warning = function (cnd) 
20: {    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    }    watcher$capture_plot_and_output()    if (on_warning$capture) {
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"))20: 23: suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))withCallingHandlers(expr, warning = function(w) if (inherits(w, 
24: 32: doTryCatch(return(expr), name, parentenv, handler)with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))runMultistart(modelInputs)
25: logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat",     "brand"), scalePar = "price", numMultiStarts = 10)        watcher$capture_plot_and_output()    classes)) tryInvokeRestart("muffleWarning"))
21:         cnd <- sanitize_call(cnd)


23: suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))
24: 
Traceback:

Traceback:
suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores)) 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: runMultistart(modelInputs) 1: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)

25: logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat",     "brand"), scalePar = "price", numMultiStarts = 10)
26: 
26: doTryCatch(return(expr), name, parentenv, handler)        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]])
        watcher$push(cnd)22: withCallingHandlers(expr, message = function(c) if (inherits(c,     classes)) tryInvokeRestart("muffleMessage"))
23: suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))
38:     }    if (on_warning$silence) {eval(expr, envir)
 5:  5:         invokeRestart("muffleWarning")tryCatchOne(expr, names, parentenv, handlers[[1L]]) 2: tryCatchOne(expr, names, parentenv, handlers[[1L]])    }}, error = function (cnd) {withRestartList(expr, restarts)
24: eval_f(x0, ...) 6: 
27: eval(expr, envir)
28: eval(expr, envir)runMultistart(modelInputs)

39: withRestarts(with_handlers({25: 
 3:     watcher$capture_plot_and_output()
    for (expr in tle$exprs) {logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat",     "brand"), scalePar = "price", numMultiStarts = 10)
26: eval(expr, envir)
27: eval(expr, envir)
28:     cnd <- sanitize_call(cnd)27:         ev <- withVisible(eval(expr, envir))withVisible(eval(expr, envir))
 6: tryCatchList(expr, classes, parentenv, handlers)
eval(expr, envir)withVisible(eval(expr, envir))tryCatchList(expr, classes, parentenv, handlers)
 *** caught segfault ***

nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,         watcher$capture_plot_and_output()    mi = mi, opts = mi$options)
 4: doTryCatch(return(expr), name, parentenv, handler)
 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE
 *** caught segfault ***
    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
address 0x110, cause 'invalid permissions'
 7:  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({29: withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) address 0x110, cause 'invalid permissions'
    model <- mi$model    result <- NULL29:     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)) {withCallingHandlers(code, error = function (e) 
        model$fail <- FALSE}, handlers)        model$coefficients <- result$solutionrlang::entrace(e), message = function (cnd) }, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE){
28:  6:     watcher$capture_plot_and_output()
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,         model$logLik <- as.numeric(-1 * result$objective)tryCatchList(expr, classes, parentenv, handlers)withVisible(eval(expr, envir))

    keep_message = if (is.numeric(options$message)) TRUE else options$message,         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)
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)
    stop_on_error = if (is.numeric(options$error)) options$error else { 7:  4: {    watcher$capture_plot_and_output()        if (options$error && options$include)     if (on_message$capture) {tryCatch({29: 33: doWithOneRestart(return(expr), restart)
34: doTryCatch(return(expr), name, parentenv, handler)            0L        else 2L    }, output_handler = knit_handlers(options$render, options)))
44: eng_r(options)
45:     result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, 
Traceback:
        mi = mi, opts = mi$options)
        watcher$push(cnd)    }    if (on_message$silence) {        invokeRestart("muffleMessage")    }}, warning = function (cnd) {
withCallingHandlers(code, error = function (e) 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)
withOneRestart(expr, restarts[[1L]]) 5: rlang::entrace(e), message = function (cnd) 28: 52: 
35: withRestartList(expr, restarts[-nr])
    if (on_message$capture) { 1:     if (getOption("warn") >= 2 || getOption("warn") < 0) {tryCatchOne(expr, names, parentenv, handlers[[1L]])mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)        return()    }    watcher$capture_plot_and_output()    if (on_warning$capture) {        cnd <- sanitize_call(cnd)

 2: eval_f(x0, ...)
 3: nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     mi = mi, opts = mi$options)
 4: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)withVisible(eval(expr, envir))tryCatch({36: }, error = function(e) {doWithOneRestart(return(expr), restart)

doTryCatch(return(expr), name, parentenv, handler)    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,  6: 
        watcher$push(cnd)        watcher$push(cnd)37: tryCatchList(expr, classes, parentenv, handlers)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()29:     }53:     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"), 

{ 7: })
 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)tryCatch({ 5:         stop = invokeRestart("eval_stop"), error = NULL)        mi = mi, opts = mi$options)    watcher$capture_plot_and_output()}, error = function(e) {})
 8: system.time({tryCatchOne(expr, names, parentenv, handlers[[1L]])    if (on_message$capture) {        watcher$push(cnd)    }    if (on_message$silence) {        invokeRestart("muffleMessage")    }}, warning = function (cnd) {    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    }    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,         model$iterations <- result$iterations    watcher$capture_plot_and_output()    if (on_warning$capture) {        cnd <- sanitize_call(cnd)    model <- mi$model        watcher$push(cnd)        mi = mi, opts = mi$options)rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(), })}, error = function(e) {
 6: tryCatchList(expr, classes, parentenv, handlers)
 7: tryCatch({    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     result <- NULL    output_dir = getwd(), ...)
54: vweave_rmarkdown(...)
55: engine$weave(file, quiet = quiet, encoding = enc)        watcher$print_value(ev$value, ev$visible, envir)})

    }    if (on_message$silence) {    }        mi = mi, opts = mi$options)    }    tryCatch({ 8: }, error = function(e) {        model$status <- result$statuswithCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) })
 8:         result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,             mi = mi, opts = mi$options)    }, error = function(e) {30: system.time({    })    if (on_warning$silence) {system.time({        model$message <- result$message    }})
 9: FUN(X[[i]], ...)
10: lapply(X = S, FUN = FUN, ...)
11: doTryCatch(return(expr), name, parentenv, handler)
12:         invokeRestart("muffleMessage"){        invokeRestart("muffleWarning")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)    model <- mi$model    model <- mi$model    result <- NULL
    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    watcher$capture_plot_and_output()34:     tryCatch({tryCatchOne(expr, names, parentenv, handlers[[1L]])    }}, error = function (cnd) {    watcher$capture_plot_and_output()    cnd <- sanitize_call(cnd)    TRUE        model$coefficients <- result$solution        model$logLik <- as.numeric(-1 * result$objective)        model$iterations <- result$iterations        model$status <- result$status        model$message <- result$message    if (on_message$capture) {    watcher$push(cnd)    }        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    }})    if (!is.null(result)) {}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)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))


    }
    switch(on_error, continue = invokeRestart("eval_continue"), 
56:         model$fail <- FALSE 9:         watcher$push(cnd)        watcher$capture_plot_and_output()}, warning = function (cnd) doTryCatch(return(expr), name, parentenv, handler){    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    }
 9:         stop = invokeRestart("eval_stop"), error = NULL)    watcher$capture_plot_and_output()    if (on_warning$capture) {FUN(X[[i]], ...)        model$coefficients <- result$solutionFUN(X[[i]], ...)        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 {        watcher$print_value(ev$value, ev$visible, envir)40:         model$logLik <- as.numeric(-1 * result$objective)13: 
57: evaluate::evaluate(...)    }    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) 
10: lapply(X = S, FUN = FUN, ...)
11: doTryCatch(return(expr), name, parentenv, handler)
tryCatchList(expr, classes, parentenv, handlers)        model$iterations <- result$iterations10:     }})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)))             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())    }
30: eval(call)            0L
        else 2L    }, output_handler = knit_handlers(options$render, options))        if (options$error && options$include) 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)

    invisible(structure(msg, class = "try-error", condition = e))    if (on_message$silence) {        model$status <- result$status
41: 31: eval(call)            0L14: tryCatch(expr, error = function(e) {    call <- conditionCall(e)    if (!is.null(call)) {
        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)))})        model$message <- result$messageevaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, lapply(X = S, FUN = FUN, ...)        if (identical(call[[1L]], quote(doTryCatch))) 
11: doTryCatch(return(expr), name, parentenv, handler)
12: tryCatchOne(expr, names, parentenv, handlers[[1L]])
13: tryCatchList(expr, classes, parentenv, handlers)
    keep_message = if (is.numeric(options$message)) TRUE else options$message, 32:     stop_on_error = if (is.numeric(options$error)) options$error else {})        if (options$error && options$include) with_handlers({            call <- sys.call(-4L)
        invokeRestart("muffleMessage")        else 2L
14:     }            0L})
 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)    for (expr in tle$exprs) {60: tryCatch(expr, error = function(e) {42:         else 2L
        ev <- withVisible(eval(expr, envir))tools:::.buildOneVignette("basic_usage.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr",     }        dcall <- deparse(call, nlines = 1L)    }, output_handler = knit_handlers(options$render, options))        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")    call <- conditionCall(e)        watcher$capture_plot_and_output()    }, output_handler = knit_handlers(options$render, options))}, warning = function (cnd) 
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)))
in_dir(input_dir(), expr)
15:         watcher$print_value(ev$value, ev$visible, envir)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){    .Internal(seterrmessage(msg[1L]))    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:     if (!is.null(call)) {    }

44: 
    if (!silent && isTRUE(getOption("show.error.messages"))) {        if (identical(call[[1L]], quote(doTryCatch))) eng_r(options)42:     TRUE43: withOneRestart(expr, restarts[[1L]])            call <- sys.call(-4L)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) {        cat(msg, file = outFile)        .Internal(printDeferredWarnings())    }    invisible(structure(msg, class = "try-error", condition = e))})
    TRUE, FALSE, "basic_usage", "UTF-8", "/Volumes/Temp/tmp/RtmpKW9PNc/filec080459a1202.rds")
        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")}, 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)    }45: 
in_dir(input_dir(), expr)
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 {    TRUEblock_exec(params)
46: call_block(x)
47: process_group(group)
14: 15: 43: }, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)    }in_input_dir(evaluate(code, envir = env, new_device = FALSE, tryCatch(expr, error = function(e) {in_input_dir(evaluate(code, envir = env, new_device = FALSE, try(lapply(X = S, FUN = FUN, ...), silent = TRUE)        dcall <- deparse(call, nlines = 1L)        if (options$error && options$include)     keep_warning = if (is.numeric(options$warning)) TRUE else options$warning,             0L        else 2L    }, output_handler = knit_handlers(options$render, options)))
44: eng_r(options)
45: block_exec(params)
46: call_block(x)    keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, An irrecoverable exception occurred. R is aborting now ...
        prefix <- paste("Error in", dcall, ": ")}, 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)

    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, ": ")

16:         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"))48:     keep_message = if (is.numeric(options$message)) TRUE else options$message, sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))47: 
17: FUN(X[[i]], ...)
18: lapply(seq_len(cores), inner.do)
19: 
40: 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) {23:         LONG <- 75L31: evaluate::evaluate(...)eval(call)
32: with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, 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 {    stop_on_error = if (is.numeric(options$error)) options$error else {        sm <- strsplit(conditionMessage(e), "\n")[[1L]]    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)        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]])

46:         if (options$error && options$include) call_block(x)            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)             0L35: withRestartList(expr, restarts[-nr])
36: doWithOneRestart(return(expr), restart)parallel::mclapply(miList, runModel, mc.cores = numCores)process_group(group)
20: withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))
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())         if (progress && is.function(pb$interrupt)) 

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) {suppressMessages(suppressWarnings(parallel::mclapply(miList,             error <<- format(e)    })
49: with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), 37: 
withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
38: withRestartList(expr, restarts)
39: 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)    })    runModel, mc.cores = numCores)))            pb$interrupt()    error = function(e) {        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)

        else 2LwithRestarts(with_handlers({        if (options$error && options$include) 49:         if (progress && is.function(pb$interrupt)) 
24: runMultistart(modelInputs)
25: logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat",     "brand"), scalePar = "price", numMultiStarts = 10)
    }, output_handler = knit_handlers(options$render, options)))51:         w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")26: eval(expr, envir)
27: eval(expr, envir)
28: withVisible(eval(expr, envir))            0Lwith_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()))    for (expr in tle$exprs) {        if (is.na(w)) 
29:             w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L], process_file(text, output)    watcher$capture_plot_and_output()
44:     if (on_message$capture) {        watcher$push(cnd)    }    if (on_message$silence) {        invokeRestart("muffleMessage")    }withCallingHandlers(code, error = function (e)         else 2L    }, output_handler = knit_handlers(options$render, options)))
44: eng_r(options)

        ev <- withVisible(eval(expr, envir))}, warning = function (cnd) 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)) rlang::entrace(e), message = function (cnd) {    watcher$capture_plot_and_output()    if (on_message$capture) {        watcher$push(cnd)    }    if (on_message$silence) {        invokeRestart("muffleMessage")                type = "b")    }eng_r(options)
52: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
53: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
54: {        if (w > LONG) }, warning = function (cnd) 
45: block_exec(params)
46: call_block(x)            prefix <- paste0(prefix, "\n  ")vweave_rmarkdown(...)    if (getOption("warn") >= 2 || getOption("warn") < 0) {        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)            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),             pb$interrupt()
{50: 47: process_group(group)
48: withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     error = function(e) {        if (progress && is.function(pb$interrupt))     error = function(e) {55: engine$weave(file, quiet = quiet, encoding = enc)
56: doTryCatch(return(expr), name, parentenv, handler)
57: tryCatchOne(expr, names, parentenv, handlers[[1L]])        if (is_R_CMD_build() || is_R_CMD_check())             pb$interrupt()
    }xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),         return()    else prefix <- "Error : "    error = function(e) {    if (getOption("warn") >= 2 || getOption("warn") < 0) {            error <<- format(e)        if (is_R_CMD_build() || is_R_CMD_check())         return()    }    watcher$capture_plot_and_output()    if (on_warning$capture) {        cnd <- sanitize_call(cnd)        watcher$push(cnd)    }58: tryCatchList(expr, classes, parentenv, handlers)
59: tryCatch({    msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {    engine$weave(file, quiet = quiet, encoding = enc)            error <<- format(e)    TRUE    }), list(rlang_trace_top_env = knit_global()))    }    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", }, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)
        cat(msg, file = outFile)    if (on_warning$silence) {        invokeRestart("muffleWarning")50:             engine = engine)        if (progress && is.function(pb$interrupt))             pb$interrupt()        if (progress && is.function(pb$interrupt))     }}, error = function (cnd) {    watcher$capture_plot_and_output()    })        .Internal(printDeferredWarnings())
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)    cnd <- sanitize_call(cnd)            pb$interrupt()    }    watcher$capture_plot_and_output()    }), list(rlang_trace_top_env = knit_global())), function(loc) {49:     watcher$push(cnd)        if (is_R_CMD_build() || is_R_CMD_check())         if (is_R_CMD_build() || is_R_CMD_check())     if (on_warning$capture) {            error <<- format(e)    }), list(rlang_trace_top_env = knit_global())), function(loc) {    setwd(wd)    write_utf8(res, output %n% stdout())    paste0("\nQuitting from ", loc, if (!is.null(error))         paste0("\n", rule(), error, "\n", rule()))}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)
51: process_file(text, output)
52: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
53: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     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]])with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     switch(on_error, continue = invokeRestart("eval_continue"),     setwd(wd)        cnd <- sanitize_call(cnd)    write_utf8(res, output %n% stdout())
    }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))}, error = function(e) {    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)    invisible(structure(msg, class = "try-error", condition = e))        paste0("\n", rule(), error, "\n", rule()))
            error <<- format(e)
        watcher$push(cnd)42: in_dir(input_dir(), expr)
43: in_input_dir(evaluate(code, envir = env, new_device = FALSE,     }), list(rlang_trace_top_env = knit_global()))    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 {        stop = invokeRestart("eval_stop"), error = NULL)58:     }    }), list(rlang_trace_top_env = knit_global())), function(loc) {    if (on_warning$silence) {        invokeRestart("muffleWarning")})})
    }        if (options$error && options$include) tryCatchList(expr, classes, parentenv, handlers)}, error = function (cnd)             0L
    OK <<- FALSE15: }, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc){    setwd(wd)30: 
try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         else 2L
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]])    write_utf8(res, output %n% stdout())59:     watcher$capture_plot_and_output()51: 50: 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/RtmpKW9PNc/filec080459a1202.rds")
An irrecoverable exception occurred. R is aborting now ...
    }, output_handler = knit_handlers(options$render, options)))
44: eng_r(options)
45: block_exec(params)
46: call_block(x)
47: 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(), ...)
xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     paste0("\nQuitting from ", loc, if (!is.null(error))         file, conditionMessage(e)))process_group(group)
48: withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     error = function(e) {        if (progress && is.function(pb$interrupt))         paste0("\n", rule(), error, "\n", rule()))
            pb$interrupt()16: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
17: FUN(X[[i]], ...)
18:     cnd <- sanitize_call(cnd)54: vweave_rmarkdown(...)
})    error = function(e) {lapply(seq_len(cores), inner.do)        if (is_R_CMD_build() || is_R_CMD_check()) }, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)55:     watcher$push(cnd)

    switch(on_error, continue = invokeRestart("eval_continue"),         stop = invokeRestart("eval_stop"), error = NULL)51:             error <<- format(e)        if (progress && is.function(pb$interrupt)) 
    })
49: engine$weave(file, quiet = quiet, encoding = enc)60: 19: })
parallel::mclapply(miList, runModel, mc.cores = numCores)
20: withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))
21: tools:::.buildOneVignette("basic_usage.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr", with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), process_file(text, output)suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))    TRUE, FALSE, "basic_usage", "UTF-8", "/Volumes/Temp/tmp/RtmpKW9PNc/filec080459a1202.rds")


56: doTryCatch(return(expr), name, parentenv, handler)
57: tryCatchOne(expr, names, parentenv, handlers[[1L]])
58: tryCatchList(expr, classes, parentenv, handlers)
59: 52: 30: 

            pb$interrupt()eval(call)tryCatch({    engine$weave(file, quiet = quiet, encoding = enc)    setwd(startdir)    output <- find_vignette_product(name, by = "weave", engine = engine)
knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)38:     if (!have.makefile && vignette_is_tex(output)) {22:         if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)withCallingHandlers(expr, message = function(c) if (inherits(c, 
    }), list(rlang_trace_top_env = knit_global())), function(loc) {53:         texi2pdf(file = output, clean = FALSE, quiet = quiet)        output <- find_vignette_product(name, by = "texi2pdf",             engine = engine)    }}, error = function(e) {An irrecoverable exception occurred. R is aborting now ...
withRestartList(expr, restarts)rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(), 31: eval(call)
32: with_handlers({    for (expr in tle$exprs) {    classes)) tryInvokeRestart("muffleMessage"))    OK <<- FALSE
39: withRestarts(with_handlers({    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",     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), eval_continue = function() TRUE, eval_stop = function() FALSE)        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }
        file, conditionMessage(e)))})
60:     output_dir = getwd(), ...)    setwd(wd)23: 
suppressMessages(suppressWarnings(parallel::mclapply(miList,         if (progress && is.function(pb$interrupt))     write_utf8(res, output %n% stdout())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)            pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check())     paste0("\nQuitting from ", loc, if (!is.null(error)) 
        paste0("\n", rule(), error, "\n", rule()))    runModel, mc.cores = numCores)))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/RtmpKW9PNc/filec080459a1202.rds")
An irrecoverable exception occurred. R is aborting now ...
    TRUE}, handlers)
33: doWithOneRestart(return(expr), restart)
34: withOneRestart(expr, restarts[[1L]])
35: withRestartList(expr, restarts[-nr])

}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)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: 
            error <<- format(e)36: 59: doWithOneRestart(return(expr), restart)
tryCatch({    }), list(rlang_trace_top_env = knit_global()))
withVisible(eval(expr, envir))37: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
40: 
38: 50: evaluate::evaluate(...)51: 
41: evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, 
    engine$weave(file, quiet = quiet, encoding = enc)    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)))})
xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), process_file(text, output)    error = function(e) {        if (progress && is.function(pb$interrupt))             pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)    }), list(rlang_trace_top_env = knit_global())), function(loc) {
60: 29:     setwd(wd)withRestartList(expr, restarts)
52:     write_utf8(res, output %n% stdout())tools:::.buildOneVignette("basic_usage.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr", knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)    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: 
53: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
54: vweave_rmarkdown(...)
55: engine$weave(file, quiet = quiet, encoding = enc)39: withCallingHandlers(code, error = function (e) withRestarts(with_handlers({
    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: 56:     TRUE, FALSE, "basic_usage", "UTF-8", "/Volumes/Temp/tmp/RtmpKW9PNc/filec080459a1202.rds")in_input_dir(evaluate(code, envir = env, new_device = FALSE, 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)knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)    keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, rlang::entrace(e), message = function (cnd) 
An irrecoverable exception occurred. R is aborting now ...

53: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
54: vweave_rmarkdown(...)    keep_message = if (is.numeric(options$message)) TRUE else options$message,     setwd(startdir)    stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)     output <- find_vignette_product(name, by = "weave", engine = engine)    for (expr in tle$exprs) {{    watcher$capture_plot_and_output()
        ev <- withVisible(eval(expr, envir))55: engine$weave(file, quiet = quiet, encoding = enc)        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")
        watcher$print_value(ev$value, ev$visible, envir)    }56: doTryCatch(return(expr), name, parentenv, handler)
57:     }}, error = function (cnd) tryCatchOne(expr, names, parentenv, handlers[[1L]])            0L        else 2L{    if (!have.makefile && vignette_is_tex(output)) {    watcher$capture_plot_and_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)))    }, output_handler = knit_handlers(options$render, options)))

    cnd <- sanitize_call(cnd)    watcher$push(cnd)})    switch(on_error, continue = invokeRestart("eval_continue"),     TRUE
58:         stop = invokeRestart("eval_stop"), error = NULL)44: eng_r(options)}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)})
30: eval(call)
31: eval(call)
tryCatchList(expr, classes, parentenv, handlers)45: block_exec(params)

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

46: 
59: 32: tryCatch({with_handlers({call_block(x)    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()
40: 47: process_group(group)
evaluate::evaluate(...)
41: evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning,     engine$weave(file, quiet = quiet, encoding = enc)        watcher$print_value(ev$value, ev$visible, envir)    setwd(startdir)    output <- find_vignette_product(name, by = "weave", engine = engine)    if (!have.makefile && vignette_is_tex(output)) {        texi2pdf(file = output, clean = FALSE, quiet = quiet)        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:     keep_message = if (is.numeric(options$message)) TRUE else options$message, 48:     TRUEtools:::.buildOneVignette("basic_usage.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr",     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)     TRUE, FALSE, "basic_usage", "UTF-8", "/Volumes/Temp/tmp/RtmpKW9PNc/filec080459a1202.rds")
An irrecoverable exception occurred. R is aborting now ...
withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),             0L    error = function(e) {        else 2L    }, output_handler = knit_handlers(options$render, options))
42: in_dir(input_dir(), expr)
        if (progress && is.function(pb$interrupt))             pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)    })
49: with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     error = function(e) {        if (progress && is.function(pb$interrupt))             pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)43: }, handlers)in_input_dir(evaluate(code, envir = env, new_device = FALSE, 
33: doWithOneRestart(return(expr), restart)
34: withOneRestart(expr, restarts[[1L]])
    }), list(rlang_trace_top_env = knit_global()))35: 
    keep_warning = if (is.numeric(options$warning)) TRUE else options$warning,     keep_message = if (is.numeric(options$message)) TRUE else options$message,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2LwithRestartList(expr, restarts[-nr])
50:     }, output_handler = knit_handlers(options$render, options)))xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), 
44: eng_r(options)
36: 45:     error = function(e) {doWithOneRestart(return(expr), restart)        if (progress && is.function(pb$interrupt))             pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check()) block_exec(params)
            error <<- format(e)    }), list(rlang_trace_top_env = knit_global())), function(loc) {    setwd(wd)    write_utf8(res, output %n% stdout())
46: call_block(x)
47: process_group(group)
48: withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     error = function(e) {        if (progress && is.function(pb$interrupt))             pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)37: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
38: withRestartList(expr, restarts)
39: withRestarts(with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))    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)
    })
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())         watcher$capture_plot_and_output()            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) {        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)
40: evaluate::evaluate(...)        if (progress && is.function(pb$interrupt)) 
            pb$interrupt()52: 41: 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(...)
evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, 55:     keep_message = if (is.numeric(options$message)) TRUE else options$message,     stop_on_error = if (is.numeric(options$error)) options$error else {engine$weave(file, quiet = quiet, encoding = enc)        if (options$error && options$include)             0L        if (is_R_CMD_build() || is_R_CMD_check()) 
56:             error <<- format(e)    }), list(rlang_trace_top_env = knit_global())), function(loc) {        else 2L    }, output_handler = knit_handlers(options$render, options))
42: in_dir(input_dir(), expr)
    setwd(wd)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 {doTryCatch(return(expr), name, parentenv, handler)
57: tryCatchOne(expr, names, parentenv, handlers[[1L]])
58: tryCatchList(expr, classes, parentenv, handlers)
59:     write_utf8(res, output %n% stdout())tryCatch({    engine$weave(file, quiet = quiet, encoding = enc)    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)        if (options$error && options$include) 
            0L        else 2L    }, output_handler = knit_handlers(options$render, options)))
44: eng_r(options)
57:     setwd(startdir)tryCatchOne(expr, names, parentenv, handlers[[1L]])45: 
58:     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)block_exec(params)tryCatchList(expr, classes, parentenv, handlers)
    }}, error = function(e) {    OK <<- FALSE
46:     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)        output <- find_vignette_product(name, by = "texi2pdf", })
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/RtmpKW9PNc/filec080459a1202.rds")
An irrecoverable exception occurred. R is aborting now ...
call_block(x)
47:             engine = engine)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()))    }}, 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/RtmpKW9PNc/filec080459a1202.rds")
An irrecoverable exception occurred. R is aborting now ...

50: xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     error = function(e) {        if (progress && is.function(pb$interrupt))             pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)    }), list(rlang_trace_top_env = knit_global())), function(loc) {    setwd(wd)    write_utf8(res, output %n% stdout())    paste0("\nQuitting from ", loc, if (!is.null(error))         paste0("\n", rule(), error, "\n", rule()))}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)
51: process_file(text, output)
52: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
53: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
54: vweave_rmarkdown(...)
55: engine$weave(file, quiet = quiet, encoding = enc)
56: doTryCatch(return(expr), name, parentenv, handler)
57: tryCatchOne(expr, names, parentenv, handlers[[1L]])
58: tryCatchList(expr, classes, parentenv, handlers)
59: tryCatch({    engine$weave(file, quiet = quiet, encoding = enc)    setwd(startdir)    output <- find_vignette_product(name, by = "weave", engine = engine)    if (!have.makefile && vignette_is_tex(output)) {        texi2pdf(file = output, clean = FALSE, quiet = quiet)        output <- find_vignette_product(name, by = "texi2pdf",             engine = engine)    }}, error = function(e) {    OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})
60: tools:::.buildOneVignette("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/RtmpKW9PNc/filec080459a1202.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'

 *** 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")
 *** caught segfault ***

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

 *** caught segfault ***
        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))
address 0x110, cause 'invalid permissions'
17: FUN(X[[i]], ...)
18: 
Traceback:
 1: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)
 2: eval_f(x0, ...)
lapply(seq_len(cores), inner.do)
19: parallel::mclapply(miList, runModel, mc.cores = numCores)
20:  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)withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))
21: suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))
22: }, 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$statuswithCallingHandlers(expr, message = function(c) if (inherits(c,     classes)) tryInvokeRestart("muffleMessage"))
23: suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))
24:         model$message <- result$message    }})
 9: FUN(X[[i]], ...)
10: lapply(X = S, FUN = FUN, ...)
11: doTryCatch(return(expr), name, parentenv, handler)
12: 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)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], 
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) {                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]], ...)
        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")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))    }}, 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: withCallingHandlers(expr, message = function(c) if (inherits(c,     classes)) tryInvokeRestart("muffleMessage"))
23: suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))
24: runMultistart(modelInputs)
eval(call)
31: eval(call)
32: with_handlers({    for (expr in tle$exprs) {25:         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: 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: 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))

Traceback:
42:  1: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)
 2: eval_f(x0, ...)
 3: withCallingHandlers(code, error = function (e) 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) {in_dir(input_dir(), expr)rlang::entrace(e), message = function (cnd) 
    })43: in_input_dir(evaluate(code, envir = env, new_device = FALSE, 
Traceback:
 1: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)
    keep_warning = if (is.numeric(options$warning)) TRUE else options$warning,     if (!is.null(result)) { 2:         model$fail <- FALSE{        model$coefficients <- result$solutioneval_f(x0, ...)
Traceback:
        model$logLik <- as.numeric(-1 * result$objective)
 1:         model$iterations <- result$iterations    watcher$capture_plot_and_output()        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]])
    if (on_message$capture) { 3: nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     keep_message = if (is.numeric(options$message)) TRUE else options$message, mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)    mi = mi, opts = mi$options)13: 
tryCatchList(expr, classes, parentenv, handlers)
    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: 
 4: call_block(x)14: tryCatch(expr, error = function(e) {    call <- conditionCall(e)    if (!is.null(call)) { 2: doTryCatch(return(expr), name, parentenv, handler)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:         watcher$push(cnd)        if (identical(call[[1L]], quote(doTryCatch)))     }    if (on_message$silence) {        invokeRestart("muffleMessage")    }}, warning = function (cnd) {    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()tryCatchOne(expr, names, parentenv, handlers[[1L]])

            call <- sys.call(-4L) 6: tryCatchList(expr, classes, parentenv, handlers)
 5:     }tryCatchOne(expr, names, parentenv, handlers[[1L]]) 7: 
tryCatch({

 *** caught segfault ***
47: address 0x110, cause 'invalid permissions'
 6: tryCatchList(expr, classes, parentenv, handlers)process_group(group)    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()    if (on_warning$capture) {48: withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     error = function(e) {

        if (progress && is.function(pb$interrupt))         cnd <- sanitize_call(cnd)        dcall <- deparse(call, nlines = 1L)        watcher$push(cnd)    }    if (on_warning$silence) {        invokeRestart("muffleWarning")    }}, error = function (cnd) {        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"))) {    watcher$capture_plot_and_output() 8:     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) 7: system.time({        cat(msg, file = outFile)            pb$interrupt()    model <- mi$model        if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)tryCatch({    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,         mi = mi, opts = mi$options)}, error = function(e) {})
    result <- NULL    })
49:     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)) {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:         .Internal(printDeferredWarnings())    } 8: system.time({    model <- mi$model    result <- NULL
    tryCatch({        model$fail <- FALSE32: xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), 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:     invisible(structure(msg, class = "try-error", condition = e))        model$coefficients <- result$solutiondoWithOneRestart(return(expr), restart)        model$logLik <- as.numeric(-1 * result$objective)        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, 
    error = function(e) {        model$iterations <- result$iterations34: withOneRestart(expr, restarts[[1L]])
35: withRestartList(expr, restarts[-nr])
36: doWithOneRestart(return(expr), restart)
        if (progress && is.function(pb$interrupt))             pb$interrupt()        model$status <- result$status})
15: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
16: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
17: FUN(X[[i]], ...)        if (is_R_CMD_build() || is_R_CMD_check())             mi = mi, opts = mi$options)        model$message <- result$message    }})
    }, error = function(e) {    })    if (!is.null(result)) {        model$fail <- FALSE        model$coefficients <- result$solution        model$logLik <- as.numeric(-1 * result$objective)        model$iterations <- result$iterations37: 
            error <<- format(e)        model$status <- result$statuswithOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
18: lapply(seq_len(cores), inner.do)
19: parallel::mclapply(miList, runModel, mc.cores = numCores)    }), list(rlang_trace_top_env = knit_global())), function(loc) {38:  9: FUN(X[[i]], ...)
10: lapply(X = S, FUN = FUN, ...)

withRestartList(expr, restarts)    setwd(wd)20: 11:         model$message <- result$messagewithCallingHandlers(expr, warning = function(w) if (inherits(w,     }doTryCatch(return(expr), name, parentenv, handler)})
    write_utf8(res, output %n% stdout())

    classes)) tryInvokeRestart("muffleWarning"))
Traceback:
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
 9: FUN(X[[i]], ...)
10: lapply(X = S, FUN = FUN, ...)
11: doTryCatch(return(expr), name, parentenv, handler)
12: tryCatchOne(expr, names, parentenv, handlers[[1L]])
12: tryCatchOne(expr, names, parentenv, handlers[[1L]])
13:     paste0("\nQuitting from ", loc, if (!is.null(error)) 21:  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)suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))
        paste0("\n", rule(), error, "\n", rule()))tryCatchList(expr, classes, parentenv, handlers)
14: tryCatch(expr, error = function(e) {}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)
}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)
51:     call <- conditionCall(e) 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
 6: process_file(text, output)
 *** caught segfault ***
address 0x110, cause 'invalid permissions'
13: 22: 
 *** caught segfault ***
address 0x110, cause 'invalid permissions'
tryCatchList(expr, classes, parentenv, handlers)
    if (!is.null(call)) {
tryCatchList(expr, classes, parentenv, handlers)        if (identical(call[[1L]], quote(doTryCatch))) withCallingHandlers(expr, message = function(c) if (inherits(c,             call <- sys.call(-4L)
52: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
        dcall <- deparse(call, nlines = 1L)
    classes)) tryInvokeRestart("muffleMessage"))
23: suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))
24: 53: 40: 14: tryCatch(expr, error = function(e) {    call <- conditionCall(e)runMultistart(modelInputs)rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)    if (!is.null(call)) {        if (identical(call[[1L]], quote(doTryCatch)))             call <- sys.call(-4L)        dcall <- deparse(call, nlines = 1L)
 7: evaluate::evaluate(...)25: 
logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat",         prefix <- paste("Error in", dcall, ": ")        LONG <- 75L54: vweave_rmarkdown(...)
55: engine$weave(file, quiet = quiet, encoding = enc)

        prefix <- paste("Error in", dcall, ": ")    "brand"), scalePar = "price", numMultiStarts = 10, startVals = wtp_mnl_pref$Estimate)tryCatch({    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,         sm <- strsplit(conditionMessage(e), "\n")[[1L]]56: doTryCatch(return(expr), name, parentenv, handler)
57: tryCatchOne(expr, names, parentenv, handlers[[1L]])
58: tryCatchList(expr, classes, parentenv, handlers)
59: tryCatch({41: 
26:         w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")        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")        mi = mi, opts = mi$options)        if (is.na(w))             w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L],                 type = "b")}, error = function(e) {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 (w > LONG) })            prefix <- paste0(prefix, "\n  ")        if (options$error && options$include) eval(expr, envir)    }        if (w > LONG) 
            prefix <- paste0(prefix, "\n  ")    }    else prefix <- "Error : "    else prefix <- "Error : " 8:     msg <- paste0(prefix, conditionMessage(e), "\n")system.time({            0L    engine$weave(file, quiet = quiet, encoding = enc)    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)) {
        else 2L    }, output_handler = knit_handlers(options$render, options))
        model$fail <- FALSE    msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L]))    setwd(startdir)42: in_dir(input_dir(), expr)
43: in_input_dir(evaluate(code, envir = env, new_device = FALSE,         model$coefficients <- result$solution    output <- find_vignette_product(name, by = "weave", engine = engine)27:         model$logLik <- as.numeric(-1 * result$objective)        model$iterations <- result$iterations        model$status <- result$status        model$message <- result$message    }})
 *** caught segfault ***
    keep_warning = if (is.numeric(options$warning)) TRUE else options$warning,     if (!have.makefile && vignette_is_tex(output)) {eval(expr, envir)
28: withVisible(eval(expr, envir))
29: withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd)     keep_message = if (is.numeric(options$message)) TRUE else options$message, address 0x110, cause 'invalid permissions'
    .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {    stop_on_error = if (is.numeric(options$error)) options$error else {
        cat(msg, file = outFile)        .Internal(printDeferredWarnings())    }    invisible(structure(msg, class = "try-error", condition = e))    if (!silent && isTRUE(getOption("show.error.messages"))) {        if (options$error && options$include)             0L        else 2L        cat(msg, file = outFile){    watcher$capture_plot_and_output()    if (on_message$capture) {})
15: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
Traceback:

Traceback:
        .Internal(printDeferredWarnings()) 9:  1: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)
FUN(X[[i]], ...) 1: 
mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)        texi2pdf(file = output, clean = FALSE, quiet = quiet)
 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:         watcher$push(cnd)    }, output_handler = knit_handlers(options$render, options)))
10: 
16:         output <- find_vignette_product(name, by = "texi2pdf",  2: lapply(X = S, FUN = FUN, ...)
tryCatch({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) {    }11:         if (progress && is.function(pb$interrupt)) sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))            engine = engine)            pb$interrupt()    }    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, 
    if (on_message$silence) {eval_f(x0, ...)        invokeRestart("muffleMessage")    }}, warning = function (cnd) {    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    }    watcher$capture_plot_and_output()    if (on_warning$capture) {
 *** caught segfault ***

doTryCatch(return(expr), name, parentenv, handler)17: 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) {    })}, error = function(e) {
        cnd <- sanitize_call(cnd) 3:     if (!is.null(result)) {FUN(X[[i]], ...)        if (is_R_CMD_build() || is_R_CMD_check())         mi = mi, opts = mi$options)12: tryCatchOne(expr, names, parentenv, handlers[[1L]])
13: tryCatchList(expr, classes, parentenv, handlers)
14: tryCatch(expr, error = function(e) {    call <- conditionCall(e)    OK <<- 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()))
50:         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)})
        model$fail <- FALSE    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    }}, error = function(e) {xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), 30:     message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})
60:         sm <- strsplit(conditionMessage(e), "\n")[[1L]]    error = function(e) {
eval(call)
Traceback:
 1: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)
 2: nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,         if (progress && is.function(pb$interrupt)) })            pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)
 8: system.time({    model <- mi$model
eval_f(x0, ...)        w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")
 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: 18:     }), list(rlang_trace_top_env = knit_global())), function(loc) {    invisible(structure(msg, class = "try-error", condition = e))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/RtmpKW9PNc/filec080710ad4b0.rds")
An irrecoverable exception occurred. R is aborting now ...
        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)        if (is.na(w))             w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L],                 type = "b")        if (w > LONG)             prefix <- paste0(prefix, "\n  ")    }})    result <- NULLlapply(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: tryCatchOne(expr, names, parentenv, handlers[[1L]])
 6: 31:     setwd(wd)
tryCatchList(expr, classes, parentenv, handlers)15:     else prefix <- "Error : "    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)
suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))    mi = mi, opts = mi$options)
    msg <- paste0(prefix, conditionMessage(e), "\n")
12: 
 4: doTryCatch(return(expr), name, parentenv, handler)
52:     .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, file = outFile)        .Internal(printDeferredWarnings())    }eval(call)
knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
    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)
try(lapply(X = S, FUN = FUN, ...), silent = TRUE) 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])22:     invisible(structure(msg, class = "try-error", condition = e))
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: tryCatchOne(expr, names, parentenv, handlers[[1L]]) 7: 
tryCatch({suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))
22: withCallingHandlers(expr, message = function(c) if (inherits(c, })32: 

20:     classes)) tryInvokeRestart("muffleMessage"))
 6: 15: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
16: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
17: FUN(X[[i]], ...)
18: 13: with_handlers({    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))
21: tryCatchList(expr, classes, parentenv, handlers)
53: tryCatchList(expr, classes, parentenv, handlers)

14: tryCatch(expr, error = function(e) {lapply(seq_len(cores), inner.do)        mi = mi, opts = mi$options)}, error = function(e) {}) 7:     call <- conditionCall(e)    if (!is.null(call)) {        if (identical(call[[1L]], quote(doTryCatch)))             call <- sys.call(-4L)

19: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),  8: parallel::mclapply(miList, runModel, mc.cores = numCores)        dcall <- deparse(call, nlines = 1L)    output_dir = getwd(), ...)suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))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)

54: vweave_rmarkdown(...)
55:         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")
    for (expr in tle$exprs) {system.time({
22: engine$weave(file, quiet = quiet, encoding = enc)
56: 27: tryCatch({    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,         mi = mi, opts = mi$options)20:     model <- mi$model    result <- NULL    tryCatch({withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))
21:         result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, withCallingHandlers(expr, message = function(c) if (inherits(c,         ev <- withVisible(eval(expr, envir))23: suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))
24: runMultistart(modelInputs)
25:     classes)) tryInvokeRestart("muffleMessage"))        if (w > LONG) }, error = function(e) {            mi = mi, opts = mi$options)suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat",     "brand"), scalePar = "price", numMultiStarts = 10, startVals = wtp_mnl_pref$Estimate)
23: suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))doTryCatch(return(expr), name, parentenv, handler)    }, error = function(e) {eval(expr, envir)

})
24:  8: system.time({    model <- mi$model
    })    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            prefix <- paste0(prefix, "\n  ")22:     result <- NULL
28: withVisible(eval(expr, envir))
29: withCallingHandlers(code, error = function (e) 57:         model$message <- result$message    }        watcher$capture_plot_and_output()    }
    else prefix <- "Error : "        watcher$print_value(ev$value, ev$visible, envir)    tryCatch({26: eval(expr, envir)
27: rlang::entrace(e), message = function (cnd)     }    TRUEtryCatchOne(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) {eval(expr, envir){    msg <- paste0(prefix, conditionMessage(e), "\n")
    watcher$capture_plot_and_output()}, handlers)
    })    if (!is.null(result)) {        model$fail <- FALSE        model$coefficients <- result$solutionrunMultistart(modelInputs)
    if (on_message$capture) {    .Internal(seterrmessage(msg[1L])) 9: 

33:         model$logLik <- as.numeric(-1 * result$objective)25: 58: 28: withVisible(eval(expr, envir))
29: withCallingHandlers(expr, message = function(c) if (inherits(c,         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()FUN(X[[i]], ...)withCallingHandlers(code, error = function (e)     classes)) tryInvokeRestart("muffleMessage"))tryCatchList(expr, classes, parentenv, handlers)
59: tryCatch({    engine$weave(file, quiet = quiet, encoding = enc)rlang::entrace(e), message = function (cnd) {    watcher$capture_plot_and_output()        model$iterations <- result$iterationsdoWithOneRestart(return(expr), restart)    if (on_warning$capture) {    setwd(startdir)    if (on_message$capture) {
23: suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))
24: runMultistart(modelInputs)

34: withOneRestart(expr, restarts[[1L]])logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat",     output <- find_vignette_product(name, by = "weave", engine = engine)    if (!have.makefile && vignette_is_tex(output)) {
    "brand"), scalePar = "price", numMultiStarts = 10, startVals = wtp_mnl_pref$Estimate)
26: eval(expr, envir)
10: lapply(X = S, FUN = FUN, ...)25:     if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, file = outFile)        .Internal(printDeferredWarnings())    }    invisible(structure(msg, class = "try-error", condition = e))
logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat", 35: withRestartList(expr, restarts[-nr])        texi2pdf(file = output, clean = FALSE, quiet = quiet)        watcher$push(cnd)        output <- find_vignette_product(name, by = "texi2pdf",             engine = engine)    }}, error = function(e) {27:     "brand"), scalePar = "price", numMultiStarts = 10, startVals = wtp_mnl_pref$Estimate)        cnd <- sanitize_call(cnd)})
11: doTryCatch(return(expr), name, parentenv, handler)    OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})
60:         model$status <- result$statuseval(expr, envir)
    }        watcher$push(cnd)

36: doWithOneRestart(return(expr), restart)
37: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])tools:::.buildOneVignette("mnl_models.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr", 12: 
tryCatchOne(expr, names, parentenv, handlers[[1L]])    if (on_message$silence) {26:         model$message <- result$message    }    }    if (on_warning$silence) {        invokeRestart("muffleWarning")    }
38: }, error = function (cnd)         invokeRestart("muffleMessage")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)28: 
    }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, ": ")
withVisible(eval(expr, envir))    }        LONG <- 75L{15: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
16: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
17: FUN(X[[i]], ...)

withRestartList(expr, restarts)
        sm <- strsplit(conditionMessage(e), "\n")[[1L]]18:     TRUE, FALSE, "mnl_models", "UTF-8", "/Volumes/Temp/tmp/RtmpKW9PNc/filec080710ad4b0.rds")39:     if (on_message$silence) {        invokeRestart("muffleMessage")
    watcher$capture_plot_and_output()    cnd <- sanitize_call(cnd)    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)withRestarts(with_handlers({        w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")        watcher$push(cnd)29: An irrecoverable exception occurred. R is aborting now ...
    }withCallingHandlers(code, error = function (e)     for (expr in tle$exprs) {lapply(seq_len(cores), inner.do)
 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:         ev <- withVisible(eval(expr, envir))    }    if (on_warning$silence) {        if (is.na(w))     switch(on_error, continue = invokeRestart("eval_continue"),         stop = invokeRestart("eval_stop"), error = NULL)        watcher$capture_plot_and_output()rlang::entrace(e), message = function (cnd) {    watcher$capture_plot_and_output()tryCatchList(expr, classes, parentenv, handlers)})
}, warning = function (cnd) {    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    }    watcher$capture_plot_and_output()    if (on_warning$capture) {
        invokeRestart("muffleWarning")    }}, error = function (cnd) {    watcher$capture_plot_and_output()            w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L],         cnd <- sanitize_call(cnd)14:     cnd <- sanitize_call(cnd)    if (on_message$capture) {
        watcher$print_value(ev$value, ev$visible, envir)        watcher$push(cnd)    watcher$push(cnd)    switch(on_error, continue = invokeRestart("eval_continue"),         stop = invokeRestart("eval_stop"), error = NULL)})    }30: eval(call)    TRUE    }    if (on_warning$silence) {
        invokeRestart("muffleWarning")    }}, error = function (cnd) tryCatch(expr, error = function(e) {                type = "b"){
31: eval(call)
32: with_handlers({19:     watcher$capture_plot_and_output()        if (w > LONG)         watcher$push(cnd)30: eval(call)    }    if (on_message$silence) {        invokeRestart("muffleMessage")    call <- conditionCall(e)            prefix <- paste0(prefix, "\n  ")parallel::mclapply(miList, runModel, mc.cores = numCores)    }}, 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) {    if (!is.null(call)) {        if (identical(call[[1L]], quote(doTryCatch)))             call <- sys.call(-4L)
    for (expr in tle$exprs) {20:         ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    cnd <- sanitize_call(cnd)}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)        invokeRestart("muffleWarning")        dcall <- deparse(call, nlines = 1L)    }    }

    TRUE        prefix <- paste("Error in", dcall, ": ")withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))
21: suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))
        LONG <- 75L        sm <- strsplit(conditionMessage(e), "\n")[[1L]]        w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")        if (is.na(w)) 31:     }    watcher$push(cnd)40:             w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L], 22: }, handlers)}, error = function (cnd)     switch(on_error, continue = invokeRestart("eval_continue"), evaluate::evaluate(...)                type = "b")
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
    else prefix <- "Error : "        stop = invokeRestart("eval_stop"), error = NULL)eval(call)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 (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)33: {})doWithOneRestart(return(expr), restart)
34: withOneRestart(expr, restarts[[1L]])
35:         .Internal(printDeferredWarnings())
    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:     msg <- paste0(prefix, conditionMessage(e), "\n")    }, output_handler = knit_handlers(options$render, options))withRestartList(expr, restarts[-nr])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)    }
    }    invisible(structure(msg, class = "try-error", condition = e))})
15: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)32: with_handlers({    for (expr in tle$exprs) {30:     .Internal(seterrmessage(msg[1L]))    TRUE
26: eval(expr, envir)
27: eval(expr, envir)
28: }, handlers)    if (!silent && isTRUE(getOption("show.error.messages"))) {
        ev <- withVisible(eval(expr, envir))
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)withVisible(eval(expr, envir))
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: 33:         cat(msg, file = outFile)42: 29: withCallingHandlers(code, error = function (e) 
in_dir(input_dir(), expr)
43: 
doWithOneRestart(return(expr), restart)doWithOneRestart(return(expr), restart)        watcher$capture_plot_and_output()26:         .Internal(printDeferredWarnings())
eval(expr, envir)
36: doWithOneRestart(return(expr), restart)
37: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
38: withRestartList(expr, restarts)34: 
    }    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]], ...)
in_input_dir(evaluate(code, envir = env, new_device = FALSE, 39: withRestarts(with_handlers({rlang::entrace(e), message = function (cnd) 34: withOneRestart(expr, restarts[[1L]])
withOneRestart(expr, restarts[[1L]])27: eval(expr, envir)

35: withRestartList(expr, restarts[-nr])35: {        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers)
    watcher$capture_plot_and_output()
withRestartList(expr, restarts[-nr])28:     if (on_message$capture) {33:     keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, 
18: 36: doWithOneRestart(return(expr), restart)doWithOneRestart(return(expr), restart)
37: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])        watcher$push(cnd)    }    if (on_message$silence) {        invokeRestart("muffleMessage")lapply(seq_len(cores), inner.do)withVisible(eval(expr, envir))


    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()    }38: withRestartList(expr, restarts)
39: 34: 29:     keep_message = if (is.numeric(options$message)) TRUE else options$message, withCallingHandlers(code, error = function (e)     stop_on_error = if (is.numeric(options$error)) options$error else {withOneRestart(expr, restarts[[1L]])withRestarts(with_handlers({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) 
36: doWithOneRestart(return(expr), restart)
37: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
38: 
    for (expr in tle$exprs) {
        watcher$print_value(ev$value, ev$visible, envir)35: withRestartList(expr, restarts[-nr])
36: doWithOneRestart(return(expr), restart)
37: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
38: withRestartList(expr, restarts){19: withRestartList(expr, restarts)        if (options$error && options$include) 
39: withRestarts(with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        ev <- withVisible(eval(expr, envir))}, warning = function (cnd) parallel::mclapply(miList, runModel, mc.cores = numCores)
            0L    }
20: withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))
21: suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))
22: withCallingHandlers(expr, message = function(c) if (inherits(c,     classes)) tryInvokeRestart("muffleMessage"))
23: suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))
24: runMultistart(modelInputs)
        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)
        else 2L39:     TRUE    if (getOption("warn") >= 2 || getOption("warn") < 0) {40: 25:         watcher$capture_plot_and_output()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$print_value(ev$value, ev$visible, envir){}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    }    watcher$capture_plot_and_output()    if (on_warning$capture) {evaluate::evaluate(...)withRestarts(with_handlers({
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)
    for (expr in tle$exprs) {
        ev <- withVisible(eval(expr, envir))    }        watcher$capture_plot_and_output()    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))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)45:         watcher$push(cnd)block_exec(params)
46: call_block(x)
        watcher$print_value(ev$value, ev$visible, envir)
        return()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:     }, output_handler = knit_handlers(options$render, options)))47:     }        cnd <- sanitize_call(cnd)call_block(x)
44: eng_r(options)
45: 

    }    watcher$capture_plot_and_output()47: process_group(group)
    }    if (on_warning$capture) {block_exec(params)    TRUE
}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)        cnd <- sanitize_call(cnd)43:         watcher$push(cnd)in_input_dir(evaluate(code, envir = env, new_device = FALSE,     }    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)    keep_warning = if (is.numeric(options$warning)) TRUE else options$warning,     if (on_message$silence) {        watcher$push(cnd)48: process_group(group)withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), 46: call_block(x)
47: process_group(group)
48: 
    error = function(e) {        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()40:     keep_message = if (is.numeric(options$message)) TRUE else options$message,         if (progress && is.function(pb$interrupt))     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))     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: withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), 
48: 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)    }    }with_handlers({evaluate::evaluate(...)            pb$interrupt()    if (on_warning$silence) {            pb$interrupt()        invokeRestart("muffleWarning")withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     error = function(e) {        if (progress && is.function(pb$interrupt))             pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check())         if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)    })        if (is_R_CMD_build() || is_R_CMD_check())     TRUE

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()))            error <<- format(e)    })
49: with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)            error <<- format(e)41:     }
}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)    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:     })    }}, 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:     error = function(e) {evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning,         if (progress && is.function(pb$interrupt))             pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)    TRUE
eval(call)xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), 
49: with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     error = function(e) {        if (progress && is.function(pb$interrupt)) 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 {    error = function(e) {    keep_message = if (is.numeric(options$message)) TRUE else options$message,         if (progress && is.function(pb$interrupt))             pb$interrupt()    })        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 {50:             pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check())     stop_on_error = if (is.numeric(options$error)) options$error else {xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), }, handlers)
33:         if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)    error = function(e) {        if (progress && is.function(pb$interrupt)) 

            pb$interrupt()        if (options$error && options$include)             error <<- format(e)49: with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     }), list(rlang_trace_top_env = knit_global()))
            0L        if (options$error && options$include)         else 2L    }, output_handler = knit_handlers(options$render, options))
42:         if (is_R_CMD_build() || is_R_CMD_check())             0L        else 2L    }, output_handler = knit_handlers(options$render, options)))
44: eng_r(options)doWithOneRestart(return(expr), restart)50: 
in_dir(input_dir(), expr)    error = function(e) {xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), 45: block_exec(params)
46: call_block(x)

            error <<- format(e)47:         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:     }), list(rlang_trace_top_env = knit_global())), function(loc) {32: with_handlers({    for (expr in tle$exprs) {
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:     setwd(wd)process_group(group)    write_utf8(res, output %n% stdout())doTryCatch(return(expr), name, parentenv, handler)    paste0("\nQuitting from ", loc, if (!is.null(error))         paste0("\n", rule(), error, "\n", rule()))}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)
    error = function(e) {    }), list(rlang_trace_top_env = knit_global())), function(loc) {    setwd(wd)
        ev <- withVisible(eval(expr, envir))        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)34:     write_utf8(res, output %n% stdout())    paste0("\nQuitting from ", loc, if (!is.null(error)) 43: withOneRestart(expr, restarts[[1L]])in_input_dir(evaluate(code, envir = env, new_device = FALSE, 51: process_file(text, output)
52: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)

52: 
        paste0("\n", rule(), error, "\n", rule()))}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)
    keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, 48: withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), 
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(), knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)57:         watcher$capture_plot_and_output()    output_dir = getwd(), ...)
tryCatchOne(expr, names, parentenv, handlers[[1L]])53: 
58: 54: 
        watcher$print_value(ev$value, ev$visible, envir)    keep_message = if (is.numeric(options$message)) TRUE else options$message,     }tryCatchList(expr, classes, parentenv, handlers)53:     TRUE    error = function(e) {
35: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(), }, handlers)rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
54:     output_dir = getwd(), ...)
33: 59:         if (progress && is.function(pb$interrupt)) vweave_rmarkdown(...)vweave_rmarkdown(...)doWithOneRestart(return(expr), restart)
withRestartList(expr, restarts[-nr])    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)))

34: 
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)            pb$interrupt()tryCatch({        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), withOneRestart(expr, restarts[[1L]])


35: 44: 55: 54:     engine$weave(file, quiet = quiet, encoding = enc)    error = function(e) {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)) {    setwd(startdir)        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())     output <- find_vignette_product(name, by = "weave", engine = engine)        texi2pdf(file = output, clean = FALSE, quiet = quiet)        output <- find_vignette_product(name, by = "texi2pdf",             error <<- format(e)withRestartList(expr, restarts[-nr])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)            engine = engine)    }    }}, error = function(e) {    TRUE
    if (!have.makefile && vignette_is_tex(output)) {    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/RtmpKW9PNc/filec080710ad4b0.rds")
An irrecoverable exception occurred. R is aborting now ...
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)) vweave_rmarkdown(...)
55: engine$weave(file, quiet = quiet, encoding = enc)        texi2pdf(file = output, clean = FALSE, quiet = quiet)    OK <<- FALSE}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)            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()))


40:     message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))    }), list(rlang_trace_top_env = knit_global())), function(loc) {})
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/RtmpKW9PNc/filec080710ad4b0.rds")
An irrecoverable exception occurred. R is aborting now ...
56:         output <- find_vignette_product(name, by = "texi2pdf", doTryCatch(return(expr), name, parentenv, handler)evaluate::evaluate(...)
    setwd(wd)50:             engine = engine)
57: tryCatchOne(expr, names, parentenv, handlers[[1L]])
58: tryCatchList(expr, classes, parentenv, handlers)
41: 36: 59: 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)    }doWithOneRestart(return(expr), restart)
37: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
38: withRestartList(expr, restarts)    write_utf8(res, output %n% stdout())}, error = function(e) {    OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})
evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, 
39: tryCatch({    keep_message = if (is.numeric(options$message)) TRUE else options$message, 60:     write_utf8(res, output %n% stdout())    paste0("\nQuitting from ", loc, if (!is.null(error))         paste0("\n", rule(), error, "\n", rule()))    paste0("\nQuitting from ", loc, if (!is.null(error)) withRestarts(with_handlers({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/RtmpKW9PNc/filec080710ad4b0.rds")    stop_on_error = if (is.numeric(options$error)) options$error else {        paste0("\n", rule(), error, "\n", rule()))    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)
51: 
An irrecoverable exception occurred. R is aborting now ...
    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)process_file(text, output)        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options))
42: in_dir(input_dir(), expr)
        output <- find_vignette_product(name, by = "texi2pdf", 51: 
    }process_file(text, output)
    TRUE}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)
40: evaluate::evaluate(...)
41:             engine = engine)
52: 43:     }}, error = function(e) {52: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
53: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)    OK <<- FALSE
54:     message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s", evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, vweave_rmarkdown(...)        file, conditionMessage(e)))

53: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
54: vweave_rmarkdown(...)
55: engine$weave(file, quiet = quiet, encoding = enc)
56: doTryCatch(return(expr), name, parentenv, handler)
57: tryCatchOne(expr, names, parentenv, handlers[[1L]])
58: tryCatchList(expr, classes, parentenv, handlers)
59: tryCatch({    engine$weave(file, quiet = quiet, encoding = enc)    setwd(startdir)    output <- find_vignette_product(name, by = "weave", engine = engine)    if (!have.makefile && vignette_is_tex(output)) {        texi2pdf(file = output, clean = FALSE, quiet = quiet)in_input_dir(evaluate(code, envir = env, new_device = FALSE, 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)        output <- find_vignette_product(name, by = "texi2pdf",     keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, 
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            engine = engine)    keep_message = if (is.numeric(options$message)) TRUE else options$message,     message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))    keep_message = if (is.numeric(options$message)) TRUE else options$message, 
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/RtmpKW9PNc/filec080710ad4b0.rds")
An irrecoverable exception occurred. R is aborting now ...
    stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options)))    }})

60:     stop_on_error = if (is.numeric(options$error)) options$error else {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/RtmpKW9PNc/filec080710ad4b0.rds")44:         if (options$error && options$include) }, error = function(e) {    OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))            0L})
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/RtmpKW9PNc/filec080710ad4b0.rds")eng_r(options)        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)))
45: An irrecoverable exception occurred. R is aborting now ...
block_exec(params)
46: call_block(x)

An irrecoverable exception occurred. R is aborting now ...
47: process_group(group)
48: withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     error = function(e) {44: eng_r(options)
45: block_exec(params)
46: call_block(x)        if (progress && is.function(pb$interrupt))             pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)    })
49: with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     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: 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)    })rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)

54: 49: with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     error = function(e) {        if (progress && is.function(pb$interrupt)) vweave_rmarkdown(...)
55: engine$weave(file, quiet = quiet, encoding = enc)
56:             pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check()) doTryCatch(return(expr), name, parentenv, handler)            error <<- format(e)
57: tryCatchOne(expr, names, parentenv, handlers[[1L]])
58:     }), list(rlang_trace_top_env = knit_global()))
50: 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)))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)
60: tools:::.buildOneVignette("mnl_models.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(), ...)
54: vweave_rmarkdown(...)
55: engine$weave(file, quiet = quiet, encoding = enc)
    TRUE, FALSE, "mnl_models", "UTF-8", "/Volumes/Temp/tmp/RtmpKW9PNc/filec080710ad4b0.rds")
An irrecoverable exception occurred. R is aborting now ...
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/RtmpKW9PNc/filec080710ad4b0.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()
 *** caught segfault ***
address 0x110, cause 'invalid permissions'
        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/RtmpKW9PNc/filec080784eded6.rds")
An irrecoverable exception occurred. R is aborting now ...

Traceback:
 1: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)
 2: eval_f(x0, ...)
 3: nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     mi = mi, opts = mi$options)
 4: doTryCatch(return(expr), name, parentenv, handler)
 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
 6: tryCatchList(expr, classes, parentenv, handlers)
 7: tryCatch({    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,         mi = mi, opts = mi$options)}, error = function(e) {})
 8: system.time({    model <- mi$model    result <- NULL    tryCatch({        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,             mi = mi, opts = mi$options)    }, error = function(e) {    })    if (!is.null(result)) {        model$fail <- FALSE        model$coefficients <- result$solution        model$logLik <- as.numeric(-1 * result$objective)        model$iterations <- result$iterations        model$status <- result$status        model$message <- result$message    }})
 9: FUN(X[[i]], ...)
10: lapply(X = S, FUN = FUN, ...)
11: doTryCatch(return(expr), name, parentenv, handler)
12: tryCatchOne(expr, names, parentenv, handlers[[1L]])
13: tryCatchList(expr, classes, parentenv, handlers)
14: tryCatch(expr, error = function(e) {    call <- conditionCall(e)    if (!is.null(call)) {        if (identical(call[[1L]], quote(doTryCatch)))             call <- sys.call(-4L)        dcall <- deparse(call, nlines = 1L)        prefix <- paste("Error in", dcall, ": ")        LONG <- 75L        sm <- strsplit(conditionMessage(e), "\n")[[1L]]        w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")        if (is.na(w))             w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L],                 type = "b")        if (w > LONG)             prefix <- paste0(prefix, "\n  ")    }    else prefix <- "Error : "    msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, file = outFile)        .Internal(printDeferredWarnings())    }    invisible(structure(msg, class = "try-error", condition = e))})
15: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
16: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
17: FUN(X[[i]], ...)
18: lapply(seq_len(cores), inner.do)
19: parallel::mclapply(miList, runModel, mc.cores = numCores)
20: withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))
21: suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))
22: withCallingHandlers(expr, message = function(c) if (inherits(c,     classes)) tryInvokeRestart("muffleMessage"))
23: suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))
24: runMultistart(modelInputs)
25: logitr(data = 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/RtmpKW9PNc/filec080784eded6.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:
 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)
Traceback:
 1: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)
 2: eval_f(x0, ...)
 3:     }, 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    }})

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:  9: FUN(X[[i]], ...)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) {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))) 
Traceback:

tryCatchOne(expr, names, parentenv, handlers[[1L]])
 6: tryCatchList(expr, classes, parentenv, handlers)
 7:  1: tryCatch({    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,         mi = mi, opts = mi$options)}, error = function(e) {})
 8:  8:             call <- sys.call(-4L)system.time({system.time({mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)
        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 <- mi$model 2: eval_f(x0, ...)
 3:     result <- NULL    model <- mi$model        if (is.na(w)) nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     mi = mi, opts = mi$options)            w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L],                 type = "b")        if (w > LONG)             prefix <- paste0(prefix, "\n  ")    }    else prefix <- "Error : "    tryCatch({    msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L]))    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]])

 *** caught segfault ***
        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, address 0x110, cause 'invalid permissions'
            mi = mi, opts = mi$options)    if (!silent && isTRUE(getOption("show.error.messages"))) {13:     }, error = function(e) {    })    if (!is.null(result)) {        model$fail <- FALSE        model$coefficients <- result$solution        cat(msg, file = outFile)tryCatchList(expr, classes, parentenv, handlers)        .Internal(printDeferredWarnings())
    }        model$logLik <- as.numeric(-1 * result$objective)14:     invisible(structure(msg, class = "try-error", condition = e))tryCatch(expr, error = function(e) {})
    call <- conditionCall(e)

Traceback:
 1: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)
    if (!is.null(call)) {15:         if (identical(call[[1L]], quote(doTryCatch)))  2:  4: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)            call <- sys.call(-4L)eval_f(x0, ...)        model$iterations <- result$iterations
16: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))doTryCatch(return(expr), name, parentenv, handler)        model$status <- result$status
17:         dcall <- deparse(call, nlines = 1L)        model$message <- result$message    }

 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,         prefix <- paste("Error in", dcall, ": ") 3:         LONG <- 75LFUN(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, nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,         mi = mi, opts = mi$options)    mi = mi, opts = mi$options)}, error = function(e) {})})
    classes)) tryInvokeRestart("muffleWarning"))
 4:  8:         sm <- strsplit(conditionMessage(e), "\n")[[1L]]

 *** caught segfault ***
system.time({        w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")    model <- mi$modeladdress 0x110, cause 'invalid permissions'
doTryCatch(return(expr), name, parentenv, handler)    result <- NULL

 5:  9: 21: FUN(X[[i]], ...)
    tryCatch({        if (is.na(w))         result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,             mi = mi, opts = mi$options)    }, error = function(e) {    })    if (!is.null(result)) {suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))10:         model$fail <- FALSElapply(X = S, FUN = FUN, ...)
11: doTryCatch(return(expr), name, parentenv, handler)
12: tryCatchOne(expr, names, parentenv, handlers[[1L]])
13: tryCatchList(expr, classes, parentenv, handlers)
tryCatchOne(expr, names, parentenv, handlers[[1L]])
14:             w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L], 22: withCallingHandlers(expr, message = function(c) if (inherits(c,     classes)) tryInvokeRestart("muffleMessage"))
 6: tryCatchList(expr, classes, parentenv, handlers)        model$coefficients <- result$solution                type = "b")        model$logLik <- as.numeric(-1 * result$objective)tryCatch(expr, error = function(e) {    call <- conditionCall(e)    if (!is.null(call)) {        model$iterations <- result$iterations        model$status <- result$status        if (identical(call[[1L]], quote(doTryCatch)))             call <- sys.call(-4L)        dcall <- deparse(call, nlines = 1L)        prefix <- paste("Error in", dcall, ": ")        LONG <- 75L        if (w > LONG)         model$message <- result$message        sm <- strsplit(conditionMessage(e), "\n")[[1L]]            prefix <- paste0(prefix, "\n  ")    }    }
})
 9: FUN(X[[i]], ...)    else prefix <- "Error : "


Traceback:
23: 10: suppressMessages(suppressWarnings(parallel::mclapply(miList,  7:     runModel, mc.cores = numCores)))
24: tryCatch({lapply(X = S, FUN = FUN, ...)    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))        w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w") 1: 
11:         if (is.na(w))     result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)})

            w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L], 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"),         mi = mi, opts = mi$options)15:  2:                 type = "b")}, error = function(e) {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, ": ")    scalePar = "price", robust = TRUE, numMultiStarts = 10)        LONG <- 75L        sm <- strsplit(conditionMessage(e), "\n")[[1L]]        w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")
try(lapply(X = S, FUN = FUN, ...), silent = TRUE)        if (is.na(w)) 26: eval(expr, envir)
16: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
17: FUN(X[[i]], ...)
eval_f(x0, ...)18:             w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L], lapply(seq_len(cores), inner.do)
 3: nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     mi = mi, opts = mi$options)
 4:                 type = "b")doTryCatch(return(expr), name, parentenv, handler)

 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
 6: })        if (w > LONG)             prefix <- paste0(prefix, "\n  ")
        if (w > LONG) 
    }    else prefix <- "Error : "    msg <- paste0(prefix, conditionMessage(e), "\n")tryCatchList(expr, classes, parentenv, handlers) 8: system.time({            prefix <- paste0(prefix, "\n  ")27: 19:     }    .Internal(seterrmessage(msg[1L]))parallel::mclapply(miList, runModel, mc.cores = numCores)
20: withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))
21:     model <- mi$model
 *** caught segfault ***
suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))address 0x110, cause 'invalid permissions'

Traceback:


 7:     if (!silent && isTRUE(getOption("show.error.messages"))) { 1: tryCatch({    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        cat(msg, file = outFile)    else prefix <- "Error : "    msg <- paste0(prefix, conditionMessage(e), "\n")    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, 22: withCallingHandlers(expr, message = function(c) if (inherits(c,     classes)) tryInvokeRestart("muffleMessage"))
23: suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))
        mi = mi, opts = mi$options)eval(expr, envir)24:         .Internal(printDeferredWarnings())runMultistart(modelInputs)
        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, ...)    }mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)
 2: eval_f(x0, ...)
    invisible(structure(msg, class = "try-error", condition = e))})
15: 25: logitr(data = cars_us, outcome = "choice", obsID = "obsnum",     pars = c("hev", "phev10", "phev20", "phev40", "bev75", "bev100", 
    .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))})11: 
 3: nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     mi = mi, opts = mi$options)
try(lapply(X = S, FUN = FUN, ...), silent = TRUE) 4: doTryCatch(return(expr), name, parentenv, handler)
 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
        "bev150", "american", "japanese", "chinese", "skorean",         "phevFastcharge", "bevFastcharge", "opCost", "accelTime"),     scalePar = "price", robust = TRUE, numMultiStarts = 10)
26: eval(expr, envir)28: }, error = function(e) {withVisible(eval(expr, envir))})
 8: 


 6: tryCatchList(expr, classes, parentenv, handlers)
16: 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) {sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))15: 27: eval(expr, envir)
28: withVisible(eval(expr, envir))
try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
29:     })    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    }})
16: 
29: withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) { 9: FUN(X[[i]], ...)
10: lapply(X = S, FUN = FUN, ...) 7: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))    watcher$capture_plot_and_output()withCallingHandlers(code, error = function (e) 
    if (on_message$capture) {rlang::entrace(e), message = function (cnd) {    watcher$capture_plot_and_output()    if (on_message$capture) {        watcher$push(cnd)tryCatch({    }    if (on_message$silence) {        invokeRestart("muffleMessage")    }}, warning = function (cnd)         watcher$push(cnd)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 (getOption("warn") >= 2 || getOption("warn") < 0) {17: FUN(X[[i]], ...)        return()
18: 
    }11:     result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, lapply(seq_len(cores), inner.do)        mi = mi, opts = mi$options)21: }, error = function(e) {    watcher$capture_plot_and_output()})
 8:     if (on_warning$capture) {    }
19: parallel::mclapply(miList, runModel, mc.cores = numCores)
20: withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))system.time({    if (on_message$silence) {
Traceback:
 1: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)doTryCatch(return(expr), name, parentenv, handler)
21: 
        invokeRestart("muffleMessage")    }}, warning = function (cnd) {        cnd <- sanitize_call(cnd) 2: eval_f(x0, ...)suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))
22: withCallingHandlers(expr, message = function(c) if (inherits(c,     classes)) tryInvokeRestart("muffleMessage"))
suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))
    model <- mi$model    result <- NULL    tryCatch({doTryCatch(return(expr), name, parentenv, handler)23: suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))
        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     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$push(cnd) 3:         invokeRestart("muffleWarning")    }    if (on_warning$silence) {        invokeRestart("muffleWarning")22: withCallingHandlers(expr, message = function(c) if (inherits(c, nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, 
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)    }
12: tryCatchOne(expr, names, parentenv, handlers[[1L]])
12:     }    mi = mi, opts = mi$options)            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}, error = function (cnd) {    watcher$capture_plot_and_output()        model$status <- result$status}, error = function (cnd)     classes)) tryInvokeRestart("muffleMessage"))
23: suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))
24:         model$message <- result$messagerunMultistart(modelInputs)
25:     cnd <- sanitize_call(cnd)
tryCatchOne(expr, names, parentenv, handlers[[1L]])26: 
 4: 13: 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"),     }13:     scalePar = "price", robust = TRUE, numMultiStarts = 10)tryCatchList(expr, classes, parentenv, handlers)    watcher$push(cnd)tryCatchList(expr, classes, parentenv, handlers)doTryCatch(return(expr), name, parentenv, handler){    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)})
    switch(on_error, continue = invokeRestart("eval_continue"),         stop = invokeRestart("eval_stop"), error = NULL)})26: eval(expr, envir)
27: eval(expr, envir)


 9: FUN(X[[i]], ...)
10: lapply(X = S, FUN = FUN, ...)
11: doTryCatch(return(expr), name, parentenv, handler)
12: tryCatchOne(expr, names, parentenv, handlers[[1L]])
14: tryCatch(expr, error = function(e) {    call <- conditionCall(e)    if (!is.null(call)) {
13: tryCatchList(expr, classes, parentenv, handlers)
14: })
30: eval(call)
30: 
14: tryCatch(expr, error = function(e) {
    call <- conditionCall(e)28: 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)
 5: tryCatch(expr, error = function(e) {tryCatchOne(expr, names, parentenv, handlers[[1L]])
33: 31: eval(expr, envir)    if (!is.null(call)) {eval(call)    call <- conditionCall(e)doWithOneRestart(return(expr), restart)        if (identical(call[[1L]], quote(doTryCatch))) 


withVisible(eval(expr, envir)) 6: 32: with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))tryCatchList(expr, classes, parentenv, handlers)34:             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 : "

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) 27: eval(expr, envir)
withOneRestart(expr, restarts[[1L]])        if (identical(call[[1L]], quote(doTryCatch)))             call <- sys.call(-4L)        dcall <- deparse(call, nlines = 1L)    msg <- paste0(prefix, conditionMessage(e), "\n")
35: withRestartList(expr, restarts[-nr])
36:         watcher$capture_plot_and_output(){        watcher$print_value(ev$value, ev$visible, envir)    } 7:         prefix <- paste("Error in", dcall, ": ")        LONG <- 75L    if (!is.null(call)) {28:         sm <- strsplit(conditionMessage(e), "\n")[[1L]]    .Internal(seterrmessage(msg[1L]))    if (getOption("warn") >= 2 || getOption("warn") < 0) {        w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")        if (identical(call[[1L]], quote(doTryCatch)))     TRUEwithVisible(eval(expr, envir))}, handlers)
33: doWithOneRestart(return(expr), restart)
34: withOneRestart(expr, restarts[[1L]])
        return()doWithOneRestart(return(expr), restart)

    }    watcher$capture_plot_and_output()    if (on_warning$capture) {        cnd <- sanitize_call(cnd)        watcher$push(cnd)    }    if (on_warning$silence) {    if (!silent && isTRUE(getOption("show.error.messages"))) {35: 37: tryCatch({            call <- sys.call(-4L)    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,         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)})        if (is.na(w))         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  ")    }
withRestartList(expr, restarts[-nr])withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])            w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L],         cat(msg, file = outFile)        mi = mi, opts = mi$options)    else prefix <- "Error : "30: eval(call)
31:         .Internal(printDeferredWarnings())29: withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) 
    }    invisible(structure(msg, class = "try-error", condition = e))38: eval(call)                type = "b")}){withRestartList(expr, restarts)    msg <- paste0(prefix, conditionMessage(e), "\n")        if (w > LONG)             prefix <- paste0(prefix, "\n  ")    }    else prefix <- "Error : "    msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L]))

}, error = function(e) {32:     watcher$capture_plot_and_output()15: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
16: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
17: FUN(X[[i]], ...)
18: lapply(seq_len(cores), inner.do)
})    if (!silent && isTRUE(getOption("show.error.messages"))) {    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()with_handlers({        cat(msg, file = outFile)    if (on_warning$capture) {19:  8:         .Internal(printDeferredWarnings())        cnd <- sanitize_call(cnd)39: parallel::mclapply(miList, runModel, mc.cores = numCores)    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))    }    .Internal(seterrmessage(msg[1L]))        watcher$capture_plot_and_output()        watcher$push(cnd)    if (!silent && isTRUE(getOption("show.error.messages"))) {    invisible(structure(msg, class = "try-error", condition = e))})
15: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
16: 
        watcher$print_value(ev$value, ev$visible, envir)withRestarts(with_handlers({36: doWithOneRestart(return(expr), restart)
37: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
38: withRestartList(expr, restarts)
39: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
system.time({    model <- mi$modelwithRestarts(with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()    result <- NULL    }    }    TRUE    if (on_warning$silence) {    tryCatch({        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,             mi = mi, opts = mi$options)        cat(msg, file = outFile)        .Internal(printDeferredWarnings())    }    invisible(structure(msg, class = "try-error", condition = e))    }, 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: }, handlers)    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        invokeRestart("muffleWarning")
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"))tryCatchOne(expr, names, parentenv, handlers[[1L]])20:         watcher$print_value(ev$value, ev$visible, envir)})
        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE

}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)33:     }    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))
21: 

15: 42: doWithOneRestart(return(expr), restart)    }13: tryCatchList(expr, classes, parentenv, handlers)
14: in_dir(input_dir(), expr)
40: 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: tryCatch(expr, error = function(e) {
43: in_input_dir(evaluate(code, envir = env, new_device = FALSE,     call <- conditionCall(e)try(lapply(X = S, FUN = FUN, ...), silent = TRUE)withCallingHandlers(expr, warning = function(w) if (inherits(w,     if (!is.null(call)) {34: runMultistart(modelInputs)}, error = function (cnd)         if (identical(call[[1L]], quote(doTryCatch))) 
{withOneRestart(expr, restarts[[1L]])
35: withRestartList(expr, restarts[-nr])
36:     watcher$capture_plot_and_output()    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 {doWithOneRestart(return(expr), restart)
    cnd <- sanitize_call(cnd)    watcher$push(cnd)    switch(on_error, continue = invokeRestart("eval_continue"), 25:     classes)) tryInvokeRestart("muffleWarning"))evaluate::evaluate(...)        if (options$error && options$include)             0L37: 
            call <- sys.call(-4L)logitr(data = cars_us, outcome = "choice", obsID = "obsnum",         dcall <- deparse(call, nlines = 1L)        prefix <- paste("Error in", dcall, ": ")        LONG <- 75L        else 2L    pars = c("hev", "phev10", "phev20", "phev40", "bev75", "bev100", 
        stop = invokeRestart("eval_stop"), error = NULL)
        sm <- strsplit(conditionMessage(e), "\n")[[1L]]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 {        "bev150", "american", "japanese", "chinese", "skorean",         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  ")21: 16: })        if (options$error && options$include)     }, output_handler = knit_handlers(options$render, options)))        "phevFastcharge", "bevFastcharge", "opCost", "accelTime"), suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))    scalePar = "price", robust = TRUE, numMultiStarts = 10)sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
            0L
44: 30: 
eng_r(options)        else 2L26: 

eval(call)
31: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])    }, output_handler = knit_handlers(options$render, options))eval(expr, envir)


27: eval(expr, envir)
28: eval(call)38: withRestartList(expr, restarts)45: withVisible(eval(expr, envir))22: 
29: withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) 
39: withRestarts(with_handlers({
    }    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: 
17: FUN(X[[i]], ...)lapply(seq_len(cores), inner.do){
    watcher$capture_plot_and_output()block_exec(params)19: withCallingHandlers(expr, message = function(c) if (inherits(c, 42:     classes)) tryInvokeRestart("muffleMessage"))
    for (expr in tle$exprs) {parallel::mclapply(miList, runModel, mc.cores = numCores)

    if (on_message$capture) {23: in_dir(input_dir(), expr)46:         watcher$push(cnd)suppressMessages(suppressWarnings(parallel::mclapply(miList, 32:         ev <- withVisible(eval(expr, envir))    runModel, mc.cores = numCores)))    }        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))
    if (on_message$silence) {call_block(x)        watcher$capture_plot_and_output()
20: withCallingHandlers(expr, warning = function(w) if (inherits(w, 18: lapply(seq_len(cores), inner.do)
19: parallel::mclapply(miList, runModel, mc.cores = numCores)
20: 

40:         watcher$print_value(ev$value, ev$visible, envir)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: 43: 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)         invokeRestart("muffleMessage")    }    TRUE}, handlers)
33: doWithOneRestart(return(expr), restart)

            0LwithCallingHandlers(expr, warning = function(w) if (inherits(w, eval(expr, envir)
34:     }    classes)) tryInvokeRestart("muffleWarning"))
21: suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))
22: withCallingHandlers(expr, message = function(c) if (inherits(c,     classes)) tryInvokeRestart("muffleMessage"))47:         else 2L}, warning = function (cnd) 
process_group(group)    }, output_handler = knit_handlers(options$render, options))    classes)) tryInvokeRestart("muffleWarning"))
42: in_dir(input_dir(), expr)
{27: eval(expr, envir)
28: withVisible(eval(expr, envir))withOneRestart(expr, restarts[[1L]])


    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()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)    })
23: 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)             0L43:     watcher$capture_plot_and_output()29: in_input_dir(evaluate(code, envir = env, new_device = FALSE, 35: suppressMessages(suppressWarnings(parallel::mclapply(miList, withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) {    watcher$capture_plot_and_output()21:     keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, 49:     keep_message = if (is.numeric(options$message)) TRUE else options$message,     if (on_warning$capture) {        else 2Lwith_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     stop_on_error = if (is.numeric(options$error)) options$error else {    }, output_handler = knit_handlers(options$render, options)))
    runModel, mc.cores = numCores)))44: eng_r(options)

45: block_exec(params)
46: call_block(x)24: withRestartList(expr, restarts[-nr])        if (options$error && options$include) 
    error = function(e) {        cnd <- sanitize_call(cnd)47: 
        watcher$push(cnd)            0Lprocess_group(group)
        if (progress && is.function(pb$interrupt))     if (on_message$capture) {runMultistart(modelInputs)    }        watcher$push(cnd)    }
            pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check())     if (on_warning$silence) {suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))
        invokeRestart("muffleWarning")36:             error <<- format(e)    if (on_message$silence) {doWithOneRestart(return(expr), restart)48: withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     error = function(e) {25:     }}, error = function (cnd) {    watcher$capture_plot_and_output()    cnd <- sanitize_call(cnd)    watcher$push(cnd)    switch(on_error, continue = invokeRestart("eval_continue"), 22:         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()))        invokeRestart("muffleMessage")

50: xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),         stop = invokeRestart("eval_stop"), error = NULL)withCallingHandlers(expr, message = function(c) if (inherits(c, })    classes)) tryInvokeRestart("muffleMessage"))
30: eval(call)    }), list(rlang_trace_top_env = knit_global()))


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", 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)) 37:         "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: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])    error = function(e) {            pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check())         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)        if (progress && is.function(pb$interrupt)) 31: withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) eval(call)logitr(data = cars_us, outcome = "choice", obsID = "obsnum", {            error <<- format(e)            pb$interrupt()    }}, warning = function (cnd) {    }), list(rlang_trace_top_env = knit_global())), function(loc) {
        if (is_R_CMD_build() || is_R_CMD_check()) 
    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    }    setwd(wd)
38: withRestartList(expr, restarts)
48:     watcher$capture_plot_and_output()39: withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     watcher$capture_plot_and_output()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)    write_utf8(res, output %n% stdout())    if (on_warning$capture) {            error <<- format(e)    paste0("\nQuitting from ", loc, if (!is.null(error)) withRestarts(with_handlers({    for (expr in tle$exprs) {        cnd <- sanitize_call(cnd)        watcher$push(cnd)    error = function(e) {    }), list(rlang_trace_top_env = knit_global())), function(loc) {        paste0("\n", rule(), error, "\n", rule()))    pars = c("hev", "phev10", "phev20", "phev40", "bev75", "bev100",     setwd(wd)    }    write_utf8(res, output %n% stdout())        if (progress && is.function(pb$interrupt))         ev <- withVisible(eval(expr, envir))    }            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)    if (on_message$capture) {    paste0("\nQuitting from ", loc, if (!is.null(error))     TRUE        watcher$capture_plot_and_output()        "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) }, handlers)        watcher$print_value(ev$value, ev$visible, envir)        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)
        watcher$push(cnd)    }), list(rlang_trace_top_env = knit_global()))}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)    }    TRUE    if (on_warning$silence) {
    }    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)53: }, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)        invokeRestart("muffleWarning")
rlang::entrace(e), message = function (cnd)         watcher$push(cnd)    }
50: 40:     }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/RtmpKW9PNc/filec080784eded6.rds")
An irrecoverable exception occurred. R is aborting now ...
}, error = function (cnd) {
33: doWithOneRestart(return(expr), restart)
    if (on_warning$silence) {evaluate::evaluate(...)        invokeRestart("muffleWarning")rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
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: 41:     }34: evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning,     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) {withOneRestart(expr, restarts[[1L]])    keep_message = if (is.numeric(options$message)) TRUE else options$message, 
35: withRestartList(expr, restarts[-nr])
36: doWithOneRestart(return(expr), restart)
37: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
38: withRestartList(expr, restarts)
}, error = function (cnd) {    watcher$capture_plot_and_output()vweave_rmarkdown(...)
54: vweave_rmarkdown(...)
55:     cnd <- sanitize_call(cnd)
        return()    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) {55:     }    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$weave(file, quiet = quiet, encoding = enc)
56: doTryCatch(return(expr), name, parentenv, handler)    stop_on_error = if (is.numeric(options$error)) options$error else {39:     watcher$push(cnd)        ev <- withVisible(eval(expr, envir))withRestarts(with_handlers({        if (options$error && options$include)         watcher$capture_plot_and_output()engine$weave(file, quiet = quiet, encoding = enc)

            0L{        else 2L    switch(on_error, continue = invokeRestart("eval_continue"), 56: doTryCatch(return(expr), name, parentenv, handler)    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: 57:         watcher$print_value(ev$value, ev$visible, envir)evaluate::evaluate(...)
41: evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning,         stop = invokeRestart("eval_stop"), error = NULL)})
30: eval(call)
    watcher$capture_plot_and_output()57: tryCatchOne(expr, names, parentenv, handlers[[1L]])
    cnd <- sanitize_call(cnd)tryCatchOne(expr, names, parentenv, handlers[[1L]])
    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))58:     watcher$push(cnd)
58: tryCatchList(expr, classes, parentenv, handlers)    switch(on_error, continue = invokeRestart("eval_continue"),     }    }, output_handler = knit_handlers(options$render, options))tryCatchList(expr, classes, parentenv, handlers)
59: 31: 

59: 
tryCatch({    engine$weave(file, quiet = quiet, encoding = enc)        stop = invokeRestart("eval_stop"), error = NULL)42:     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)))})    TRUEtryCatch({})}, handlers)
33: doWithOneRestart(return(expr), restart)
34: in_dir(input_dir(), expr)
withOneRestart(expr, restarts[[1L]])


42: 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]])in_dir(input_dir(), expr)43:     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)) {35: 60: tools:::.buildOneVignette("mnl_models_weighted.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr", withRestartList(expr, restarts[-nr])in_input_dir(evaluate(code, envir = env, new_device = FALSE,     TRUE, FALSE, "mnl_models_weighted", "UTF-8", "/Volumes/Temp/tmp/RtmpKW9PNc/filec080784eded6.rds")43: 
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_warning = if (is.numeric(options$warning)) TRUE else options$warning,         texi2pdf(file = output, clean = FALSE, quiet = quiet)in_input_dir(evaluate(code, envir = env, new_device = FALSE,     keep_message = if (is.numeric(options$message)) TRUE else options$message,     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 <- find_vignette_product(name, by = "texi2pdf",             engine = engine)    }}, error = function(e) {    OK <<- FALSE30:         else 2Leval(call)
    }, output_handler = knit_handlers(options$render, options)))    keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, 
44: eng_r(options)
An irrecoverable exception occurred. R is aborting now ...
    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 2L31: 
45: block_exec(params)36:     stop_on_error = if (is.numeric(options$error)) options$error else {    }, output_handler = knit_handlers(options$render, options)))
44:         if (options$error && options$include) doWithOneRestart(return(expr), restart)    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s", 
37: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
eng_r(options)
46: call_block(x)            0Leval(call)
32: with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))
45: block_exec(params)
46: call_block(x)        watcher$capture_plot_and_output()38:         else 2L
47: process_group(group)
48: withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), 
    }, output_handler = knit_handlers(options$render, options)))
        file, conditionMessage(e)))        watcher$print_value(ev$value, ev$visible, envir)withRestartList(expr, restarts)})    }    error = function(e) {44: 
    TRUEeng_r(options)47: process_group(group)60:         if (progress && is.function(pb$interrupt)) 
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()
            pb$interrupt()}, handlers)48:         if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)    })
        if (is_R_CMD_build() || is_R_CMD_check()) 

tools:::.buildOneVignette("mnl_models_weighted.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr", 49: 39: with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),             error <<- format(e)    })
49: with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     error = function(e) {    TRUE, FALSE, "mnl_models_weighted", "UTF-8", "/Volumes/Temp/tmp/RtmpKW9PNc/filec080784eded6.rds")withRestarts(with_handlers({        if (progress && is.function(pb$interrupt))     for (expr in tle$exprs) {withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),         ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE    error = function(e) {        if (progress && is.function(pb$interrupt))             pb$interrupt()    error = function(e) {
            pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)    }), list(rlang_trace_top_env = knit_global()))
        if (progress && is.function(pb$interrupt)) 33: 50: }, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)            pb$interrupt()An irrecoverable exception occurred. R is aborting now ...

xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), 40: evaluate::evaluate(...)    error = function(e) {        if (is_R_CMD_build() || is_R_CMD_check())         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) {
            error <<- format(e)    setwd(wd)doWithOneRestart(return(expr), restart)        if (is_R_CMD_build() || is_R_CMD_check()) 
34: 41:     })withOneRestart(expr, restarts[[1L]])evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, 

    write_utf8(res, output %n% stdout())    paste0("\nQuitting from ", loc, if (!is.null(error))         paste0("\n", rule(), error, "\n", rule()))49: }, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)            error <<- format(e)35:     keep_message = if (is.numeric(options$message)) TRUE else options$message, 
51: process_file(text, output)
52: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)withRestartList(expr, restarts[-nr])    }), list(rlang_trace_top_env = knit_global()))    stop_on_error = if (is.numeric(options$error)) options$error else {
with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), 

36: 50:     error = function(e) {doWithOneRestart(return(expr), restart)
37: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
        if (progress && is.function(pb$interrupt)) 53: xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), 38:             pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check()) rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),             error <<- format(e)    }), list(rlang_trace_top_env = knit_global()))withRestartList(expr, restarts)
39: withRestarts(with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))    error = function(e) {    output_dir = getwd(), ...)        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)
40:         if (options$error && options$include) evaluate::evaluate(...)
        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)
54: 50: xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     error = function(e) {
            0L        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) {        else 2L    setwd(wd)51:     }, output_handler = knit_handlers(options$render, options))vweave_rmarkdown(...)41:     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)
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(), evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, 55: 
42: in_dir(input_dir(), expr)

    output_dir = getwd(), ...)
54: vweave_rmarkdown(...)
55: engine$weave(file, quiet = quiet, encoding = enc)43: 51: process_file(text, output)
52: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)    keep_message = if (is.numeric(options$message)) TRUE else options$message, 
56: doTryCatch(return(expr), name, parentenv, handler)
    stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options))
42: in_input_dir(evaluate(code, envir = env, new_device = FALSE, 53: in_dir(input_dir(), expr)
engine$weave(file, quiet = quiet, encoding = enc)
rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
54: 
43: 56: vweave_rmarkdown(...)
55: engine$weave(file, quiet = quiet, encoding = enc)doTryCatch(return(expr), name, parentenv, handler)in_input_dir(evaluate(code, envir = env, new_device = FALSE, 

    keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, 57:     keep_message = if (is.numeric(options$message)) TRUE else options$message,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include) 57: tryCatchOne(expr, names, parentenv, handlers[[1L]])
            0L        else 2L    }, output_handler = knit_handlers(options$render, options)))56: tryCatchOne(expr, names, parentenv, handlers[[1L]])
    keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, 58: tryCatchList(expr, classes, parentenv, handlers)
59: tryCatch({    keep_message = if (is.numeric(options$message)) TRUE else options$message, doTryCatch(return(expr), name, parentenv, handler)
57: tryCatchOne(expr, names, parentenv, handlers[[1L]])
    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)    }58: 44: eng_r(options)
45: block_exec(params)}, error = function(e) {
tryCatchList(expr, classes, parentenv, handlers)
46: 59: tryCatch({    engine$weave(file, quiet = quiet, encoding = enc)    setwd(startdir)
    OK <<- FALSE    stop_on_error = if (is.numeric(options$error)) options$error else {58: tryCatchList(expr, classes, parentenv, handlers)
call_block(x)59: 
        if (options$error && options$include)     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/RtmpKW9PNc/filec080784eded6.rds")
An irrecoverable exception occurred. R is aborting now ...
    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)    }47: process_group(group)
48: withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), }, error = function(e) {tryCatch({    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/RtmpKW9PNc/filec080784eded6.rds")
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: 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)            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:     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", 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) {        file, conditionMessage(e)))    OK <<- FALSE})
60: tools:::.buildOneVignette("mnl_models_weighted.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr",     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/RtmpKW9PNc/filec080784eded6.rds")
An irrecoverable exception occurred. R is aborting now ...
    }), 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(), ...)    TRUE, FALSE, "mnl_models_weighted", "UTF-8", "/Volumes/Temp/tmp/RtmpKW9PNc/filec080784eded6.rds")
An irrecoverable exception occurred. R is aborting now ...

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/RtmpKW9PNc/filec080784eded6.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, ...)
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: 
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$modellogitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat",     "brand"), scalePar = "price", numMultiStarts = 10)
    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: 26: eval(expr, envir)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())    }
27: eval(expr, envir)
28: withVisible(eval(expr, envir))    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))

29: withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) {    watcher$capture_plot_and_output()    if (on_message$capture) {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:         watcher$push(cnd)    }    if (on_message$silence) {        invokeRestart("muffleMessage")    }}, warning = function (cnd) {    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    }withCallingHandlers(expr, message = function(c) if (inherits(c,     classes)) tryInvokeRestart("muffleMessage"))
23: suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))
24:     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)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) })
30: eval(call)
31: eval(call)
32: with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir)){    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$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){    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()
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) 
 *** caught segfault ***

 *** caught segfault ***
address 0x110, cause 'invalid permissions'
        watcher$print_value(ev$value, ev$visible, envir)address 0x110, cause 'invalid permissions'
    }    TRUE
 *** caught segfault ***
            0L        else 2L    }, output_handler = knit_handlers(options$render, options)))
address 0x110, cause 'invalid permissions'
44: eng_r(options)
45: block_exec(params)
46: call_block(x)
47: process_group(group)
48: }, handlers)
33: doWithOneRestart(return(expr), restart)
34: withOneRestart(expr, restarts[[1L]])
35: withRestartList(expr, restarts[-nr])
36: doWithOneRestart(return(expr), restart)
37: 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()))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(...)

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)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 {
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(), ...)
        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("predict.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr",     TRUE, FALSE, "predict", "UTF-8", "/Volumes/Temp/tmp/RtmpKW9PNc/filec08062bc0543.rds")
An irrecoverable exception occurred. R is aborting now ...
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/RtmpKW9PNc/filec08062bc0543.rds")
An irrecoverable exception occurred. R is aborting now ...

Traceback:
 1: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)
 2: eval_f(x0, ...)
 3: nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     mi = mi, opts = mi$options)
 4: doTryCatch(return(expr), name, parentenv, handler)
 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
 6: 
Traceback:
 1: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)
 2: eval_f(x0, ...)
 3: 
Traceback:
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)
 1:  7: tryCatchList(expr, classes, parentenv, handlers)
 7: tryCatch({mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, tryCatch({    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,         mi = mi, opts = mi$options)}, error = function(e) {        mi = mi, opts = mi$options)}, error = function(e) {
 2: })
 8: system.time({})
eval_f(x0, ...)
 3: nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     mi = mi, opts = mi$options)
 8: system.time({ 4:     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) {    model <- mi$modeldoTryCatch(return(expr), name, parentenv, handler)    result <- NULL    tryCatch({        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, 
    }) 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
 6: tryCatchList(expr, classes, parentenv, handlers)
 7:             mi = mi, opts = mi$options)tryCatch({    }, error = function(e) {    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     })    if (!is.null(result)) {        mi = mi, opts = mi$options)        model$fail <- FALSE}, error = function(e) {        model$coefficients <- result$solution})    if (!is.null(result)) {        model$logLik <- as.numeric(-1 * result$objective)        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 9: FUN(X[[i]], ...)
 8: system.time({    model <- mi$model    result <- NULL        model$status <- result$status
        model$message <- result$message    }})
 9: FUN(X[[i]], ...)
10:     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$iterations10: lapply(X = S, FUN = FUN, ...)
11: 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) {doTryCatch(return(expr), name, parentenv, handler)    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, ": ")        model$status <- result$status        LONG <- 75L
12:         model$message <- result$messagetryCatchOne(expr, names, parentenv, handlers[[1L]])    }})
 9: 
13:         sm <- strsplit(conditionMessage(e), "\n")[[1L]]FUN(X[[i]], ...)tryCatchList(expr, classes, parentenv, handlers)
10: lapply(X = S, FUN = FUN, ...)
11: 
14: tryCatch(expr, error = function(e) {    call <- conditionCall(e)        w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")    if (!is.null(call)) {        if (is.na(w))         if (identical(call[[1L]], quote(doTryCatch)))             call <- sys.call(-4L)doTryCatch(return(expr), name, parentenv, handler)
            w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L],                 type = "b")        if (w > LONG)             prefix <- paste0(prefix, "\n  ")12:     }tryCatchOne(expr, names, parentenv, handlers[[1L]])    else prefix <- "Error : "    msg <- paste0(prefix, conditionMessage(e), "\n")        dcall <- deparse(call, nlines = 1L)    .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {
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")        prefix <- paste("Error in", dcall, ": ")        if (is.na(w))         LONG <- 75L        cat(msg, file = outFile)            w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L],         .Internal(printDeferredWarnings())    }    invisible(structure(msg, class = "try-error", condition = e))})
15: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
                type = "b")        sm <- strsplit(conditionMessage(e), "\n")[[1L]]        if (w > LONG) 16: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
            prefix <- paste0(prefix, "\n  ")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,     else prefix <- "Error : "    msg <- paste0(prefix, conditionMessage(e), "\n")    classes)) tryInvokeRestart("muffleMessage"))
23: suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))        w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")
24: runMultistart(modelInputs)
25: logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat",     "brand"), scalePar = "price", numMultiStarts = 10)
        if (is.na(w)) 26:             w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L],     .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:                 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))eval(expr, envir)
27: eval(expr, envir)
28: withVisible(eval(expr, envir))
29: parallel::mclapply(miList, runModel, mc.cores = numCores)withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) {    watcher$capture_plot_and_output()    if (on_message$capture) {})        watcher$push(cnd)
15: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
16: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
 *** caught segfault ***

20: withCallingHandlers(expr, warning = function(w) if (inherits(w,     }address 0x110, cause 'invalid permissions'
    if (on_message$silence) {
17: FUN(X[[i]], ...)
18: lapply(seq_len(cores), inner.do)
    classes)) tryInvokeRestart("muffleWarning"))
21:         invokeRestart("muffleMessage")    }}, warning = function (cnd) {    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    }    watcher$capture_plot_and_output()    if (on_warning$capture) {19: suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))
22: withCallingHandlers(expr, message = function(c) if (inherits(c,         cnd <- sanitize_call(cnd)        watcher$push(cnd)    }    if (on_warning$silence) {        invokeRestart("muffleWarning")    }}, error = function (cnd) {    watcher$capture_plot_and_output()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,     classes)) tryInvokeRestart("muffleMessage"))
23: suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))
    cnd <- sanitize_call(cnd)    watcher$push(cnd)    switch(on_error, continue = invokeRestart("eval_continue"),         stop = invokeRestart("eval_stop"), error = NULL)24: })runMultistart(modelInputs)
30: eval(call)
31: eval(call)    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: 
 *** caught segfault ***
address 0x110, cause 'invalid permissions'

withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) {    watcher$capture_plot_and_output()

 *** caught segfault ***

 *** caught segfault ***
32: with_handlers({address 0x110, cause 'invalid permissions'
25: logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat",     "brand"), scalePar = "price", numMultiStarts = 10)
address 0x110, cause 'invalid permissions'
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)     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) {        invokeRestart("muffleMessage")    if (on_message$capture) {        watcher$push(cnd)    }    if (on_message$silence) {        invokeRestart("muffleMessage")
 *** caught segfault ***
address 0x110, cause 'invalid permissions'
    }}, warning = function (cnd) {    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers)
    }    watcher$capture_plot_and_output()    if (on_warning$capture) {        cnd <- sanitize_call(cnd)        watcher$push(cnd)    }    if (on_warning$silence) {33: doWithOneRestart(return(expr), restart)
        invokeRestart("muffleWarning")    }    }34: withOneRestart(expr, restarts[[1L]])
35: withRestartList(expr, restarts[-nr])
36: doWithOneRestart(return(expr), restart)
}, error = function (cnd) }, warning = function (cnd) {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)){    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")    watcher$capture_plot_and_output()    }    cnd <- sanitize_call(cnd)}, error = function (cnd) 
Traceback:
{    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)})
        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))
30:  1: eval(call)mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)

 2: eval_f(x0, ...)
 3: nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, 42:     watcher$push(cnd)31:     switch(on_error, continue = invokeRestart("eval_continue"), eval(call)in_dir(input_dir(), expr)
32: with_handlers({    for (expr in tle$exprs) {    mi = mi, opts = mi$options)
43: in_input_dir(evaluate(code, envir = env, new_device = FALSE,         ev <- withVisible(eval(expr, envir))        stop = invokeRestart("eval_stop"), error = NULL)        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)
    }    keep_warning = if (is.numeric(options$warning)) TRUE else options$warning,  4:     keep_message = if (is.numeric(options$message)) TRUE else options$message, doTryCatch(return(expr), name, parentenv, handler)    stop_on_error = if (is.numeric(options$error)) options$error else {
        if (options$error && options$include)     TRUE}, handlers)})
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,  5: 
tryCatchOne(expr, names, parentenv, handlers[[1L]])
 6: tryCatchList(expr, classes, parentenv, handlers)
    mi = mi, opts = mi$options)            0L        else 2L33: 
Traceback:
    }, output_handler = knit_handlers(options$render, options)))30: 
Traceback:


 7: tryCatch({    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,         mi = mi, opts = mi$options)}, error = function(e) { 1:  4: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)doWithOneRestart(return(expr), restart)eval(call)
34: withOneRestart(expr, restarts[[1L]])
35: withRestartList(expr, restarts[-nr])
36: doWithOneRestart(return(expr), restart)
 1: 

doTryCatch(return(expr), name, parentenv, handler)
Traceback:
 2: 
})eval_f(x0, ...)
31: eval(call)
32: 
 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
 6: 
tryCatchList(expr, classes, parentenv, handlers)with_handlers({ 3:  1: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar)37: 
nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,  7: mi$logitFuncs$getMnlV(pars, d$X, d$scalePar) 8: 
    mi = mi, opts = mi$options)
tryCatch({44: eng_r(options)
45: block_exec(params)
system.time({ 4: doTryCatch(return(expr), name, parentenv, handler)
 5:     for (expr in tle$exprs) {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)    })
 2: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])        ev <- withVisible(eval(expr, envir))tryCatchOne(expr, names, parentenv, handlers[[1L]])    model <- mi$modeleval_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)
 6: 

    result <- NULL    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,  2: eval_f(x0, ...)
 3: nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     mi = mi, opts = mi$options)}, error = function(e) {38:     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})
 8: system.time({    model <- mi$model    result <- NULL    tryCatch({        mi = mi, opts = mi$options)        watcher$capture_plot_and_output()tryCatchList(expr, classes, parentenv, handlers)
        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers)
33:  7: tryCatch({    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,         mi = mi, opts = mi$options)}, error = function(e) {})
withRestartList(expr, restarts)
        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,  4: 49:  8: doTryCatch(return(expr), name, parentenv, handler)
 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
 6: with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),             mi = mi, opts = mi$options)tryCatchList(expr, classes, parentenv, handlers)
    }, error = function(e) {doWithOneRestart(return(expr), restart)
}, error = function(e) { 7: })    })    if (!is.null(result)) {
34: withOneRestart(expr, restarts[[1L]])
35: withRestartList(expr, restarts[-nr])
36:         model$status <- result$status    error = function(e) {        if (progress && is.function(pb$interrupt))         model$message <- result$message    }            pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check()) })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
system.time({            error <<- format(e)    }    model <- mi$model    }), list(rlang_trace_top_env = knit_global()))39:         model$fail <- FALSEdoWithOneRestart(return(expr), restart)})withRestarts(with_handlers({
 9: FUN(X[[i]], ...)
    for (expr in tle$exprs) {

37:         model$coefficients <- result$solution        model$logLik <- as.numeric(-1 * result$objective)        model$iterations <- result$iterations        model$status <- result$status        model$message <- result$message    }10: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])        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(...)    result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,     result <- NULL
50:         mi = mi, opts = mi$options)}, error = function(e) {})
 8: system.time({    model <- mi$model
    tryCatch({        result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective,  9: FUN(X[[i]], ...)
10: lapply(X = S, FUN = FUN, ...)
11: doTryCatch(return(expr), name, parentenv, handler)
})lapply(X = S, FUN = FUN, ...)38: withRestartList(expr, restarts)12: 
39: withRestarts(with_handlers({            mi = mi, opts = mi$options)    }, error = function(e) {    })    if (!is.null(result)) {
    for (expr in tle$exprs) {tryCatchOne(expr, names, parentenv, handlers[[1L]])41: 11: xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), doTryCatch(return(expr), name, parentenv, handler)    error = function(e) {
        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$message12: evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, tryCatchOne(expr, names, parentenv, handlers[[1L]])    keep_message = if (is.numeric(options$message)) TRUE else options$message,     }})

        if (progress && is.function(pb$interrupt))             pb$interrupt() 9: FUN(X[[i]], ...)
10: lapply(X = S, FUN = FUN, ...)
11: 
 9: FUN(X[[i]], ...)
doTryCatch(return(expr), name, parentenv, handler)    stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include) 
        ev <- withVisible(eval(expr, envir))    result <- NULL12: 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)13:         dcall <- deparse(call, nlines = 1L)        watcher$capture_plot_and_output()
    tryCatch({            0L        if (is_R_CMD_build() || is_R_CMD_check())         result <- nloptr::nloptr(x0 = mi$model$startVals, eval_f = mi$evalFuncs$objective, 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        watcher$print_value(ev$value, ev$visible, envir)            mi = mi, opts = mi$options)        sm <- strsplit(conditionMessage(e), "\n")[[1L]]            error <<- format(e)    }, error = function(e) {    })        else 2L    }    }), list(rlang_trace_top_env = knit_global())), function(loc) {13: tryCatchList(expr, classes, parentenv, handlers)
14: tryCatch(expr, error = function(e) {    call <- conditionCall(e)    if (!is.null(call)) {10:     if (!is.null(result)) {        prefix <- paste("Error in", dcall, ": ")    }, output_handler = knit_handlers(options$render, options))        w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")        if (identical(call[[1L]], quote(doTryCatch))) lapply(X = S, FUN = FUN, ...)
        model$fail <- FALSE        if (is.na(w))         LONG <- 75L        sm <- strsplit(conditionMessage(e), "\n")[[1L]]        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")        model$coefficients <- result$solution    setwd(wd)    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,             w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L],     write_utf8(res, output %n% stdout())    paste0("\nQuitting from ", loc, if (!is.null(error))         if (is.na(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"))) {        model$logLik <- as.numeric(-1 * result$objective)11:         cat(msg, file = outFile)        model$iterations <- result$iterations        model$status <- result$status        model$message <- result$message    }})
    stop_on_error = if (is.numeric(options$error)) options$error else {
42: in_dir(input_dir(), expr)
43: in_input_dir(evaluate(code, envir = env, new_device = FALSE,         if (options$error && options$include)         .Internal(printDeferredWarnings())    keep_warning = if (is.numeric(options$warning)) TRUE else options$warning,             0L    }    keep_message = if (is.numeric(options$message)) TRUE else options$message,                 type = "b") 9: FUN(X[[i]], ...)doTryCatch(return(expr), name, parentenv, handler)    invisible(structure(msg, class = "try-error", condition = e))        else 2L

12: tryCatchOne(expr, names, parentenv, handlers[[1L]])        if (w > LONG)             prefix <- paste0(prefix, "\n  ")    }    else prefix <- "Error : "    msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L]))    stop_on_error = if (is.numeric(options$error)) options$error else {        paste0("\n", rule(), error, "\n", rule()))    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 (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)
        if (options$error && options$include)             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")})            0L        else 2L    }, output_handler = knit_handlers(options$render, options)))
44: eng_r(options)
45: block_exec(params)
46: 16: 51: process_file(text, output)
52: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
53:     }, output_handler = knit_handlers(options$render, options))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]]
    .Internal(seterrmessage(msg[1L]))        w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")        if (is.na(w)) sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))

42: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)10: 
54: vweave_rmarkdown(...)    if (!silent && isTRUE(getOption("show.error.messages"))) {15: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
16: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))17: lapply(X = S, FUN = FUN, ...)
11: doTryCatch(return(expr), name, parentenv, handler)
12:             w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L], 
        cat(msg, file = outFile)                type = "b")in_dir(input_dir(), expr)

call_block(x)
47: 43: 55: engine$weave(file, quiet = quiet, encoding = enc)
tryCatchOne(expr, names, parentenv, handlers[[1L]])FUN(X[[i]], ...)
in_input_dir(evaluate(code, envir = env, new_device = FALSE, 17: FUN(X[[i]], ...)

        .Internal(printDeferredWarnings())process_group(group)13: 
48: withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     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,         if (progress && is.function(pb$interrupt)) 56:     }        if (w > LONG) 18: doTryCatch(return(expr), name, parentenv, handler)            pb$interrupt()    invisible(structure(msg, class = "try-error", condition = e))tryCatchList(expr, classes, parentenv, handlers)        if (is_R_CMD_build() || is_R_CMD_check())             prefix <- paste0(prefix, "\n  ")})    }    else prefix <- "Error : "    msg <- paste0(prefix, conditionMessage(e), "\n")            error <<- format(e)lapply(seq_len(cores), inner.do)18: 
    stop_on_error = if (is.numeric(options$error)) options$error else {    .Internal(seterrmessage(msg[1L]))    })
lapply(seq_len(cores), inner.do)15: 
        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options)))
44: eng_r(options)49: 

45: block_exec(params)
46: call_block(x)


try(lapply(X = S, FUN = FUN, ...), silent = TRUE)47: 19: parallel::mclapply(miList, runModel, mc.cores = numCores)
20: 57: tryCatchOne(expr, names, parentenv, handlers[[1L]])
58: tryCatchList(expr, classes, parentenv, handlers)
59: tryCatch({    engine$weave(file, quiet = quiet, encoding = enc)process_group(group)
16: withCallingHandlers(expr, warning = function(w) if (inherits(w, 19: parallel::mclapply(miList, runModel, mc.cores = numCores)
20: withCallingHandlers(expr, warning = function(w) if (inherits(w,     classes)) tryInvokeRestart("muffleWarning"))
21: suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))
14:     setwd(startdir)    output <- find_vignette_product(name, by = "weave", engine = engine)
with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     error = function(e) {        if (progress && is.function(pb$interrupt))             pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)    if (!have.makefile && vignette_is_tex(output)) {sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))    if (!silent && isTRUE(getOption("show.error.messages"))) {tryCatch(expr, error = function(e) {        cat(msg, file = outFile)22:     }), list(rlang_trace_top_env = knit_global()))    call <- conditionCall(e)    if (!is.null(call)) {    classes)) tryInvokeRestart("muffleWarning"))        .Internal(printDeferredWarnings())
        texi2pdf(file = output, clean = FALSE, quiet = quiet)        output <- find_vignette_product(name, by = "texi2pdf",             engine = engine)    }}, error = function(e) {21: 
50:     OK <<- FALSEwithCallingHandlers(expr, message = function(c) if (inherits(c, 48:         if (identical(call[[1L]], quote(doTryCatch)))     message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s", 
suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))
22:             call <- sys.call(-4L)17: 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)    })withCallingHandlers(expr, message = function(c) if (inherits(c,     classes)) tryInvokeRestart("muffleMessage"))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"))    }        file, conditionMessage(e)))    classes)) tryInvokeRestart("muffleMessage"))        dcall <- deparse(call, nlines = 1L)        prefix <- paste("Error in", dcall, ": ")

})
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/RtmpKW9PNc/filec08062bc0543.rds")
An irrecoverable exception occurred. R is aborting now ...
21:     invisible(structure(msg, class = "try-error", condition = e))49: xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),         LONG <- 75L        sm <- strsplit(conditionMessage(e), "\n")[[1L]]        w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")        if (is.na(w)) suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores))with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     error = function(e) {            w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L], 
22: withCallingHandlers(expr, message = function(c) if (inherits(c,     classes)) tryInvokeRestart("muffleMessage"))
23: 
23: suppressMessages(suppressWarnings(parallel::mclapply(miList,     error = function(e) {})
15:     runModel, mc.cores = numCores)))
23: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)        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))         if (progress && is.function(pb$interrupt))                 type = "b")            pb$interrupt()suppressMessages(suppressWarnings(parallel::mclapply(miList,             pb$interrupt()

    runModel, mc.cores = numCores)))
24: suppressMessages(suppressWarnings(parallel::mclapply(miList,     runModel, mc.cores = numCores)))
24: runMultistart(modelInputs)
25: 24:         if (is_R_CMD_build() || is_R_CMD_check()) logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat", 16:         if (w > LONG)             prefix <- paste0(prefix, "\n  ")    }    else prefix <- "Error : "    msg <- paste0(prefix, conditionMessage(e), "\n")sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
17: FUN(X[[i]], ...)        if (is_R_CMD_build() || is_R_CMD_check())     .Internal(seterrmessage(msg[1L]))            error <<- format(e)
18: lapply(seq_len(cores), inner.do)
19: parallel::mclapply(miList, runModel, mc.cores = numCores)
20: withCallingHandlers(expr, warning = function(w) if (inherits(w, runMultistart(modelInputs)    "brand"), scalePar = "price", numMultiStarts = 10)
            error <<- format(e)    classes)) tryInvokeRestart("muffleWarning"))
21: 26:     }), list(rlang_trace_top_env = knit_global())), function(loc) {
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) runMultistart(modelInputs)suppressWarnings(parallel::mclapply(miList, runModel, mc.cores = numCores)){    if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, file = outFile)    }), list(rlang_trace_top_env = knit_global())), function(loc) {    watcher$capture_plot_and_output()
eval(expr, envir)
27: eval(expr, envir)
    setwd(wd)22:         .Internal(printDeferredWarnings())
28: withVisible(eval(expr, envir))
    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)    write_utf8(res, output %n% stdout())    if (on_message$capture) {        watcher$push(cnd)    }    if (on_message$silence) {        invokeRestart("muffleMessage")    }}, warning = function (cnd) withCallingHandlers(expr, message = function(c) if (inherits(c,     classes)) tryInvokeRestart("muffleMessage"))
29: 
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()withCallingHandlers(code, error = function (e) {    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    }    watcher$capture_plot_and_output()    if (on_warning$capture) {53:     }23:     invisible(structure(msg, class = "try-error", condition = e))    paste0("\nQuitting from ", loc, if (!is.null(error)) rlang::entrace(e), message = function (cnd) suppressMessages(suppressWarnings(parallel::mclapply(miList, {    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)    runModel, mc.cores = numCores)))rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(), 
24: runMultistart(modelInputs)
25: logitr(data = yogurt, outcome = "choice", obsID = "obsID", pars = c("feat",     "brand"), scalePar = "price", numMultiStarts = 10)
26: eval(expr, envir)})        paste0("\n", rule(), error, "\n", rule()))        watcher$push(cnd)        cnd <- sanitize_call(cnd)        watcher$push(cnd)    }    output_dir = getwd(), ...)
27: eval(expr, envir)}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)
    if (on_message$capture) {15: 

try(lapply(X = S, FUN = FUN, ...), silent = TRUE)        watcher$push(cnd)51:     if (on_warning$silence) {        invokeRestart("muffleWarning")    }    }process_file(text, output)
    if (on_warning$silence) {    }}, error = function (cnd) {    watcher$capture_plot_and_output()52:         invokeRestart("muffleWarning")    cnd <- sanitize_call(cnd)    }knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)    if (on_message$silence) {}, error = function (cnd) {    watcher$capture_plot_and_output()    cnd <- sanitize_call(cnd)    watcher$push(cnd)28: withVisible(eval(expr, envir))
29: 
        invokeRestart("muffleMessage")    }}, warning = function (cnd) {    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    }    watcher$capture_plot_and_output()    if (on_warning$capture) {    switch(on_error, continue = invokeRestart("eval_continue"), 
withCallingHandlers(code, error = function (e) 
16: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))        cnd <- sanitize_call(cnd)    watcher$push(cnd)
    switch(on_error, continue = invokeRestart("eval_continue"),         watcher$push(cnd)54: vweave_rmarkdown(...)
55: rlang::entrace(e), message = function (cnd) 17: FUN(X[[i]], ...)
18: lapply(seq_len(cores), inner.do)
19: parallel::mclapply(miList, runModel, mc.cores = numCores)
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)53:     }rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
54:     output <- find_vignette_product(name, by = "weave", engine = engine)        stop = invokeRestart("eval_stop"), error = NULL)    if (!have.makefile && vignette_is_tex(output)) {{vweave_rmarkdown(...)    watcher$capture_plot_and_output()        texi2pdf(file = output, clean = FALSE, quiet = quiet)20:     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) {        stop = invokeRestart("eval_stop"), error = NULL)        output <- find_vignette_product(name, by = "texi2pdf", withCallingHandlers(expr, warning = function(w) if (inherits(w, })
        invokeRestart("muffleWarning")})
30: eval(call)30: 
55: engine$weave(file, quiet = quiet, encoding = enc)eval(call)
31: eval(call)
32:             engine = engine)
56: doTryCatch(return(expr), name, parentenv, handler)with_handlers({    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)
31: eval(call)
32: with_handlers({    for (expr in tle$exprs) {    if (on_warning$silence) {
27: eval(expr, envir)
        ev <- withVisible(eval(expr, envir))    for (expr in tle$exprs) {    }}, error = function (cnd) {    watcher$capture_plot_and_output()    cnd <- sanitize_call(cnd)    watcher$push(cnd)        ev <- withVisible(eval(expr, envir))57: 
28:     }    switch(on_error, continue = invokeRestart("eval_continue"), }, error = function(e) {    OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))        invokeRestart("muffleWarning")        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)        stop = invokeRestart("eval_stop"), error = NULL)        watcher$capture_plot_and_output()})withVisible(eval(expr, envir))})
30: 
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/RtmpKW9PNc/filec08062bc0543.rds")
An irrecoverable exception occurred. R is aborting now ...
tryCatchOne(expr, names, parentenv, handlers[[1L]])    }    TRUE}, handlers)
33: doWithOneRestart(return(expr), restart)
    }}, 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)})
        watcher$print_value(ev$value, ev$visible, envir)58: 29: eval(call)tryCatchList(expr, classes, parentenv, handlers)withCallingHandlers(code, error = function (e)     }    TRUE}, handlers)
33: doWithOneRestart(return(expr), restart)
34: withOneRestart(expr, restarts[[1L]])
35: withRestartList(expr, restarts[-nr])
36: 
59: 
rlang::entrace(e), message = function (cnd) doWithOneRestart(return(expr), restart)tryCatch({30: {
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: 34:     watcher$capture_plot_and_output()    if (on_message$capture) {        watcher$push(cnd)    }    if (on_message$silence) {        invokeRestart("muffleMessage")    }}, warning = function (cnd) 37: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
38: withRestartList(expr, restarts)    engine$weave(file, quiet = quiet, encoding = enc)withOneRestart(expr, restarts[[1L]])
eval(call)    setwd(startdir)
39: withRestarts(with_handlers({    for (expr in tle$exprs) {{    output <- find_vignette_product(name, by = "weave", engine = engine)
        ev <- withVisible(eval(expr, envir))    if (!have.makefile && vignette_is_tex(output)) {31: 35: withRestartList(expr, restarts[-nr])
36: doWithOneRestart(return(expr), restart)
        watcher$capture_plot_and_output()withOneRestart(expr, restarts[[1L]])        texi2pdf(file = output, clean = FALSE, quiet = quiet)eval(call)
32:         watcher$print_value(ev$value, ev$visible, envir)    }
37:     if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()with_handlers({withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
38:     TRUE        output <- find_vignette_product(name, by = "texi2pdf", 35: }, 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, withRestartList(expr, restarts[-nr])    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }withRestartList(expr, restarts)
36: doWithOneRestart(return(expr), restart)    watcher$capture_plot_and_output()
            engine = engine)    if (on_warning$capture) {
        cnd <- sanitize_call(cnd)    }    TRUE39:     stop_on_error = if (is.numeric(options$error)) options$error else {}, handlers)
37: }, error = function(e) {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)33:         if (options$error && options$include)         watcher$push(cnd)    }withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])    }    TRUE}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)
doWithOneRestart(return(expr), restart)
    if (on_warning$silence) {        invokeRestart("muffleWarning")    }}, error = function (cnd) {    watcher$capture_plot_and_output()    cnd <- sanitize_call(cnd)            0L40: 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    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))
34: withOneRestart(expr, restarts[[1L]])
35: withRestartList(expr, restarts[-nr])
36: doWithOneRestart(return(expr), restart)
37: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
38:         else 2L    }, output_handler = knit_handlers(options$render, options))38:     OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s", 
    }, output_handler = knit_handlers(options$render, options))withRestartList(expr, restarts)42: 
42: in_dir(input_dir(), expr)
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 {        file, conditionMessage(e)))        if (options$error && options$include) 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)
            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)    })
43:         watcher$capture_plot_and_output()
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:         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)49: 
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: eng_r(options)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)
in_input_dir(evaluate(code, envir = env, new_device = FALSE, 45: block_exec(params)
46: call_block(x)
47: 
process_group(group)process_group(group)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    keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, 

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),     }, output_handler = knit_handlers(options$render, 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()) 60:     keep_message = if (is.numeric(options$message)) TRUE else options$message, 48:     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)
51:             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)47: 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), tools:::.buildOneVignette("predict.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/logitr.Rcheck/vign_test/logitr", 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)    }process_group(group)    error = function(e) {
    TRUE, FALSE, "predict", "UTF-8", "/Volumes/Temp/tmp/RtmpKW9PNc/filec08062bc0543.rds")withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), }, error = function(e) {    error = function(e) {        if (progress && is.function(pb$interrupt))             pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)    })
48:         if (progress && is.function(pb$interrupt)) 56: 
doTryCatch(return(expr), name, parentenv, handler)An irrecoverable exception occurred. R is aborting now ...
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), 
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/RtmpKW9PNc/filec08062bc0543.rds")
An irrecoverable exception occurred. R is aborting now ...
            pb$interrupt()    OK <<- FALSE    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)49:         if (is_R_CMD_build() || is_R_CMD_check()) with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})
    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/RtmpKW9PNc/filec08062bc0543.rds")
An irrecoverable exception occurred. R is aborting now ...
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/RtmpKW9PNc/filec08062bc0543.rds")
An irrecoverable exception occurred. R is aborting now ...
            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)    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:     }), list(rlang_trace_top_env = knit_global()))process_file(text, output)
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)
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",     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)
            engine = engine)    }}, error = function(e) {    OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))52: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
53: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(), })
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/RtmpKW9PNc/filec08062bc0543.rds")    output_dir = getwd(), ...)
54: vweave_rmarkdown(...)
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)    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/RtmpKW9PNc/filec08062bc0543.rds")
An irrecoverable exception occurred. R is aborting now ...

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

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

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

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

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

Error: Vignette re-building failed.
Execution halted