CRAN Package Check Results for Package IGP

Last updated on 2019-04-21 01:47:51 CEST.

Flavor Version Tinstall Tcheck Ttotal Status Flags
r-devel-linux-x86_64-debian-clang 0.1.0 9.26 28.44 37.70 ERROR
r-devel-linux-x86_64-debian-gcc 0.1.0 7.36 82.57 89.93 OK
r-devel-linux-x86_64-fedora-clang 0.1.0 54.30 OK
r-devel-linux-x86_64-fedora-gcc 0.1.0 52.69 OK
r-devel-windows-ix86+x86_64 0.1.0 17.00 65.00 82.00 OK
r-patched-linux-x86_64 0.1.0 8.86 34.49 43.35 OK
r-release-linux-x86_64 0.1.0 7.20 33.62 40.82 OK
r-release-windows-ix86+x86_64 0.1.0 10.00 49.00 59.00 OK
r-release-osx-x86_64 0.1.0 OK
r-oldrel-windows-ix86+x86_64 0.1.0 3.00 63.00 66.00 OK
r-oldrel-osx-x86_64 0.1.0 OK

Check Details

Version: 0.1.0
Check: examples
Result: ERROR
    Running examples in 'IGP-Ex.R' failed
    The error most likely occurred in:
    
    > base::assign(".ptime", proc.time(), pos = "CheckExEnv")
    > ### Name: IGP_mlegp
    > ### Title: IGP R6 object for fitting mlegp model
    > ### Aliases: IGP_mlegp
    > ### Keywords: Gaussian data, kriging, process, regression
    >
    > ### ** Examples
    >
    > n <- 40
    > d <- 2
    > n2 <- 20
    > f1 <- function(x) {sin(2*pi*x[1]) + sin(2*pi*x[2])}
    > X1 <- matrix(runif(n*d),n,d)
    > Z1 <- apply(X1,1,f1) + rnorm(n, 0, 1e-3)
    > X2 <- matrix(runif(n2*d),n2,d)
    > Z2 <- apply(X2,1,f1)
    > XX1 <- matrix(runif(10),5,2)
    > ZZ1 <- apply(XX1, 1, f1)
    > u <- IGP_mlegp$new(X=X1,Z=Z1)
    Error in FUN(X[[i]], ...) :
     BLAS/LAPACK routine 'DPPTRS' gave error code -1
    Calls: <Anonymous> ... eval -> eval -> do.call -> <Anonymous> -> lapply -> FUN
    Execution halted
Flavor: r-devel-linux-x86_64-debian-clang

Version: 0.1.0
Check: tests
Result: ERROR
     Running 'testthat.R' [1s/1s]
    Running the tests in 'tests/testthat.R' failed.
    Complete output:
     > library(testthat)
     > library(IGP)
    
     Initialize Python Version 2.7.16 (default, Apr 6 2019, 01:42:57)
     [GCC 8.3.0]
    
     >
     > test_check("IGP")
     [1] "laGP"
     [1] "mlegp"
     -- 1. Error: 1D data works (@test_IGP.R#11) -----------------------------------
     BLAS/LAPACK routine 'DPPTRS' gave error code -1
     1: IGP(package = package, X = X1, Z = Z1) at testthat/test_IGP.R:11
     2: IGP_mlegp$new(X = X, Z = Z, ...)
     3: .subset2(public_bind_env, "initialize")(...)
     4: self$init(...)
     5: self$.init(...)
     6: capture.output(m <- do.call(mlegp::mlegp, argss))
     7: evalVis(expr)
     8: withVisible(eval(expr, pf))
     9: eval(expr, pf)
     10: eval(expr, pf)
     11: do.call(mlegp::mlegp, argss)
     12: (function (X, Z, constantMean = 1, nugget = NULL, nugget.known = 0, min.nugget = 0,
     param.names = NULL, gp.names = NULL, PC.UD = NULL, PC.num = NULL, PC.percent = NULL,
     simplex.ntries = 5, simplex.maxiter = 500, simplex.reltol = 1e-08, BFGS.maxiter = 500,
     BFGS.tol = 0.01, BFGS.h = 1e-10, seed = 0, verbose = 1, parallel = FALSE)
     {
     X = as.matrix(X)
     orig.X = X
     Z = as.matrix(Z)
     reps = NULL
     un.sum = NULL
     if (nrow(X) == 1) {
     stop("error: there must be at least two input values")
     }
     if (!is.null(param.names) && length(param.names) != dim(X)[2]) {
     stop("length of param.names must match number of columns of X")
     }
     if (!is.null(PC.percent))
     PC.num = numSingularValues(Z, PC.percent)
     if (!is.null(PC.num)) {
     weights = pcweights(Z, weights.num = PC.num)
     Z = t(weights$Vprime)
     if (PC.num == 1) {
     stop("error: currently not implemented for PC.num = 1 (set PC.num directly)")
     }
     PC.UD = weights$UD
     }
     if (!is.null(dim(Z))) {
     numGPs = dim(Z)[2]
     }
     else {
     numGPs = 1
     Z = matrix(Z)
     }
     if (length(seed) != 1 && length(seed) != ncol(Z)) {
     stop("error: seed length must equal dimensions of Z, or 1")
     }
     if (is.null(gp.names)) {
     gp.names = paste("gp #", 1:numGPs)
     }
     if (length(gp.names) != numGPs) {
     stop("length of gp.names must match number of GPs")
     }
     if (dim(X)[1] != dim(Z)[1]) {
     stop("error: X matrix and output matrix must have same number of rows; \n\tfor PC weights, make sure each column of Z is a computer model run")
     }
     if (min(diag(var(Z))) <= 0) {
     stop("error: Z does not vary for at least one column")
     }
     if (dim(Z)[2] > 1 && !is.null(nugget) && length(nugget) > 1) {
     stop("error: cannot handle nugget matrix with multiple field observations; try fitting 1 gp at a time")
     }
     if (!is.null(nugget) && length(nugget) > dim(Z)[1]) {
     stop("length of nugget matrix must match number of observations")
     }
     if (min(apply(X, 2, max) - apply(X, 2, min)) == 0) {
     stop("error: at least one parameter does not vary in design")
     }
     if (constantMean != 1) {
     ones = rep(1, dim(X)[1])
     dX = cbind(ones, X)
     t = try(solve(t(dX) %*% dX), TRUE)
     if (class(t) == "try-error") {
     stop("error: design matrix with intercept is not full rank; set constantMean = 1")
     }
     }
     if (nugget.known == 1) {
     if (!is.null(nugget) && length(nugget) > 1 && length(nugget) != nrow(X)) {
     stop("error: for nugget.known = 1, length of nugget matrix must be nrow(X) or 1")
     }
     un.sum = uniqueSummary(X, Z)
     orig.X = X
     X = un.sum$uniqueX
     Z = un.sum$uniqueMeans
     reps = un.sum$reps
     }
     if (!is.null(nugget) && length(nugget) == 1 && nugget <= 0) {
     if (anyReps(X))
     stop("at least 2 or more inputs are identical...must use nugget!")
     }
     if (is.null(nugget)) {
     if (!anyReps(X)) {
     if (verbose > 0)
     cat("no reps detected - nugget will not be estimated\n")
     }
     else {
     if (verbose > 0 && nugget.known == 0)
     cat("reps detected - nugget will be estimated\n")
     }
     }
     numEstimates = dim(X)[2] + 1
     if (anyReps(X) || !is.null(nugget) || length(nugget) > 1)
     numEstimates = numEstimates + 1
     if (constantMean == 1) {
     numEstimates = numEstimates + 1
     }
     else {
     numEstimates = numEstimates + dim(X)[2] + 1
     }
     estimates = rep(0, numEstimates)
     if (verbose > 0)
     cat("\n")
     l = NULL
     Zlist = list()
     if (length(seed) == 1)
     seed = rep(seed, ncol(Z))
     for (i in 1:ncol(Z)) {
     Zlist[[i]] = list()
     Zlist[[i]]$Z = matrix(Z[, i])
     Zlist[[i]]$i = i
     Zlist[[i]]$seed = seed[i]
     }
     if (!parallel) {
     l = lapply(Zlist, mlegp2, XX = X, orig.XX = orig.X, nugget = nugget, nugget.known = nugget.known,
     reps = reps, un.sum = un.sum, numEstimates = numEstimates, constantMean = constantMean,
     simplex.ntries = simplex.ntries, simplex.maxiter = simplex.maxiter, simplex.reltol = simplex.reltol,
     BFGS.maxiter = BFGS.maxiter, BFGS.tol = BFGS.tol, BFGS.h = BFGS.h, min.nugget = min.nugget,
     verbose = verbose, param.names = param.names)
     }
     if (parallel) {
     if (requireNamespace("snowfall", quietly = TRUE)) {
     cat("fitting ")
     cat(length(Zlist))
     cat(" GPs in parallel mode...\n")
     l = snowfall::sfLapply(Zlist, mlegp2, XX = X, orig.XX = orig.X, nugget = nugget,
     nugget.known = nugget.known, reps = reps, un.sum = un.sum, numEstimates = numEstimates,
     constantMean = constantMean, simplex.ntries = simplex.ntries, simplex.maxiter = simplex.maxiter,
     simplex.reltol = simplex.reltol, BFGS.maxiter = BFGS.maxiter, BFGS.tol = BFGS.tol,
     BFGS.h = BFGS.h, min.nugget = min.nugget, verbose = verbose, param.names = param.names)
     cat("...done\n")
     }
     else {
     cat("Error: the package \"snowfall\" is required when parallel = TRUE")
     }
     }
     if (numGPs == 1) {
     return(l[[1]])
     }
     return(gp.list(l, UD = PC.UD, param.names = param.names, gp.names = gp.names))
     })(X = structure(c(0.431383780669421, 0.0847480273805559, 0.669725982472301, 0.742276915349066,
     0.702303667087108, 0.412591723026708, 0.564003813778982, 0.747180632781237, 0.629792189458385,
     0.583402889082208, 0.990191630087793, 0.688501687021926, 0.937565944157541, 0.481788545614108,
     0.391555829206482, 0.920299082994461, 0.069120925385505, 0.304958664113656, 0.524085310520604,
     0.641501284437254, 0.787347999634221, 0.759747466538101, 0.561778316739947, 0.842776936944574,
     0.239728574175388, 0.371173423714936, 0.922606354346499, 0.207367954077199, 0.80359738599509,
     0.994649830507115, 0.444668480660766, 0.662641674745828, 0.100170437945053, 0.378250744193792,
     0.464136413298547, 0.650036250706762, 0.609493031632155, 0.71058535692282, 0.566839393228292,
     0.677861607633531, 0.929305276134983, 0.548527685226873, 0.738134586950764, 0.609726114664227,
     0.0578795054461807, 0.590277252253145, 0.994969966355711, 0.247521705925465, 0.0586586720310152,
     0.0159673395100981, 0.556175865232944, 0.850412625120953, 0.337549382122234, 0.612958484562114,
     0.645565947750583, 0.0270494786091149, 0.86632057488896, 0.152945569716394, 0.469686375930905,
     0.32185567333363, 0.253180197207257, 0.0693656948860735, 0.605277357855812, 0.0338871385902166,
     0.144951172405854, 0.504664499312639, 0.107877490110695, 0.242791277822107, 0.722701709950343,
     0.280683866003528, 0.990473644575104, 0.371987003833055, 0.304061043309048, 0.163270904682577,
     0.760639767395332, 0.982638258021325, 0.852677452610806, 0.0347764145117253, 0.787253661314026,
     0.859534551156685), .Dim = c(40L, 2L)), Z = c(-0.0122482881470953, 0.205953975384856,
     -1.87336445250237, -1.63394559638316, -0.599442707781801, -0.0159641318741752, -0.422878167036917,
     0.00142334209603638, -0.368242203342996, -0.401301501222653, -0.406188946256342,
     -1.73201818900304, 0.46917279398551, -0.536978394401708, -0.161401210268972, -0.311278490202035,
     -0.323310287566342, 1.76082396715489, 0.0365894323281462, 0.124114316449632, 0.0272818061711772,
     -0.578129512760552, -0.992613752490526, -0.621971723021247, 1.78724394783391, 0.694142470137045,
     0.158586372625414, 1.96414518535386, -1.9288288905279, 0.949267413676999, 0.281965124952695,
     -0.132961658772781, 1.53067449849547, 1.5464584621025, -0.77447136498945, -0.918908406461642,
     -1.43287588433745, -0.754424010673925, -1.3789609372135, -1.67106286933387), verbose = 0,
     nugget = 1e-08, nugget.known = 1e-08)
     13: lapply(Zlist, mlegp2, XX = X, orig.XX = orig.X, nugget = nugget, nugget.known = nugget.known,
     reps = reps, un.sum = un.sum, numEstimates = numEstimates, constantMean = constantMean,
     simplex.ntries = simplex.ntries, simplex.maxiter = simplex.maxiter, simplex.reltol = simplex.reltol,
     BFGS.maxiter = BFGS.maxiter, BFGS.tol = BFGS.tol, BFGS.h = BFGS.h, min.nugget = min.nugget,
     verbose = verbose, param.names = param.names)
     14: FUN(X[[i]], ...)
    
     == testthat results ===========================================================
     OK: 11 SKIPPED: 0 FAILED: 1
     1. Error: 1D data works (@test_IGP.R#11)
    
     Error: testthat unit tests failed
     Execution halted
Flavor: r-devel-linux-x86_64-debian-clang