Last updated on 2024-05-10 17:50:12 CEST.
| Flavor | Version | Tinstall | Tcheck | Ttotal | Status | Flags |
|---|---|---|---|---|---|---|
| r-devel-linux-x86_64-debian-clang | 1.0.6 | 137.62 | 393.53 | 531.15 | OK | |
| r-devel-linux-x86_64-debian-gcc | 1.0.6 | 122.03 | 284.01 | 406.04 | OK | |
| r-devel-linux-x86_64-fedora-clang | 1.0.6 | 649.85 | OK | |||
| r-devel-linux-x86_64-fedora-gcc | 1.0.6 | 783.95 | OK | |||
| r-devel-windows-x86_64 | 1.0.6 | 109.00 | 431.00 | 540.00 | NOTE | |
| r-patched-linux-x86_64 | 1.0.6 | 112.60 | 378.04 | 490.64 | OK | |
| r-release-linux-x86_64 | 1.0.6 | 112.29 | 376.17 | 488.46 | OK | |
| r-release-macos-arm64 | 1.0.6 | 234.00 | NOTE | |||
| r-release-windows-x86_64 | 1.0.6 | 104.00 | 417.00 | 521.00 | ERROR | |
| r-oldrel-macos-arm64 | 1.0.6 | 341.00 | NOTE | |||
| r-oldrel-macos-x86_64 | 1.0.6 | 488.00 | NOTE | |||
| r-oldrel-windows-x86_64 | 1.0.6 | 136.00 | 537.00 | 673.00 | NOTE |
Version: 1.0.6
Check: installed package size
Result: NOTE
installed size is 16.2Mb
sub-directories of 1Mb or more:
doc 1.2Mb
help 1.0Mb
libs 13.6Mb
Flavors: r-devel-windows-x86_64, r-release-macos-arm64, r-release-windows-x86_64, r-oldrel-macos-arm64, r-oldrel-macos-x86_64, r-oldrel-windows-x86_64
Version: 1.0.6
Check: tests
Result: ERROR
Running 'testthat.R' [134s]
Running the tests in 'tests/testthat.R' failed.
Complete output:
> # Copyright 2021 Province of British Columbia
> #
> # Licensed under the Apache License, Version 2.0 (the "License");
> # you may not use this file except in compliance with the License.
> # You may obtain a copy of the License at
> #
> # https://www.apache.org/licenses/LICENSE-2.0
> #
> # Unless required by applicable law or agreed to in writing, software
> # distributed under the License is distributed on an "AS IS" BASIS,
> # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
> # See the License for the specific language governing permissions and
> # limitations under the License.
>
> library(testthat)
> library(ssdtools)
Please replace the following in your scripts:
- `ssdtools::boron_data` with `ssddata::ccme_boron`
- `ssdtools::ccme_data` with `ssddata::ccme_data`
>
> test_check("ssdtools")
Attaching package: 'purrr'
The following object is masked from 'package:testthat':
is_null
[ FAIL 1 | WARN 0 | SKIP 113 | PASS 931 ]
══ Skipped tests (113) ═════════════════════════════════════════════════════════
• On CRAN (15): 'test-estimates.R:20:3', 'test-fit.R:267:3',
'test-ggplot.R:112:3', 'test-gompertz.R:37:3', 'test-gompertz.R:54:3',
'test-hc.R:458:3', 'test-hp.R:356:3', 'test-match-moments.R:19:3',
'test-print.R:3:3', 'test-print.R:8:3', 'test-print.R:17:3',
'test-print.R:26:3', 'test-print.R:40:3', 'test-utils.R:20:3',
'test-weibull.R:20:3'
• On Windows (97): 'test-autoplot.R:17:3', 'test-autoplot.R:22:3',
'test-autoplot.R:28:3', 'test-burrIII3.R:28:3', 'test-burrIII3.R:39:3',
'test-burrIII3.R:48:3', 'test-coef.R:21:3', 'test-data.R:20:3',
'test-data.R:31:3', 'test-data.R:35:3', 'test-data.R:40:3',
'test-data.R:45:3', 'test-fit.R:217:3', 'test-fit.R:252:3',
'test-fit.R:361:3', 'test-fit.R:388:3', 'test-fit.R:395:3',
'test-fit.R:402:3', 'test-fit.R:410:3', 'test-ggplot.R:24:3',
'test-ggplot.R:36:3', 'test-ggplot.R:42:3', 'test-ggplot.R:50:3',
'test-ggplot.R:56:3', 'test-ggplot.R:65:3', 'test-ggplot.R:71:3',
'test-ggplot.R:77:3', 'test-ggplot.R:83:3', 'test-ggplot.R:91:3',
'test-ggplot.R:99:3', 'test-glance.R:6:3', 'test-glance.R:55:3',
'test-gof.R:20:3', 'test-gof.R:32:3', 'test-gompertz.R:29:3',
'test-hc-burrlioz.R:20:3', 'test-hc-burrlioz.R:31:3',
'test-hc-burrlioz.R:46:3', 'test-hc.R:21:3', 'test-hc.R:126:3',
'test-hc.R:135:3', 'test-hc.R:144:3', 'test-hc.R:153:3', 'test-hc.R:161:3',
'test-hc.R:183:3', 'test-hc.R:192:3', 'test-hc.R:200:3', 'test-hc.R:220:3',
'test-hc.R:231:3', 'test-hc.R:394:3', 'test-hc.R:409:3', 'test-hc.R:429:3',
'test-hc.R:447:3', 'test-hc.R:472:3', 'test-hc.R:483:3', 'test-hc.R:494:3',
'test-hc.R:509:3', 'test-hp.R:22:3', 'test-hp.R:45:3', 'test-hp.R:54:3',
'test-hp.R:63:3', 'test-hp.R:72:3', 'test-hp.R:81:3', 'test-hp.R:90:3',
'test-hp.R:99:3', 'test-hp.R:109:3', 'test-hp.R:118:3', 'test-hp.R:127:3',
'test-hp.R:162:3', 'test-hp.R:291:3', 'test-hp.R:306:3', 'test-hp.R:327:3',
'test-hp.R:345:3', 'test-invpareto.R:27:3', 'test-invpareto.R:35:3',
'test-lnorm-lnorm.R:53:3', 'test-plot-cdf.R:19:3', 'test-plot-cdf.R:25:3',
'test-plot-cdf.R:29:3', 'test-plot-cdf.R:38:3', 'test-plot-cf.R:17:3',
'test-plot-data.R:16:3', 'test-plot.R:10:3', 'test-predict.R:22:3',
'test-predict.R:33:3', 'test-predict.R:44:3', 'test-predict.R:56:3',
'test-schwarz-tillmans.R:24:3', 'test-ssd-plot.R:16:3',
'test-ssd-plot.R:28:3', 'test-ssd-plot.R:37:3', 'test-ssd-plot.R:42:3',
'test-ssd-plot.R:57:3', 'test-tidy.R:20:3', 'test-weibull.R:29:3',
'test-weibull.R:36:3', 'test-weibull.R:43:3'
• invpareto ABNORMAL_TERMINATION_IN_LNSRCH. (1): 'test-invpareto.R:117:3'
══ Failed tests ════════════════════════════════════════════════════════════════
── Error ('test-hc.R:522:3'): ssd_hc passing all boots ccme_chloride lnorm_lnorm ──
<purrr_error_indexed/rlang_error/error/condition>
Error in `(function (.x, .f, ..., .progress = FALSE)
{
map_("list", .x, .f, ..., .progress = .progress)
})(.x = list(lnorm_lnorm = structure(list(dist = "lnorm_lnorm",
model = list(par = c(meanlog1 = 5.69175792393478, log_sdlog1 = 0.0576328004057056,
meanlog2 = 7.65970275036418, log_sdlog2 = -0.362053197750657,
logit_pmix = 0), fn = function (x = last.par[lfixed()], ...)
{
if (tracepar) {
cat("par:\n")
print(x)
}
if (!validpar(x))
return(NaN)
if (is.null(random)) {
ans <- f(x, order = 0)
if (!ADreport) {
if (is.finite(ans) && ans < value.best) {
last.par.best <<- x
value.best <<- ans
}
}
}
else {
ans <- try({
if (MCcontrol$doMC) {
ff(x, order = 0)
MC(last.par, n = MCcontrol$n, seed = MCcontrol$seed,
order = 0)
}
else ff(x, order = 0)
}, silent = silent)
if (is.character(ans))
ans <- NaN
}
ans
}, gr = function (x = last.par[lfixed()], ...)
{
if (is.null(random)) {
ans <- f(x, order = 1)
}
else {
ans <- try({
if (MCcontrol$doMC) {
ff(x, order = 0)
MC(last.par, n = MCcontrol$n, seed = MCcontrol$seed,
order = 1)
}
else ff(x, order = 1)
}, silent = silent)
if (is.character(ans))
ans <- rep(NaN, length(x))
}
if (tracemgc)
cat("outer mgc: ", max(abs(ans)), "\n")
ans
}, he = function (x = last.par[lfixed()], atomic = usingAtomics())
{
if (is.null(random)) {
if (!atomic)
return(f(x, order = 2))
if (is.null(ADGrad))
retape_adgrad()
return(f(x, type = "ADGrad", order = 1))
}
else {
stop("Hessian not yet implemented for models with random effects.")
}
}, hessian = FALSE, method = "BFGS", retape = function (set.defaults = TRUE)
{
omp <- config(DLL = DLL)
random <<- .random
if (atomic) {
Fun <<- MakeDoubleFunObject(data, parameters, reportenv,
DLL = DLL)
out <- EvalDoubleFunObject(Fun, unlist(parameters),
get_reportdims = TRUE)
ADreportDims <<- attr(out, "reportdims")
}
if (is.character(profile)) {
random <<- c(random, profile)
}
if (is.character(random)) {
if (!regexp) {
if (!all(random %in% names(parameters))) {
cat("Some 'random' effect names does not match 'parameter' list:\n")
print(setdiff(random, names(parameters)))
cat("(Note that regular expression match is disabled by default)\n")
stop()
}
if (any(duplicated(random))) {
cat("Duplicates in 'random' - will be removed\n")
random <<- unique(random)
}
tmp <- lapply(parameters, function(x) x * 0)
tmp[random] <- lapply(tmp[random], function(x) x *
0 + 1)
random <<- which(as.logical(unlist(tmp)))
if (length(random) == 0)
random <<- NULL
}
if (regexp) {
random <<- grepRandomParameters(parameters, random)
if (length(random) == 0) {
cat("Selected random effects did not match any model parameters.\n")
random <<- NULL
}
}
if (is.character(profile)) {
tmp <- lapply(parameters, function(x) x * 0)
tmp[profile] <- lapply(tmp[profile], function(x) x *
0 + 1)
profile <<- match(which(as.logical(unlist(tmp))),
random)
if (length(profile) == 0)
random <<- NULL
if (any(duplicated(profile)))
stop("Profile parameter vector not unique.")
tmp <- rep(0L, length(random))
tmp[profile] <- 1L
profile <<- tmp
}
if (set.defaults) {
par <<- unlist(parameters)
}
}
if ("ADFun" %in% type) {
if (omp$autopar)
openmp(1, DLL = DLL)
ADFun <<- MakeADFunObject(data, parameters, reportenv,
ADreport = ADreport, DLL = DLL)
if (omp$autopar)
openmp(omp$nthreads, DLL = DLL)
if (!is.null(integrate)) {
nm <- sapply(parameters, length)
nmpar <- rep(names(nm), nm)
for (i in seq_along(integrate)) {
I <- integrate[i]
if (is.null(names(I)) || names(I) == "") {
I <- I[[1]]
}
ok <- all(names(I) %in% nmpar[random])
if (!ok)
stop("Names to be 'integrate'd must be among the random parameters")
w <- which(nmpar[random] %in% names(I))
arg_which <- I[[1]]$which
if (!is.null(arg_which))
w <- w[arg_which]
method <- sapply(I, function(x) x$method)
ok <- all(duplicated(method)[-1])
if (!ok)
stop("Grouping only allowed for identical methods")
method <- method[1]
cfg <- NULL
if (method == "marginal_sr") {
fac <- factor(nmpar[random[w]], levels = names(I))
cfg <- list(grid = I, random2grid = fac)
}
else {
cfg <- I[[1]]
}
stopifnot(is.list(cfg))
TransformADFunObject(ADFun, method = method,
random_order = random[w], config = cfg, mustWork = 1L)
activeDomain <- as.logical(info(ADFun)$activeDomain)
random_remove <- random[w][!activeDomain[random[w]]]
TransformADFunObject(ADFun, method = "remove_random_parameters",
random_order = random_remove, mustWork = 1L)
attr(ADFun$ptr, "par") <- attr(ADFun$ptr, "par")[-random_remove]
par_mask <- rep(FALSE, length(attr(ADFun$ptr,
"par")))
par_mask[random] <- TRUE
par <<- par[-random_remove]
nmpar <- nmpar[-random_remove]
par_mask <- par_mask[-random_remove]
random <<- which(par_mask)
if (length(random) == 0) {
random <<- NULL
type <<- setdiff(type, "ADGrad")
}
if (config(DLL = DLL)$optimize.instantly) {
TransformADFunObject(ADFun, method = "optimize",
mustWork = 1L)
}
}
}
if (intern) {
cfg <- inner.control
if (is.null(cfg$sparse))
cfg$sparse <- TRUE
cfg <- lapply(cfg, as.double)
TransformADFunObject(ADFun, method = "laplace",
config = cfg, random_order = random, mustWork = 1L)
TransformADFunObject(ADFun, method = "remove_random_parameters",
random_order = random, mustWork = 1L)
attr(ADFun$ptr, "par") <- attr(ADFun$ptr, "par")[-random]
par <<- par[-random]
random <<- NULL
if (config(DLL = DLL)$optimize.instantly) {
TransformADFunObject(ADFun, method = "optimize",
mustWork = 1L)
}
}
if (set.defaults) {
par <<- attr(ADFun$ptr, "par")
last.par <<- par
last.par1 <<- par
last.par2 <<- par
last.par.best <<- par
value.best <<- Inf
}
}
if (omp$autopar && !ADreport) {
TransformADFunObject(ADFun, method = "parallel_accumulate",
num_threads = as.integer(openmp(DLL = DLL)),
mustWork = 0L)
}
if (length(random) > 0) {
TransformADFunObject(ADFun, method = "reorder_random",
random_order = random, mustWork = 0L)
}
if ("Fun" %in% type) {
Fun <<- MakeDoubleFunObject(data, parameters, reportenv,
DLL = DLL)
}
if ("ADGrad" %in% type) {
retape_adgrad(lazy = TRUE)
}
env$skipFixedEffects <- !is.null(ADGrad)
delayedAssign("spHess", sparseHessianFun(env, skipFixedEffects = skipFixedEffects),
assign.env = env)
}, env = <environment>, report = function (par = last.par)
{
f(par, order = 0, type = "double")
as.list(reportenv)
}, simulate = function (par = last.par, complete = FALSE)
{
f(par, order = 0, type = "double", do_simulate = TRUE)
sim <- as.list(reportenv)
if (complete) {
ans <- data
ans[names(sim)] <- sim
}
else {
ans <- sim
}
ans
}), optim = list(par = c(meanlog1 = 3.45322872225588, log_sdlog1 = -1.27365236267236,
meanlog2 = 6.9178496184246, log_sdlog2 = -0.00080019297882199,
logit_pmix = -2.58856103427256), value = 231.035341081078,
counts = c(`function` = 39L, gradient = 39L), convergence = 0L,
message = "CONVERGENCE: REL_REDUCTION_OF_F <= FACTR*EPSMCH",
hessian = structure(c(24.4343212245894, -0.0146175077037586,
-0.352084007511189, 0.964659399601814, -0.114039244316153,
-0.0146175077037586, 3.90078563018057, -0.00441613734465312,
0.0107952875691186, -0.0016056057905534, -0.352084007511189,
-0.00441613734465312, 25.6382708896679, 1.32590495428742,
-0.136721618709502, 0.964659399601814, 0.0107952875691186,
1.32590495428742, 48.1234964360616, 0.404147717565761,
-0.114039244316153, -0.0016056057905534, -0.136721618709502,
0.404147717565761, 1.77789194599387), dim = c(5L, 5L), dimnames = list(
c("meanlog1", "log_sdlog1", "meanlog2", "log_sdlog2",
"logit_pmix"), c("meanlog1", "log_sdlog1", "meanlog2",
"log_sdlog2", "logit_pmix")))), est = c(meanlog1 = 3.45322872225588,
meanlog2 = 6.9178496184246, pmix = 0.0698782509920365, sdlog1 = 0.279807793679678,
sdlog2 = 0.999200127090202), pars = list(meanlog1 = 3.45322872225588,
meanlog2 = 6.9178496184246, logit_pmix = -2.58856103427256,
log_sdlog1 = -1.27365236267236, log_sdlog2 = -0.00080019297882199)), class = "tmbfit"),
llogis_llogis = structure(list(dist = "llogis_llogis", model = list(
par = c(locationlog1 = 5.69175792393478, log_scalelog1 = 0.653056541921051,
locationlog2 = 7.65970275036418, log_scalelog2 = 0.233370543764688,
logit_pmix = 0), fn = function (x = last.par[lfixed()],
...)
{
if (tracepar) {
cat("par:\n")
print(x)
}
if (!validpar(x))
return(NaN)
if (is.null(random)) {
ans <- f(x, order = 0)
if (!ADreport) {
if (is.finite(ans) && ans < value.best) {
last.par.best <<- x
value.best <<- ans
}
}
}
else {
ans <- try({
if (MCcontrol$doMC) {
ff(x, order = 0)
MC(last.par, n = MCcontrol$n, seed = MCcontrol$seed,
order = 0)
}
else ff(x, order = 0)
}, silent = silent)
if (is.character(ans))
ans <- NaN
}
ans
}, gr = function (x = last.par[lfixed()], ...)
{
if (is.null(random)) {
ans <- f(x, order = 1)
}
else {
ans <- try({
if (MCcontrol$doMC) {
ff(x, order = 0)
MC(last.par, n = MCcontrol$n, seed = MCcontrol$seed,
order = 1)
}
else ff(x, order = 1)
}, silent = silent)
if (is.character(ans))
ans <- rep(NaN, length(x))
}
if (tracemgc)
cat("outer mgc: ", max(abs(ans)), "\n")
ans
}, he = function (x = last.par[lfixed()], atomic = usingAtomics())
{
if (is.null(random)) {
if (!atomic)
return(f(x, order = 2))
if (is.null(ADGrad))
retape_adgrad()
return(f(x, type = "ADGrad", order = 1))
}
else {
stop("Hessian not yet implemented for models with random effects.")
}
}, hessian = FALSE, method = "BFGS", retape = function (set.defaults = TRUE)
{
omp <- config(DLL = DLL)
random <<- .random
if (atomic) {
Fun <<- MakeDoubleFunObject(data, parameters,
reportenv, DLL = DLL)
out <- EvalDoubleFunObject(Fun, unlist(parameters),
get_reportdims = TRUE)
ADreportDims <<- attr(out, "reportdims")
}
if (is.character(profile)) {
random <<- c(random, profile)
}
if (is.character(random)) {
if (!regexp) {
if (!all(random %in% names(parameters))) {
cat("Some 'random' effect names does not match 'parameter' list:\n")
print(setdiff(random, names(parameters)))
cat("(Note that regular expression match is disabled by default)\n")
stop()
}
if (any(duplicated(random))) {
cat("Duplicates in 'random' - will be removed\n")
random <<- unique(random)
}
tmp <- lapply(parameters, function(x) x * 0)
tmp[random] <- lapply(tmp[random], function(x) x *
0 + 1)
random <<- which(as.logical(unlist(tmp)))
if (length(random) == 0)
random <<- NULL
}
if (regexp) {
random <<- grepRandomParameters(parameters,
random)
if (length(random) == 0) {
cat("Selected random effects did not match any model parameters.\n")
random <<- NULL
}
}
if (is.character(profile)) {
tmp <- lapply(parameters, function(x) x * 0)
tmp[profile] <- lapply(tmp[profile], function(x) x *
0 + 1)
profile <<- match(which(as.logical(unlist(tmp))),
random)
if (length(profile) == 0)
random <<- NULL
if (any(duplicated(profile)))
stop("Profile parameter vector not unique.")
tmp <- rep(0L, length(random))
tmp[profile] <- 1L
profile <<- tmp
}
if (set.defaults) {
par <<- unlist(parameters)
}
}
if ("ADFun" %in% type) {
if (omp$autopar)
openmp(1, DLL = DLL)
ADFun <<- MakeADFunObject(data, parameters, reportenv,
ADreport = ADreport, DLL = DLL)
if (omp$autopar)
openmp(omp$nthreads, DLL = DLL)
if (!is.null(integrate)) {
nm <- sapply(parameters, length)
nmpar <- rep(names(nm), nm)
for (i in seq_along(integrate)) {
I <- integrate[i]
if (is.null(names(I)) || names(I) == "") {
I <- I[[1]]
}
ok <- all(names(I) %in% nmpar[random])
if (!ok)
stop("Names to be 'integrate'd must be among the random parameters")
w <- which(nmpar[random] %in% names(I))
arg_which <- I[[1]]$which
if (!is.null(arg_which))
w <- w[arg_which]
method <- sapply(I, function(x) x$method)
ok <- all(duplicated(method)[-1])
if (!ok)
stop("Grouping only allowed for identical methods")
method <- method[1]
cfg <- NULL
if (method == "marginal_sr") {
fac <- factor(nmpar[random[w]], levels = names(I))
cfg <- list(grid = I, random2grid = fac)
}
else {
cfg <- I[[1]]
}
stopifnot(is.list(cfg))
TransformADFunObject(ADFun, method = method,
random_order = random[w], config = cfg,
mustWork = 1L)
activeDomain <- as.logical(info(ADFun)$activeDomain)
random_remove <- random[w][!activeDomain[random[w]]]
TransformADFunObject(ADFun, method = "remove_random_parameters",
random_order = random_remove, mustWork = 1L)
attr(ADFun$ptr, "par") <- attr(ADFun$ptr,
"par")[-random_remove]
par_mask <- rep(FALSE, length(attr(ADFun$ptr,
"par")))
par_mask[random] <- TRUE
par <<- par[-random_remove]
nmpar <- nmpar[-random_remove]
par_mask <- par_mask[-random_remove]
random <<- which(par_mask)
if (length(random) == 0) {
random <<- NULL
type <<- setdiff(type, "ADGrad")
}
if (config(DLL = DLL)$optimize.instantly) {
TransformADFunObject(ADFun, method = "optimize",
mustWork = 1L)
}
}
}
if (intern) {
cfg <- inner.control
if (is.null(cfg$sparse))
cfg$sparse <- TRUE
cfg <- lapply(cfg, as.double)
TransformADFunObject(ADFun, method = "laplace",
config = cfg, random_order = random, mustWork = 1L)
TransformADFunObject(ADFun, method = "remove_random_parameters",
random_order = random, mustWork = 1L)
attr(ADFun$ptr, "par") <- attr(ADFun$ptr, "par")[-random]
par <<- par[-random]
random <<- NULL
if (config(DLL = DLL)$optimize.instantly) {
TransformADFunObject(ADFun, method = "optimize",
mustWork = 1L)
}
}
if (set.defaults) {
par <<- attr(ADFun$ptr, "par")
last.par <<- par
last.par1 <<- par
last.par2 <<- par
last.par.best <<- par
value.best <<- Inf
}
}
if (omp$autopar && !ADreport) {
TransformADFunObject(ADFun, method = "parallel_accumulate",
num_threads = as.integer(openmp(DLL = DLL)),
mustWork = 0L)
}
if (length(random) > 0) {
TransformADFunObject(ADFun, method = "reorder_random",
random_order = random, mustWork = 0L)
}
if ("Fun" %in% type) {
Fun <<- MakeDoubleFunObject(data, parameters,
reportenv, DLL = DLL)
}
if ("ADGrad" %in% type) {
retape_adgrad(lazy = TRUE)
}
env$skipFixedEffects <- !is.null(ADGrad)
delayedAssign("spHess", sparseHessianFun(env, skipFixedEffects = skipFixedEffects),
assign.env = env)
}, env = <environment>, report = function (par = last.par)
{
f(par, order = 0, type = "double")
as.list(reportenv)
}, simulate = function (par = last.par, complete = FALSE)
{
f(par, order = 0, type = "double", do_simulate = TRUE)
sim <- as.list(reportenv)
if (complete) {
ans <- data
ans[names(sim)] <- sim
}
else {
ans <- sim
}
ans
}), optim = list(par = c(locationlog1 = 3.4415187965093,
log_scalelog1 = -1.69878131168861, locationlog2 = 6.87489323219086,
log_scalelog2 = -0.535066732027458, logit_pmix = -2.6639430473479
), value = 231.5133845404, counts = c(`function` = 36L, gradient = 36L
), convergence = 0L, message = "CONVERGENCE: REL_REDUCTION_OF_F <= FACTR*EPSMCH",
hessian = structure(c(13.7397815901994, -0.424279054288108,
-0.480707647224373, 1.023405694938, -0.286416713800277,
-0.424279054288108, 2.85418443038394, -0.0587367487173721,
0.0881145371418381, -0.0363182442951076, -0.480707647224373,
-0.0587367487173721, 24.4972515897217, 0.182540498854102,
-0.28188883055788, 1.023405694938, 0.0881145371418381,
0.182540498854102, 34.699165489759, 0.754200895626512,
-0.286416713800277, -0.0363182442951076, -0.28188883055788,
0.754200895626512, 1.53837320004628), dim = c(5L, 5L), dimnames = list(
c("locationlog1", "log_scalelog1", "locationlog2",
"log_scalelog2", "logit_pmix"), c("locationlog1",
"log_scalelog1", "locationlog2", "log_scalelog2",
"logit_pmix")))), est = c(locationlog1 = 3.4415187965093,
locationlog2 = 6.87489323219086, pmix = 0.0651348202055833,
scalelog1 = 0.182906294044203, scalelog2 = 0.585630208549654
), pars = list(locationlog1 = 3.4415187965093, locationlog2 = 6.87489323219086,
logit_pmix = -2.6639430473479, log_scalelog1 = -1.69878131168861,
log_scalelog2 = -0.535066732027458)), class = "tmbfit")),
.f = function (...)
{
{
...furrr_chunk_seeds_i <- ...furrr_chunk_seeds_env[["i"]]
...furrr_chunk_seeds_env[["i"]] <- ...furrr_chunk_seeds_i +
1L
assign(x = ".Random.seed", value = ...furrr_chunk_seeds[[...furrr_chunk_seeds_i]],
envir = globalenv(), inherits = FALSE)
}
NULL
...furrr_out <- ...furrr_fn(...)
...furrr_out
}, proportion = 0.05, ci = TRUE, level = 0.95, nboot = 1000,
min_pboot = 0.99, data = structure(list(Chemical = c("Chloride",
"Chloride", "Chloride", "Chloride", "Chloride", "Chloride",
"Chloride", "Chloride", "Chloride", "Chloride", "Chloride",
"Chloride", "Chloride", "Chloride", "Chloride", "Chloride",
"Chloride", "Chloride", "Chloride", "Chloride", "Chloride",
"Chloride", "Chloride", "Chloride", "Chloride", "Chloride",
"Chloride", "Chloride"), Species = c("Pimephales promelas",
"Salmo trutta fario", "Oncorhynchus mykiss", "Xenopus laevis",
"Rana pipiens", "Lampsilis fasciola", "Epioblasma torulosa rangiana",
"Musculium securis", "Daphnia ambigua", "Daphnia pulex",
"Elliptio complanata", "Daphnia magna", "Hyalella azteca",
"Ceriodaphnia dubia", "Tubifex tubifex", "Villosa delumbis",
"Villosa constricta", "Lumbriculus variegates", "Brachionus calyciflorus",
"Lampsilis siliquoidea", "Gammarus pseudopinmaeus", "Physa sp",
"Stenonema modestum", "Chironomus tentans", "Lemna minor",
"Chlorella minutissimo", "Chlorella zofingiensis", "Chlorella emersonii"
), Group = structure(c(2L, 2L, 2L, 1L, 1L, 3L, 3L, 3L, 3L,
3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L,
4L, 4L, 4L, 4L), levels = c("Amphibian", "Fish", "Invertebrate",
"Plant"), class = "factor"), Units = c("mg/L", "mg/L", "mg/L",
"mg/L", "mg/L", "mg/L", "mg/L", "mg/L", "mg/L", "mg/L", "mg/L",
"mg/L", "mg/L", "mg/L", "mg/L", "mg/L", "mg/L", "mg/L", "mg/L",
"mg/L", "mg/L", "mg/L", "mg/L", "mg/L", "mg/L", "mg/L", "mg/L",
"mg/L"), weight = c(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1), left = c(598,
607, 989, 1307, 3431, 24, 42, 121, 259, 368, 406, 421, 421,
454, 519, 716, 789, 825, 1241, 1474, 2000, 2000, 2047, 2316,
1171, 6066, 6066, 6824), right = c(598, 607, 989, 1307, 3431,
24, 42, 121, 259, 368, 406, 421, 421, 454, 519, 716, 789,
825, 1241, 1474, 2000, 2000, 2047, 2316, 1171, 6066, 6066,
6824)), row.names = c(NA, -28L), class = c("tbl_df", "tbl",
"data.frame")), rescale = 1, weighted = 1, censoring = c(0,
Inf), min_pmix = 1e-04, range_shape1 = c(0.05, 20), range_shape2 = c(0.05,
20), parametric = TRUE, control = list())`: i In index: 1.
i With name: lnorm_lnorm.
Caused by error in `quantile.default()`:
! missing values and NaN's not allowed if 'na.rm' is FALSE
Backtrace:
▆
1. ├─testthat::expect_warning(...) at test-hc.R:522:3
2. │ └─testthat:::expect_condition_matching(...)
3. │ └─testthat:::quasi_capture(...)
4. │ ├─testthat (local) .capture(...)
5. │ │ └─base::withCallingHandlers(...)
6. │ └─rlang::eval_bare(quo_get_expr(.quo), quo_get_env(.quo))
7. ├─ssdtools::ssd_hc(fits, ci = TRUE, nboot = 1000, average = FALSE)
8. ├─ssdtools:::ssd_hc.fitdists(fits, ci = TRUE, nboot = 1000, average = FALSE)
9. │ └─ssdtools:::.ssd_hc_fitdists(...)
10. │ └─furrr::future_map(...)
11. │ └─furrr:::furrr_map_template(...)
12. │ └─furrr:::furrr_template(...)
13. │ └─future::future(...)
14. │ ├─future::run(future)
15. │ └─future:::run.Future(future)
16. │ ├─future::run(future)
17. │ └─future:::run.UniprocessFuture(future)
18. │ └─base::eval(expr, envir = envir, enclos = baseenv())
19. │ └─base::eval(expr, envir = envir, enclos = baseenv())
20. │ ├─base::tryCatch(...)
21. │ │ └─base (local) tryCatchList(expr, classes, parentenv, handlers)
22. │ │ └─base (local) tryCatchOne(expr, names, parentenv, handlers[[1L]])
23. │ │ └─base (local) doTryCatch(return(expr), name, parentenv, handler)
24. │ ├─base::withCallingHandlers(...)
25. │ ├─base::withVisible(...)
26. │ ├─base::local(...)
27. │ │ └─base::eval.parent(substitute(eval(quote(expr), envir)))
28. │ │ └─base::eval(expr, p)
29. │ │ └─base::eval(expr, p)
30. │ └─base::eval(...)
31. │ └─base::eval(...)
32. │ ├─base::do.call(...furrr_map_fn, args)
33. │ └─purrr (local) `<fn>`(...)
34. │ └─purrr:::map_("list", .x, .f, ..., .progress = .progress)
35. │ ├─purrr:::with_indexed_errors(...)
36. │ │ └─base::withCallingHandlers(...)
37. │ ├─purrr:::call_with_cleanup(...)
38. │ └─ssdtools (local) .f(.x[[i]], ...)
39. │ └─ssdtools (local) ...furrr_fn(...)
40. │ └─ssdtools:::cis_estimates(estimates, what, level = level, x = proportion)
41. │ └─base::lapply(x, xcis_estimates, args, what, level)
42. │ └─ssdtools (local) FUN(X[[i]], ...)
43. │ ├─stats::quantile(samples, probs = probs(level))
44. │ └─stats:::quantile.default(samples, probs = probs(level))
45. │ └─base::stop("missing values and NaN's not allowed if 'na.rm' is FALSE")
46. └─base::.handleSimpleError(...)
47. └─purrr (local) h(simpleError(msg, call))
48. └─cli::cli_abort(...)
49. └─rlang::abort(...)
[ FAIL 1 | WARN 0 | SKIP 113 | PASS 931 ]
Deleting unused snapshots:
• autoplot/autoplot.png
• autoplot/autoplot_new.png
• autoplot/autoplot_rescale.png
• burrIII3/hc_chloride.csv
• burrIII3/hc_uranium.csv
• burrIII3/tidy_anon_e.csv
• coef/coef.csv
• data/boron_data.csv
• data/boron_stable.csv
• data/boron_unstable.csv
• data/ccme_data.csv
• data/dist_data.csv
• fit/min_pmix5.csv
• fit/min_pmix_05.csv
• fit/tidy_gamma_unstable.csv
• fit/tidy_pmix0.csv
• fit/tidy_stable_anon_e.csv
• fit/tidy_stable_computable.csv
• fit/tidy_stable_rescale.csv
• fit/tidy_unstable_anon_e.csv
• ggplot/geom_hcintersect.png
• ggplot/geom_hcintersect_aes.png
• ggplot/geom_ssd.png
• ggplot/geom_ssdpoint.png
• ggplot/geom_ssdpoint_identity.png
• ggplot/geom_ssdsegment.png
• ggplot/geom_ssdsegment_arrow.png
• ggplot/geom_ssdsegment_identity.png
• ggplot/geom_ssdsegment_nodata.png
• ggplot/geom_xribbon.png
• ggplot/geoms_all.png
• ggplot/stat_ssd.png
• glance/fit.csv
• glance/fit_cens.csv
• glance/fit_cens_n.csv
• glance/glance.csv
• gof/gof.csv
• gof/gof_pvalue_mixture.csv
• gof/gof_statistic.csv
• gof/gof_statistic_mixture.csv
• gompertz/hc_prob.csv
• hc-burrlioz/hc_boron.csv
• hc-burrlioz/hc_burrIII3.csv
• hc-burrlioz/hc_burrIII3_parametric.csv
• hc/hc.csv
• hc/hc114.csv
• hc/hc122.csv
• hc/hc130.csv
• hc/hc138.csv
• hc/hc145.csv
• hc/hc153.csv
• hc/hc161.csv
• hc/hc168.csv
• hc/hc_1.csv
• hc/hc_30.csv
• hc/hc_boron.csv
• hc/hc_burrIII3.csv
• hc/hc_burrIII3_parametric.csv
• hc/hc_cis.csv
• hc/hc_cis_chloride50.csv
• hc/hc_cis_level08.csv
• hc/hc_err.csv
• hc/hc_err_avg.csv
• hc/hc_err_na.csv
• hc/hc_err_two.csv
• hc/hc_nonpara.csv
• hc/hc_para.csv
• hc/hc_para_small.csv
• hp/hp.csv
• hp/hp106.csv
• hp/hp114.csv
• hp/hp130.csv
• hp/hp41.csv
• hp/hp49.csv
• hp/hp57.csv
• hp/hp65.csv
• hp/hp73.csv
• hp/hp81.csv
• hp/hp89.csv
• hp/hp98.csv
• hp/hp_1.csv
• hp/hp_30.csv
• hp/hp_err.csv
• hp/hp_err_avg.csv
• hp/hp_err_na.csv
• hp/hp_err_two.csv
• hp/hp_nonpara.csv
• hp/hp_para.csv
• invpareto/anon_a.csv
• invpareto/hc_boron.csv
• lnorm-lnorm/plot_anonb.png
• lnorm-lnorm/tidy_anonb.csv
• match-moments/cdf.png
• plot-cdf/fits.png
• plot-cdf/fits_average.png
• plot-cdf/fits_delta.png
• plot-cdf/fits_rescale.png
• plot-cdf/list.png
• plot-cf/ccme_boron.png
• plot-data/ccme_boron.png
• plot/plot.png
• predict/pred_cis.csv
• predict/pred_cis_burrlioz.csv
• predict/pred_dists.csv
• predict/pred_notaverage.csv
• schwarz-tillmans/gof.csv
• schwarz-tillmans/hc.csv
• schwarz-tillmans/hc_avg.csv
• ssd-plot/boron_breaks.png
• ssd-plot/boron_cens_pred.png
• ssd-plot/boron_cens_pred_ribbon.png
• ssd-plot/boron_cens_pred_species.png
• ssd-plot/boron_color.png
• ssd-plot/boron_pred.png
• ssd-plot/boron_pred_label.png
• ssd-plot/boron_pred_ribbon.png
• ssd-plot/boron_pred_shift_x.png
• ssd-plot/boron_shape.png
• ssd-plot/missing_order.png
• tidy/tidy.csv
• weibull/hc_anona.csv
• weibull/tidy.csv
• weibull/tidy_anona.csv
Error: Test failures
Execution halted
Flavor: r-release-windows-x86_64