CRAN Package Check Results for Package clusternor

Last updated on 2019-12-10 16:47:43 CET.

Flavor Version Tinstall Tcheck Ttotal Status Flags
r-devel-linux-x86_64-debian-clang 0.0-3 84.53 31.84 116.37 ERROR
r-devel-linux-x86_64-debian-gcc 0.0-3 57.27 24.89 82.16 NOTE
r-devel-linux-x86_64-fedora-clang 0.0-3 184.14 NOTE
r-devel-linux-x86_64-fedora-gcc 0.0-3 148.62 NOTE
r-devel-windows-ix86+x86_64 0.0-3 177.00 88.00 265.00 NOTE
r-devel-windows-ix86+x86_64-gcc8 0.0-3 169.00 72.00 241.00 NOTE
r-patched-linux-x86_64 0.0-3 65.20 29.00 94.20 NOTE
r-patched-solaris-x86 0.0-3 131.70 ERROR
r-release-linux-x86_64 0.0-3 63.75 28.93 92.68 NOTE
r-release-windows-ix86+x86_64 0.0-3 175.00 61.00 236.00 NOTE
r-release-osx-x86_64 0.0-3 NOTE
r-oldrel-windows-ix86+x86_64 0.0-3 166.00 64.00 230.00 NOTE
r-oldrel-osx-x86_64 0.0-3 NOTE

Check Details

Version: 0.0-3
Check: for GNU extensions in Makefiles
Result: NOTE
    GNU make is a SystemRequirements.
Flavors: r-devel-linux-x86_64-debian-clang, r-devel-linux-x86_64-debian-gcc, r-devel-linux-x86_64-fedora-clang, r-devel-linux-x86_64-fedora-gcc, r-devel-windows-ix86+x86_64, r-devel-windows-ix86+x86_64-gcc8, r-patched-linux-x86_64, r-patched-solaris-x86, r-release-linux-x86_64, r-release-windows-ix86+x86_64, r-release-osx-x86_64, r-oldrel-windows-ix86+x86_64, r-oldrel-osx-x86_64

Version: 0.0-3
Check: examples
Result: ERROR
    Running examples in 'clusternor-Ex.R' failed
    The error most likely occurred in:
    
    > base::assign(".ptime", proc.time(), pos = "CheckExEnv")
    > ### Name: FuzzyCMeans
    > ### Title: Perform Fuzzy C-means clustering on a data matrix. A soft
    > ### variant of the kmeans algorithm where each data point are assigned a
    > ### contribution weight to each cluster
    > ### Aliases: FuzzyCMeans
    >
    > ### ** Examples
    >
    > iris.mat <- as.matrix(iris[,1:4])
    > k <- length(unique(iris[, dim(iris)[2]])) # Number of unique classes
    > fcm <- FuzzyCMeans(iris.mat, k, iter.max=5)
     ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
    :
     --- package (from environment) ---
    clusternor
     --- call from context ---
    FuzzyCMeans(iris.mat, k, iter.max = 5)
     --- call from argument ---
    if (class(data) == "character") {
     if (class(centers) == "numeric" || class(centers) == "integer") {
     ret <- .Call("R_fcm_data_em", normalizePath(as.character(data)),
     as.integer(centers), as.double(nrow), as.double(ncol),
     as.double(iter.max), as.integer(nthread), as.integer(fuzz.index),
     as.character(init), as.double(tolerance), as.character(dist.type),
     PACKAGE = "clusternor")
     }
     else if (class(centers) == "matrix") {
     ret <- .Call("R_fcm_data_em_centroids_im", normalizePath(as.character(data)),
     as.matrix(centers), as.double(nrow), as.double(ncol),
     as.double(iter.max), as.integer(nthread), as.integer(fuzz.index),
     as.double(tolerance), as.character(dist.type), PACKAGE = "clusternor")
     }
     else {
     stop(paste("Cannot handle centers of type", class(centers),
     "\n"))
     }
    } else if (class(data) == "matrix") {
     if (class(centers) == "numeric" || class(centers) == "integer") {
     ret <- .Call("R_fcm_data_im", as.matrix(data), as.integer(centers),
     as.double(iter.max), as.integer(nthread), as.integer(fuzz.index),
     as.character(init), as.double(tolerance), as.character(dist.type),
     PACKAGE = "clusternor")
     }
     else if (class(centers) == "matrix") {
     ret <- .Call("R_fcm_data_centroids_im", as.matrix(data),
     as.matrix(centers), as.double(iter.max), as.integer(nthread),
     as.integer(fuzz.index), as.double(tolerance), as.character(dist.type),
     PACKAGE = "clusternor")
     }
     else {
     stop(paste("Cannot handle centers of type", class(centers),
     "\n"))
     }
    } else {
     stop(paste("Cannot handle data of type", class(data), "\n"))
    }
     --- R stacktrace ---
    where 1: FuzzyCMeans(iris.mat, k, iter.max = 5)
    
     --- value of length: 2 type: logical ---
    [1] FALSE FALSE
     --- function from context ---
    function (data, centers, nrow = -1, ncol = -1, iter.max = .Machine$integer.max,
     nthread = -1, fuzz.index = 2, init = c("forgy", "none"),
     tolerance = 1e-06, dist.type = c("sqeucl", "eucl", "cos",
     "taxi"))
    {
     if (class(data) == "character") {
     if (class(centers) == "numeric" || class(centers) ==
     "integer") {
     ret <- .Call("R_fcm_data_em", normalizePath(as.character(data)),
     as.integer(centers), as.double(nrow), as.double(ncol),
     as.double(iter.max), as.integer(nthread), as.integer(fuzz.index),
     as.character(init), as.double(tolerance), as.character(dist.type),
     PACKAGE = "clusternor")
     }
     else if (class(centers) == "matrix") {
     ret <- .Call("R_fcm_data_em_centroids_im", normalizePath(as.character(data)),
     as.matrix(centers), as.double(nrow), as.double(ncol),
     as.double(iter.max), as.integer(nthread), as.integer(fuzz.index),
     as.double(tolerance), as.character(dist.type),
     PACKAGE = "clusternor")
     }
     else {
     stop(paste("Cannot handle centers of type", class(centers),
     "\n"))
     }
     }
     else if (class(data) == "matrix") {
     if (class(centers) == "numeric" || class(centers) ==
     "integer") {
     ret <- .Call("R_fcm_data_im", as.matrix(data), as.integer(centers),
     as.double(iter.max), as.integer(nthread), as.integer(fuzz.index),
     as.character(init), as.double(tolerance), as.character(dist.type),
     PACKAGE = "clusternor")
     }
     else if (class(centers) == "matrix") {
     ret <- .Call("R_fcm_data_centroids_im", as.matrix(data),
     as.matrix(centers), as.double(iter.max), as.integer(nthread),
     as.integer(fuzz.index), as.double(tolerance),
     as.character(dist.type), PACKAGE = "clusternor")
     }
     else {
     stop(paste("Cannot handle centers of type", class(centers),
     "\n"))
     }
     }
     else {
     stop(paste("Cannot handle data of type", class(data),
     "\n"))
     }
    }
    <bytecode: 0x3e4b330>
    <environment: namespace:clusternor>
     --- function search by body ---
    Function FuzzyCMeans in namespace clusternor has this body.
     ----------- END OF FAILURE REPORT --------------
    Error in if (class(data) == "character") { : the condition has length > 1
    Calls: FuzzyCMeans
    Execution halted
Flavor: r-devel-linux-x86_64-debian-clang

Version: 0.0-3
Check: tests
Result: ERROR
     Running 'testthat.R' [3s/3s]
    Running the tests in 'tests/testthat.R' failed.
    Complete output:
     > library(testthat)
     > library(clusternor)
     Loading required package: Rcpp
     >
     > test_check("clusternor")
    
    
     ***Running test for fcmeans***
    
     Data ==> memory, centroids ==> memory
    
     ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
     :
     --- package (from environment) ---
     clusternor
     --- call from context ---
     FuzzyCMeans(test_data, test_centroids, iter.max = iter.max, fuzz.index = 5,
     nthread = nthread)
     --- call from argument ---
     if (class(data) == "character") {
     if (class(centers) == "numeric" || class(centers) == "integer") {
     ret <- .Call("R_fcm_data_em", normalizePath(as.character(data)),
     as.integer(centers), as.double(nrow), as.double(ncol),
     as.double(iter.max), as.integer(nthread), as.integer(fuzz.index),
     as.character(init), as.double(tolerance), as.character(dist.type),
     PACKAGE = "clusternor")
     }
     else if (class(centers) == "matrix") {
     ret <- .Call("R_fcm_data_em_centroids_im", normalizePath(as.character(data)),
     as.matrix(centers), as.double(nrow), as.double(ncol),
     as.double(iter.max), as.integer(nthread), as.integer(fuzz.index),
     as.double(tolerance), as.character(dist.type), PACKAGE = "clusternor")
     }
     else {
     stop(paste("Cannot handle centers of type", class(centers),
     "\n"))
     }
     } else if (class(data) == "matrix") {
     if (class(centers) == "numeric" || class(centers) == "integer") {
     ret <- .Call("R_fcm_data_im", as.matrix(data), as.integer(centers),
     as.double(iter.max), as.integer(nthread), as.integer(fuzz.index),
     as.character(init), as.double(tolerance), as.character(dist.type),
     PACKAGE = "clusternor")
     }
     else if (class(centers) == "matrix") {
     ret <- .Call("R_fcm_data_centroids_im", as.matrix(data),
     as.matrix(centers), as.double(iter.max), as.integer(nthread),
     as.integer(fuzz.index), as.double(tolerance), as.character(dist.type),
     PACKAGE = "clusternor")
     }
     else {
     stop(paste("Cannot handle centers of type", class(centers),
     "\n"))
     }
     } else {
     stop(paste("Cannot handle data of type", class(data), "\n"))
     }
     --- R stacktrace ---
     where 1 at testthat/test-fuzzy-cmeans.R#54: FuzzyCMeans(test_data, test_centroids, iter.max = iter.max, fuzz.index = 5,
     nthread = nthread)
     where 2 at testthat/test-fuzzy-cmeans.R#62: test.data.centroids.in.mem()
     where 3: eval(code, test_env)
     where 4: eval(code, test_env)
     where 5: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 6: doTryCatch(return(expr), name, parentenv, handler)
     where 7: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 8: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 9: doTryCatch(return(expr), name, parentenv, handler)
     where 10: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 11: tryCatchList(expr, classes, parentenv, handlers)
     where 12: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 13: test_code(NULL, exprs, env)
     where 14: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
     where 15: force(code)
     where 16: doWithOneRestart(return(expr), restart)
     where 17: withOneRestart(expr, restarts[[1L]])
     where 18: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 19: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter,
     {
     reporter$start_file(basename(path))
     lister$start_file(basename(path))
     source_file(path, new.env(parent = env), chdir = TRUE,
     wrap = wrap)
     reporter$.end_context()
     reporter$end_file()
     })
     where 20: FUN(X[[i]], ...)
     where 21: lapply(paths, test_file, env = env, reporter = current_reporter,
     start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
     where 22: force(code)
     where 23: doWithOneRestart(return(expr), restart)
     where 24: withOneRestart(expr, restarts[[1L]])
     where 25: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 26: with_reporter(reporter = current_reporter, results <- lapply(paths,
     test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE,
     load_helpers = FALSE, wrap = wrap))
     where 27: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 28: test_dir(path = test_path, reporter = reporter, env = env, filter = filter,
     ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning,
     wrap = wrap)
     where 29: test_package_dir(package = package, test_path = test_path, filter = filter,
     reporter = reporter, ..., stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 30: test_check("clusternor")
    
     --- value of length: 2 type: logical ---
     [1] FALSE FALSE
     --- function from context ---
     function (data, centers, nrow = -1, ncol = -1, iter.max = .Machine$integer.max,
     nthread = -1, fuzz.index = 2, init = c("forgy", "none"),
     tolerance = 1e-06, dist.type = c("sqeucl", "eucl", "cos",
     "taxi"))
     {
     if (class(data) == "character") {
     if (class(centers) == "numeric" || class(centers) ==
     "integer") {
     ret <- .Call("R_fcm_data_em", normalizePath(as.character(data)),
     as.integer(centers), as.double(nrow), as.double(ncol),
     as.double(iter.max), as.integer(nthread), as.integer(fuzz.index),
     as.character(init), as.double(tolerance), as.character(dist.type),
     PACKAGE = "clusternor")
     }
     else if (class(centers) == "matrix") {
     ret <- .Call("R_fcm_data_em_centroids_im", normalizePath(as.character(data)),
     as.matrix(centers), as.double(nrow), as.double(ncol),
     as.double(iter.max), as.integer(nthread), as.integer(fuzz.index),
     as.double(tolerance), as.character(dist.type),
     PACKAGE = "clusternor")
     }
     else {
     stop(paste("Cannot handle centers of type", class(centers),
     "\n"))
     }
     }
     else if (class(data) == "matrix") {
     if (class(centers) == "numeric" || class(centers) ==
     "integer") {
     ret <- .Call("R_fcm_data_im", as.matrix(data), as.integer(centers),
     as.double(iter.max), as.integer(nthread), as.integer(fuzz.index),
     as.character(init), as.double(tolerance), as.character(dist.type),
     PACKAGE = "clusternor")
     }
     else if (class(centers) == "matrix") {
     ret <- .Call("R_fcm_data_centroids_im", as.matrix(data),
     as.matrix(centers), as.double(iter.max), as.integer(nthread),
     as.integer(fuzz.index), as.double(tolerance),
     as.character(dist.type), PACKAGE = "clusternor")
     }
     else {
     stop(paste("Cannot handle centers of type", class(centers),
     "\n"))
     }
     }
     else {
     stop(paste("Cannot handle data of type", class(data),
     "\n"))
     }
     }
     <bytecode: 0x2d50418>
     <environment: namespace:clusternor>
     --- function search by body ---
     Function FuzzyCMeans in namespace clusternor has this body.
     ----------- END OF FAILURE REPORT --------------
     -- 1. Error: (unknown) (@test-fuzzy-cmeans.R#62) ------------------------------
     the condition has length > 1
     Backtrace:
     1. clusternor:::test.data.centroids.in.mem()
     2. clusternor::FuzzyCMeans(...)
    
    
    
     ***Running test for hmeans***
    
     Data ==> ,centroids ==> memory
    
     ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
     :
     --- package (from environment) ---
     clusternor
     --- call from context ---
     Hmeans(fn, kmax, nrow, ncol, iter.max = iter.max, init = test_centroids[1:2,
     ], nthread = nthread)
     --- call from argument ---
     if (class(init) == "character") {
     ret <- .Call("R_hmeans_data_em_init", as.character(data),
     as.integer(kmax), as.double(nrow), as.double(ncol), as.double(iter.max),
     as.integer(nthread), as.character(init), as.double(tolerance),
     as.character(dist.type), as.integer(min.clust.size),
     PACKAGE = "clusternor")
     } else if (class(init) == "matrix") {
     if (!(all(dim(init) == c(2, ncol), TRUE)))
     stop("init centers must have dim: `c(2, ncol)'")
     ret <- .Call("R_hmeans_data_em_centers", as.character(data),
     as.integer(kmax), as.double(nrow), as.double(ncol), as.double(iter.max),
     as.integer(nthread), as.matrix(init), as.double(tolerance),
     as.character(dist.type), as.integer(min.clust.size),
     PACKAGE = "clusternor")
     } else {
     stop(paste("Cannot handle init of type", class(init), "\n"))
     }
     --- R stacktrace ---
     where 1: Hmeans(fn, kmax, nrow, ncol, iter.max = iter.max, init = test_centroids[1:2,
     ], nthread = nthread)
     where 2 at testthat/test-hmeans.R#54: print(Hmeans(fn, kmax, nrow, ncol, iter.max = iter.max, init = test_centroids[1:2,
     ], nthread = nthread))
     where 3 at testthat/test-hmeans.R#62: test.centroids.in.mem()
     where 4: eval(code, test_env)
     where 5: eval(code, test_env)
     where 6: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 7: doTryCatch(return(expr), name, parentenv, handler)
     where 8: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 9: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 10: doTryCatch(return(expr), name, parentenv, handler)
     where 11: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 12: tryCatchList(expr, classes, parentenv, handlers)
     where 13: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 14: test_code(NULL, exprs, env)
     where 15: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
     where 16: force(code)
     where 17: doWithOneRestart(return(expr), restart)
     where 18: withOneRestart(expr, restarts[[1L]])
     where 19: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 20: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter,
     {
     reporter$start_file(basename(path))
     lister$start_file(basename(path))
     source_file(path, new.env(parent = env), chdir = TRUE,
     wrap = wrap)
     reporter$.end_context()
     reporter$end_file()
     })
     where 21: FUN(X[[i]], ...)
     where 22: lapply(paths, test_file, env = env, reporter = current_reporter,
     start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
     where 23: force(code)
     where 24: doWithOneRestart(return(expr), restart)
     where 25: withOneRestart(expr, restarts[[1L]])
     where 26: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 27: with_reporter(reporter = current_reporter, results <- lapply(paths,
     test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE,
     load_helpers = FALSE, wrap = wrap))
     where 28: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 29: test_dir(path = test_path, reporter = reporter, env = env, filter = filter,
     ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning,
     wrap = wrap)
     where 30: test_package_dir(package = package, test_path = test_path, filter = filter,
     reporter = reporter, ..., stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 31: test_check("clusternor")
    
     --- value of length: 2 type: logical ---
     [1] FALSE FALSE
     --- function from context ---
     function (data, kmax, nrow = -1, ncol = -1, iter.max = 20, nthread = -1,
     init = c("forgy"), tolerance = 1e-06, dist.type = c("eucl",
     "cos", "sqeucl", "taxi"), min.clust.size = 1)
     {
     if (class(data) == "character") {
     if (class(init) == "character") {
     ret <- .Call("R_hmeans_data_em_init", as.character(data),
     as.integer(kmax), as.double(nrow), as.double(ncol),
     as.double(iter.max), as.integer(nthread), as.character(init),
     as.double(tolerance), as.character(dist.type),
     as.integer(min.clust.size), PACKAGE = "clusternor")
     }
     else if (class(init) == "matrix") {
     if (!(all(dim(init) == c(2, ncol), TRUE)))
     stop("init centers must have dim: `c(2, ncol)'")
     ret <- .Call("R_hmeans_data_em_centers", as.character(data),
     as.integer(kmax), as.double(nrow), as.double(ncol),
     as.double(iter.max), as.integer(nthread), as.matrix(init),
     as.double(tolerance), as.character(dist.type),
     as.integer(min.clust.size), PACKAGE = "clusternor")
     }
     else {
     stop(paste("Cannot handle init of type", class(init),
     "\n"))
     }
     }
     else if (class(data) == "matrix") {
     if (class(init) == "character") {
     ret <- .Call("R_hmeans_data_im_init", as.matrix(data),
     as.integer(kmax), as.double(iter.max), as.integer(nthread),
     as.character(init), as.double(tolerance), as.character(dist.type),
     as.integer(min.clust.size), PACKAGE = "clusternor")
     }
     else if (class(init) == "matrix") {
     if (!(all(dim(init) == c(2, dim(data)[2]), TRUE)))
     stop("init centers must have dim: `c(2, dim(data)[1])'")
     ret <- .Call("R_hmeans_data_im_centers", as.matrix(data),
     as.integer(kmax), as.double(iter.max), as.integer(nthread),
     as.matrix(init), as.double(tolerance), as.character(dist.type),
     as.integer(min.clust.size), PACKAGE = "clusternor")
     }
     else {
     stop(paste("Cannot handle init of type", class(init),
     "\n"))
     }
     }
     }
     <bytecode: 0x3197e60>
     <environment: namespace:clusternor>
     --- function search by body ---
     Function Hmeans in namespace clusternor has this body.
     ----------- END OF FAILURE REPORT --------------
     -- 2. Error: (unknown) (@test-hmeans.R#62) ------------------------------------
     the condition has length > 1
     Backtrace:
     1. clusternor:::test.centroids.in.mem()
     3. clusternor::Hmeans(...)
    
    
    
     ***Running test for kmeanspp***
    
     Data ==> memory, centroids ==> compute
    
     ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
     :
     --- package (from environment) ---
     clusternor
     --- call from context ---
     KmeansPP(test_data, k, nrow, ncol, nstart = 10, nthread = nthread)
     --- call from argument ---
     if (class(data) == "matrix") {
     if (class(centers) == "numeric" || class(centers) == "integer") {
     ret <- .Call("R_kmeanspp_data_im", as.matrix(data), as.integer(centers),
     as.integer(nstart), as.integer(nthread), as.character(dist.type),
     PACKAGE = "clusternor")
     ret$iters <- NULL
     ret
     }
     else {
     stop(paste("Cannot handle centers of type", class(centers),
     "\n"))
     }
     } else if (class(data) == "character") {
     if (class(centers) == "numeric" || class(centers) == "integer") {
     ret <- .Call("R_kmeanspp_data_em", normalizePath(as.character(data)),
     as.integer(centers), as.double(nrow), as.double(ncol),
     as.integer(nstart), as.integer(nthread), as.character(dist.type),
     PACKAGE = "clusternor")
     ret$iters <- NULL
     ret
     }
     else {
     stop(paste("Cannot handle centers of type", class(centers),
     "\n"))
     }
     } else {
     stop(paste("Cannot handle data of type", class(data), "\n"))
     }
     --- R stacktrace ---
     where 1: KmeansPP(test_data, k, nrow, ncol, nstart = 10, nthread = nthread)
     where 2 at testthat/test-kmeanspp.R#32: print(KmeansPP(test_data, k, nrow, ncol, nstart = 10, nthread = nthread))
     where 3 at testthat/test-kmeanspp.R#44: test.data.in.mem()
     where 4: eval(code, test_env)
     where 5: eval(code, test_env)
     where 6: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 7: doTryCatch(return(expr), name, parentenv, handler)
     where 8: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 9: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 10: doTryCatch(return(expr), name, parentenv, handler)
     where 11: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 12: tryCatchList(expr, classes, parentenv, handlers)
     where 13: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 14: test_code(NULL, exprs, env)
     where 15: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
     where 16: force(code)
     where 17: doWithOneRestart(return(expr), restart)
     where 18: withOneRestart(expr, restarts[[1L]])
     where 19: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 20: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter,
     {
     reporter$start_file(basename(path))
     lister$start_file(basename(path))
     source_file(path, new.env(parent = env), chdir = TRUE,
     wrap = wrap)
     reporter$.end_context()
     reporter$end_file()
     })
     where 21: FUN(X[[i]], ...)
     where 22: lapply(paths, test_file, env = env, reporter = current_reporter,
     start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
     where 23: force(code)
     where 24: doWithOneRestart(return(expr), restart)
     where 25: withOneRestart(expr, restarts[[1L]])
     where 26: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 27: with_reporter(reporter = current_reporter, results <- lapply(paths,
     test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE,
     load_helpers = FALSE, wrap = wrap))
     where 28: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 29: test_dir(path = test_path, reporter = reporter, env = env, filter = filter,
     ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning,
     wrap = wrap)
     where 30: test_package_dir(package = package, test_path = test_path, filter = filter,
     reporter = reporter, ..., stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 31: test_check("clusternor")
    
     --- value of length: 2 type: logical ---
     [1] TRUE FALSE
     --- function from context ---
     function (data, centers, nrow = -1, ncol = -1, nstart = 1, nthread = -1,
     dist.type = c("sqeucl", "eucl", "cos", "taxi"))
     {
     if (class(data) == "matrix") {
     if (class(centers) == "numeric" || class(centers) ==
     "integer") {
     ret <- .Call("R_kmeanspp_data_im", as.matrix(data),
     as.integer(centers), as.integer(nstart), as.integer(nthread),
     as.character(dist.type), PACKAGE = "clusternor")
     ret$iters <- NULL
     ret
     }
     else {
     stop(paste("Cannot handle centers of type", class(centers),
     "\n"))
     }
     }
     else if (class(data) == "character") {
     if (class(centers) == "numeric" || class(centers) ==
     "integer") {
     ret <- .Call("R_kmeanspp_data_em", normalizePath(as.character(data)),
     as.integer(centers), as.double(nrow), as.double(ncol),
     as.integer(nstart), as.integer(nthread), as.character(dist.type),
     PACKAGE = "clusternor")
     ret$iters <- NULL
     ret
     }
     else {
     stop(paste("Cannot handle centers of type", class(centers),
     "\n"))
     }
     }
     else {
     stop(paste("Cannot handle data of type", class(data),
     "\n"))
     }
     }
     <bytecode: 0x3202070>
     <environment: namespace:clusternor>
     --- function search by body ---
     Function KmeansPP in namespace clusternor has this body.
     ----------- END OF FAILURE REPORT --------------
     -- 3. Error: (unknown) (@test-kmeanspp.R#44) ----------------------------------
     the condition has length > 1
     Backtrace:
     1. clusternor:::test.data.in.mem()
     3. clusternor::KmeansPP(test_data, k, nrow, ncol, nstart = 10, nthread = nthread)
    
    
    
     ***Running test for knori***
    
     Data ==> memory, centroids ==> compute
    
     ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
     :
     --- package (from environment) ---
     clusternor
     --- call from context ---
     Kmeans(test_data, k, nrow, ncol, nthread = nthread)
     --- call from argument ---
     if (class(data) == "character") {
     if (class(centers) == "numeric" || class(centers) == "integer") {
     ret <- .Call("R_kmeans", normalizePath(as.character(data)),
     as.integer(centers), as.double(nrow), as.double(ncol),
     as.double(iter.max), as.integer(nthread), as.character(init),
     as.double(tolerance), as.character(dist.type), PACKAGE = "clusternor")
     }
     else if (class(centers) == "matrix") {
     ret <- .Call("R_kmeans_centroids_im", normalizePath(as.character(data)),
     as.matrix(centers), as.double(nrow), as.double(iter.max),
     as.integer(nthread), as.double(tolerance), as.character(dist.type),
     PACKAGE = "clusternor")
     }
     else if (class(centers) == "list") {
     ret <- .Call("R_kmeans_data_centroids_em", normalizePath(as.character(data)),
     normalizePath(as.character(centers[1])), as.integer(centers[2]),
     as.double(nrow), as.double(ncol), as.double(iter.max),
     as.integer(nthread), as.double(tolerance), as.character(dist.type),
     PACKAGE = "clusternor")
     }
     else {
     stop(paste("Cannot handle centers of type", class(centers),
     "\n"))
     }
     } else if (class(data) == "matrix") {
     if (class(centers) == "numeric" || class(centers) == "integer") {
     ret <- .Call("R_kmeans_data_im", as.matrix(data), as.integer(centers),
     as.double(iter.max), as.integer(nthread), as.character(init),
     as.double(tolerance), as.character(dist.type), PACKAGE = "clusternor")
     }
     else if (class(centers) == "matrix") {
     ret <- .Call("R_kmeans_data_centroids_im", as.matrix(data),
     as.matrix(centers), as.double(iter.max), as.integer(nthread),
     as.double(tolerance), as.character(dist.type), PACKAGE = "clusternor")
     }
     else if (class(centers) == "character") {
     ret <- .Call("R_kmeans_data_im_centroids_em", as.matrix(data),
     normalizePath(centers), as.double(iter.max), as.integer(nthread),
     as.double(tolerance), as.character(dist.type), PACKAGE = "clusternor")
     }
     else {
     stop(paste("Cannot handle centers of type", class(centers),
     "\n"))
     }
     } else {
     stop(paste("Cannot handle data of type", class(data), "\n"))
     }
     --- R stacktrace ---
     where 1: Kmeans(test_data, k, nrow, ncol, nthread = nthread)
     where 2 at testthat/test-knori.R#32: print(Kmeans(test_data, k, nrow, ncol, nthread = nthread))
     where 3 at testthat/test-knori.R#68: test.data.in.mem()
     where 4: eval(code, test_env)
     where 5: eval(code, test_env)
     where 6: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 7: doTryCatch(return(expr), name, parentenv, handler)
     where 8: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 9: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 10: doTryCatch(return(expr), name, parentenv, handler)
     where 11: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 12: tryCatchList(expr, classes, parentenv, handlers)
     where 13: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 14: test_code(NULL, exprs, env)
     where 15: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
     where 16: force(code)
     where 17: doWithOneRestart(return(expr), restart)
     where 18: withOneRestart(expr, restarts[[1L]])
     where 19: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 20: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter,
     {
     reporter$start_file(basename(path))
     lister$start_file(basename(path))
     source_file(path, new.env(parent = env), chdir = TRUE,
     wrap = wrap)
     reporter$.end_context()
     reporter$end_file()
     })
     where 21: FUN(X[[i]], ...)
     where 22: lapply(paths, test_file, env = env, reporter = current_reporter,
     start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
     where 23: force(code)
     where 24: doWithOneRestart(return(expr), restart)
     where 25: withOneRestart(expr, restarts[[1L]])
     where 26: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 27: with_reporter(reporter = current_reporter, results <- lapply(paths,
     test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE,
     load_helpers = FALSE, wrap = wrap))
     where 28: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 29: test_dir(path = test_path, reporter = reporter, env = env, filter = filter,
     ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning,
     wrap = wrap)
     where 30: test_package_dir(package = package, test_path = test_path, filter = filter,
     reporter = reporter, ..., stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 31: test_check("clusternor")
    
     --- value of length: 2 type: logical ---
     [1] FALSE FALSE
     --- function from context ---
     function (data, centers, nrow = -1, ncol = -1, iter.max = .Machine$integer.max,
     nthread = -1, init = c("kmeanspp", "random", "forgy", "none"),
     tolerance = 1e-06, dist.type = c("eucl", "sqeucl", "cos",
     "taxi"))
     {
     if (class(data) == "character") {
     if (class(centers) == "numeric" || class(centers) ==
     "integer") {
     ret <- .Call("R_kmeans", normalizePath(as.character(data)),
     as.integer(centers), as.double(nrow), as.double(ncol),
     as.double(iter.max), as.integer(nthread), as.character(init),
     as.double(tolerance), as.character(dist.type),
     PACKAGE = "clusternor")
     }
     else if (class(centers) == "matrix") {
     ret <- .Call("R_kmeans_centroids_im", normalizePath(as.character(data)),
     as.matrix(centers), as.double(nrow), as.double(iter.max),
     as.integer(nthread), as.double(tolerance), as.character(dist.type),
     PACKAGE = "clusternor")
     }
     else if (class(centers) == "list") {
     ret <- .Call("R_kmeans_data_centroids_em", normalizePath(as.character(data)),
     normalizePath(as.character(centers[1])), as.integer(centers[2]),
     as.double(nrow), as.double(ncol), as.double(iter.max),
     as.integer(nthread), as.double(tolerance), as.character(dist.type),
     PACKAGE = "clusternor")
     }
     else {
     stop(paste("Cannot handle centers of type", class(centers),
     "\n"))
     }
     }
     else if (class(data) == "matrix") {
     if (class(centers) == "numeric" || class(centers) ==
     "integer") {
     ret <- .Call("R_kmeans_data_im", as.matrix(data),
     as.integer(centers), as.double(iter.max), as.integer(nthread),
     as.character(init), as.double(tolerance), as.character(dist.type),
     PACKAGE = "clusternor")
     }
     else if (class(centers) == "matrix") {
     ret <- .Call("R_kmeans_data_centroids_im", as.matrix(data),
     as.matrix(centers), as.double(iter.max), as.integer(nthread),
     as.double(tolerance), as.character(dist.type),
     PACKAGE = "clusternor")
     }
     else if (class(centers) == "character") {
     ret <- .Call("R_kmeans_data_im_centroids_em", as.matrix(data),
     normalizePath(centers), as.double(iter.max),
     as.integer(nthread), as.double(tolerance), as.character(dist.type),
     PACKAGE = "clusternor")
     }
     else {
     stop(paste("Cannot handle centers of type", class(centers),
     "\n"))
     }
     }
     else {
     stop(paste("Cannot handle data of type", class(data),
     "\n"))
     }
     }
     <bytecode: 0x2d4b250>
     <environment: namespace:clusternor>
     --- function search by body ---
     Function Kmeans in namespace clusternor has this body.
     ----------- END OF FAILURE REPORT --------------
     -- 4. Error: (unknown) (@test-knori.R#68) -------------------------------------
     the condition has length > 1
     Backtrace:
     1. clusternor:::test.data.in.mem()
     3. clusternor::Kmeans(test_data, k, nrow, ncol, nthread = nthread)
    
    
    
     ***Running test for kmeans***
    
     Data ==> disk, centroids ==> memory
    
     ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
     :
     --- package (from environment) ---
     clusternor
     --- call from context ---
     MiniBatchKmeans(fn, test_centroids, nrow, iter.max = iter.max,
     batch.size, nthread = nthread)
     --- call from argument ---
     if (class(centers) == "matrix") {
     ret <- .Call("R_mbkmeans_centroids_im", normalizePath(as.character(data)),
     as.matrix(centers), as.double(nrow), as.integer(batch.size),
     as.double(iter.max), as.integer(nthread), as.double(tolerance),
     as.character(dist.type), PACKAGE = "clusternor")
     } else {
     stop(paste("Cannot handle centers of type", class(centers),
     "\n"))
     }
     --- R stacktrace ---
     where 1: MiniBatchKmeans(fn, test_centroids, nrow, iter.max = iter.max,
     batch.size, nthread = nthread)
     where 2 at testthat/test-mb-kmeans.R#48: print(MiniBatchKmeans(fn, test_centroids, nrow, iter.max = iter.max,
     batch.size, nthread = nthread))
     where 3 at testthat/test-mb-kmeans.R#62: test.centroids.in.mem()
     where 4: eval(code, test_env)
     where 5: eval(code, test_env)
     where 6: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 7: doTryCatch(return(expr), name, parentenv, handler)
     where 8: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 9: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 10: doTryCatch(return(expr), name, parentenv, handler)
     where 11: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 12: tryCatchList(expr, classes, parentenv, handlers)
     where 13: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 14: test_code(NULL, exprs, env)
     where 15: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
     where 16: force(code)
     where 17: doWithOneRestart(return(expr), restart)
     where 18: withOneRestart(expr, restarts[[1L]])
     where 19: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 20: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter,
     {
     reporter$start_file(basename(path))
     lister$start_file(basename(path))
     source_file(path, new.env(parent = env), chdir = TRUE,
     wrap = wrap)
     reporter$.end_context()
     reporter$end_file()
     })
     where 21: FUN(X[[i]], ...)
     where 22: lapply(paths, test_file, env = env, reporter = current_reporter,
     start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
     where 23: force(code)
     where 24: doWithOneRestart(return(expr), restart)
     where 25: withOneRestart(expr, restarts[[1L]])
     where 26: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 27: with_reporter(reporter = current_reporter, results <- lapply(paths,
     test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE,
     load_helpers = FALSE, wrap = wrap))
     where 28: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 29: test_dir(path = test_path, reporter = reporter, env = env, filter = filter,
     ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning,
     wrap = wrap)
     where 30: test_package_dir(package = package, test_path = test_path, filter = filter,
     reporter = reporter, ..., stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 31: test_check("clusternor")
    
     --- value of length: 2 type: logical ---
     [1] TRUE FALSE
     --- function from context ---
     function (data, centers, nrow = -1, ncol = -1, batch.size = 100,
     iter.max = .Machine$integer.max, nthread = -1, init = c("kmeanspp",
     "random", "forgy", "none"), tolerance = 0.01, dist.type = c("sqeucl",
     "eucl", "cos", "taxi"), max.no.improvement = 3)
     {
     if (class(data) == "character") {
     if (class(centers) == "numeric" || class(centers) ==
     "integer") {
     ret <- .Call("R_mbkmeans", normalizePath(as.character(data)),
     as.integer(centers), as.double(nrow), as.double(ncol),
     as.integer(batch.size), as.double(iter.max),
     as.integer(nthread), as.character(init), as.double(tolerance),
     as.character(dist.type), PACKAGE = "clusternor")
     }
     else if (class(centers) == "matrix") {
     ret <- .Call("R_mbkmeans_centroids_im", normalizePath(as.character(data)),
     as.matrix(centers), as.double(nrow), as.integer(batch.size),
     as.double(iter.max), as.integer(nthread), as.double(tolerance),
     as.character(dist.type), PACKAGE = "clusternor")
     }
     else {
     stop(paste("Cannot handle centers of type", class(centers),
     "\n"))
     }
     }
     else if (class(data) == "matrix") {
     if (class(centers) == "numeric" || class(centers) ==
     "integer") {
     ret <- .Call("R_mbkmeans_data_im", as.matrix(data),
     as.integer(centers), as.integer(batch.size),
     as.double(iter.max), as.integer(nthread), as.character(init),
     as.double(tolerance), as.character(dist.type),
     PACKAGE = "clusternor")
     }
     else if (class(centers) == "matrix") {
     ret <- .Call("R_mbkmeans_data_centroids_im", as.matrix(data),
     as.matrix(centers), as.integer(batch.size), as.double(iter.max),
     as.integer(nthread), as.double(tolerance), as.character(dist.type),
     PACKAGE = "clusternor")
     }
     else {
     stop(paste("Cannot handle centers of type", class(centers),
     "\n"))
     }
     }
     else {
     stop(paste("Cannot handle data of type", class(data),
     "\n"))
     }
     }
     <bytecode: 0x30eefd8>
     <environment: namespace:clusternor>
     --- function search by body ---
     Function MiniBatchKmeans in namespace clusternor has this body.
     ----------- END OF FAILURE REPORT --------------
     -- 5. Error: (unknown) (@test-mb-kmeans.R#62) ---------------------------------
     the condition has length > 1
     Backtrace:
     1. clusternor:::test.centroids.in.mem()
     3. clusternor::MiniBatchKmeans(...)
    
    
    
     ***Running test for skmeans***
    
     Data ==> disk, centroids ==> memory
    
     ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
     :
     --- package (from environment) ---
     clusternor
     --- call from context ---
     Skmeans(fn, test_centroids, nrow, ncol, nthread = nthread)
     --- call from argument ---
     if (class(centers) == "matrix") {
     ret <- .Call("R_skmeans_centroids_im", normalizePath(as.character(data)),
     as.matrix(centers), as.double(nrow), as.double(iter.max),
     as.integer(nthread), as.double(tolerance), PACKAGE = "clusternor")
     }
     --- R stacktrace ---
     where 1: Skmeans(fn, test_centroids, nrow, ncol, nthread = nthread)
     where 2 at testthat/test-skmeans.R#44: print(Skmeans(fn, test_centroids, nrow, ncol, nthread = nthread))
     where 3 at testthat/test-skmeans.R#55: test.centroids.in.mem()
     where 4: eval(code, test_env)
     where 5: eval(code, test_env)
     where 6: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 7: doTryCatch(return(expr), name, parentenv, handler)
     where 8: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 9: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 10: doTryCatch(return(expr), name, parentenv, handler)
     where 11: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 12: tryCatchList(expr, classes, parentenv, handlers)
     where 13: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 14: test_code(NULL, exprs, env)
     where 15: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
     where 16: force(code)
     where 17: doWithOneRestart(return(expr), restart)
     where 18: withOneRestart(expr, restarts[[1L]])
     where 19: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 20: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter,
     {
     reporter$start_file(basename(path))
     lister$start_file(basename(path))
     source_file(path, new.env(parent = env), chdir = TRUE,
     wrap = wrap)
     reporter$.end_context()
     reporter$end_file()
     })
     where 21: FUN(X[[i]], ...)
     where 22: lapply(paths, test_file, env = env, reporter = current_reporter,
     start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
     where 23: force(code)
     where 24: doWithOneRestart(return(expr), restart)
     where 25: withOneRestart(expr, restarts[[1L]])
     where 26: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 27: with_reporter(reporter = current_reporter, results <- lapply(paths,
     test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE,
     load_helpers = FALSE, wrap = wrap))
     where 28: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 29: test_dir(path = test_path, reporter = reporter, env = env, filter = filter,
     ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning,
     wrap = wrap)
     where 30: test_package_dir(package = package, test_path = test_path, filter = filter,
     reporter = reporter, ..., stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 31: test_check("clusternor")
    
     --- value of length: 2 type: logical ---
     [1] TRUE FALSE
     --- function from context ---
     function (data, centers, nrow = -1, ncol = -1, iter.max = .Machine$integer.max,
     nthread = -1, init = c("kmeanspp", "random", "forgy", "none"),
     tolerance = 1e-06)
     {
     if (class(data) == "matrix") {
     if (class(centers) == "numeric" || class(centers) ==
     "integer") {
     ret <- .Call("R_skmeans_data_im", as.matrix(data),
     as.integer(centers), as.double(iter.max), as.integer(nthread),
     as.character(init), as.double(tolerance), PACKAGE = "clusternor")
     }
     else if (class(centers) == "matrix") {
     ret <- .Call("R_skmeans_data_centroids_im", as.matrix(data),
     as.matrix(centers), as.double(iter.max), as.integer(nthread),
     as.double(tolerance), PACKAGE = "clusternor")
     }
     else {
     stop(paste("Cannot handle centers of type", class(centers),
     "\n"))
     }
     }
     else if (class(data) == "character") {
     if (class(centers) == "numeric" || class(centers) ==
     "integer") {
     ret <- .Call("R_skmeans_data_em", normalizePath(as.character(data)),
     as.integer(centers), as.double(nrow), as.double(ncol),
     as.double(iter.max), as.integer(nthread), as.character(init),
     as.double(tolerance), PACKAGE = "clusternor")
     }
     else if (class(centers) == "matrix") {
     ret <- .Call("R_skmeans_centroids_im", normalizePath(as.character(data)),
     as.matrix(centers), as.double(nrow), as.double(iter.max),
     as.integer(nthread), as.double(tolerance), PACKAGE = "clusternor")
     }
     }
     else {
     stop(paste("Cannot handle data of type", class(data),
     "\n"))
     }
     }
     <bytecode: 0x30eb7b8>
     <environment: namespace:clusternor>
     --- function search by body ---
     Function Skmeans in namespace clusternor has this body.
     ----------- END OF FAILURE REPORT --------------
     -- 6. Error: (unknown) (@test-skmeans.R#55) -----------------------------------
     the condition has length > 1
     Backtrace:
     1. clusternor:::test.centroids.in.mem()
     3. clusternor::Skmeans(fn, test_centroids, nrow, ncol, nthread = nthread)
    
    
    
     ***Running test for xmeans***
    
     Data ==> disk, centroids ==> memory
    
     ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
     :
     --- package (from environment) ---
     clusternor
     --- call from context ---
     Xmeans(fn, kmax, nrow, ncol, iter.max = iter.max, init = test_centroids[1:2,
     ], nthread = nthread)
     --- call from argument ---
     if (class(init) == "character") {
     ret <- .Call("R_xmeans_data_em_init", as.character(data),
     as.integer(kmax), as.double(nrow), as.double(ncol), as.double(iter.max),
     as.integer(nthread), as.character(init), as.double(tolerance),
     as.character(dist.type), as.integer(min.clust.size),
     PACKAGE = "clusternor")
     } else if (class(init) == "matrix") {
     if (!(all(dim(init) == c(2, ncol), TRUE)))
     stop("init centers must have dim: `c(2, ncol)'")
     ret <- .Call("R_xmeans_data_em_centers", as.character(data),
     as.integer(kmax), as.double(nrow), as.double(ncol), as.double(iter.max),
     as.integer(nthread), as.matrix(init), as.double(tolerance),
     as.character(dist.type), as.integer(min.clust.size),
     PACKAGE = "clusternor")
     } else {
     stop(paste("Cannot handle init of type", class(init), "\n"))
     }
     --- R stacktrace ---
     where 1: Xmeans(fn, kmax, nrow, ncol, iter.max = iter.max, init = test_centroids[1:2,
     ], nthread = nthread)
     where 2 at testthat/test-xmeans.R#55: print(Xmeans(fn, kmax, nrow, ncol, iter.max = iter.max, init = test_centroids[1:2,
     ], nthread = nthread))
     where 3 at testthat/test-xmeans.R#62: test.centroids.in.mem()
     where 4: eval(code, test_env)
     where 5: eval(code, test_env)
     where 6: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 7: doTryCatch(return(expr), name, parentenv, handler)
     where 8: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 9: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 10: doTryCatch(return(expr), name, parentenv, handler)
     where 11: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 12: tryCatchList(expr, classes, parentenv, handlers)
     where 13: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 14: test_code(NULL, exprs, env)
     where 15: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
     where 16: force(code)
     where 17: doWithOneRestart(return(expr), restart)
     where 18: withOneRestart(expr, restarts[[1L]])
     where 19: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 20: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter,
     {
     reporter$start_file(basename(path))
     lister$start_file(basename(path))
     source_file(path, new.env(parent = env), chdir = TRUE,
     wrap = wrap)
     reporter$.end_context()
     reporter$end_file()
     })
     where 21: FUN(X[[i]], ...)
     where 22: lapply(paths, test_file, env = env, reporter = current_reporter,
     start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
     where 23: force(code)
     where 24: doWithOneRestart(return(expr), restart)
     where 25: withOneRestart(expr, restarts[[1L]])
     where 26: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 27: with_reporter(reporter = current_reporter, results <- lapply(paths,
     test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE,
     load_helpers = FALSE, wrap = wrap))
     where 28: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 29: test_dir(path = test_path, reporter = reporter, env = env, filter = filter,
     ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning,
     wrap = wrap)
     where 30: test_package_dir(package = package, test_path = test_path, filter = filter,
     reporter = reporter, ..., stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 31: test_check("clusternor")
    
     --- value of length: 2 type: logical ---
     [1] FALSE FALSE
     --- function from context ---
     function (data, kmax, nrow = -1, ncol = -1, iter.max = 20, nthread = -1,
     init = c("forgy"), tolerance = 1e-06, dist.type = c("eucl",
     "cos", "taxi"), min.clust.size = 1)
     {
     if (class(data) == "character") {
     if (class(init) == "character") {
     ret <- .Call("R_xmeans_data_em_init", as.character(data),
     as.integer(kmax), as.double(nrow), as.double(ncol),
     as.double(iter.max), as.integer(nthread), as.character(init),
     as.double(tolerance), as.character(dist.type),
     as.integer(min.clust.size), PACKAGE = "clusternor")
     }
     else if (class(init) == "matrix") {
     if (!(all(dim(init) == c(2, ncol), TRUE)))
     stop("init centers must have dim: `c(2, ncol)'")
     ret <- .Call("R_xmeans_data_em_centers", as.character(data),
     as.integer(kmax), as.double(nrow), as.double(ncol),
     as.double(iter.max), as.integer(nthread), as.matrix(init),
     as.double(tolerance), as.character(dist.type),
     as.integer(min.clust.size), PACKAGE = "clusternor")
     }
     else {
     stop(paste("Cannot handle init of type", class(init),
     "\n"))
     }
     }
     else if (class(data) == "matrix") {
     if (class(init) == "character") {
     ret <- .Call("R_xmeans_data_im_init", as.matrix(data),
     as.integer(kmax), as.double(iter.max), as.integer(nthread),
     as.character(init), as.double(tolerance), as.character(dist.type),
     as.integer(min.clust.size), PACKAGE = "clusternor")
     }
     else if (class(init) == "matrix") {
     if (!(all(dim(init) == c(2, dim(data)[2]), TRUE)))
     stop("init centers must have dim: `c(2, dim(data)[1])'")
     ret <- .Call("R_xmeans_data_im_centers", as.matrix(data),
     as.integer(kmax), as.double(iter.max), as.integer(nthread),
     as.matrix(init), as.double(tolerance), as.character(dist.type),
     as.integer(min.clust.size), PACKAGE = "clusternor")
     }
     else {
     stop(paste("Cannot handle init of type", class(init),
     "\n"))
     }
     }
     }
     <bytecode: 0x3256958>
     <environment: namespace:clusternor>
     --- function search by body ---
     Function Xmeans in namespace clusternor has this body.
     ----------- END OF FAILURE REPORT --------------
     -- 7. Error: (unknown) (@test-xmeans.R#62) ------------------------------------
     the condition has length > 1
     Backtrace:
     1. clusternor:::test.centroids.in.mem()
     3. clusternor::Xmeans(...)
    
     == testthat results ===========================================================
     [ OK: 0 | SKIPPED: 0 | WARNINGS: 0 | FAILED: 7 ]
     1. Error: (unknown) (@test-fuzzy-cmeans.R#62)
     2. Error: (unknown) (@test-hmeans.R#62)
     3. Error: (unknown) (@test-kmeanspp.R#44)
     4. Error: (unknown) (@test-knori.R#68)
     5. Error: (unknown) (@test-mb-kmeans.R#62)
     6. Error: (unknown) (@test-skmeans.R#55)
     7. Error: (unknown) (@test-xmeans.R#62)
    
     Error: testthat unit tests failed
     Execution halted
Flavor: r-devel-linux-x86_64-debian-clang

Version: 0.0-3
Check: installed package size
Result: NOTE
     installed size is 6.7Mb
     sub-directories of 1Mb or more:
     libs 6.5Mb
Flavors: r-devel-linux-x86_64-fedora-clang, r-release-osx-x86_64

Version: 0.0-3
Check: tests
Result: ERROR
     Running ‘testthat.R’ [4s/14s]
    Running the tests in ‘tests/testthat.R’ failed.
    Complete output:
     > library(testthat)
     > library(clusternor)
     Loading required package: Rcpp
     >
     > test_check("clusternor")
    
    
     ***Running test for fcmeans***
    
     Data ==> memory, centroids ==> memory
    
     Data ==> memory, centroids ==> memory
    
     Data ==> memory, centroids ==> compute
    
     $nrow
     [1] 50
    
     $ncol
     [1] 5
    
     $iters
     [1] 17
    
     $k
     [1] 8
    
     $centers
     [,1] [,2] [,3] [,4] [,5]
     [1,] 1.944158 1.873933 1.811169 1.829127 1.705401
     [2,] 1.944158 1.873933 1.811169 1.829127 1.705401
     [3,] 1.944158 1.873933 1.811169 1.829127 1.705401
     [4,] 1.944158 1.873933 1.811169 1.829127 1.705401
     [5,] 1.944158 1.873933 1.811169 1.829127 1.705401
     [6,] 1.944158 1.873933 1.811169 1.829127 1.705401
     [7,] 1.944158 1.873933 1.811169 1.829127 1.705402
     [8,] 1.944158 1.873933 1.811169 1.829127 1.705401
    
     $cluster
     [1] 7 3 7 7 3 7 7 7 7 3 7 3 7 3 3 7 3 7 3 7 3 7 7 3 3 7 7 3 3 3 7 3 3 7 3 7 3 3
     [39] 7 3 3 3 3 3 7 3 3 3 3 3
    
     $size
     [1] 0 0 29 0 0 0 21 0
    
     Data ==> memory, centroids ==> compute
    
     $nrow
     [1] 50
    
     $ncol
     [1] 5
    
     $iters
     [1] 17
    
     $k
     [1] 8
    
     $centers
     [,1] [,2] [,3] [,4] [,5]
     [1,] 1.944158 1.873933 1.811169 1.829127 1.705401
     [2,] 1.944158 1.873933 1.811169 1.829127 1.705401
     [3,] 1.944158 1.873933 1.811169 1.829127 1.705401
     [4,] 1.944158 1.873933 1.811169 1.829127 1.705401
     [5,] 1.944158 1.873933 1.811169 1.829127 1.705401
     [6,] 1.944158 1.873933 1.811169 1.829127 1.705401
     [7,] 1.944158 1.873933 1.811169 1.829127 1.705402
     [8,] 1.944158 1.873933 1.811169 1.829127 1.705401
    
     $cluster
     [1] 7 3 7 7 3 7 7 7 7 3 7 3 7 3 3 7 3 7 3 7 3 7 7 3 3 7 7 3 3 3 7 3 3 7 3 7 3 3
     [39] 7 3 3 3 3 3 7 3 3 3 3 3
    
     $size
     [1] 0 0 29 0 0 0 21 0
    
     Data ==> disk, centroids ==> compute
    
     $nrow
     [1] 50
    
     $ncol
     [1] 5
    
     $iters
     [1] 21
    
     $k
     [1] 8
    
     $centers
     [,1] [,2] [,3] [,4] [,5]
     [1,] 1.639097 1.559699 1.690567 1.784127 1.738475
     [2,] 1.639094 1.559697 1.690577 1.784087 1.738516
     [3,] 1.639089 1.559693 1.690596 1.784007 1.738599
     [4,] 1.639107 1.559707 1.690528 1.784283 1.738314
     [5,] 1.639106 1.559706 1.690532 1.784267 1.738331
     [6,] 1.639107 1.559706 1.690529 1.784282 1.738317
     [7,] 1.639095 1.559698 1.690571 1.784108 1.738495
     [8,] 1.639136 1.559735 1.690416 1.784741 1.737839
    
     $cluster
     [1] 3 3 3 3 8 8 3 3 8 3 3 8 8 3 3 8 3 3 8 3 8 8 8 3 3 8 3 3 8 3 3 3 3 8 8 8 3 3
     [39] 8 3 8 8 3 3 8 3 8 8 3 3
    
     $size
     [1] 0 0 29 0 0 0 0 21
    
     Data ==> disk, centroids ==> compute
    
     $nrow
     [1] 50
    
     $ncol
     [1] 5
    
     $iters
     [1] 21
    
     $k
     [1] 8
    
     $centers
     [,1] [,2] [,3] [,4] [,5]
     [1,] 1.639097 1.559699 1.690567 1.784127 1.738475
     [2,] 1.639094 1.559697 1.690577 1.784087 1.738516
     [3,] 1.639089 1.559693 1.690596 1.784007 1.738599
     [4,] 1.639107 1.559707 1.690528 1.784283 1.738314
     [5,] 1.639106 1.559706 1.690532 1.784267 1.738331
     [6,] 1.639107 1.559706 1.690529 1.784282 1.738317
     [7,] 1.639095 1.559698 1.690571 1.784108 1.738495
     [8,] 1.639136 1.559735 1.690416 1.784741 1.737839
    
     $cluster
     [1] 3 3 3 3 8 8 3 3 8 3 3 8 8 3 3 8 3 3 8 3 8 8 8 3 3 8 3 3 8 3 3 3 3 8 8 8 3 3
     [39] 8 3 8 8 3 3 8 3 8 8 3 3
    
     $size
     [1] 0 0 29 0 0 0 0 21
    
    
    
     ***Running test for hmeans***
    
     Data ==> ,centroids ==> memory
    
     $nrow
     [1] 50
    
     $ncol
     [1] 5
    
     $iters
     [1] 20
    
     $k
     [1] 8
    
     $centers
     [,1] [,2] [,3] [,4] [,5]
     [1,] 2.426766 2.953499 4.043335 2.244559 3.710492
     [2,] 4.122332 2.465384 3.589322 2.166748 3.575502
     [3,] 2.626000 3.584148 2.022466 2.295955 4.134119
     [4,] 1.943198 1.376050 2.189751 3.513497 4.592882
     [5,] 4.307359 2.781234 3.196755 4.311270 3.415023
     [6,] 2.795000 3.228041 4.430282 4.288907 1.526741
     [7,] 1.580627 3.095462 1.962946 4.057300 1.642651
     [8,] 2.477416 2.417114 2.200970 4.737974 2.761689
    
     $cluster
     [1] 5 1 3 2 7 8 1 1 8 1 4 7 6 1 5 5 5 1 5 2 6 5 2 3 4 5 1 2 7 3 3 4 3 7 5 8 1 1
     [39] 6 5 5 6 2 3 7 3 5 7 2 3
    
     $size
     [1] 9 6 8 3 11 4 6 3
    
     Data ==> memory, centroids ==> memory
    
     $nrow
     [1] 50
    
     $ncol
     [1] 5
    
     $iters
     [1] 20
    
     $k
     [1] 8
    
     $centers
     [,1] [,2] [,3] [,4] [,5]
     [1,] 2.888524 2.603497 2.066828 2.375178 4.408128
     [2,] 2.221906 3.679545 2.487253 2.001356 4.078200
     [3,] 3.363949 1.514688 3.809288 1.941361 3.547053
     [4,] 2.513951 3.081818 4.215258 1.409905 3.593325
     [5,] 1.676915 3.191770 2.080428 4.447292 2.429021
     [6,] 3.672408 1.905373 2.369369 4.077653 2.867364
     [7,] 3.815225 4.217887 1.862281 2.514782 2.702868
     [8,] 3.703079 4.045515 3.700746 3.861883 2.418166
    
     $cluster
     [1] 1 6 3 4 7 4 3 3 2 6 3 8 2 7 6 7 6 7 5 4 5 1 4 8 8 4 4 8 8 5 1 6 8 2 7 8 6 8
     [39] 1 8 7 8 5 8 2 8 6 8 5 8
    
     $size
     [1] 4 4 4 6 5 7 6 14
    
     Data ==> memory, centroids ==> memory
    
     $nrow
     [1] 50
    
     $ncol
     [1] 5
    
     $iters
     [1] 20
    
     $k
     [1] 8
    
     $centers
     [,1] [,2] [,3] [,4] [,5]
     [1,] 2.888524 2.603497 2.066828 2.375178 4.408128
     [2,] 2.221906 3.679545 2.487253 2.001356 4.078200
     [3,] 3.363949 1.514688 3.809288 1.941361 3.547053
     [4,] 2.513951 3.081818 4.215258 1.409905 3.593325
     [5,] 1.676915 3.191770 2.080428 4.447292 2.429021
     [6,] 3.672408 1.905373 2.369369 4.077653 2.867364
     [7,] 3.815225 4.217887 1.862281 2.514782 2.702868
     [8,] 3.703079 4.045515 3.700746 3.861883 2.418166
    
     $cluster
     [1] 1 6 3 4 7 4 3 3 2 6 3 8 2 7 6 7 6 7 5 4 5 1 4 8 8 4 4 8 8 5 1 6 8 2 7 8 6 8
     [39] 1 8 7 8 5 8 2 8 6 8 5 8
    
     $size
     [1] 4 4 4 6 5 7 6 14
    
     Data ==> memory, centroids ==> compute
    
     $nrow
     [1] 50
    
     $ncol
     [1] 5
    
     $iters
     [1] 20
    
     $k
     [1] 8
    
     $centers
     [,1] [,2] [,3] [,4] [,5]
     [1,] 4.318027 3.274617 3.602438 4.262944 3.290726
     [2,] 4.269881 4.268848 2.425307 3.481196 2.341417
     [3,] 4.132397 1.768855 4.801009 1.373922 4.613465
     [4,] 4.193760 3.652908 4.680513 1.539610 4.934383
     [5,] 2.270267 3.412114 2.075016 3.820038 3.503621
     [6,] 2.111149 2.999140 1.868376 3.905545 1.677061
     [7,] 2.279295 3.155427 3.458205 1.953112 3.614739
     [8,] 3.067549 2.376654 2.715911 1.486537 2.405939
    
     $cluster
     [1] 1 5 3 4 2 7 8 8 7 6 7 2 7 8 1 2 1 8 6 7 6 8 7 1 7 7 7 6 1 5 7 1 1 5 2 8 6 1
     [39] 7 1 5 1 5 2 7 6 1 2 5 1
    
     $size
     [1] 12 6 1 1 6 6 12 6
    
     Data ==> memory, centroids ==> compute
    
     $nrow
     [1] 50
    
     $ncol
     [1] 5
    
     $iters
     [1] 20
    
     $k
     [1] 8
    
     $centers
     [,1] [,2] [,3] [,4] [,5]
     [1,] 4.318027 3.274617 3.602438 4.262944 3.290726
     [2,] 4.269881 4.268848 2.425307 3.481196 2.341417
     [3,] 4.132397 1.768855 4.801009 1.373922 4.613465
     [4,] 4.193760 3.652908 4.680513 1.539610 4.934383
     [5,] 2.270267 3.412114 2.075016 3.820038 3.503621
     [6,] 2.111149 2.999140 1.868376 3.905545 1.677061
     [7,] 2.279295 3.155427 3.458205 1.953112 3.614739
     [8,] 3.067549 2.376654 2.715911 1.486537 2.405939
    
     $cluster
     [1] 1 5 3 4 2 7 8 8 7 6 7 2 7 8 1 2 1 8 6 7 6 8 7 1 7 7 7 6 1 5 7 1 1 5 2 8 6 1
     [39] 7 1 5 1 5 2 7 6 1 2 5 1
    
     $size
     [1] 12 6 1 1 6 6 12 6
    
     Data ==> test.data.bin , centroids ==> compute
    
     $nrow
     [1] 50
    
     $ncol
     [1] 5
    
     $iters
     [1] 20
    
     $k
     [1] 8
    
     $centers
     [,1] [,2] [,3] [,4] [,5]
     [1,] 4.558290 3.366808 4.267130 4.358562 4.008078
     [2,] 4.168830 2.707612 3.295831 3.355779 2.900720
     [3,] 2.840925 1.679445 3.518764 4.744002 1.590549
     [4,] 2.933031 1.435231 2.307501 4.381139 4.365722
     [5,] 2.483710 2.725254 3.572734 2.464197 3.162331
     [6,] 1.592081 2.303133 2.266422 4.066587 1.733709
     [7,] 2.449150 4.140533 1.550568 3.287508 2.548211
     [8,] 3.012037 3.752096 3.148389 2.154862 4.366184
    
     $cluster
     [1] 1 5 8 8 6 3 8 5 7 8 4 6 5 2 4 2 4 5 1 1 3 2 5 8 4 2 5 2 7 8 7 5 8 7 4 4 5 5
     [39] 5 1 1 3 5 5 6 7 2 6 8 7
    
     $size
     [1] 5 6 3 6 12 4 6 8
    
     Data ==> test.data.bin , centroids ==> compute
    
     $nrow
     [1] 50
    
     $ncol
     [1] 5
    
     $iters
     [1] 20
    
     $k
     [1] 8
    
     $centers
     [,1] [,2] [,3] [,4] [,5]
     [1,] 4.558290 3.366808 4.267130 4.358562 4.008078
     [2,] 4.168830 2.707612 3.295831 3.355779 2.900720
     [3,] 2.840925 1.679445 3.518764 4.744002 1.590549
     [4,] 2.933031 1.435231 2.307501 4.381139 4.365722
     [5,] 2.483710 2.725254 3.572734 2.464197 3.162331
     [6,] 1.592081 2.303133 2.266422 4.066587 1.733709
     [7,] 2.449150 4.140533 1.550568 3.287508 2.548211
     [8,] 3.012037 3.752096 3.148389 2.154862 4.366184
    
     $cluster
     [1] 1 5 8 8 6 3 8 5 7 8 4 6 5 2 4 2 4 5 1 1 3 2 5 8 4 2 5 2 7 8 7 5 8 7 4 4 5 5
     [39] 5 1 1 3 5 5 6 7 2 6 8 7
    
     $size
     [1] 5 6 3 6 12 4 6 8
    
    
    
     ***Running test for kmeanspp***
    
     Data ==> memory, centroids ==> compute
    
     $nrow
     [1] 50
    
     $ncol
     [1] 5
    
     $k
     [1] 8
    
     $centers
     [,1] [,2] [,3] [,4] [,5]
     [1,] 4.676106 4.259068 3.930618 4.701506 1.163457
     [2,] 4.360751 3.103981 2.929963 3.557833 4.917737
     [3,] 2.577532 1.344223 1.863300 4.038939 3.975245
     [4,] 4.132397 1.768855 4.801009 1.373922 4.613465
     [5,] 4.193760 3.652908 4.680513 1.539610 4.934383
     [6,] 4.646589 4.560930 1.590640 3.080840 3.667521
     [7,] 1.790205 2.395572 4.524249 1.312929 2.989034
     [8,] 2.340891 1.256685 3.564322 1.279626 1.655872
    
     $cluster
     [1] 2 3 4 5 6 7 8 4 2 3 7 6 7 6 2 6 1 6 3 5 3 8 7 2 7 7 7 7 1 3 2 3 1 6 6 8 3 1
     [39] 3 1 6 1 6 1 7 6 2 1 3 1
    
     $size
     [1] 9 6 9 2 2 10 9 3
    
     $best.start
     [1] 5
    
     $energy
     [1] 250.3165
    
     Data ==> disk, centroids ==> compute
    
     $nrow
     [1] 50
    
     $ncol
     [1] 5
    
     $k
     [1] 8
    
     $centers
     [,1] [,2] [,3] [,4] [,5]
     [1,] 1.412685 1.504301 2.981776 4.041901 4.939007
     [2,] 4.360751 2.577532 4.132397 4.193760 4.646589
     [3,] 1.790205 2.340891 4.072918 2.111099 3.215880
     [4,] 2.909588 3.515484 2.459138 3.053604 4.808919
     [5,] 4.664780 3.542847 3.869188 1.566410 3.427876
     [6,] 1.065202 1.971547 1.548926 4.216707 1.626716
     [7,] 2.603778 1.519162 1.435235 4.995698 1.873028
     [8,] 3.051730 4.356449 3.450559 2.184126 3.550209
    
     $cluster
     [1] 2 3 4 5 6 7 8 3 7 8 1 6 8 3 1 2 2 3 2 2 3 5 5 4 1 8 3 5 6 4 8 1 4 6 7 1 8 3
     [39] 8 2 2 7 5 3 6 4 2 6 5 4
    
     $size
     [1] 5 8 8 6 6 6 4 7
    
     $best.start
     [1] 9
    
     $energy
     [1] 209.9886
    
     Data ==> memory, centroids ==> compute
    
     $nrow
     [1] 50
    
     $ncol
     [1] 5
    
     $k
     [1] 8
    
     $centers
     [,1] [,2] [,3] [,4] [,5]
     [1,] 4.676106 4.259068 3.930618 4.701506 1.163457
     [2,] 4.360751 3.103981 2.929963 3.557833 4.917737
     [3,] 2.577532 1.344223 1.863300 4.038939 3.975245
     [4,] 4.132397 1.768855 4.801009 1.373922 4.613465
     [5,] 4.193760 3.652908 4.680513 1.539610 4.934383
     [6,] 4.646589 4.560930 1.590640 3.080840 3.667521
     [7,] 1.790205 2.395572 4.524249 1.312929 2.989034
     [8,] 2.340891 1.256685 3.564322 1.279626 1.655872
    
     $cluster
     [1] 2 3 4 5 6 7 8 4 2 3 7 6 7 6 2 6 1 6 3 5 3 8 7 2 7 7 7 7 1 3 2 3 1 6 6 8 3 1
     [39] 3 1 6 1 6 1 7 6 2 1 3 1
    
     $size
     [1] 9 6 9 2 2 10 9 3
    
     $best.start
     [1] 5
    
     $energy
     [1] 250.3165
    
     Data ==> memory, centroids ==> compute
    
     $nrow
     [1] 50
    
     $ncol
     [1] 5
    
     $k
     [1] 8
    
     $centers
     [,1] [,2] [,3] [,4] [,5]
     [1,] 4.676106 4.259068 3.930618 4.701506 1.163457
     [2,] 4.360751 3.103981 2.929963 3.557833 4.917737
     [3,] 2.577532 1.344223 1.863300 4.038939 3.975245
     [4,] 4.132397 1.768855 4.801009 1.373922 4.613465
     [5,] 4.193760 3.652908 4.680513 1.539610 4.934383
     [6,] 4.646589 4.560930 1.590640 3.080840 3.667521
     [7,] 1.790205 2.395572 4.524249 1.312929 2.989034
     [8,] 2.340891 1.256685 3.564322 1.279626 1.655872
    
     $cluster
     [1] 2 3 4 5 6 7 8 4 2 3 7 6 7 6 2 6 1 6 3 5 3 8 7 2 7 7 7 7 1 3 2 3 1 6 6 8 3 1
     [39] 3 1 6 1 6 1 7 6 2 1 3 1
    
     $size
     [1] 9 6 9 2 2 10 9 3
    
     $best.start
     [1] 5
    
     $energy
     [1] 250.3165
    
     Data ==> disk, centroids ==> compute
    
     $nrow
     [1] 50
    
     $ncol
     [1] 5
    
     $k
     [1] 8
    
     $centers
     [,1] [,2] [,3] [,4] [,5]
     [1,] 1.412685 1.504301 2.981776 4.041901 4.939007
     [2,] 4.360751 2.577532 4.132397 4.193760 4.646589
     [3,] 1.790205 2.340891 4.072918 2.111099 3.215880
     [4,] 2.909588 3.515484 2.459138 3.053604 4.808919
     [5,] 4.664780 3.542847 3.869188 1.566410 3.427876
     [6,] 1.065202 1.971547 1.548926 4.216707 1.626716
     [7,] 2.603778 1.519162 1.435235 4.995698 1.873028
     [8,] 3.051730 4.356449 3.450559 2.184126 3.550209
    
     $cluster
     [1] 2 3 4 5 6 7 8 3 7 8 1 6 8 3 1 2 2 3 2 2 3 5 5 4 1 8 3 5 6 4 8 1 4 6 7 1 8 3
     [39] 8 2 2 7 5 3 6 4 2 6 5 4
    
     $size
     [1] 5 8 8 6 6 6 4 7
    
     $best.start
     [1] 9
    
     $energy
     [1] 209.9886
    
     Data ==> disk, centroids ==> compute
    
     $nrow
     [1] 50
    
     $ncol
     [1] 5
    
     $k
     [1] 8
    
     $centers
     [,1] [,2] [,3] [,4] [,5]
     [1,] 1.412685 1.504301 2.981776 4.041901 4.939007
     [2,] 4.360751 2.577532 4.132397 4.193760 4.646589
     [3,] 1.790205 2.340891 4.072918 2.111099 3.215880
     [4,] 2.909588 3.515484 2.459138 3.053604 4.808919
     [5,] 4.664780 3.542847 3.869188 1.566410 3.427876
     [6,] 1.065202 1.971547 1.548926 4.216707 1.626716
     [7,] 2.603778 1.519162 1.435235 4.995698 1.873028
     [8,] 3.051730 4.356449 3.450559 2.184126 3.550209
    
     $cluster
     [1] 2 3 4 5 6 7 8 3 7 8 1 6 8 3 1 2 2 3 2 2 3 5 5 4 1 8 3 5 6 4 8 1 4 6 7 1 8 3
     [39] 8 2 2 7 5 3 6 4 2 6 5 4
    
     $size
     [1] 5 8 8 6 6 6 4 7
    
     $best.start
     [1] 9
    
     $energy
     [1] 209.9886
    
    
    
     ***Running test for knori***
    
     Data ==> memory, centroids ==> compute
    
     $nrow
     [1] 50
    
     $ncol
     [1] 5
    
     $iters
     [1] 4
    
     $k
     [1] 8
    
     $centers
     [,1] [,2] [,3] [,4] [,5]
     [1,] 4.234274 3.372592 3.798064 4.303089 3.188256
     [2,] 2.144040 2.558916 1.986447 4.209667 2.476013
     [3,] 4.132397 1.768855 4.801009 1.373922 4.613465
     [4,] 3.810818 3.661901 4.653864 1.377920 4.233336
     [5,] 3.556691 4.384075 2.042767 2.942817 2.655017
     [6,] 1.886782 3.410515 3.715263 1.962420 3.092535
     [7,] 2.719020 1.789017 3.746458 1.339093 1.334399
     [8,] 2.959328 2.135373 1.949842 2.018854 3.947807
    
     $cluster
     [1] 1 2 3 4 5 6 7 8 6 2 1 5 6 5 1 5 1 5 2 4 2 8 6 1 6 6 6 6 1 2 8 8 1 5 5 7 2 1
     [39] 8 1 5 1 2 5 8 5 1 1 2 1
    
     $size
     [1] 13 8 1 2 10 8 2 6
    
     Data ==> disk, centroids ==> compute
    
     $nrow
     [1] 50
    
     $ncol
     [1] 5
    
     $iters
     [1] 4
    
     $k
     [1] 8
    
     $centers
     [,1] [,2] [,3] [,4] [,5]
     [1,] 4.238475 2.807865 3.835232 4.434350 4.154347
     [2,] 2.167674 2.448746 3.163576 2.048924 3.026819
     [3,] 2.172151 2.691416 2.284776 3.093116 4.571899
     [4,] 3.832705 3.505895 2.655783 2.254102 3.021686
     [5,] 1.580627 3.095462 1.962946 4.057300 1.642651
     [6,] 3.611003 1.878082 2.978747 4.479156 2.216911
     [7,] 3.277000 4.302607 3.433434 4.121130 1.954065
     [8,] 2.844765 2.605606 4.271809 2.098687 4.150285
    
     $cluster
     [1] 1 2 3 4 5 6 4 8 7 8 3 5 7 8 1 6 1 8 1 1 6 4 4 3 3 7 2 8 5 3 4 3 3 5 6 3 2 8
     [39] 7 1 1 6 8 2 5 4 6 5 4 3
    
     $size
     [1] 7 4 9 7 6 6 4 7
    
     Data ==> disk, centroids ==> memory
    
     $nrow
     [1] 50
    
     $ncol
     [1] 5
    
     $iters
     [1] 5
    
     $k
     [1] 8
    
     $centers
     [,1] [,2] [,3] [,4] [,5]
     [1,] 3.858255 3.949648 3.659874 1.875268 3.489042
     [2,] 1.769369 1.781791 1.864545 4.094046 1.671924
     [3,] 2.752201 2.942786 3.766991 2.339935 4.246304
     [4,] 3.049170 4.134157 3.000881 4.262852 1.896699
     [5,] 4.152392 2.810450 4.084028 4.331085 3.121473
     [6,] 2.701588 1.413001 2.237661 4.161788 4.353291
     [7,] 2.555224 3.756859 1.389014 2.182601 3.412007
     [8,] 2.703618 2.166590 3.399669 1.997725 2.191857
    
     $cluster
     [1] 5 8 3 1 2 2 1 3 4 3 6 2 4 3 6 5 6 3 5 5 5 4 8 3 6 4 8 3 7 3 7 6 7 4 6 6 3 3
     [39] 4 5 5 5 3 7 4 7 5 2 3 7
    
     $size
     [1] 2 4 12 7 9 7 6 3
    
     Data ==> disk, centroids ==> disk
    
     $nrow
     [1] 50
    
     $ncol
     [1] 5
    
     $iters
     [1] 8
    
     $k
     [1] 8
    
     $centers
     [,1] [,2] [,3] [,4] [,5]
     [1,] 3.282731 2.462581 4.008404 2.136492 3.722234
     [2,] 2.703933 2.009029 4.117280 4.282299 1.812595
     [3,] 2.445569 3.734412 3.217135 2.310018 4.546464
     [4,] 4.154634 3.375270 2.203525 3.033030 2.589680
     [5,] 2.544671 1.593151 1.683771 3.742628 1.947451
     [6,] 4.423816 3.082989 4.016012 4.385518 4.059532
     [7,] 2.096457 1.820028 2.139390 3.410359 4.299556
     [8,] 2.229674 4.406236 2.825953 4.241458 1.730474
    
     $cluster
     [1] 6 1 3 1 5 5 3 1 8 3 7 5 8 1 7 2 6 1 6 6 2 4 4 3 7 4 5 1 8 3 4 7 3 8 5 7 3 3
     [39] 8 6 6 2 1 7 8 4 4 2 1 7
    
     $size
     [1] 8 4 8 6 5 6 7 6
    
     Data ==> memory, centroids ==> memory
    
     Data ==> memory, centroids ==> memory
    
     Data ==> memory, centroids ==> disk
    
     Data ==> memory, centroids ==> disk
    
    
    
     ***Running test for kmeans***
    
     Data ==> disk, centroids ==> memory
    
     $nrow
     [1] 50
    
     $ncol
     [1] 5
    
     $iters
     [1] 7
    
     $k
     [1] 8
    
     $centers
     [,1] [,2] [,3] [,4] [,5]
     [1,] 3.589406 4.085247 3.590094 1.978220 3.509423
     [2,] 1.578741 2.443173 2.451461 4.408251 2.742272
     [3,] 2.728232 2.873897 3.723849 2.321811 4.171865
     [4,] 3.649423 4.150500 3.328218 3.886749 1.907760
     [5,] 4.137572 2.831258 4.016044 4.398623 2.999367
     [6,] 3.790450 1.374192 1.965606 4.490850 4.092711
     [7,] 2.531311 3.641182 1.393328 2.226843 3.535699
     [8,] 2.843946 1.882912 2.690144 2.133782 1.579166
    
     $cluster
     [1] 5 3 3 1 2 2 1 3 4 3 6 8 4 3 6 5 6 3 5 5 5 4 8 3 2 4 8 3 7 3 7 2 7 2 6 2 3 3
     [39] 4 5 5 5 3 7 2 7 5 2 3 7
    
     $size
     [1] 2 8 13 5 9 4 6 3
    
     Data ==> memory, centroids ==> memory
    
     Data ==> memory, centroids ==> memory
    
     Data ==> memory, centroids ==> compute
    
     $nrow
     [1] 50
    
     $ncol
     [1] 5
    
     $iters
     [1] 100
    
     $k
     [1] 8
    
     $centers
     [,1] [,2] [,3] [,4] [,5]
     [1,] 4.532210 4.149091 4.046524 4.364007 2.591687
     [2,] 3.441246 2.275520 2.625159 4.080671 2.759457
     [3,] 3.398254 2.510082 2.824572 2.521021 4.487394
     [4,] 3.062624 3.821176 4.723837 1.760542 3.479308
     [5,] 3.269141 4.414499 2.132048 2.200501 3.035984
     [6,] 1.743932 3.657376 1.999350 4.380789 1.943076
     [7,] 2.269861 2.161770 4.173427 1.331416 2.170448
     [8,] 1.894461 2.561763 2.284230 1.386668 3.698546
    
     $cluster
     [1] 3 2 3 4 5 7 7 3 3 2 3 5 5 5 2 5 2 5 6 4 6 8 8 1 4 4 8 6 1 2 3 2 2 5 5 7 2 1
     [39] 8 1 5 1 6 1 8 6 1 1 6 1
    
     $size
     [1] 9 8 6 4 9 6 3 5
    
     Data ==> memory, centroids ==> compute
    
     $nrow
     [1] 50
    
     $ncol
     [1] 5
    
     $iters
     [1] 100
    
     $k
     [1] 8
    
     $centers
     [,1] [,2] [,3] [,4] [,5]
     [1,] 4.532210 4.149091 4.046524 4.364007 2.591687
     [2,] 3.441246 2.275520 2.625159 4.080671 2.759457
     [3,] 3.398254 2.510082 2.824572 2.521021 4.487394
     [4,] 3.062624 3.821176 4.723837 1.760542 3.479308
     [5,] 3.269141 4.414499 2.132048 2.200501 3.035984
     [6,] 1.743932 3.657376 1.999350 4.380789 1.943076
     [7,] 2.269861 2.161770 4.173427 1.331416 2.170448
     [8,] 1.894461 2.561763 2.284230 1.386668 3.698546
    
     $cluster
     [1] 3 2 3 4 5 7 7 3 3 2 3 5 5 5 2 5 2 5 6 4 6 8 8 1 4 4 8 6 1 2 3 2 2 5 5 7 2 1
     [39] 8 1 5 1 6 1 8 6 1 1 6 1
    
     $size
     [1] 9 8 6 4 9 6 3 5
    
     Data ==> disk, centroids ==> compute
    
     $nrow
     [1] 50
    
     $ncol
     [1] 5
    
     $iters
     [1] 100
    
     $k
     [1] 8
    
     $centers
     [,1] [,2] [,3] [,4] [,5]
     [1,] 3.929987 2.452540 3.219532 1.996989 2.976537
     [2,] 2.158013 1.884118 3.150730 4.379401 1.682652
     [3,] 3.083532 3.894414 1.342027 2.111190 3.973926
     [4,] 2.183121 4.376905 3.350886 4.320878 1.816118
     [5,] 3.018796 1.432811 2.400296 4.454700 4.368040
     [6,] 4.535041 3.366485 3.906760 4.215733 3.602246
     [7,] 2.134208 2.431276 2.092706 1.541212 3.868645
     [8,] 2.240420 3.145472 4.275668 2.409495 4.362905
    
     $cluster
     [1] 6 8 3 1 2 2 8 8 4 8 5 2 4 8 5 1 5 8 6 6 2 6 1 7 5 6 1 1 4 8 3 7 3 4 5 5 8 8
     [39] 4 6 6 2 1 7 4 3 6 2 1 3
    
     $size
     [1] 7 6 5 6 6 8 3 9
    
     Data ==> disk, centroids ==> compute
    
     $nrow
     [1] 50
    
     $ncol
     [1] 5
    
     $iters
     [1] 100
    
     $k
     [1] 8
    
     $centers
     [,1] [,2] [,3] [,4] [,5]
     [1,] 3.929987 2.452540 3.219532 1.996989 2.976537
     [2,] 2.158013 1.884118 3.150730 4.379401 1.682652
     [3,] 3.083532 3.894414 1.342027 2.111190 3.973926
     [4,] 2.183121 4.376905 3.350886 4.320878 1.816118
     [5,] 3.018796 1.432811 2.400296 4.454700 4.368040
     [6,] 4.535041 3.366485 3.906760 4.215733 3.602246
     [7,] 2.134208 2.431276 2.092706 1.541212 3.868645
     [8,] 2.240420 3.145472 4.275668 2.409495 4.362905
    
     $cluster
     [1] 6 8 3 1 2 2 8 8 4 8 5 2 4 8 5 1 5 8 6 6 2 6 1 7 5 6 1 1 4 8 3 7 3 4 5 5 8 8
     [39] 4 6 6 2 1 7 4 3 6 2 1 3
    
     $size
     [1] 7 6 5 6 6 8 3 9
    
    
    
     ***Running test for skmeans***
    
     Data ==> disk, centroids ==> memory
    
     $nrow
     [1] 50
    
     $ncol
     [1] 5
    
     $iters
     [1] 6
    
     $k
     [1] 8
    
     $centers
     [,1] [,2] [,3] [,4] [,5]
     [1,] 0.5129117 0.61425608 0.54783488 0.1662356 0.7627501
     [2,] 0.1705187 0.44286204 0.30143462 0.9162664 0.1587901
     [3,] 0.4147028 0.39775646 0.78571647 0.3123535 0.7434087
     [4,] 0.7236763 0.64872167 0.54430359 0.7486481 0.2903284
     [5,] 0.7065545 0.27068215 0.84571544 0.7712132 0.4611821
     [6,] 0.4324568 0.06868496 0.31514500 0.7756302 0.8323913
     [7,] 0.4097125 0.77523911 0.06840404 0.2907896 0.5821922
     [8,] 0.6208653 0.44920879 0.66913995 0.4070033 0.3679342
    
     $cluster
     [1] 5 3 1 1 2 2 1 3 4 1 6 4 4 3 6 5 6 3 4 5 5 4 8 1 6 4 8 3 7 3 7 6 7 2 6 6 3 3
     [39] 4 8 4 5 3 1 2 7 4 2 1 7
    
     $size
     [1] 7 5 9 9 5 7 5 3
    
     Data ==> memory, centroids ==> memory
    
     Data ==> memory, centroids ==> memory
    
     Data ==> memory, centroids ==> compute
    
     $nrow
     [1] 50
    
     $ncol
     [1] 5
    
     $iters
     [1] 6
    
     $k
     [1] 8
    
     $centers
     [,1] [,2] [,3] [,4] [,5]
     [1,] 0.7443497 0.6021787 0.6941622 0.79635789 0.52683576
     [2,] 0.3861703 0.2859536 0.1660593 0.82760900 0.39840962
     [3,] 0.7881642 0.4288792 0.9468353 0.11049036 0.95908184
     [4,] 0.3365143 0.6874086 0.3258380 0.26905008 0.81732087
     [5,] 0.5944591 0.8373270 0.2165306 0.50192735 0.35696635
     [6,] 0.2597403 0.5733455 0.8174615 0.17554461 0.53841303
     [7,] 0.4207656 0.1864392 0.6801867 0.08094902 0.08197797
     [8,] 0.4256398 0.1225859 0.2018627 0.19039163 0.78361785
    
     $cluster
     [1] 1 2 3 3 5 6 7 8 4 2 1 5 4 5 2 5 1 5 2 6 2 8 6 1 6 6 6 5 1 2 4 1 1 4 5 7 2 1
     [39] 8 1 5 1 5 5 4 5 1 1 1 1
    
     $size
     [1] 14 7 2 5 11 6 2 3
    
     Data ==> memory, centroids ==> compute
    
     $nrow
     [1] 50
    
     $ncol
     [1] 5
    
     $iters
     [1] 6
    
     $k
     [1] 8
    
     $centers
     [,1] [,2] [,3] [,4] [,5]
     [1,] 0.7443497 0.6021787 0.6941622 0.79635789 0.52683576
     [2,] 0.3861703 0.2859536 0.1660593 0.82760900 0.39840962
     [3,] 0.7881642 0.4288792 0.9468353 0.11049036 0.95908184
     [4,] 0.3365143 0.6874086 0.3258380 0.26905008 0.81732087
     [5,] 0.5944591 0.8373270 0.2165306 0.50192735 0.35696635
     [6,] 0.2597403 0.5733455 0.8174615 0.17554461 0.53841303
     [7,] 0.4207656 0.1864392 0.6801867 0.08094902 0.08197797
     [8,] 0.4256398 0.1225859 0.2018627 0.19039163 0.78361785
    
     $cluster
     [1] 1 2 3 3 5 6 7 8 4 2 1 5 4 5 2 5 1 5 2 6 2 8 6 1 6 6 6 5 1 2 4 1 1 4 5 7 2 1
     [39] 8 1 5 1 5 5 4 5 1 1 1 1
    
     $size
     [1] 14 7 2 5 11 6 2 3
    
     Data ==> disk, centroids ==> compute
    
     $nrow
     [1] 50
    
     $ncol
     [1] 5
    
     $iters
     [1] 7
    
     $k
     [1] 8
    
     $centers
     [,1] [,2] [,3] [,4] [,5]
     [1,] 0.8039996 0.44379726 0.79169393 0.8211810 0.5131260
     [2,] 0.3564577 0.07421840 0.36766916 0.7518415 0.8746260
     [3,] 0.3933026 0.64978723 0.35630166 0.3082583 0.7780279
     [4,] 0.8218595 0.58618939 0.43531624 0.3154077 0.4257493
     [5,] 0.1112964 0.52928224 0.34978374 0.8953330 0.1510998
     [6,] 0.5499824 0.05313038 0.04147118 0.7786273 0.2657419
     [7,] 0.3594540 0.91564142 0.53843174 0.7032899 0.1606744
     [8,] 0.4201048 0.36073783 0.80767576 0.2172899 0.6796988
    
     $cluster
     [1] 1 8 3 4 5 6 3 8 7 8 2 6 7 8 2 1 2 8 1 1 1 4 4 3 2 4 8 8 7 3 4 2 3 5 6 2 3 8
     [39] 7 1 1 1 8 3 5 3 1 5 4 3
    
     $size
     [1] 9 6 9 6 4 3 4 9
    
     Data ==> disk, centroids ==> compute
    
     $nrow
     [1] 50
    
     $ncol
     [1] 5
    
     $iters
     [1] 7
    
     $k
     [1] 8
    
     $centers
     [,1] [,2] [,3] [,4] [,5]
     [1,] 0.8039996 0.44379726 0.79169393 0.8211810 0.5131260
     [2,] 0.3564577 0.07421840 0.36766916 0.7518415 0.8746260
     [3,] 0.3933026 0.64978723 0.35630166 0.3082583 0.7780279
     [4,] 0.8218595 0.58618939 0.43531624 0.3154077 0.4257493
     [5,] 0.1112964 0.52928224 0.34978374 0.8953330 0.1510998
     [6,] 0.5499824 0.05313038 0.04147118 0.7786273 0.2657419
     [7,] 0.3594540 0.91564142 0.53843174 0.7032899 0.1606744
     [8,] 0.4201048 0.36073783 0.80767576 0.2172899 0.6796988
    
     $cluster
     [1] 1 8 3 4 5 6 3 8 7 8 2 6 7 8 2 1 2 8 1 1 1 4 4 3 2 4 8 8 7 3 4 2 3 5 6 2 3 8
     [39] 7 1 1 1 8 3 5 3 1 5 4 3
    
     $size
     [1] 9 6 9 6 4 3 4 9
    
    
    
     ***Running test for xmeans***
    
     Data ==> disk, centroids ==> memory
    
    
     *** caught segfault ***
     address 0, cause 'memory not mapped'
    
     Traceback:
     1: Xmeans(fn, kmax, nrow, ncol, iter.max = iter.max, init = test_centroids[1:2, ], nthread = nthread)
     2: print(Xmeans(fn, kmax, nrow, ncol, iter.max = iter.max, init = test_centroids[1:2, ], nthread = nthread))
     3: test.centroids.in.mem()
     4: eval(code, test_env)
     5: eval(code, test_env)
     6: withCallingHandlers({ eval(code, test_env) if (!handled && !is.null(test)) { skip_empty() }}, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, message = handle_message, error = handle_error)
     7: doTryCatch(return(expr), name, parentenv, handler)
     8: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     9: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     10: doTryCatch(return(expr), name, parentenv, handler)
     11: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), names[nh], parentenv, handlers[[nh]])
     12: tryCatchList(expr, classes, parentenv, handlers)
     13: tryCatch(withCallingHandlers({ eval(code, test_env) if (!handled && !is.null(test)) { skip_empty() }}, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, message = handle_message, error = handle_error), error = handle_fatal, skip = function(e) { })
     14: test_code(NULL, exprs, env)
     15: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
     16: force(code)
     17: doWithOneRestart(return(expr), restart)
     18: withOneRestart(expr, restarts[[1L]])
     19: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     20: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter, { reporter$start_file(basename(path)) lister$start_file(basename(path)) source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap) reporter$.end_context() reporter$end_file() })
     21: FUN(X[[i]], ...)
     22: lapply(paths, test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
     23: force(code)
     24: doWithOneRestart(return(expr), restart)
     25: withOneRestart(expr, restarts[[1L]])
     26: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     27: with_reporter(reporter = current_reporter, results <- lapply(paths, test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap))
     28: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning, wrap = wrap)
     29: test_dir(path = test_path, reporter = reporter, env = env, filter = filter, ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning, wrap = wrap)
     30: test_package_dir(package = package, test_path = test_path, filter = filter, reporter = reporter, ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning, wrap = wrap)
     31: test_check("clusternor")
     An irrecoverable exception occurred. R is aborting now ...
Flavor: r-patched-solaris-x86