Running 'bist_optbin.R' [160s]
Running the tests in 'tests/bist_optbin.R' failed.
Complete output:
  > 
  > library(optbin)
  > 
  > 
  > ### Helper Functions
  > 
  > # Short for cat(sprintf(fmt, ...)).  Automatically appends \n to fmt.
  > catf <- function(fmt, ...) {
  +   cat(sprintf(sprintf("%s\n", fmt), ...))
  + }
  > 
  > # Nearly-equal floating point test of two numbers, within the absolute
  > # accuracy acc.
  > fpnear <- function(x1, x2, acc=1e-7) {
  +   return(abs(x1-x2) < acc)
  + }
  > 
  > 
  > ### optbin Functionality Tests
  > 
  > # Test the optimal binning result res with nbin bins against the expected
  > # endpoints expend, threshold values expthr, the total, best (M)SE expse,
  > # and the average value per bin expavg.  Returns TRUE if all tests pass,
  > # FALSE if any fail.
  > verify_binning <- function(nbin, res, expend, expthr, expse, expavg) {
  +   passed <- TRUE
  + 
  +   if (nbin != res$numbins) {
  +     catf("    expected %d bins but result has %d", nbin, res$numbins)
  +     passed <- FALSE
  +   }
  + 
  +   for (b in 1:nbin) {
  +     if (expend[b] != res$breaks[b]) {
  +       catf("    expected bin %d endpoint at %d but got %d",
  +            b, expend[b], res$breaks[b])
  +       passed <- FALSE
  +     }
  +   }
  + 
  +   for (b in 1:nbin) {
  +     if (!fpnear(expthr[b], res$thr[b])) {
  +       catf("    expected bin %d threshold %.3f but got %.3f",
  +            b, expthr[b], res$thr[b])
  +       passed <- FALSE
  +     }
  +   }
  + 
  +   if (!fpnear(expse, res$minse)) {
  +     catf("    expected bin %d metric %.5f but got %.5f",
  +          b, expse, res$minse)
  +     passed <- FALSE
  +   }
  + 
  +   for (b in 1:nbin) {
  +     if (!fpnear(expavg[b], res$binavg[b])) {
  +       catf("    expected bin %d average %.3f but got %.3f",
  +            b, expavg[b], res$binavg[b])
  +       passed <- FALSE
  +     }
  +   }
  + 
  +   return(passed)
  + }
  > 
  > # Compare two binning results, resA and resB.  Any difference causes the
  > # test to fail.  Returns TRUE if the two are the same, FALSE if there
  > # are differences.
  > compare_binning <- function(resA, resB) {
  +   passed <- TRUE
  + 
  +   if (resA$numbins != resB$numbins) {
  +     catf("    binning A has %d bins, B %d", resA$numbins, resB$numbins)
  +     passed <- FALSE
  +   }
  + 
  +   if (resA$metric != resB$metric) {
  +     catf("    binning A used %s, B %s", resA$metric, resB$metric)
  +     passed <- FALSE
  +   }
  + 
  +   if (!fpnear(resA$minse, resB$minse)) {
  +     catf("    binning A best %s %.5f, B %.5f", toupper(resA$metric),
  +          resA$minse, resB$minse)
  +     passed <- FALSE
  +   }
  + 
  +   for (b in 1:resA$numbins) {
  +     if (!fpnear(resA$thr[b], resB$thr[b])) {
  +       catf("    bin %d threshold in A is %.5f, B %.5f",
  +            b, resA$thr[b], resB$thr[b])
  +       passed <- FALSE
  +     }
  +   }
  + 
  +   for (b in 1:resA$numbins) {
  +     if (!fpnear(resA$binavg[b], resB$binavg[b])) {
  +       catf("    bin %d average in A is %.5f, B %.5f",
  +            b, resA$binavg[b], resB$binavg[b])
  +       passed <- FALSE
  +     }
  +   }
  + 
  +   for (b in 1:resA$numbins) {
  +     if (!fpnear(resA$thr[b], resB$thr[b])) {
  +       catf("    bin %d (M)SE in A is %.5f, B %.5f",
  +            b, resA$binse[b], resB$binse[b])
  +       passed <- FALSE
  +     }
  +   }
  + 
  +   for (b in 1:resA$numbins) {
  +     if (resA$breaks[b] != resB$breaks[b]) {
  +       catf("    bin %d endpoint in A is %d, B %d",
  +            b, resA$breaks[b], resB$breaks[b])
  +       passed <- FALSE
  +     }
  +   }
  + 
  +   return(passed)
  + }
  > 
  > 
  > # Test 1: Small linear sequence.  Check with 2, 3, and 4 bins.
  > optbin_test1 <- function() {
  +   passed <- TRUE
  + 
  +   data <- c(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0)
  + 
  +   catf("  running test set 1 with cache")
  + 
  +   b <- optbin(data, 2)
  +   if (!verify_binning(2, b, c(5, 10), c(5.0, 10.0), 20.0, c(3.0, 8.0))) {
  +     passed <- FALSE
  +   }
  + 
  +   b <- optbin(data, 3)
  +   if (!verify_binning(3, b, c(3, 6, 10), c(3.0, 6.0, 10.0),
  +                       9.0, c(2.0, 5.0, 8.5))) {
  +     passed <- FALSE
  +   }
  + 
  +   b <- optbin(data, 4)
  +   if (!verify_binning(4, b, c(2, 4, 7, 10), c(2.0, 4.0, 7.0, 10.0),
  +                       5.0, c(1.5, 3.5, 6.0, 9.0))) {
  +     passed <- FALSE
  +   }
  + 
  +   if (passed) {
  +     catf("    tests passed")
  +   }
  +   catf("  running test set 1 without cache")
  + 
  +   b <- optbin(data, 2, max.cache=0)
  +   if (!verify_binning(2, b, c(5, 10), c(5.0, 10.0), 20.0, c(3.0, 8.0))) {
  +     passed <- FALSE
  +   }
  + 
  +   b <- optbin(data, 3, max.cache=0)
  +   if (!verify_binning(3, b, c(3, 6, 10), c(3.0, 6.0, 10.0),
  +                       9.0, c(2.0, 5.0, 8.5))) {
  +     passed <- FALSE
  +   }
  + 
  +   b <- optbin(data, 4, max.cache=0)
  +   if (!verify_binning(4, b, c(2, 4, 7, 10), c(2.0, 4.0, 7.0, 10.0),
  +                       5.0, c(1.5, 3.5, 6.0, 9.0))) {
  +     passed <- FALSE
  +   }
  + 
  +   if (passed) {
  +     catf("    tests passed")
  +   }
  +   return(passed)
  + }
  > 
  > # Test 2: Two normals, N(1, 0.25), N(2, 0.25).  Check with 2, 3, and 4 bins.
  > optbin_test2 <- function() {
  +   passed <- TRUE
  + 
  +   data <- c(0.86, 0.91, 0.92, 1.04, 1.23, 1.23, 1.30, 1.36, 1.79, 1.89,
  +             1.89, 2.34, 2.41, 2.58, 2.79, 2.93, 2.96, 3.21, 3.41, 3.55)
  + 
  +   catf("  running test set 2 with cache")
  + 
  +   b <- optbin(data, 2)
  +   if (!verify_binning(2, b, c(11, 20), c(1.89, 3.55),
  +                       2.956779797980, c(1.31090909, 2.90888888))) {
  +     passed <- FALSE
  +   }
  + 
  +   b <- optbin(data, 3)
  +   if (!verify_binning(3, b, c(8, 14, 20), c(1.36, 2.58, 3.55),
  +                       1.269070833333, c(1.10625, 2.15, 3.14166666))) {
  +     passed <- FALSE
  +   }
  + 
  +   b <- optbin(data, 4)
  +   if (!verify_binning(4, b, c(8, 11, 17, 20), c(1.36, 1.89, 2.96, 3.55),
  +                       0.686537500000,
  +                       c(1.10625, 1.85666666, 2.668333333, 3.39))) {
  +     passed <- FALSE
  +   }
  + 
  +   if (passed) {
  +     catf("    tests passed")
  +   }
  +   catf("  running test set 2 without cache")
  + 
  +   b <- optbin(data, 2, max.cache=0)
  +   if (!verify_binning(2, b, c(11, 20), c(1.89, 3.55),
  +                       2.956779797980, c(1.31090909, 2.90888888))) {
  +     passed <- FALSE
  +   }
  + 
  +   b <- optbin(data, 3, max.cache=0)
  +   if (!verify_binning(3, b, c(8, 14, 20), c(1.36, 2.58, 3.55),
  +                       1.269070833333, c(1.10625, 2.15, 3.14166666))) {
  +     passed <- FALSE
  +   }
  + 
  +   b <- optbin(data, 4, max.cache=0)
  +   if (!verify_binning(4, b, c(8, 11, 17, 20), c(1.36, 1.89, 2.96, 3.55),
  +                       0.686537500000,
  +                       c(1.10625, 1.85666666, 2.668333333, 3.39))) {
  +     passed <- FALSE
  +   }
  + 
  +   if (passed) {
  +     catf("    tests passed")
  +   }
  +   return(passed)
  + }
  > 
  > # Test 3: Four constant bins.  Check with 2 t/m 6 bins (tie resolution 5, 6).
  > optbin_test3 <- function() {
  +   passed <- TRUE
  + 
  +   data <- c(1.0, 1.0, 1.0, 1.0, 3.0, 3.0, 3.0, 3.0,
  +             5.0, 5.0, 5.0, 5.0, 7.0, 7.0, 7.0, 7.0)
  + 
  +   catf("  running test set 3 with cache")
  + 
  +   b <- optbin(data, 2)
  +   if (!verify_binning(2, b, c(8, 16), c(3.0, 7.0), 16.0, c(2.0, 6.0))) {
  +     passed <- FALSE
  +   }
  + 
  +   b <- optbin(data, 3)
  +   if (!verify_binning(3, b, c(4, 8, 16), c(1.0, 3.0, 7.0), 8.0,
  +                       c(1.0, 3.0, 6.0))) {
  +     passed <- FALSE
  +   }
  + 
  +   b <- optbin(data, 4)
  +   if (!verify_binning(4, b, c(4, 8, 12, 16), c(1.0, 3.0, 5.0, 7.0), 
  +                       0.0, c(1.0, 3.0, 5.0, 7.0))) {
  +     passed <- FALSE
  +   }
  + 
  +   b <- optbin(data, 5)
  +   if (!verify_binning(5, b, c(2, 4, 8, 12, 16), c(1.0, 1.0, 3.0, 5.0, 7.0),
  +                       0.0, c(1.0, 1.0, 3.0, 5.0, 7.0))) {
  +     passed <- FALSE
  +   }
  + 
  +   b <- optbin(data, 6)
  +   if (!verify_binning(6, b, c(2, 4, 6, 8, 12, 16),
  +                       c(1.0, 1.0, 3.0, 3.0, 5.0, 7.0), 0.0,
  +                       c(1.0, 1.0, 3.0, 3.0, 5.0, 7.0))) {
  +     passed <- FALSE
  +   }
  + 
  +   if (passed) {
  +     catf("    tests passed")
  +   }
  +   catf("  running test set 3 without cache")
  + 
  +   b <- optbin(data, 2, max.cache=0)
  +   if (!verify_binning(2, b, c(8, 16), c(3.0, 7.0), 16.0, c(2.0, 6.0))) {
  +     passed <- FALSE
  +   }
  + 
  +   b <- optbin(data, 3, max.cache=0)
  +   if (!verify_binning(3, b, c(4, 8, 16), c(1.0, 3.0, 7.0), 8.0,
  +                       c(1.0, 3.0, 6.0))) {
  +     passed <- FALSE
  +   }
  + 
  +   b <- optbin(data, 4, max.cache=0)
  +   if (!verify_binning(4, b, c(4, 8, 12, 16), c(1.0, 3.0, 5.0, 7.0), 
  +                       0.0, c(1.0, 3.0, 5.0, 7.0))) {
  +     passed <- FALSE
  +   }
  + 
  +   b <- optbin(data, 5, max.cache=0)
  +   if (!verify_binning(5, b, c(2, 4, 8, 12, 16), c(1.0, 1.0, 3.0, 5.0, 7.0),
  +                       0.0, c(1.0, 1.0, 3.0, 5.0, 7.0))) {
  +     passed <- FALSE
  +   }
  + 
  +   b <- optbin(data, 6, max.cache=0)
  +   if (!verify_binning(6, b, c(2, 4, 6, 8, 12, 16),
  +                       c(1.0, 1.0, 3.0, 3.0, 5.0, 7.0), 0.0,
  +                       c(1.0, 1.0, 3.0, 3.0, 5.0, 7.0))) {
  +     passed <- FALSE
  +   }
  + 
  +   if (passed) {
  +     catf("    tests passed")
  +   }
  +   return(passed)
  + }
  > 
  > # Test 4: Data where SE and MSE bins differ.  Check with 2 and 3 bins.
  > optbin_test4 <- function() {
  +   passed <- TRUE
  + 
  +   data <- c(1.00, 1.25, 1.50, 1.75, 2.00, 2.25, 2.50, 2.75, 3.00,
  +             5.00, 8.00, 8.25, 8.50)
  + 
  +   catf("  running test set 2 with cache and using SE")
  + 
  +   b <- optbin(data, 2, metric='se')
  +   if (!verify_binning(2, b, c(9, 13), c(3.0, 8.5),
  +                       11.796875000000, c(2.0, 7.4375))) {
  +     passed <- FALSE
  +   }
  + 
  +   b <- optbin(data, 3, metric='se')
  +   if (!verify_binning(3, b, c(8, 10, 13), c(2.75, 5.0, 8.50),
  +                       4.750000000000, c(1.875, 4.0, 8.25))) {
  +     passed <- FALSE
  +   }
  + 
  +   if (passed) {
  +     catf("    tests passed")
  +   }
  +   catf("  running test set 2 with cache and using MSE")
  + 
  +   b <- optbin(data, 2, metric='mse')
  +   if (!verify_binning(2, b, c(10, 13), c(5.0, 8.5),
  +                       1.226666666667, c(2.30, 8.25))) {
  +     passed <- FALSE
  +   }
  + 
  +   b <- optbin(data, 3, metric='mse')
  +   if (!verify_binning(3, b, c(3, 10, 13), c(1.5, 5.0, 8.5),
  +                       1.08333333333, c(1.25, 2.75, 8.25))) {
  +     passed <- FALSE
  +   }
  + 
  +   if (passed) {
  +     catf("    tests passed")
  +   }
  +   catf("  running test set 2 without cache and using SE")
  + 
  +   b <- optbin(data, 2, metric='se', max.cache=0)
  +   if (!verify_binning(2, b, c(9, 13), c(3.0, 8.5),
  +                       11.796875000000, c(2.0, 7.4375))) {
  +     passed <- FALSE
  +   }
  + 
  +   b <- optbin(data, 3, metric='se', max.cache=0)
  +   if (!verify_binning(3, b, c(8, 10, 13), c(2.75, 5.0, 8.50),
  +                       4.750000000000, c(1.875, 4.0, 8.25))) {
  +     passed <- FALSE
  +   }
  + 
  +   if (passed) {
  +     catf("    tests passed")
  +   }
  +   catf("  running test set 2 without cache and using MSE")
  + 
  +   b <- optbin(data, 2, metric='mse', max.cache=0)
  +   if (!verify_binning(2, b, c(10, 13), c(5.0, 8.5),
  +                       1.226666666667, c(2.30, 8.25))) {
  +     passed <- FALSE
  +   }
  + 
  +   b <- optbin(data, 3, metric='mse', max.cache=0)
  +   if (!verify_binning(3, b, c(3, 10, 13), c(1.5, 5.0, 8.5),
  +                       1.08333333333, c(1.25, 2.75, 8.25))) {
  +     passed <- FALSE
  +   }
  + 
  +   if (passed) {
  +     catf("    tests passed")
  +   }
  +   return(passed)
  + }
  > 
  > # Fill a large array with random data and compare the results with and
  > # without caching.
  > optbin_caching <- function() {
  +   passed <- TRUE
  + 
  +   catf("  running random data with and without caching using SE")
  + 
  +   # 2520 is a multiple of 5, 7, 8, and 9 so all bins fall on endpoints.
  + 	set.seed(17)
  +   data <- runif(2520)
  + 
  +   for (b in 2:10) {
  +     bcache <- optbin(data, b)
  +     bnocache <- optbin(data, b, max.cache=0)
  +     if (!compare_binning(bcache, bnocache)) {
  +       passed <- FALSE
  +     }
  +   }
  + 
  +   if (passed) {
  +     catf("    tests passed")
  +   }
  +   catf("  running random data with and without caching using MSE")
  + 
  +   for (b in 2:10) {
  +     bcache <- optbin(data, b, metric='mse')
  +     bnocache <- optbin(data, b, metric='mse', max.cache=0)
  +     if (!compare_binning(bcache, bnocache)) {
  +       passed <- FALSE
  +     }
  +   }
  + 
  +   if (passed) {
  +     catf("    tests passed")
  +   }
  +   return(passed)
  + }
  > 
  > 
  > ### assign.optbin Functionality Tests
  > 
  > # Check that the count of values assigned to each bin match the bin size
  > # in points.  Returns TRUE if all tests pass, FALSE if any fail.
  > assign_test1 <- function() {
  +   passed <- TRUE
  + 
  +   catf("  running assign.optbin tests")
  + 
  +   set.seed(19)
  +   data <- rnorm(1000, mean=2, sd=0.5)
  + 
  +   binned <- optbin(data, 10)
  +   cnt <- table(assign.optbin(data, binned))
  +   stpt <- 1
  +   for (b in 1:10) {
  +     expcnt <- binned$breaks[b] - stpt + 1
  +     if (cnt[b] != expcnt) {
  +       catf("    %d values assigned to bin %d but range has %d",
  +            cnt[b], b, expcnt)
  +       passed <- FALSE
  +     }
  +     stpt <- binned$breaks[b] + 1
  +   }
  + 
  +   if (passed) {
  +     catf("    tests passed")
  +   }
  +   catf("  running assign.optbin tests without extending upper bound")
  + 
  +   dmax <- max(data)
  +   data2 <- c(data, dmax+1:10)
  +   cnt <- table(assign.optbin(data2, binned))
  +   stpt <- 1
  +   for (b in 1:10) {
  +     expcnt <- binned$breaks[b] - stpt + 1
  +     if (cnt[b] != expcnt) {
  +       catf("    %d values assigned to bin %d but range has %d",
  +            cnt[b], b, expcnt)
  +       passed <- FALSE
  +     }
  +     stpt <- binned$breaks[b] + 1
  +   }
  + 
  +   if (passed) {
  +     catf("    tests passed")
  +   }
  +   catf("  running assign.optbin tests while extending upper bound")
  + 
  +   cnt <- table(assign.optbin(data2, binned, extend.upper=TRUE))
  +   stpt <- 1
  +   for (b in 1:9) {
  +     expcnt <- binned$breaks[b] - stpt + 1
  +     if (cnt[b] != expcnt) {
  +       catf("    %d values assigned to bin %d but range has %d",
  +            cnt[b], b, expcnt)
  +       passed <- FALSE
  +     }
  +     stpt <- binned$breaks[b] + 1
  +   }
  + 
  +   b <- 10
  +   expcnt <- binned$breaks[b] - stpt + 1
  +   if (cnt[b] != (expcnt + 10)) {
  +     catf("    %d values assigned to bin %d but expected %d",
  +          cnt[b], b, expcnt+10)
  +     passed <- FALSE
  +   }
  + 
  +   if (passed) {
  +     catf("    tests passed")
  +   }
  +   return(passed)
  + }
  > 
  > 
  > ### Break The Part tests
  > 
  > # Various error checks on input data to optbin.  Returns TRUE if all tests
  > # pass, FALSE if any fail.
  > BTP_optbin <- function() {
  +   passed <- TRUE
  + 
  +   catf("  running optbin BTP tests")
  + 
  +   b <- tryCatch(optbin(c(1, 2, 3, 4, 5, "blah", 6), -1),
  +                 error=function(e) { NULL })
  +   if (!is.null(b)) {
  +     catf("    negative number of bins did not raise error")
  +     passed <- FALSE
  +   }
  + 
  +   b <- tryCatch(optbin(c(1, 2, 3, 4, 5, "blah", 6), 1),
  +                 error=function(e) { NULL })
  +   if (!is.null(b)) {
  +     catf("    too few bins did not raise error")
  +     passed <- FALSE
  +   }
  + 
  +   b <- tryCatch(optbin(c(1, 2, 3, 4, 5, "blah", 6), 2),
  +                 error=function(e) { NULL })
  +   if (!is.null(b)) {
  +     catf("    non-numeric entry in data without na.rm did not raise error")
  +     passed <- FALSE
  +   }
  + 
  +   b <- tryCatch(b <- optbin(c(1, 2, 3, 4, 5, "blah", 6), 2, na.rm=TRUE),
  +                 error=function(e) { NULL })
  +   if (is.null(b)) {
  +     catf("    non-numeric entry in data with na.rm did raise error")
  +     passed <- FALSE
  +   } else if (!verify_binning(2, b, c(3,6), c(3.0, 6.0), 4, c(2.0, 5.0))) {
  +     passed <- FALSE
  +   }
  + 
  +   b <- tryCatch(optbin(c(1, 2, 3, 4, 5, 6), 10),
  +                 error=function(e) { NULL })
  +   if (!is.null(b)) {
  +     catf("    too few values for number of bins did not raise error")
  +     passed <- FALSE
  +   }
  + 
  +   # This is test1 data.
  +   data <- c(1.0, 2.0, 3.0, 4.0, NA, 5.0, 6.0, 7.0, NA, 8.0, 9.0, NA, 10.0)
  + 
  +   b <- tryCatch(optbin(data, 2),
  +                 error=function(e) { NULL })
  +   if (!is.null(b)) {
  +     catf("    NAs in data without removing did not raise error")
  +     passed <- FALSE
  +   }
  + 
  +   b <- tryCatch(optbin(data, 2, na.rm=TRUE),
  +                 error=function(e) { NULL })
  +   if (is.null(b)) {
  +     catf("    removed NAs still caused error")
  +     passed <- FALSE
  +   } else if (!verify_binning(2, b, c(5, 10), c(5.0, 10.0), 20.0, c(3.0, 8.0))) {
  +     passed <- FALSE
  +   }
  + 
  +   b <- tryCatch(optbin(reverse(data), 2, is.sorted=TRUE),
  +                 error=function(e) { NULL })
  +   if (!is.null(b)) {
  +     catf("    unsorted data after setting is.sorted TRUE did not raise error")
  +     passed <- FALSE
  +   }
  + 
  +   b <- tryCatch(optbin(data, 2, is.sorted=T, na.rm=TRUE),
  +                 error=function(e) { NULL })
  +   if (is.null(b)) {
  +     catf("    pre-sorted data raised error")
  +     passed <- FALSE
  +   } else if (!verify_binning(2, b, c(5, 10), c(5.0, 10.0), 20.0, c(3.0, 8.0))) {
  +     passed <- FALSE
  +   }
  + 
  +   if (passed) {
  +     catf("    tests passed")
  +   }
  +   return(passed)
  + }
  > 
  > # Error checks on the arguments to plot.optbin.  Returns TRUE if all tests
  > # pass, FALSE if any fail.
  > BTP_plot <- function() {
  +   passed <- TRUE
  + 
  +   catf("  running plot.optbin BTP tests")
  + 
  +   data <- 1:10
  +   b <- optbin(data, 2)
  + 
  +   # These generate an error because we use them in the basic plot.
  +   # plot doesn't return anything so our error function will generate an NA.
  +   res <- tryCatch(plot(b2, ann=TRUE), error=function(e) { NA })
  +   if (!is.na(res)) {
  +     catf("    passing ann to plot.optbin did not raise error")
  +     passed <- FALSE
  +   }
  + 
  +   res <- tryCatch(plot(b2, xaxt='s'), error=function(e) { NA })
  +   if (!is.na(res)) {
  +     catf("    passing xaxt to plot.optbin did not raise error")
  +     passed <- FALSE
  +   }
  + 
  +   if (passed) {
  +     catf("    tests passed")
  +   }
  +   return(passed)
  + }
  > 
  > 
  > 
  > ### Top Level
  > 
  > allpass <- TRUE
  > cat('\nStarting optbin verification\n')
  
  Starting optbin verification
  > 
  > if (!optbin_test1()) {
  +   allpass <- FALSE
  + }
    running test set 1 with cache
      tests passed
    running test set 1 without cache
      tests passed
  > if (!optbin_test2()) {
  +   allpass <- FALSE
  + }
    running test set 2 with cache
      tests passed
    running test set 2 without cache
      tests passed
  > if (!optbin_test3()) {
  +   allpass <- FALSE
  + }
    running test set 3 with cache
      tests passed
    running test set 3 without cache
      tests passed
  > if (!optbin_test4()) {
  +   allpass <- FALSE
  + }
    running test set 2 with cache and using SE
      tests passed
    running test set 2 with cache and using MSE
      tests passed
    running test set 2 without cache and using SE
      tests passed
    running test set 2 without cache and using MSE
      tests passed
  > if (!optbin_caching()) {
  +   allpass <- FALSE
  + }
    running random data with and without caching using SE
      tests passed
    running random data with and without caching using MSE
      tests passed
  > if (!suppressWarnings(BTP_optbin())) {
  +   allpass <- FALSE
  + }
    running optbin BTP tests
      tests passed
  > 
  > if (!assign_test1()) {
  +   allpass <- FALSE
  + }
    running assign.optbin tests
      tests passed
    running assign.optbin tests without extending upper bound
      tests passed
    running assign.optbin tests while extending upper bound
      tests passed
  > 
  > if (!BTP_plot()) {
  +   allpass <- FALSE
  + }
    running plot.optbin BTP tests
      tests passed
  > 
  > 
  > if (allpass) {
  +   cat('\nAll tests PASSED\n\n')
  + } else {
  +   cat('\nSome test FAILED\n\n')
  +   # This should cause the build check to fail.
  +   error("test failure")
  + }
  
  All tests PASSED
  
  > 
  > 
  > proc.time()
     user  system elapsed 
     2.00    0.25    2.26