pixiedust 0.0.5 → 0.0.6

data/History.txt

@@ -1,3 +1,6 @@
+== 0.0.6 / 2008-05-16
+* Sped up RandomDust some more, using bit masks for 8 and 16 bit values
+
 == 0.0.5 / 2008-05-14
 * Sped up RandomDust, no longer raising errors and catching, 2x faster
 * Added

data/lib/pixiedust.rb

@@ -5,7 +5,7 @@ rescue LoadError
 end
 
 class PixieDust
-  VERSION = '0.0.5'
+  VERSION = '0.0.6'
 end
 
 class Object
@@ -22,33 +22,92 @@ class RandomDust
     RandomDust.between(min, max)
   end
 
+  def RandomDust.bits_needed(val)
+    return val.to_s(2).length
+  end
+
+  def RandomDust.ubytes_needed(val)
+    bits = bits_needed(val)
+    bytes = bits/8
+    if bits%8 > 0
+      bytes += 1
+    end
+    return bytes
+  end
+
+=begin
+    uint32s = bytes_allocated / 4
+    delta = 2**(8*val.size) - val # diff between num of uint32s and bytes needed
+
+      if    delta >= 2**56 && delta < 2**64 then bytes_needed -= 7; unp="C"
+      elsif delta >= 2**48 && delta < 2**56 then bytes_needed -= 6; unp="S"
+      elsif delta >= 2**40 && delta < 2**48 then bytes_needed -= 5; unp="SC"
+      elsif delta >= 2**32 && delta < 2**40 then bytes_needed -= 4; unp="L"
+      #else                                                          unp=""
+      #end
+      #if    delta >= 2**24 && delta < 2**32 then bytes_needed -= 3; unp="C"
+      elsif delta >= 2**24 && delta < 2**32 then bytes_needed -= 3; unp="C"
+      elsif delta >= 2**16 && delta < 2**24 then bytes_needed -= 2; unp="S"
+      elsif delta >= 2**8  && range < 2**16 then bytes_needed -= 1; unp="SC"
+      else                                                          unp=""
+      end
+      puts "delta is #{delta}, unp is #{unp}"
+=end
+
   def RandomDust.between(min, max)
+    if min == max then raise "min == max in RandomDust.between"; end
     if min > max then raise "min > max in RandomDust.between"; end
 
     value = 0
+    attempts = 0
     range = max - min
-    bytes_used = range.size
-    uints = range.size/4
-
-    delta = 2**(8*range.size) - range
+    byte_count = RandomDust.ubytes_needed(range)
+    uint32s = byte_count / 4
+    bytes = byte_count % 4
 
-    if    delta >  16777216                  then bytes_used -= 3; unp="C"
-    elsif delta >= 65536 && delta < 16777216 then bytes_used -= 2; unp="S"
-    elsif delta >= 256   && range < 65536    then bytes_used -= 1; unp="SC"
-    else                                                           unp=""
+    case bytes
+    when 3
+      unp = 'SC'
+    when 2
+      unp = 'S'
+    when 1
+      unp = 'C'
+    else
+      unp = ''
     end
 
     while true
-      rand = OpenSSL::Random.random_bytes(bytes_used)
-      parts = rand.unpack(unp + "L"*(uints))
-      value = parts.shift
-      parts.length.upto(uints - 1){ |x|
-        value += parts[x] << 32*x
-      }
+      attempts += 1
+      rand = OpenSSL::Random.random_bytes(byte_count) # XXX: grab extra to save time
+
+      # handle single byte values specially
+      # 255 & 0b0111_1111 # mask the highest bit
+      if byte_count == 1
+        value = rand.unpack('C').first
+
+        bits = bits_needed(range)
+        value = value & (2**bits - 1)
+      elsif byte_count == 2
+        value = rand.unpack('S').first
+
+        bits = bits_needed(range)
+        value = value & (2**bits - 1)
+      else
+        parts = rand.unpack(unp + "L"*(uint32s))
+        value = parts.shift
+        if bytes == 3
+          p = parts.shift
+          value += p << 16
+        end
+        parts.length.upto(uint32s - 1) { |x|
+          value += parts[x] << 32 * x
+        }
+      end
 
       value += min
 
       unless value < min || value > max
+        open('pixiedust-attempts.txt', "a+") { |f| f << "#{attempts} needed (#{min}-#{max} range\n" }
         return value
       end
     end

data/test/random_dust.rb

@@ -3,40 +3,70 @@ require 'spec'
 require 'statarray'
 begin
   require 'ruby-prof'
-  profile = false
+  profile = true
 rescue LoadError
 end
 
 require "#{File.dirname(__FILE__)}/../lib/pixiedust"
 
 describe RandomDust do
-  it "Shouldn't generate numbers outside of range" do
-    min = -5
-    max = 15
-    if profile then RubyProf.start; end
-    1000.times {
-      val = RandomDust.between(min,max)
-      val.should <= max
-      val.should >= min
+  #it "Shouldn't generate numbers outside of range" do
+  #  min = -5
+  #  max = 15
+  #  if profile then RubyProf.start; end
+  #  1000.times {
+  #    val = RandomDust.between(min,max)
+  #    val.should <= max
+  #    val.should >= min
+  #  }
+  #  if profile
+  #    profile_data = RubyProf.stop
+  #    printer = RubyProf::FlatPrinter.new(profile_data)
+  #    printer.print(open("profile-#{DateDust.now_str}.txt", "w+"), 0)
+  #  end
+  #end
+
+  it "Should know how many bytes are really needed by a number" do
+    RandomDust.ubytes_needed(1).should == 1
+    RandomDust.ubytes_needed(255).should == 1
+    RandomDust.ubytes_needed(256).should == 2
+    RandomDust.ubytes_needed(65535).should == 2
+    RandomDust.ubytes_needed(65536).should == 3
+    RandomDust.ubytes_needed(16777215).should == 3
+    RandomDust.ubytes_needed(16777216).should == 4
+    RandomDust.ubytes_needed(18446744073709551616).should == 9
+
+  end
+
+  it "Should generate numbers at ends of range" do
+    min = 0
+    max = [1, 4, 555]
+
+    max.each { |x|
+      vlist = []
+      2000.times {
+        vlist << RandomDust.between(min, x)
+      }
+      vstat = vlist.to_statarray
+      #puts "min: #{min}, min seen: #{vstat.min}"
+      #puts "max: #{x}, max seen: #{vstat.max}"
+      vstat.min.should == min
+      vstat.max.should == x
     }
-    if profile
-      profile_data = RubyProf.stop
-      printer = RubyProf::FlatPrinter.new(profile_data)
-      printer.print(open("profile-#{DateDust.now_str}.txt", "w+"), 0)
-    end
   end
 
   it "Should generate numbers at ends of range" do
     min = -5
     max = 5
-    hit_min = false
-    hit_max = false
+    vlist = []
     100.times {
-      if RandomDust.between(min, max) == min; then hit_min = true; end
-      if RandomDust.between(min, max) == max; then hit_max = true; end
+      vlist << RandomDust.between(min, max)
     }
-    hit_min.should == true
-    hit_max.should == true
+    vstat = vlist.to_statarray
+    #puts "min:    #{vstat.min}"
+    #puts "max:    #{vstat.max}"
+    vstat.min.should == min
+    vstat.max.should == max
   end
 
   it "Should have roughly equal counts of numbers in range" do
@@ -52,16 +82,14 @@ describe RandomDust do
     }
 
     counts = []
-    values.keys.each { |k|
+    values.keys.sort.each { |k|
       counts << values[k]
+      #puts "#{k}: #{values[k]}"
     }
 
-    ca = counts.to_statarray
-    #puts "min:    #{ca.min}"
-    #puts "max:    #{ca.max}"
-    #puts "median: #{ca.median}"
-    #puts "stddev: #{ca.stddev}"
-    ca.stddev.should < 100
-
+    cstat = counts.to_statarray
+    #puts "median: #{cstat.median}"
+    #puts "stddev: #{cstat.stddev}"
+    cstat.stddev.should < 50
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: pixiedust
 version: !ruby/object:Gem::Version 
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors: 
 - Jonathan Wilkins
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-05-14 00:00:00 -07:00
+date: 2008-05-16 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency