external 0.1.0

data/lib/external/io.rb

@@ -0,0 +1,398 @@
+require 'stringio'
+require 'tempfile'
+require 'external/chunkable'
+
+module External
+  # Position gets IO objects to work properly for large files.  Additionally, 
+  # IO adds a length accessor for getting the size of the IO contents.  Note
+  # that length is not automatically adjusted by write, for performance
+  # reasons.  length must be managed manually, or reset after writes using
+  # reset_length.
+  #
+  # A variety of bugs needed to be addressed per-platform:
+  #
+  # == Mac OS X Tiger
+  #
+  # Using the default (broken) installation of Ruby, StringIO does not correctly
+  # position itself when a pos= statement is issued.
+  #
+  #   s = StringIO.new "abc"
+  #   s.read    # => "abc"
+  #   s.pos = 0
+  #   s.read    # => nil
+  #
+  # For regular IO objects, as expected, the second read statement returns
+  # "abc".  Install the a fixed version of Ruby, perhaps with the one-click
+  # installer: http://rubyosx.rubyforge.org/
+  #
+  # == Windows
+  #
+  # Ruby on Windows has problems with files larger than ~2 gigabytes.
+  # Sizes return as negative, and positions cannot be set beyond the max
+  # size of a long (2147483647 ~ 2GB = 2475636895).  IO corrects both of 
+  # these issues thanks in large part to a bit of code taken from 
+  # 'win32/file/stat' (http://rubyforge.org/projects/win32utils/).
+  #
+  # == Others
+  #
+  # I haven't found errors on Fedora and haven't tested on any other platforms.
+  # If you find and solve some wierd positioning errors, please let me know. 
+  module IO
+    
+    # Determines the generic mode of the input io using the _mode
+    # method for the input io class.  By default IO provides _mode
+    # methods for File, Tempfile, and StringIO.  The return string
+    # is determined as follows:
+    #
+    # readable & writable:: r+
+    # readable:: r
+    # writable:: w
+    #
+    # The _mode method takes the input io and should return an array 
+    # specifying whether or not io is readable and writable 
+    # (ie [readable, writable]). 
+    #
+    # See try_handle for more details.
+    def self.mode(io) 
+      readable, writable = try_handle(io, "mode")
+
+      case
+      when readable && writable then "r+"
+      when readable then "r"
+      when writable then "w"
+      else
+        # occurs for r+ mode, for some reason
+        "r+"
+      end
+    end
+    
+    # Determines the length of the input io using the _length method
+    # for the input io class.  Non-External::IO inputs are extended 
+    # in this process.
+    #
+    # The _length method takes the input io, and should return the 
+    # current length of the input io (ie a flush operation may be 
+    # required). 
+    # 
+    # See try_handle for more details.
+    def self.length(io)
+      case io
+      when External::IO
+        try_handle(io, "length")
+      else
+        io.extend External::IO
+        io.length
+      end
+    end
+    
+    # Returns an array of bools determining if the input File 
+    # is readable and writable.
+    def self.file_mode(io)
+      begin
+        dup = io.dup
+        
+        # determine readable/writable by sending close methods
+        # to the duplicated IO.  If the io cannot  be closed for 
+        # read/write then it will raise an error, indicating that 
+        # it was not open in the given mode.   
+        [:close_read, :close_write].collect do |method|
+          begin
+            dup.send(method)
+            true
+          rescue(IOError)
+            false
+          end
+        end
+      ensure
+        # Be sure that the io is fully closed before proceeding!  
+        # (Otherwise Tempfiles will not be properly disposed of
+        # ... at least on Windows, perhaps on others)
+        dup.close if dup && !dup.closed?
+      end
+    end
+    
+    # Returns the length of the input File
+    def self.file_length(io)
+      io.fsync unless io.generic_mode == 'r'
+      File.size(io.path)
+    end
+    
+    # Returns an array of bools determining if the input Tempfile 
+    # is readable and writable.
+    def self.tempfile_mode(io)
+      file_mode(io.instance_variable_get("@tmpfile"))
+    end
+    
+    # Returns the length of the input Tempfile
+    def self.tempfile_length(io)
+      file_length(io)
+    end
+    
+    # Returns an array of bools determining if the input StringIO 
+    # is readable and writable.
+    #
+    #   s = StringIO.new("abcde", "r+")
+    #   External::IO.stringio_mode(s)  # => [true, true]
+    #
+    def self.stringio_mode(io)
+      [!io.closed_read?, !io.closed_write?]
+    end
+    
+    # Returns the length of the input StringIO
+    #
+    #   s = StringIO.new("abcde", "r+")
+    #   External::IO.length(s)  # => 5
+    #
+    def self.stringio_length(io)
+      io.string.length
+    end
+    
+    def self.extended(base) # :nodoc:
+      base.instance_variable_set("@generic_mode", mode(base))
+      base.reset_length
+      base.default_blksize = 1024
+      base.binmode
+    end
+    
+    protected
+    
+    # try_handle is a forwarding method allowing External::IO to handle
+    # non-File, non-Tempfile IO objects.  try_handle infers a method
+    # name based on the class of the input and trys to forward the 
+    # input io to that method within External::IO. For instance:
+    #
+    # * the _mode method for StringIO is 'stringio_mode'
+    # * the _length method for StringIO is 'stringio_length' 
+    # 
+    # Nested classes have '::' replaced by '_'.  Thus to add support
+    # for Some::Unknown::IO, extend External::IO as below:
+    #
+    #   module External::IO
+    #     def some_unknown_io_mode(io)
+    #       ...
+    #     end
+    # 
+    #     def some_unknown_io_length(io)
+    #       ...
+    #     end
+    #   end
+    #
+    # See stringio_mode and stringio_length for more details.
+    def self.try_handle(io, method)
+      method_name = io.class.to_s.downcase.gsub(/::/, "_") + "_#{method}"
+      if self.respond_to?(method_name)
+        External::IO.send(method_name, io)
+      else
+        raise "cannot determine #{method} for '%s'" % io.class
+      end
+    end
+    
+    public
+    
+    include Chunkable
+    attr_reader :generic_mode
+
+    # True if self is a File or Tempfile
+    def file?
+      self.kind_of?(File) || self.kind_of?(Tempfile)
+    end
+
+    # Modified truncate that adjusts length
+    def truncate(n)
+      super
+      self.pos = n if self.pos > n
+      self.length = n
+    end
+    
+    # Resets length to the length returned by External::IO.length
+    def reset_length
+      self.length = External::IO.length(self)
+    end
+    
+    #
+    # comparison
+    #
+    
+    # Quick comparision with another IO.  Returns true if
+    # another == self, or if both are file-type IOs and 
+    # their paths are equal.
+    def quick_compare(another)
+      self == another || (self.file? && another.file? && self.path == another.path)
+    end
+
+    # Sort compare with another IO, behaving like a comparison between
+    # the full string contents of self and another.  Can be a long 
+    # operation if it requires the full read of two large IO objects.
+    def sort_compare(another, blksize=default_blksize)
+      # equal in comparison if the ios are equal
+      return 0 if quick_compare(another)
+       
+      if another.length > self.length
+        return -1
+      elsif self.length < another.length
+        return 1
+      else
+        self.flush unless self.generic_mode == 'r'
+        self.pos = 0
+        another.flush unless another.generic_mode == 'r'
+        another.pos = 0
+
+        sa = sb = nil
+        while sa == sb
+          sa = self.read(blksize)
+          sb = another.read(blksize)
+          break if sa.nil? || sb.nil?
+        end
+
+        sa.to_s <=> sb.to_s
+      end
+    end
+    
+    # Sort compare with another IO, behaving like a comparison between
+    # the full string contents of self and another.  Can be a long 
+    # operation if it requires the full read of two large IO objects.
+    def <=>(another)
+      sort_compare(another)
+    end
+    
+    #
+    # reading
+    #
+    
+    def scan(range_or_span=default_span, blksize=default_blksize, carryover_limit=default_blksize)
+      carryover = 0
+      chunk(range_or_span, blksize) do |offset, length|
+        raise "carryover exceeds limit: #{carryover} (#{carryover_limit})" if carryover > carryover_limit
+        
+        scan_begin = offset - carryover
+        self.pos = scan_begin
+        string = self.read(length + carryover)
+        carryover = yield(scan_begin, string)
+      end
+      carryover
+    end
+    
+    #
+    # writing
+    #
+    
+    # 
+    def insert(src, range=0..src.length, pos=nil)
+      self.pos = pos unless pos == nil
+      
+      start_pos = self.pos
+      length_written = 0
+
+      src.flush unless src.generic_mode == 'r'   
+      src.pos = range.begin 
+      src.chunk(range) do |offset, length|
+        length_written += write(src.read(length))
+      end
+
+      end_pos = start_pos + length_written
+      self.length = end_pos if end_pos > self.length
+      length_written
+    end
+    
+    # 
+    def concat(src, range=0..src.length)
+      insert(src, range, length)
+    end
+    
+    #--
+    # it appears that as long as the io opening t.path closes,
+    # the tempfile will be deleted at the exit of the ruby 
+    # instance... otherwise it WILL NOT BE DELETED
+    # Make note of this in the documentation to be sure to close
+    # files if you start inserting because it may make tempfiles
+    #++
+    def copy(mode="r", range=0..length)
+      self.flush
+      
+      temp = Tempfile.new("copy")
+      temp.extend IO
+      temp.insert(self, range)
+      temp.close
+
+      cp = File.open(temp.path, mode)
+      cp.extend IO
+
+      if block_given?
+        begin
+          yield(cp)
+        ensure
+          cp.close unless cp.closed?
+          FileUtils.rm(cp.path) if File.exists?(cp.path)
+        end
+      else
+        cp
+      end
+    end
+  
+  end
+end
+
+# This code block modifies IO only if running on windows
+unless RUBY_PLATFORM.index('mswin').nil?
+require 'Win32API' 
+
+module External
+  module IO
+    # Modfied to properly determine file lengths on Windows. Uses code
+    # from 'win32/file/stat' (http://rubyforge.org/projects/win32utils/)
+    def self.file_length(io) # :nodoc:
+      io.fsync unless io.generic_mode == 'r'
+
+      # I would have liked to use win32/file/stat to do this... however, some issue
+      # arose involving FileUtils.cp, File.stat, and File::Stat.mode.  cp raised an 
+      # error because the mode would be nil for files.  I wasn't sure how to fix it, 
+      # so I've lifted the relevant code for pulling the large file size.
+
+      # Note this is a simplified version... if you base.path point to a chardev, 
+      # this may need to be changed, because apparently the call to the Win32API 
+      # may fail
+
+      stat_buf = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0].pack('ISSssssIILILILIL')
+      Win32API.new('msvcrt', '_stat64', 'PP', 'I').call(io.path, stat_buf)
+      stat_buf[24, 4].unpack('L').first # Size of file in bytes
+    end
+    
+    POSITION_MAX = 2147483647  # maximum size of long
+    
+    # Modified to handle positions past the 2Gb limit
+    def pos # :nodoc:
+      @pos || super
+    end
+    
+    # Positions larger than the max value of a long cannot be directly given 
+    # to the default +pos=+.  This version incrementally seeks to positions 
+    # beyond the maximum, if necessary.
+    #
+    # Note: setting the position beyond the 2Gb limit requires the use of a 
+    # sysseek statement.  As such, errors will arise if you try to position 
+    # an IO object that does not support this method (for example StringIO... 
+    # but then what are you doing with a 2Gb StringIO anyhow?)
+    def pos=(pos)
+      if pos < POSITION_MAX
+        super(pos)
+        @pos = nil
+      elsif @pos != pos
+        # note sysseek appears to be necessary here, rather than io.seek
+        @pos = pos
+        
+        super(POSITION_MAX)
+        pos -= POSITION_MAX
+        
+        while pos > POSITION_MAX
+          pos -= POSITION_MAX
+          self.sysseek(POSITION_MAX, Object::IO::SEEK_CUR)
+        end
+        
+        self.sysseek(pos, Object::IO::SEEK_CUR)
+      end
+    end
+    
+  end
+end
+
+end # end the windows-specific code

data/lib/external.rb

@@ -0,0 +1,3 @@
+require 'ext_ind'
+require 'ext_arr'
+require 'ext_arc'

data/test/benchmarks/benchmarks_20070918.txt

@@ -0,0 +1,45 @@
+############################################
+#  Index with batch processing
+############################################
+
+............
+test_element_assignment_speed
+                          user     system      total        real
+I
+10kx [index]=         0.160000   0.050000   0.210000 (  0.208374)
+10kx [range]=        11.510000  13.240000  24.750000 ( 28.489626)
+10kx [s,1]=          11.490000  13.010000  24.500000 ( 27.930727)
+
+IIIIIIIIII
+10kx [index]=         0.220000   0.050000   0.270000 (  0.263851)
+10kx [range]=        11.390000  13.790000  25.180000 ( 28.857814)
+10kx [s,1]=          11.590000  13.920000  25.510000 ( 28.947041)
+
+array reference
+10kx [index]=         0.000000   0.000000   0.000000 (  0.003049)
+10kx [range]=         0.010000   0.000000   0.010000 (  0.006701)
+10kx [s,1]=           0.000000   0.000000   0.000000 (  0.005084)
+
+.
+test_element_reference_speed
+                          user     system      total        real
+I
+100kx [index]         1.590000   0.640000   2.230000 (  2.226855)
+100kx [range]         0.670000   0.000000   0.670000 (  0.674267)
+100kx [s,1]           2.140000   0.710000   2.850000 (  3.660551)
+100kx [s,100]        11.110000   0.680000  11.790000 ( 11.797169)
+
+IIIIIIIIII
+100kx [index]         0.380000   0.000000   0.380000 (  0.381269)
+100kx [range]         0.590000   0.000000   0.590000 (  0.596402)
+100kx [s,1]           0.460000   0.000000   0.460000 (  0.456065)
+100kx [s,100]         0.440000   0.000000   0.440000 (  0.438470)
+
+array reference
+100kx [index]         0.020000   0.000000   0.020000 (  0.026224)
+100kx [range]         0.080000   0.000000   0.080000 (  0.079051)
+100kx [s,1]           0.050000   0.000000   0.050000 (  0.049507)
+100kx [s,100]         0.050000   0.000000   0.050000 (  0.050872)
+
+..............
+Finished in 135.398082 seconds.

data/test/benchmarks/benchmarks_20070921.txt

@@ -0,0 +1,91 @@
+#######################################
+# reworked osx
+#######################################
+test_element_reference_speed
+                          user     system      total        real
+I
+100kx [index]         1.950000   0.660000   2.610000 (  2.658425)
+100kx [range]         2.880000   0.650000   3.530000 (  3.573627)
+100kx [s,1]           2.100000   0.640000   2.740000 (  2.774918)
+100kx [s,100]        20.810000   0.700000  21.510000 ( 21.615324)
+
+IIIIIIIIII
+100kx [index]         1.630000   0.360000   1.990000 (  1.995421)
+100kx [range]         1.140000   0.000000   1.140000 (  1.145692)
+100kx [s,1]           0.470000   0.000000   0.470000 (  0.472543)
+100kx [s,100]         0.470000   0.000000   0.470000 (  0.472698)
+
+array reference
+100kx [index]         0.030000   0.000000   0.030000 (  0.026341)
+100kx [range]         0.060000   0.000000   0.060000 (  0.060080)
+100kx [s,1]           0.050000   0.000000   0.050000 (  0.052237)
+100kx [s,100]         0.040000   0.000000   0.040000 (  0.042142)
+
+#######################################
+# reworked osx accelerated
+#######################################
+test_element_reference_speed
+                          user     system      total        real
+I
+100kx [index]         1.970000   0.650000   2.620000 (  2.677882)
+100kx [range]         2.870000   0.650000   3.520000 (  3.530610)
+100kx [s,1]           2.130000   0.640000   2.770000 (  2.777566)
+100kx [s,100]         8.410000   0.670000   9.080000 (  9.118457)
+
+IIIIIIIIII
+100kx [index]         1.630000   0.360000   1.990000 (  2.001829)
+100kx [range]         1.150000   0.010000   1.160000 (  1.157869)
+100kx [s,1]           0.470000   0.000000   0.470000 (  0.477857)
+100kx [s,100]         0.470000   0.000000   0.470000 (  0.476172)
+
+array reference
+100kx [index]         0.020000   0.000000   0.020000 (  0.026329)
+100kx [range]         0.060000   0.000000   0.060000 (  0.060740)
+100kx [s,1]           0.050000   0.000000   0.050000 (  0.051872)
+100kx [s,100]         0.040000   0.000000   0.040000 (  0.043028)
+
+..............................................................p. ..
+
+#####################################
+# with bulk processing only
+#####################################
+...........F..
+test_element_assignment_speed
+                          user     system      total        real
+I
+10kx [index]=         0.190000   0.060000   0.250000 (  0.278135)
+10kx [range]=        12.760000  12.470000  25.230000 ( 40.200132)
+10kx [s,1]=          12.740000  12.360000  25.100000 ( 40.450334)
+
+IIIIIIIIII
+10kx [index]=         0.240000   0.050000   0.290000 (  0.287169)
+10kx [range]=        12.410000  13.020000  25.430000 ( 40.168660)
+10kx [s,1]=          12.510000  13.070000  25.580000 ( 40.690157)
+
+array reference
+10kx [index]=         0.000000   0.000000   0.000000 (  0.003034)
+10kx [range]=         0.010000   0.000000   0.010000 (  0.007231)
+10kx [s,1]=           0.000000   0.000000   0.000000 (  0.005260)
+
+.
+test_element_reference_speed
+                          user     system      total        real
+I
+100kx [index]         1.740000   0.670000   2.410000 (  2.414568)
+100kx [range]         2.510000   0.660000   3.170000 (  3.183513)
+100kx [s,1]           1.920000   0.680000   2.600000 (  3.314087)
+100kx [s,100]        11.460000   0.730000  12.190000 ( 12.384289)
+
+IIIIIIIIII
+100kx [index]         1.420000   0.360000   1.780000 (  1.785599)
+100kx [range]         0.870000   0.000000   0.870000 (  0.875749)
+100kx [s,1]           0.330000   0.000000   0.330000 (  0.326366)
+100kx [s,100]         0.300000   0.000000   0.300000 (  0.304128)
+
+array reference
+100kx [index]         0.030000   0.000000   0.030000 (  0.025789)
+100kx [range]         0.060000   0.000000   0.060000 (  0.060912)
+100kx [s,1]           0.040000   0.000000   0.040000 (  0.042461)
+100kx [s,100]         0.050000   0.000000   0.050000 (  0.051094)
+
+..................................F...

data/test/benchmarks/benchmarks_20071006.txt

@@ -0,0 +1,147 @@
+##########################################
+# OSX before ASET optimizations
+##########################################
+
+test_array_methods
+                          user     system      total        real
+1M <<                 0.290000   0.010000   0.300000 (  0.300562)
+1M []                 0.310000   0.000000   0.310000 (  0.302214)
+....
+test_read_from_open_file
+                          user     system      total        real
+1kx read from file    0.040000   0.200000   0.240000 (  0.519244)
+1kx file.read         0.140000   0.250000   0.390000 (  0.395224)
+.
+test_read_in_chunk_vs_read_in_pieces
+                          user     system      total        real
+1kx read in chunk     0.220000   0.160000   0.380000 (  0.515190)
+1kx read in pieces    0.620000   0.110000   0.730000 (  0.728748)
+1kx read in one block  0.050000   0.110000   0.160000 (  0.160819)
+1kx read in blocks    0.390000   0.110000   0.500000 (  0.495172)
+1kx File.read         0.160000   0.270000   0.430000 (  0.438735)
+.
+test_read_into_arrays
+                          user     system      total        real
+100x unpack to array  0.310000   0.030000   0.340000 (  0.346243)
+100x File.read.unpack  0.940000   0.060000   1.000000 (  1.022879)
+...
+test_unpack_speed
+                          user     system      total        real
+100x unpack           0.300000   0.000000   0.300000 (  0.313970)
+100x str.unpack       0.930000   0.020000   0.950000 (  0.960535)
+............................
+test_element_assignment_speed_for_index
+                          user     system      total        real
+I
+1kx [index]=          0.010000   0.000000   0.010000 (  0.011112)
+1kx [range]=          0.020000   0.000000   0.020000 (  0.014436)
+1kx [s,1]=            0.000000   0.000000   0.000000 (  0.007936)
+
+IIIIIIIIII
+1kx [index]=          0.010000   0.000000   0.010000 (  0.012760)
+1kx [range]=          0.020000   0.000000   0.020000 (  0.014060)
+1kx [s,1]=            0.000000   0.000000   0.000000 (  0.007683)
+
+array reference
+1kx [index]=          0.000000   0.000000   0.000000 (  0.000359)
+1kx [range]=          0.010000   0.000000   0.010000 (  0.001003)
+1kx [s,1]=            0.000000   0.000000   0.000000 (  0.000532)
+
+.
+test_element_reference_speed_for_index
+                          user     system      total        real
+I
+100kx [index]         0.170000   0.000000   0.170000 (  0.170148)
+100kx [range]         0.200000   0.000000   0.200000 (  0.207506)
+100kx [s,1]           0.210000   0.000000   0.210000 (  0.206175)
+100kx [s,10]          0.190000   0.000000   0.190000 (  0.196211)
+100kx [s,100]         0.210000   0.000000   0.210000 (  0.207395)
+
+IIIIIIIIII
+100kx [index]         0.170000   0.000000   0.170000 (  0.171383)
+100kx [range]         0.220000   0.000000   0.220000 (  0.218904)
+100kx [s,1]           0.220000   0.000000   0.220000 (  0.217726)
+100kx [s,10]          0.220000   0.000000   0.220000 (  0.227541)
+100kx [s,100]         0.230000   0.010000   0.240000 (  0.239500)
+
+array reference
+100kx [index]         0.030000   0.000000   0.030000 (  0.026727)
+100kx [range]         0.060000   0.000000   0.060000 (  0.062518)
+100kx [s,1]           0.040000   0.000000   0.040000 (  0.043396)
+100kx [s,10]          0.040000   0.000000   0.040000 (  0.043224)
+100kx [s,100]         0.040000   0.000000   0.040000 (  0.043834)
+
+................................................................
+test_element_assignment_speed_for_ext_arr
+                          user     system      total        real
+
+1kx [index]=          0.120000   0.010000   0.130000 (  0.120187)
+1kx [range]=          0.080000   0.000000   0.080000 (  0.082323)
+1kx [s,1]=            0.110000   0.010000   0.120000 (  0.117434)
+
+array reference
+1kx [index]=          0.110000   0.000000   0.110000 (  0.118859)
+1kx [range]=          0.080000   0.010000   0.090000 (  0.082343)
+1kx [s,1]=            0.110000   0.010000   0.120000 (  0.116168)
+
+.
+test_element_reference_speed_for_ext_arr
+                          user     system      total        real
+
+10kx [index]          0.320000   0.130000   0.450000 (  0.445001)
+10kx [range]          0.450000   0.110000   0.560000 (  0.567785)
+10kx [s,1]            0.310000   0.070000   0.380000 (  0.391895)
+10kx [s,10]           2.490000   0.150000   2.640000 (  2.669212)
+
+array reference
+10kx [index]          0.000000   0.000000   0.000000 (  0.002583)
+10kx [range]          0.010000   0.000000   0.010000 (  0.004749)
+10kx [s,1]            0.000000   0.000000   0.000000 (  0.006787)
+10kx [s,10]           0.000000   0.000000   0.000000 (  0.003268)
+
+....................................
+test_element_assignment_speed_for_index
+                          user     system      total        real
+I
+1kx [index]=          0.020000   0.010000   0.030000 (  0.026291)
+1kx [range]=          5.400000   1.410000   6.810000 (  8.220439)
+1kx [s,1]=            5.620000   1.410000   7.030000 (  8.293661)
+
+IIIIIIIIII
+1kx [index]=          0.020000   0.010000   0.030000 (  0.029998)
+1kx [range]=          5.880000   1.480000   7.360000 (  8.588676)
+1kx [s,1]=            5.580000   1.470000   7.050000 (  8.308494)
+
+array reference
+1kx [index]=          0.000000   0.000000   0.000000 (  0.000329)
+1kx [range]=          0.000000   0.000000   0.000000 (  0.000700)
+1kx [s,1]=            0.000000   0.000000   0.000000 (  0.000570)
+
+.
+test_element_reference_speed_for_index
+                          user     system      total        real
+I
+100kx [index]         1.950000   0.640000   2.590000 (  2.598391)
+100kx [range]         3.130000   0.650000   3.780000 (  3.786401)
+100kx [s,1]           2.390000   0.640000   3.030000 (  3.029791)
+100kx [s,10]          3.410000   0.650000   4.060000 (  4.059696)
+100kx [s,100]        11.250000   0.670000  11.920000 ( 11.970536)
+
+IIIIIIIIII
+100kx [index]         1.610000   0.360000   1.970000 (  1.972972)
+100kx [range]         1.070000   0.010000   1.080000 (  1.080418)
+100kx [s,1]           0.380000   0.000000   0.380000 (  0.382648)
+100kx [s,10]          0.380000   0.000000   0.380000 (  0.383150)
+100kx [s,100]         0.440000   0.000000   0.440000 (  0.439358)
+
+array reference
+100kx [index]         0.020000   0.000000   0.020000 (  0.026210)
+100kx [range]         0.050000   0.000000   0.050000 (  0.050129)
+100kx [s,1]           0.040000   0.000000   0.040000 (  0.033032)
+100kx [s,10]          0.050000   0.000000   0.050000 (  0.055461)
+100kx [s,100]         0.040000   0.000000   0.040000 (  0.032775)
+
+.........................................................................p. ..
+Finished in 82.428089 seconds.
+
+216 tests, 5189 assertions, 0 failures, 0 errors