Running ‘test-ISCC-NBS.R’
  Running ‘test-VandY.R’
  Running ‘test-conversions.R’ [54s/64s]
  Running ‘test-poly.R’
  Running ‘test-transforms.R’ [190s/237s]
Running the tests in ‘tests/test-transforms.R’ failed.
Complete output:
  > 
  > #   This is only for   HVC  <--->  xyY   transforms
  > 
  > library( munsellinterpol )
  Loading required package: geometry
  Loading required package: magic
  Loading required package: abind
  Loading required package: rootSolve
  > 
  > options( width=144 )
  > 
  > printf <- function( msg, ... )
  +     {    
  +     mess = sprintf( msg[1], ... )    # should this really be msg[1] ?
  +     cat( mess, '\n' )   #, file=stderr() )
  +     }
  >     
  > #   returns time in seconds, from an arbitrary origin
  > gettime <- function()
  +     {
  +     if( requireNamespace('microbenchmark') )
  +         return( microbenchmark::get_nanotime() * 1.e-9 )
  +     else
  +         return( as.double( base::Sys.time() ) )
  +     }
  >     
  >     
  > testCentroids <- function()
  +     {
  +     #   path = "../inst/extdata/Centrals_ISCC_NBS.txt"    
  +     path = system.file( "extdata/Centroids_ISCC-NBS.txt", package='munsellinterpol' )
  +     
  +     df = read.table( path, header=T,  sep='\t', stringsAsFactors=F )    
  + 
  +     printf( "-----------  testCentroids()   %d samples -----------------------", nrow(df) )
  +         
  +     #   printf( "Testing centroids..." )   
  +     
  +     # go forwards HVC -> xyY
  + 
  +     HVC = HVCfromMunsellName( df$MunsellSpec )
  +     
  +     time_start  = gettime()
  +     
  +     res = MunsellToxyY( HVC, warn=FALSE )    
  + 
  +     time_elapsed = gettime() - time_start
  +     
  +     failures = sum( is.na(res$xyY[ ,1]) )
  +     
  +     printf(  "There were %d forward failures, out of %d samples.  time=%g sec.  %g/sample.",
  +                 failures, nrow(df), time_elapsed, time_elapsed/nrow(HVC) )
  + 
  +     
  +     if( 0 < failures )  return(FALSE)
  +     
  +     #   now go backwards xyY -> HVC
  +     time_start  = gettime()
  +     
  +     res = xyYtoMunsell( res$xyY, perf=TRUE )
  +     
  +     time_elapsed = gettime() - time_start
  +     
  +     failures = sum( is.na(res$HVC[ ,1]) )
  +     
  +     printf(  "There were %d reverse failures, out of %d samples.  time=%g sec.  %g/sample.",
  +                             failures, nrow(HVC), time_elapsed, time_elapsed/nrow(HVC) )
  + 
  +     printf( "Performance:")
  +     cat( "Time Elapsed 5-number summary:  " )
  +     cat( fivenum(res$time.elapsed,na.rm=T), '\n' )        
  +     cat( "Iterations 5-number summary:  " )
  +     cat( fivenum(res$iterations,na.rm=T), '\n' )    
  +     cat( "Evaluations 5-number summary:  " )
  +     cat( fivenum(res$evaluations,na.rm=T), '\n' )   
  +     
  +     #   compare HVC and res$HVC
  +     tol = 0.01    
  +     HVC.delta   = abs(HVC - res$HVC)
  +     HVC.delta[ ,1]  = pmin( HVC.delta[ ,1], 100 - HVC.delta[ ,1] )
  +     err = rowSums( HVC.delta )    
  +     idx = which.max( err )
  +     df  = data.frame( row.names=1 )
  +     df$HVC      = HVC[ idx, , drop=F ]
  +     df$xyY      = res$xyY[ idx, , drop=F ]
  +     df$HVC.back = res$HVC[ idx, , drop=F ]
  +     printf(  "Maximum round-trip error = %g  (tol=%g).", err[idx], tol )
  +     print( df )
  +     
  +     #   how many exceeded the tolerance
  +     count   = sum( tol < err )
  +     if( 0 < count )
  +         printf( "%d round-trip errors exceeded %g.", count, tol )
  +     
  +     if( 0 < failures  ||  0 < count )  return(FALSE)
  + 
  +     return( TRUE )
  +     }
  >      
  >      
  > testOptimals <- function()
  +     {
  +     path = system.file( "extdata/OptimalColorsForIlluminantC.txt", package='munsellinterpol' )
  +     
  +     df = read.table( path, header=T )        
  +     
  +     printf( "---------  testOptimals()  %d samples -----------------------", nrow(df) )
  +        
  +     xyY = as.matrix( df )
  +     
  +     out = TRUE
  +     
  +     for( hcinterp in c('bilin','bicub') )
  +         {
  +         for( vinterp in c('lin','cub') )
  +             {
  +             #   go backwards xyY -> HVC
  +             printf( "-----  hcinterp='%s',  vinterp='%s'  -----", hcinterp, vinterp )
  +             
  +             time_start  = gettime()
  +             
  +             res = xyYtoMunsell( xyY, warn=FALSE, perf=TRUE, hcinterp=hcinterp, vinterp=vinterp )
  +             
  +             time_elapsed = gettime() - time_start
  +             
  +             #   print( res )
  +             #   return(FALSE)
  +             
  +             HVC = res$HVC            
  +             
  +             mask    = is.na( HVC[ ,1] )
  +             
  +             failures = sum( mask )
  +             
  +             printf( "testOptimals(). There were %d inversion failures, out of %d samples.  time=%g sec.  %g/sample.",
  +                                 failures, nrow(xyY), time_elapsed, time_elapsed/nrow(xyY) )
  +                                 
  +             if( 0 < failures )
  +                 {
  +                 colnames(xyY)   = c('x','y','Y')                
  +                 colnames(HVC)   = c('H','V','C')
  +                 df  = data.frame( row.names=1:failures )
  +                 df$xyY  = xyY[mask, , drop=FALSE]                
  +                 df$HVC  = HVC[mask, , drop=FALSE]
  +                 print( df )
  +                 
  +                 #print( res )
  +                 out = FALSE
  +                 }
  +                 
  +             printf( "Performance:")
  +             cat( "Time Elapsed 5-number summary:  " )
  +             cat( fivenum(res$time.elapsed,na.rm=T), '\n' )        
  +             cat( "Iterations 5-number summary:  " )
  +             cat( fivenum(res$iterations,na.rm=T), '\n' )    
  +             cat( "Evaluations 5-number summary:  " )
  +             cat( fivenum(res$evaluations,na.rm=T), '\n' )    
  +             
  +             if( max( res$iterations, na.rm=T ) == 100 )
  +                 {
  +                 idx =  which( res$iterations == 100 )   # ; print(idx)
  +                 printf( "There were %d samples that failed to converge.", length(idx) )
  +                 df  = res[ idx, , drop=FALSE ]
  +                 print(df)
  +                 }
  + 
  +             if( out )
  +                 {
  +                 #   do round-trip
  +                 xyY.back    = MunsellToxyY( HVC, warn=FALSE,  hcinterp=hcinterp, vinterp=vinterp )$xyY
  +                 
  +                 delta   = rowSums( abs(xyY - xyY.back) )
  +                 
  +                 #   ignore pure black
  +                 mask        = xyY[ ,3]==0  &  xyY.back[ ,3]==0
  +                 delta[mask] = 0
  +                 
  +                 cat( "Round trip xyY -> HVC -> xyY  inversion error 5-number summary:  " )
  +                 cat( fivenum(delta), '\n' )               
  + 
  +                 idx = which.max( delta )
  +                 df  = data.frame( row.names=1 )
  +                 df$xyY      = xyY[ idx, , drop=F ]                
  +                 df$HVC      = HVC[ idx, , drop=F ]
  +                 df$xyY.back = xyY.back[ idx, , drop=F ]
  +                 printf(  "Maximum inversion error occurs for this one:" )
  +                 print( df )
  +                 }
  +             }
  +         }
  +             
  +     return( out )
  +     }
  >      
  >      
  >      
  > testReals <- function()
  +     {
  +     df.real     = subset( Munsell2xy, real==TRUE )
  +     
  +     printf( "----------------  testReals()  %d samples -----------------------", nrow(df.real) )
  +     
  +     HVC         = cbind( df.real$H, df.real$V, df.real$C )
  +     xyY         = cbind( df.real$x, df.real$y, YfromV(df.real$V) )
  +     
  +     #   go backwards xyY -> HVC
  +     time_start  = gettime()
  +     
  +     res = xyYtoMunsell( xyY, warn=FALSE, perf=TRUE )
  +     
  +     time_elapsed = gettime() - time_start
  +     
  +     mask    = is.na( res$HVC[ ,1] )
  +     
  +     failures = sum( mask )
  +     
  +     printf( "There were %d inversion failures, out of %d samples.  time=%g sec.  %g/sample.",
  +                         failures, nrow(xyY), time_elapsed, time_elapsed/nrow(xyY) )
  +                         
  + 
  +     if( 0 < failures )
  +         {
  +         colnames(HVC)   = c('H','V','C')
  +         colnames(xyY)   = c('x','y','Y')
  +         df  = data.frame( row.names=MunsellNameFromHVC( HVC[mask, ] ) )
  +         df$HVC  = HVC[mask, ]
  +         df$xyY  = xyY[mask, ]
  +         print( df )
  +         }
  +         
  +     printf( "Performance:")
  +     cat( "Time Elapsed 5-number summary:  " )
  +     cat( fivenum(res$time.elapsed,na.rm=T), '\n' )        
  +     cat( "Iterations 5-number summary:  " )
  +     cat( fivenum(res$iterations,na.rm=T), '\n' )    
  +     cat( "Evaluations 5-number summary:  " )
  +     cat( fivenum(res$evaluations,na.rm=T), '\n' )    
  +             
  +         
  +     
  +     #   compare HVC and res$HVC
  +     HVC.delta   = abs(HVC - res$HVC)
  +     HVC.delta[ ,1]  = pmin( HVC.delta[ ,1], 100 - HVC.delta[ ,1] )
  +     delta   = rowSums( HVC.delta )
  +     cat( "Round trip HVC -> xyY -> HVC  inversion error 5-number summary:  " )
  +     cat( fivenum(delta), '\n' )
  +     idx = which.max( delta )
  +     df  = data.frame( row.names=1 )
  +     df$HVC      = HVC[ idx, , drop=F ]
  +     df$xyY      = xyY[ idx, , drop=F ]
  +     df$HVC.back = res$HVC[ idx, , drop=F ]
  +     printf(  "Maximum inversion error occurs for this one:" )
  +     print( df )
  +          
  + 
  +     return( failures == 0 )
  +     }
  >      
  >      
  > testNeutrals <- function()
  +     {
  +     #   check that Chroma is small, and finite
  +     RGB = matrix( 0:255, 256, 3 )
  +     colnames(RGB)   = c('R','G','B')
  +     
  +     printf( "-----------  testNeutrals()   %d samples  -----------------------", nrow(RGB) )
  +           
  +     HVC = sRGBtoMunsell( RGB )
  +     
  +     chroma      = HVC[ ,3]
  +     mask        = is.na(chroma) 
  +     failures    = sum(mask)
  +     if( 0 < failures )
  +         {
  +         printf( "testNeutrals().  There were %d failures to convert.", failures )
  +         df  = data.frame( row.names=which(mask) )
  +         df$RGB  = RGB[mask, ]
  +         print( df )
  +         }    
  +         
  +     tol = 1.e-13
  +     mask    = (is.finite(chroma) & tol < chroma)
  +     count   = sum( mask  )
  +     if( 0 < count )
  +         {
  +         printf( "testNeutrals().  There were %d chromas > %g.", count, tol )
  +         df  = data.frame( row.names=which(mask) )
  +         df$RGB  = RGB[mask, ]
  +         df$Chroma   = chroma[mask]        
  +         print( df )
  +         }        
  +         
  +     #   now go back
  +     res = MunsellTosRGB( HVC )
  +     
  +     RGB.delta   = abs(RGB - res$sRGB)
  +     delta   = rowSums( RGB.delta )
  +     cat( "Round-trip error  (RGB -> HVC -> RGB)  5-number summary:  " )
  +     cat( fivenum(delta), '\n' )    
  +     
  +     return( failures==0  &&  count==0 )
  +     }
  >     
  >     
  > testNearNeutrals <- function()
  +     {
  +     #   check that Chroma is small, and finite
  +     RGB = matrix( 0, 0, 3 )
  +     colnames(RGB)   = c('R','G','B')
  +         
  +     for( k in 10:255 )
  +         {
  +         RGB = rbind( RGB, matrix(k,3,3) - diag(3) )
  +         }
  +         
  +     printf( "-------  testNearNeutrals()  %d samples   -----------------------", nrow(RGB) )
  +               
  +         
  +     HVC = sRGBtoMunsell( RGB )
  +     
  +     chroma      = HVC[ ,3]
  +     mask        = is.na(chroma) 
  +     failures    = sum(mask)
  +     if( 0 < failures )
  +         {
  +         printf( "testNearNeutrals().  There were %d failures to convert.", failures )
  +         df  = data.frame( row.names=which(mask) )
  +         df$RGB  = RGB[mask, ]
  +         print( df )
  +         return(FALSE)
  +         }    
  +         
  +     tol = 0.30
  +     mask    = (is.finite(chroma) & tol < chroma)
  +     count   = sum( mask  )
  +     if( 0 < count )
  +         {
  +         printf( "testNearNeutrals().  There were %d chromas > %g.", count, tol )
  +         df  = data.frame( row.names=which(mask) )
  +         df$RGB      = RGB[mask, ]
  +         df$Chroma   = chroma[mask]
  +         print( df )
  +         return(FALSE)
  +         }        
  +         
  +         
  +     #   now go back
  +     res         = MunsellTosRGB( HVC )
  +     RGB.delta   = abs(RGB - res$sRGB)
  +     delta   = rowSums( RGB.delta )
  +     cat( "Round-trip error  (RGB->HVC->RGB)  5-number summary:  " )
  +     cat( fivenum(delta), '\n' )         
  + 
  +     tol = 0.005
  +     if( tol < max(delta) )
  +         {
  +         printf( "Maximum round-trip error = %g > %g.", max(delta), tol )
  +         return(FALSE)
  +         }
  +     
  +     return( TRUE )
  +     }
  >     
  > testDarks <- function()
  +     {
  +     rgbmax  = 8  # 10    # 5
  +     
  +     RGB = as.matrix( expand.grid( R=0:rgbmax, G=0:rgbmax, B=0:rgbmax ) )    
  + 
  +     printf( "---------------------  testDarks() %d samples   -----------------------", nrow(RGB) )    
  + 
  +     HVC = sRGBtoMunsell( RGB )
  +     
  +     chroma      = HVC[ ,3]
  +     mask        = is.na(chroma) 
  +     failures    = sum(mask)
  +     if( 0 < failures )
  +         {
  +         printf( "testDarks().  There were %d failures to convert.", failures )
  +         df  = data.frame( row.names=which(mask) )
  +         df$RGB  = RGB[mask, , drop=FALSE ]
  +         print( df )
  +         return(FALSE)
  +         }    
  +         
  +     #   now go back
  +     res         = MunsellTosRGB( HVC )
  +     RGB.delta   = abs(RGB - res$sRGB)
  +     delta   = rowSums( RGB.delta )
  +     cat( "Round-trip error  (RGB->HVC->RGB)  5-number summary:  " )
  +     cat( fivenum(delta), '\n' )        
  +         
  +     return( failures==0 )
  +     }
  >      
  >      
  > {  
  + x = gettime()   # load microbenchmark
  + 
  + 
  + if( testCentroids() )
  +     printf( "testCentroids() passed." )
  + else
  +     stop( "testCentroids() failed !", call.=FALSE )
  + 
  + 
  + if( testNeutrals() )
  +     printf( "testNeutrals() passed." )
  + else
  +     stop( "testNeutrals() failed !", call.=FALSE )
  + 
  + if( testNearNeutrals() )
  +     printf( "testNearNeutrals() passed." )
  + else
  +     stop( "testNearNeutrals() failed !", call.=FALSE )
  + 
  + if( testDarks() )
  +     printf( "testDarks() passed." )
  + else
  +     stop( "testDarks() failed !", call.=FALSE )
  + 
  + if( testReals() ) 
  +     printf( "testReals() passed." )
  + else
  +     stop( "testReals() failed !", call.=FALSE )    
  +     
  + if( testOptimals() )
  +     printf( "testOptimals() passed." )
  + else
  +     stop( "testOptimals() failed !", call.=FALSE )
  + 
  +         
  + 
  + printf(  "Passed all Munsell Transforms tests !" )
  + }     
  -----------  testCentroids()   267 samples ----------------------- 
  There were 0 forward failures, out of 267 samples.  time=0.589307 sec.  0.00220714/sample. 
  There were 0 reverse failures, out of 267 samples.  time=4.02859 sec.  0.0150883/sample. 
  Performance: 
  Time Elapsed 5-number summary:  3.936887e-05 0.01072171 0.01268903 0.01530476 0.1215501 
  Iterations 5-number summary:  2 3 3 4 5 
  Evaluations 5-number summary:  8 11 11 14 17 
  Maximum round-trip error = 0.00586671  (tol=0.01). 
    HVC.H HVC.V HVC.C      xyY.x      xyY.y      xyY.Y  HVC.back.H  HVC.back.V  HVC.back.C
  1 23.00  5.50  0.06  0.3112943  0.3174985 23.9680791 23.00584689  5.50000000  0.05998018
  testCentroids() passed. 
  -----------  testNeutrals()   256 samples  ----------------------- 
  Round-trip error  (RGB -> HVC -> RGB)  5-number summary:  0 1.958786e-08 4.648791e-08 7.315463e-08 1.73029e-07 
  testNeutrals() passed. 
  -------  testNearNeutrals()  738 samples   ----------------------- 
  Round-trip error  (RGB->HVC->RGB)  5-number summary:  8.34649e-09 5.933329e-06 3.97252e-05 0.0001695386 0.002710453 
  testNearNeutrals() passed. 
  ---------------------  testDarks() 729 samples   ----------------------- 
  Round-trip error  (RGB->HVC->RGB)  5-number summary:  0 1.619968e-07 5.103613e-07 4.905405e-06 0.0001205648 
  testDarks() passed. 
  ----------------  testReals()  3089 samples ----------------------- 
  There were 0 inversion failures, out of 3089 samples.  time=40.1832 sec.  0.0130085/sample. 
  Performance: 
  Time Elapsed 5-number summary:  0.005925488 0.008138355 0.009596761 0.01142863 0.3956024 
  Iterations 5-number summary:  2 3 4 4 7 
  Evaluations 5-number summary:  8 11 14 14 23 
  Round trip HVC -> xyY -> HVC  inversion error 5-number summary:  5.727951e-11 5.477427e-08 1.891157e-06 2.41726e-05 0.0008014207 
  Maximum inversion error occurs for this one: 
    HVC.1 HVC.2 HVC.3    xyY.1    xyY.2    xyY.3 HVC.back.H HVC.back.V HVC.back.C
  1    60     9     2  0.29070  0.31590 76.69559  60.000797   9.000000   2.000005
  testReals() passed. 
  ---------  testOptimals()  994 samples ----------------------- 
  -----  hcinterp='bilin',  vinterp='lin'  ----- 
  testOptimals(). There were 0 inversion failures, out of 994 samples.  time=48.8289 sec.  0.0491236/sample. 
  Performance: 
  Time Elapsed 5-number summary:  4.547089e-05 0.03679486 0.04164315 0.05064006 0.3715816 
  Iterations 5-number summary:  2 3 3 4 5 
  Evaluations 5-number summary:  8 11 11 14 17 
  Round trip xyY -> HVC -> xyY  inversion error 5-number summary:  0 5.000748e-09 1.922579e-08 1.48315e-07 1.971535e-06 
  Maximum inversion error occurs for this one: 
      xyY.x   xyY.y   xyY.Y     HVC.H     HVC.V     HVC.C xyY.back.x xyY.back.y xyY.back.Y
  1 0.24813 0.06337 8.55260 84.431250  3.457032 34.087337 0.24812882 0.06337079 8.55260000
  -----  hcinterp='bilin',  vinterp='cub'  ----- 
  Error in iH:(iH + 1) : NA/NaN argument
  xyYtoMunsell(). DEBUG.  rootSolve::multiroot() failed.  ABstart=8.31181,-32.934.   HCstart=78.9346,33.9667.  value=1.20151 
  Error in iH:(iH + 1) : NA/NaN argument
  xyYtoMunsell(). DEBUG.  rootSolve::multiroot() failed.  ABstart=4.81499,-35.1188.   HCstart=77.1686,35.4473.  value=1.26055 
  Error in iH:(iH + 1) : NA/NaN argument
  xyYtoMunsell(). DEBUG.  rootSolve::multiroot() failed.  ABstart=4.3269,-32.4866.   HCstart=77.1074,32.7734.  value=1.26484 
  Error in iH:(iH + 1) : NA/NaN argument
  xyYtoMunsell(). DEBUG.  rootSolve::multiroot() failed.  ABstart=4.6762,-34.0492.   HCstart=77.1722,34.3688.  value=1.47022 
  Error in iH:(iH + 1) : NA/NaN argument
  xyYtoMunsell(). DEBUG.  rootSolve::multiroot() failed.  ABstart=4.17028,-31.4193.   HCstart=77.1002,31.6949.  value=1.49134 
  testOptimals(). There were 5 inversion failures, out of 994 samples.  time=47.9768 sec.  0.0482664/sample. 
       xyY.x    xyY.y    xyY.Y    HVC.H    HVC.V    HVC.C
  1 0.180430 0.018839 1.470600       NA 1.201512       NA
  2 0.157560 0.017166 1.562400       NA 1.260549       NA
  3 0.154430 0.020125 1.569200       NA 1.264840       NA
  4 0.156710 0.018308 1.916600       NA 1.470223       NA
  5 0.153500 0.021457 1.954900       NA 1.491338       NA
  Performance: 
  Time Elapsed 5-number summary:  4.957244e-05 0.03587053 0.04201185 0.05153048 0.2671467 
  Iterations 5-number summary:  2 3 3 4 6 
  Evaluations 5-number summary:  8 11 11 14 20 
  -----  hcinterp='bicub',  vinterp='lin'  ----- 
  testOptimals(). There were 0 inversion failures, out of 994 samples.  time=33.3967 sec.  0.0335983/sample. 
  Performance: 
  Time Elapsed 5-number summary:  4.843622e-05 0.02231098 0.02718019 0.03435763 0.2605089 
  Iterations 5-number summary:  2 3 4 4 6 
  Evaluations 5-number summary:  8 11 14 14 20 
  -----  hcinterp='bicub',  vinterp='cub'  ----- 
  Error in max(iH - 1, 1):min(iH + 2, length(H.vector)) : NA/NaN argument
  xyYtoMunsell(). DEBUG.  rootSolve::multiroot() failed.  ABstart=8.31181,-32.934.   HCstart=78.9346,33.9667.  value=1.20151 
  Error in max(iH - 1, 1):min(iH + 2, length(H.vector)) : NA/NaN argument
  xyYtoMunsell(). DEBUG.  rootSolve::multiroot() failed.  ABstart=4.81499,-35.1188.   HCstart=77.1686,35.4473.  value=1.26055 
  Error in max(iH - 1, 1):min(iH + 2, length(H.vector)) : NA/NaN argument
  xyYtoMunsell(). DEBUG.  rootSolve::multiroot() failed.  ABstart=4.3269,-32.4866.   HCstart=77.1074,32.7734.  value=1.26484 
  Error in max(iH - 1, 1):min(iH + 2, length(H.vector)) : NA/NaN argument
  xyYtoMunsell(). DEBUG.  rootSolve::multiroot() failed.  ABstart=4.6762,-34.0492.   HCstart=77.1722,34.3688.  value=1.47022 
  Error in max(iH - 1, 1):min(iH + 2, length(H.vector)) : NA/NaN argument
  xyYtoMunsell(). DEBUG.  rootSolve::multiroot() failed.  ABstart=4.17028,-31.4193.   HCstart=77.1002,31.6949.  value=1.49134 
  testOptimals(). There were 5 inversion failures, out of 994 samples.  time=22.1163 sec.  0.0222498/sample. 
       xyY.x    xyY.y    xyY.Y    HVC.H    HVC.V    HVC.C
  1 0.180430 0.018839 1.470600       NA 1.201512       NA
  2 0.157560 0.017166 1.562400       NA 1.260549       NA
  3 0.154430 0.020125 1.569200       NA 1.264840       NA
  4 0.156710 0.018308 1.916600       NA 1.470223       NA
  5 0.153500 0.021457 1.954900       NA 1.491338       NA
  Performance: 
  Time Elapsed 5-number summary:  5.212799e-05 0.01220233 0.01392398 0.01899247 0.6586663 
  Iterations 5-number summary:  2 3 4 4 7 
  Evaluations 5-number summary:  8 11 14 14 23 
  Error: testOptimals() failed !
  Execution halted