 Normalization tool. (c) 2003 NRC/CNRC by Daniel Lemire, Owen Kaser 
 Usage: ./normalizer BinaryFileName -groupby n1,n2,n3 
 or  ./normalizer BinaryFileName -dumpinfo 
[info] Your data cube will have dimensions... 
[info]  8 12 12 13 3 5 
[info] rounding up cube so that all dimensions are divisible by sqrt-based chunking
[info]  9 12 12 16 4 6 
Normalization default normalization
Normalization Slice Sorting (Less-than ordering)
Normalization GreedyFrequencySort (Less-than ordering)
Normalization Greedy Iteration (Less-than ordering)
------------------------
Using regular chunks of size 2

  1= 31004 (  85.6%)- Slice Sorting (Less-than ordering)
  2= 31308 (  86.4%)- GreedyFrequencySort (Less-than ordering)
  3= 31544 (  87.1%)- Greedy Iteration (Less-than ordering)
  4= 36236 (   100%)- default normalization

------------------------
Using regular chunks of size 3

  1= 38677 (  83.5%)- Slice Sorting (Less-than ordering)
  2= 38693 (  83.5%)- GreedyFrequencySort (Less-than ordering)
  3= 38959 (  84.1%)- Greedy Iteration (Less-than ordering)
  4= 46327 (   100%)- default normalization

------------------------
Using regular chunks of size 4

  1= 46588 (  95.4%)- Greedy Iteration (Less-than ordering)
  2= 46588 (  95.4%)- GreedyFrequencySort (Less-than ordering)
  3= 46588 (  95.4%)- Slice Sorting (Less-than ordering)
  4= 48820 (   100%)- default normalization

----------------------
Using sqrt-based chunking: cube shape (in chunks) approximates chunk shape (in cells)

  1= 36272 (  83.6%)- Slice Sorting (Less-than ordering)
  2= 36520 (  84.1%)- GreedyFrequencySort (Less-than ordering)
  3= 36572 (  84.2%)- Greedy Iteration (Less-than ordering)
  4= 43412 (   100%)- default normalization

m = 2
 Frequency Sort = 31004 (100%)
 Dual Frequency Sort = 30976 (99.9%)
m = 3
 Frequency Sort = 38677 (100%)
 Dual Frequency Sort = 38602 (99.8%)
m = 4
 Frequency Sort = 46588 (100%)
 Dual Frequency Sort = 46588 (100%)
 Normalization tool. (c) 2003 NRC/CNRC by Daniel Lemire, Owen Kaser 
 Usage: ./normalizer BinaryFileName -groupby n1,n2,n3 
 or  ./normalizer BinaryFileName -dumpinfo 
[info] Your data cube will have dimensions... 
[info]  12 12 13 3 5 13 
[info] rounding up cube so that all dimensions are divisible by sqrt-based chunking
[info]  12 12 16 4 6 16 
Normalization default normalization
Normalization Slice Sorting (Less-than ordering)
Normalization GreedyFrequencySort (Less-than ordering)
Normalization Greedy Iteration (Less-than ordering)
------------------------
Using regular chunks of size 2

  1= 31904 (  85.2%)- GreedyFrequencySort (Less-than ordering)
  2= 32080 (  85.7%)- Slice Sorting (Less-than ordering)
  3= 32464 (  86.7%)- Greedy Iteration (Less-than ordering)
  4= 37428 (   100%)- default normalization

------------------------
Using regular chunks of size 3

  1= 39570 (  84.5%)- GreedyFrequencySort (Less-than ordering)
  2= 40114 (  85.7%)- Slice Sorting (Less-than ordering)
  3= 40284 (  86.1%)- Greedy Iteration (Less-than ordering)
  4= 46812 (   100%)- default normalization

------------------------
Using regular chunks of size 4

  1= 47396 (  95.9%)- Slice Sorting (Less-than ordering)
  2= 47420 (    96%)- GreedyFrequencySort (Less-than ordering)
  3= 48404 (    98%)- Greedy Iteration (Less-than ordering)
  4= 49404 (   100%)- default normalization

----------------------
Using sqrt-based chunking: cube shape (in chunks) approximates chunk shape (in cells)

  1= 39136 (  87.2%)- Slice Sorting (Less-than ordering)
  2= 39248 (  87.5%)- GreedyFrequencySort (Less-than ordering)
  3= 40760 (  90.9%)- Greedy Iteration (Less-than ordering)
  4= 44860 (   100%)- default normalization

m = 2
 Frequency Sort = 32080 (100%)
 Dual Frequency Sort = 32024 (99.8%)
m = 3
 Frequency Sort = 40114 (100%)
 Dual Frequency Sort = 39814 (99.3%)
m = 4
 Frequency Sort = 47396 (100%)
 Dual Frequency Sort = 47396 (100%)
 Normalization tool. (c) 2003 NRC/CNRC by Daniel Lemire, Owen Kaser 
 Usage: ./normalizer BinaryFileName -groupby n1,n2,n3 
 or  ./normalizer BinaryFileName -dumpinfo 
[info] Your data cube will have dimensions... 
[info]  12 13 3 5 13 5 
[info] rounding up cube so that all dimensions are divisible by sqrt-based chunking
[info]  12 16 4 6 16 6 
Normalization default normalization
Normalization Slice Sorting (Less-than ordering)
Normalization GreedyFrequencySort (Less-than ordering)
Normalization Greedy Iteration (Less-than ordering)
------------------------
Using regular chunks of size 2

  1= 16540 (  79.3%)- Greedy Iteration (Less-than ordering)
  2= 16544 (  79.3%)- GreedyFrequencySort (Less-than ordering)
  3= 16560 (  79.4%)- Slice Sorting (Less-than ordering)
  4= 20868 (   100%)- default normalization

------------------------
Using regular chunks of size 3

  1= 19853 (    77%)- Greedy Iteration (Less-than ordering)
  2= 20063 (  77.8%)- GreedyFrequencySort (Less-than ordering)
  3= 20113 (    78%)- Slice Sorting (Less-than ordering)
  4= 25792 (   100%)- default normalization

------------------------
Using regular chunks of size 4

  1= 24848 (  93.1%)- Slice Sorting (Less-than ordering)
  2= 24884 (  93.2%)- GreedyFrequencySort (Less-than ordering)
  3= 24900 (  93.3%)- Greedy Iteration (Less-than ordering)
  4= 26696 (   100%)- default normalization

----------------------
Using sqrt-based chunking: cube shape (in chunks) approximates chunk shape (in cells)

  1= 19484 (  80.5%)- Slice Sorting (Less-than ordering)
  2= 19560 (  80.8%)- GreedyFrequencySort (Less-than ordering)
  3= 19596 (    81%)- Greedy Iteration (Less-than ordering)
  4= 24196 (   100%)- default normalization

m = 2
 Frequency Sort = 16560 (100%)
 Dual Frequency Sort = 16500 (99.6%)
m = 3
 Frequency Sort = 20113 (100%)
 Dual Frequency Sort = 19893 (98.9%)
m = 4
 Frequency Sort = 24848 (100%)
 Dual Frequency Sort = 24844 (100%)
 Normalization tool. (c) 2003 NRC/CNRC by Daniel Lemire, Owen Kaser 
 Usage: ./normalizer BinaryFileName -groupby n1,n2,n3 
 or  ./normalizer BinaryFileName -dumpinfo 
[info] Your data cube will have dimensions... 
[info]  13 3 5 13 5 3 
[info] rounding up cube so that all dimensions are divisible by sqrt-based chunking
[info]  16 4 6 16 6 4 
Normalization default normalization
Normalization Slice Sorting (Less-than ordering)
Normalization GreedyFrequencySort (Less-than ordering)
Normalization Greedy Iteration (Less-than ordering)
------------------------
Using regular chunks of size 2

  1=  8312 (  76.4%)- Greedy Iteration (Less-than ordering)
  2=  8372 (  76.9%)- Slice Sorting (Less-than ordering)
  3=  8432 (  77.5%)- GreedyFrequencySort (Less-than ordering)
  4= 10880 (   100%)- default normalization

------------------------
Using regular chunks of size 3

  1= 13165 (  81.2%)- Greedy Iteration (Less-than ordering)
  2= 13198 (  81.4%)- Slice Sorting (Less-than ordering)
  3= 13284 (  81.9%)- GreedyFrequencySort (Less-than ordering)
  4= 16214 (   100%)- default normalization

------------------------
Using regular chunks of size 4

  1= 16376 (   100%)- Greedy Iteration (Less-than ordering)
  2= 16376 (   100%)- GreedyFrequencySort (Less-than ordering)
  3= 16376 (   100%)- Slice Sorting (Less-than ordering)
  4= 16376 (   100%)- default normalization

----------------------
Using sqrt-based chunking: cube shape (in chunks) approximates chunk shape (in cells)

  1=  8760 (  66.2%)- Greedy Iteration (Less-than ordering)
  2=  8760 (  66.2%)- GreedyFrequencySort (Less-than ordering)
  3=  8760 (  66.2%)- Slice Sorting (Less-than ordering)
  4= 13232 (   100%)- default normalization

m = 2
 Frequency Sort = 8372 (100%)
 Dual Frequency Sort = 8376 (100%)
m = 3
 Frequency Sort = 13198 (100%)
 Dual Frequency Sort = 13198 (100%)
m = 4
 Frequency Sort = 16376 (100%)
 Dual Frequency Sort = 16376 (100%)
 Normalization tool. (c) 2003 NRC/CNRC by Daniel Lemire, Owen Kaser 
 Usage: ./normalizer BinaryFileName -groupby n1,n2,n3 
 or  ./normalizer BinaryFileName -dumpinfo 
[info] Your data cube will have dimensions... 
[info]  3 5 13 5 3 3 
[info] rounding up cube so that all dimensions are divisible by sqrt-based chunking
[info]  4 6 16 6 4 4 
Normalization default normalization
Normalization Slice Sorting (Less-than ordering)
Normalization GreedyFrequencySort (Less-than ordering)
Normalization Greedy Iteration (Less-than ordering)
------------------------
Using regular chunks of size 2

  1=  2056 (  59.8%)- Greedy Iteration (Less-than ordering)
  2=  2056 (  59.8%)- GreedyFrequencySort (Less-than ordering)
  3=  2056 (  59.8%)- Slice Sorting (Less-than ordering)
  4=  3440 (   100%)- default normalization

------------------------
Using regular chunks of size 3

  1=  3368 (  84.4%)- Slice Sorting (Less-than ordering)
  2=  3371 (  84.4%)- Greedy Iteration (Less-than ordering)
  3=  3371 (  84.4%)- GreedyFrequencySort (Less-than ordering)
  4=  3992 (   100%)- default normalization

------------------------
Using regular chunks of size 4

  1=  3992 (   100%)- Greedy Iteration (Less-than ordering)
  2=  3992 (   100%)- GreedyFrequencySort (Less-than ordering)
  3=  3992 (   100%)- Slice Sorting (Less-than ordering)
  4=  3992 (   100%)- default normalization

----------------------
Using sqrt-based chunking: cube shape (in chunks) approximates chunk shape (in cells)

  1=  2296 (  63.1%)- Greedy Iteration (Less-than ordering)
  2=  2296 (  63.1%)- GreedyFrequencySort (Less-than ordering)
  3=  2296 (  63.1%)- Slice Sorting (Less-than ordering)
  4=  3636 (   100%)- default normalization

m = 2
 Frequency Sort = 2056 (100%)
 Dual Frequency Sort = 2056 (100%)
m = 3
 Frequency Sort = 3368 (100%)
 Dual Frequency Sort = 3368 (100%)
m = 4
 Frequency Sort = 3992 (100%)
 Dual Frequency Sort = 3992 (100%)
 Normalization tool. (c) 2003 NRC/CNRC by Daniel Lemire, Owen Kaser 
 Usage: ./normalizer BinaryFileName -groupby n1,n2,n3 
 or  ./normalizer BinaryFileName -dumpinfo 
[info] Your data cube will have dimensions... 
[info]  5 13 5 3 3 9 
[info] rounding up cube so that all dimensions are divisible by sqrt-based chunking
[info]  6 16 6 4 4 9 
Normalization default normalization
Normalization Slice Sorting (Less-than ordering)
Normalization GreedyFrequencySort (Less-than ordering)
Normalization Greedy Iteration (Less-than ordering)
------------------------
Using regular chunks of size 2

  1=  5756 (  60.8%)- GreedyFrequencySort (Less-than ordering)
  2=  5768 (  60.9%)- Slice Sorting (Less-than ordering)
  3=  5796 (  61.2%)- Greedy Iteration (Less-than ordering)
  4=  9464 (   100%)- default normalization

------------------------
Using regular chunks of size 3

  1=  7876 (  76.9%)- Greedy Iteration (Less-than ordering)
  2=  7876 (  76.9%)- Slice Sorting (Less-than ordering)
  3=  8007 (  78.2%)- GreedyFrequencySort (Less-than ordering)
  4= 10241 (   100%)- default normalization

------------------------
Using regular chunks of size 4

  1= 10296 (   100%)- Greedy Iteration (Less-than ordering)
  2= 10296 (   100%)- GreedyFrequencySort (Less-than ordering)
  3= 10296 (   100%)- Slice Sorting (Less-than ordering)
  4= 10296 (   100%)- default normalization

----------------------
Using sqrt-based chunking: cube shape (in chunks) approximates chunk shape (in cells)

  1=  6424 (  63.6%)- Greedy Iteration (Less-than ordering)
  2=  6424 (  63.6%)- GreedyFrequencySort (Less-than ordering)
  3=  6424 (  63.6%)- Slice Sorting (Less-than ordering)
  4= 10108 (   100%)- default normalization

m = 2
 Frequency Sort = 5768 (99.5%)
 Dual Frequency Sort = 5796 (100%)
m = 3
 Frequency Sort = 7876 (100%)
 Dual Frequency Sort = 7872 (99.9%)
m = 4
 Frequency Sort = 10296 (100%)
 Dual Frequency Sort = 10296 (100%)
 Normalization tool. (c) 2003 NRC/CNRC by Daniel Lemire, Owen Kaser 
 Usage: ./normalizer BinaryFileName -groupby n1,n2,n3 
 or  ./normalizer BinaryFileName -dumpinfo 
[info] Your data cube will have dimensions... 
[info]  13 5 3 3 9 4 
[info] rounding up cube so that all dimensions are divisible by sqrt-based chunking
[info]  16 6 4 4 9 4 
Normalization default normalization
Normalization Slice Sorting (Less-than ordering)
Normalization GreedyFrequencySort (Less-than ordering)
Normalization Greedy Iteration (Less-than ordering)
------------------------
Using regular chunks of size 2

  1=  4824 (  58.9%)- GreedyFrequencySort (Less-than ordering)
  2=  4828 (    59%)- Slice Sorting (Less-than ordering)
  3=  4872 (  59.5%)- Greedy Iteration (Less-than ordering)
  4=  8184 (   100%)- default normalization

------------------------
Using regular chunks of size 3

  1=  6829 (  74.7%)- Slice Sorting (Less-than ordering)
  2=  6864 (  75.1%)- Greedy Iteration (Less-than ordering)
  3=  6956 (  76.1%)- GreedyFrequencySort (Less-than ordering)
  4=  9140 (   100%)- default normalization

------------------------
Using regular chunks of size 4

  1=  9216 (   100%)- Greedy Iteration (Less-than ordering)
  2=  9216 (   100%)- GreedyFrequencySort (Less-than ordering)
  3=  9216 (   100%)- Slice Sorting (Less-than ordering)
  4=  9216 (   100%)- default normalization

----------------------
Using sqrt-based chunking: cube shape (in chunks) approximates chunk shape (in cells)

  1=  5256 (  59.6%)- GreedyFrequencySort (Less-than ordering)
  2=  5260 (  59.6%)- Greedy Iteration (Less-than ordering)
  3=  5260 (  59.6%)- Slice Sorting (Less-than ordering)
  4=  8824 (   100%)- default normalization

m = 2
 Frequency Sort = 4828 (99%)
 Dual Frequency Sort = 4876 (100%)
m = 3
 Frequency Sort = 6829 (100%)
 Dual Frequency Sort = 6825 (99.9%)
m = 4
 Frequency Sort = 9216 (100%)
 Dual Frequency Sort = 9216 (100%)
 Normalization tool. (c) 2003 NRC/CNRC by Daniel Lemire, Owen Kaser 
 Usage: ./normalizer BinaryFileName -groupby n1,n2,n3 
 or  ./normalizer BinaryFileName -dumpinfo 
[info] Your data cube will have dimensions... 
[info]  5 3 3 9 4 5 
[info] rounding up cube so that all dimensions are divisible by sqrt-based chunking
[info]  6 4 4 9 4 6 
Normalization default normalization
Normalization Slice Sorting (Less-than ordering)
Normalization GreedyFrequencySort (Less-than ordering)
Normalization Greedy Iteration (Less-than ordering)
------------------------
Using regular chunks of size 2

  1=  2956 (  56.5%)- Slice Sorting (Less-than ordering)
  2=  3004 (  57.5%)- Greedy Iteration (Less-than ordering)
  3=  3020 (  57.8%)- GreedyFrequencySort (Less-than ordering)
  4=  5228 (   100%)- default normalization

------------------------
Using regular chunks of size 3

  1=  4707 (  83.7%)- Greedy Iteration (Less-than ordering)
  2=  4707 (  83.7%)- GreedyFrequencySort (Less-than ordering)
  3=  4707 (  83.7%)- Slice Sorting (Less-than ordering)
  4=  5625 (   100%)- default normalization

------------------------
Using regular chunks of size 4

  1=  5972 (   100%)- Greedy Iteration (Less-than ordering)
  2=  5972 (   100%)- GreedyFrequencySort (Less-than ordering)
  3=  5972 (   100%)- Slice Sorting (Less-than ordering)
  4=  5972 (   100%)- default normalization

----------------------
Using sqrt-based chunking: cube shape (in chunks) approximates chunk shape (in cells)

  1=  3244 (  59.9%)- Greedy Iteration (Less-than ordering)
  2=  3244 (  59.9%)- GreedyFrequencySort (Less-than ordering)
  3=  3244 (  59.9%)- Slice Sorting (Less-than ordering)
  4=  5416 (   100%)- default normalization

m = 2
 Frequency Sort = 2956 (96.3%)
 Dual Frequency Sort = 3068 (100%)
m = 3
 Frequency Sort = 4707 (100%)
 Dual Frequency Sort = 4707 (100%)
m = 4
 Frequency Sort = 5972 (100%)
 Dual Frequency Sort = 5972 (100%)
 Normalization tool. (c) 2003 NRC/CNRC by Daniel Lemire, Owen Kaser 
 Usage: ./normalizer BinaryFileName -groupby n1,n2,n3 
 or  ./normalizer BinaryFileName -dumpinfo 
[info] Your data cube will have dimensions... 
[info]  3 3 9 4 5 6 
[info] rounding up cube so that all dimensions are divisible by sqrt-based chunking
[info]  4 4 9 4 6 6 
Normalization default normalization
Normalization Slice Sorting (Less-than ordering)
Normalization GreedyFrequencySort (Less-than ordering)
Normalization Greedy Iteration (Less-than ordering)
------------------------
Using regular chunks of size 2

  1=  4104 (  61.9%)- Greedy Iteration (Less-than ordering)
  2=  4104 (  61.9%)- Slice Sorting (Less-than ordering)
  3=  4108 (    62%)- GreedyFrequencySort (Less-than ordering)
  4=  6628 (   100%)- default normalization

------------------------
Using regular chunks of size 3

  1=  6647 (  87.2%)- Greedy Iteration (Less-than ordering)
  2=  6647 (  87.2%)- GreedyFrequencySort (Less-than ordering)
  3=  6647 (  87.2%)- Slice Sorting (Less-than ordering)
  4=  7622 (   100%)- default normalization

------------------------
Using regular chunks of size 4

  1=  8916 (   100%)- Greedy Iteration (Less-than ordering)
  2=  8916 (   100%)- GreedyFrequencySort (Less-than ordering)
  3=  8916 (   100%)- Slice Sorting (Less-than ordering)
  4=  8916 (   100%)- default normalization

----------------------
Using sqrt-based chunking: cube shape (in chunks) approximates chunk shape (in cells)

  1=  4152 (  60.3%)- Greedy Iteration (Less-than ordering)
  2=  4152 (  60.3%)- Slice Sorting (Less-than ordering)
  3=  4184 (  60.7%)- GreedyFrequencySort (Less-than ordering)
  4=  6888 (   100%)- default normalization

m = 2
 Frequency Sort = 4104 (99.8%)
 Dual Frequency Sort = 4112 (100%)
m = 3
 Frequency Sort = 6647 (100%)
 Dual Frequency Sort = 6647 (100%)
m = 4
 Frequency Sort = 8916 (100%)
 Dual Frequency Sort = 8916 (100%)
