pick_me_too 1.0.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ac4906dd27b93c363b8e9af9e82ffe636c3149519d79654a7b8a2f0a2bdfdf25
-  data.tar.gz: a902f070e98dc4fab62695fe7e556e499ad33c3d1dd2b0dc21764923b37f310f
+  metadata.gz: 0b52966a03f64a0e479d224c5c93abed4ca6e3316ae05b88a86f1c9742da799c
+  data.tar.gz: 912417eb4f4c70b4d5211ed0e706f6fbd5be43b518ae4f3be8b198e52d9072b5
 SHA512:
-  metadata.gz: 73f4816247afc780c1dae9c5399fbc1280db8795d191f575fd4829d39ea8b5f39f61974d9953a0883f25160dcd256feabefe0e75ddc323728523c9fa3a2c997c
-  data.tar.gz: ef409f69716637d562c45b52d2ea71843e2bfb3fe568d2dfd82447084a27cd93cae9fdf99f1a4decbe37036db1639d2332fe6debfb13ed5f268c5dffae632456
+  metadata.gz: f9391158418a645aa5886a86934d695251e22168870c7df05946dfbc9d4a2a64253f8476574dbe44e3bf40fc6f9f9b4e6c9e1d8a466586baef29c4c729c41a03
+  data.tar.gz: 3e77cab8f0ce92f2ef30434ad5d45eb99003eae157aad21be287636b71ec16a1f373e3018941c8a8094882053806a1d5749667fec9ae9734a137392806a9075d

data/CHANGES.md

@@ -1,4 +1,8 @@
 # Change Log
 
+## 1.1.1 *2022-10-30*
+* simplified, and perhaps improved, the code to compile the frequency list into a nested ternary expression; ***NOTE***: I am not considering this a breaking change, though it may change the sequence of items picked by a fixed random number sequence
+## 1.1.0 *2022-8-21*
+* added the `randomize!` method
 ## 1.0.0 *2022-8-14*
 * initial release

data/README.md

@@ -29,7 +29,7 @@ picker = PickMeToo.new({foo: 1, bar: 2, baz: 0.5}, -> { rng.rand })
 counter = Hash.new 0
 32.times { counter[picker.pick] += 1 }
 counter
-# => {:foo=>13, :bar=>12, :baz=>7}
+# => {:bar=>15, :foo=>12, :baz=>5}
 
 # you don't need to provide your own random number sequence
 picker = PickMeToo({a: 1, b: 2, c: 3})
@@ -47,7 +47,7 @@ of frequencies:
 
 What you need is something that will randomly pick these things for you with the frequencies you specify.
 
-One way to do this would be to make an array, filling it with the items according to the frequencies specified
+One way to do this would be to make an array, fill it with the items according to the frequencies specified,
 and then pick randomly from the array:
 
 ```ruby
@@ -72,7 +72,7 @@ This is the "[urn](https://en.wikipedia.org/wiki/Urn_problem)" containing the it
 
 "Fill" the urn.
 
-The required `frequencies` parameter must be something that is effectivly a list of pairs:
+The required `frequencies` parameter must be something that is effectively a list of pairs:
 things to pick paired with their frequency. The "frequency" is just any positive number.
 
 The optional `rnd` parameter is a `Proc` that when called returns a number, ideally in the interval
@@ -88,6 +88,18 @@ This constructor method will raise a `PickMeToo::Error` if
 
 Draw an item from the urn.
 
+## `PickMeToo#randomize!([rnd])`
+
+Replace the random number generator.
+If the optional argument is omitted, the replacement is just
+
+```ruby
+-> { rand }
+```
+
+This is useful if you want to switch from a seeded random number generator
+to something more truly random.
+
 # Installation
 
 `pick_me_too` is available as a gem, so one installs it as one does gems.

data/lib/pick_me_too.rb

@@ -2,7 +2,7 @@
 
 ##
 # An "urn" from which you can pick things with specified frequencies.
-# 
+#
 #   require 'pick_me_too'
 #
 #   wandering_monsters = PickMeToo.new({goblin: 10, bugbear: 2, orc: 5, spider: 3, troll: 1})
@@ -17,14 +17,14 @@
 # probability the next thing you pick is also a cat, and the urn will never be picked empty. (And of course
 # this is all a metaphor.)
 class PickMeToo
-  VERSION = '1.0.0'
+  VERSION = '1.1.1'
 
   class Error < StandardError; end
 
   ##
   # "Fill" the urn.
   #
-  # The required frequencies parameter must be something that is effectivly a list of pairs:
+  # The required frequencies parameter must be something that is effectively a list of pairs:
   # things to pick paired with their frequency. The "frequency" is just any positive number.
   #
   # The optional rnd parameter is a Proc that when called returns a number, ideally in the interval
@@ -42,11 +42,9 @@ class PickMeToo
     if @objects.length == 1
       @picker = ->(_p) { 0 }
     else
-      frequencies = frequencies.map(&:last)
-      balanced_binary_tree = bifurcate(frequencies.dup)
-      probability_tree = probabilities(frequencies, balanced_binary_tree)
+      root = balanced_binary_tree(frequencies)
       # compile everything into a nested ternary expression
-      @picker = eval "->(p) { #{ternerize(probability_tree)} }"
+      @picker = eval "->(p) { #{ternarize(root, 0)} }"
     end
   end
 
@@ -56,6 +54,19 @@ class PickMeToo
     @objects[@picker.call(@rnd.call)]
   end
 
+  ##
+  # Replace the random number generator.
+  #
+  # If the optional argument is omitted, the replacement is just
+  #
+  #   -> { rand }
+  #
+  # This is useful if you want to switch from a seeded random number generator
+  # to something more truly random.
+  def randomize!(rnd = -> { rand })
+    @rnd = rnd
+  end
+
   private
 
   # sanity check and normalization of frequencies
@@ -69,94 +80,49 @@ class PickMeToo
     raise Error, "the following have non-positive frequencies: #{bad.inspect}" if bad.any?
 
     total = good.map(&:last).sum.to_f
-    good.map { |o, n| [o, n / total] }
-  end
-
-  # reduce the probability tree to nested ternary expressions
-  def ternerize(ptree)
-    p, left, right = ptree.values_at :p, :left, :right
-    left = left.is_a?(Numeric) ? left : ternerize(left)
-    right = right.is_a?(Numeric) ? right : ternerize(right)
-    "(p > #{p} ? #{right} : #{left})"
+    # sort by size of probability interval -- optimization step
+    good.sort_by(&:last).reverse.map { |o, n| [o, n / total] }
   end
 
-  def probabilities(frequencies, tree)
-    tree = sum_probabilities(tree, 0)
-    replace_frequencies_with_indices(tree, frequencies.each_with_index.to_a)
-    tree
-  end
+  # treat the frequencies as a heap
+  # returns the root of this binary tree
+  def balanced_binary_tree(frequencies)
+    frequencies = frequencies.each_with_index.map { |(*, i), idx| { interval: i, index: idx } }
+    frequencies.each do |obj|
+      left_idx = obj[:index] * 2 + 1
+      next unless (left = frequencies[left_idx])
 
-  def replace_frequencies_with_indices(tree, frequencies)
-    left, right = tree.values_at :left, :right
-    if left.is_a?(Numeric)
-      i = frequencies.index { |v,| v == left }
-      *, i = frequencies.slice!(i)
-      tree[:left] = i
-    else
-      replace_frequencies_with_indices(left, frequencies)
-    end
-    if right.is_a?(Numeric)
-      i = frequencies.index { |v,| v == right }
-      *, i = frequencies.slice!(i)
-      tree[:right] = i
-    else
-      replace_frequencies_with_indices(right, frequencies)
+      obj[:left] = left
+      right_idx = left_idx + 1
+      if (right = frequencies[right_idx])
+        obj[:right] = right
+      end
     end
+    frequencies[0]
   end
 
-  # convert the frequency numbers to probabilities
-  def sum_probabilities(tree, base)
-    left, right = tree
-    p = left.flatten.sum + base
-    left = left.length == 1 ? left.first : sum_probabilities(left, base)
-    right = right.length == 1 ? right.first : sum_probabilities(right, p)
-    { p: p, left: left, right: right }
-  end
+  # what is the sum of all intervals under this node?
+  def sum(obj)
+    return 0 unless obj
 
-  # distribute the frequencies so their as balanced as possible
-  # the better to reduce expected length of the binary search
-  def bifurcate(nums)
-    return nums if nums.length < 2
-
-    max = total = 0
-    max_index = -1
-    # make one loop find all these things
-    nums.each_with_index do |n, i|
-      total += n
-      if n > max
-        max = n
-        max_index = i
-      end
-    end
-    half = total / 2.0
-    right = [nums.slice!(max_index)]
-    if max >= half
-      [bifurcate(nums), right]
-    else
-      gap = half - max
-      while rv = fit_gap(gap, nums)
-        removed, remaining_gap = rv
-        right << removed
-        break unless gap = remaining_gap
-      end
-      [bifurcate(nums), bifurcate(right)]
+    obj[:sum] ||= begin
+      left = sum(obj[:left])
+      right = sum(obj[:right])
+      left + right + obj[:interval]
     end
   end
 
-  # look for the frequency best suited to balance the two branches
-  def fit_gap(gap, nums)
-    best_index = 0
-    best_fit = (gap - nums[0]).abs
-    nums.each_with_index.drop(1).each do |n, i|
-      fit = (gap - n).abs
-      if fit < best_fit
-        best_index = i
-        best_fit = fit
-      end
-    end
-    if nums[best_index] < gap * 2
-      n = nums.slice!(best_index)
-      [n, n < gap ? gap - n : nil]
+  # reduce the probability tree to nested ternary expressions
+  def ternarize(node, acc)
+    left = sum(node[:left])
+    return node[:index] if left == 0 # this is a leaf
+
+    right = if (r = node[:right])
+              increment = acc + left + node[:interval]
+              "(p < #{increment} ? #{node[:index]} : #{ternarize(r, increment)})"
+            else
+              node[:index]
     end
+    "(p < #{left + acc} ? #{ternarize(node[:left], acc)} : #{right})"
   end
 end

data/pick_me_too.gemspec

@@ -25,7 +25,7 @@ Gem::Specification.new do |s|
   s.require_paths         = ['lib']
 
   s.add_development_dependency 'bundler', '~> 1.7'
-  s.add_development_dependency 'byebug', '~> 9.1.0'
+  s.add_development_dependency 'byebug', '~> 9.1', '>= 9.1.0'
   s.add_development_dependency 'json', '~> 2'
   s.add_development_dependency 'minitest', '~> 5'
   s.add_development_dependency 'rake', '~> 10.0'

data/test/basic_test.rb

@@ -19,7 +19,7 @@ class BasicTest < Minitest::Test
 
   def test_hash
     rnd = Random.new 1
-    picker = PickMeToo.new({'cat' => 2, 'dog' => 1}, -> { rnd.rand })
+    picker = PickMeToo.new({ 'cat' => 2, 'dog' => 1 }, -> { rnd.rand })
     counter = Hash.new(0)
     3000.times { counter[picker.pick] += 1 }
     assert_equal 2, (counter['cat'] / 1000.0).round, 'right number of cats'
@@ -70,4 +70,19 @@ class BasicTest < Minitest::Test
       PickMeToo.new([['foo', nil]])
     end
   end
+
+  def test_randomize
+    rnd1 = Random.new 1
+    rnd2 = Random.new 1
+    rnd3 = Random.new 2
+    picker1 = PickMeToo.new({ foo: 1, bar: 2, baz: 3 }, -> { rnd1.rand })
+    picker2 = PickMeToo.new({ foo: 1, bar: 2, baz: 3 }, -> { rnd2.rand })
+    ar1 = Array.new(100) { picker1.pick }
+    ar2 = Array.new(100) { picker2.pick }
+    assert_equal ar1, ar2, 'with the same seeds we get the same sequences'
+    picker2.randomize! -> { rnd3.rand }
+    ar1 = Array.new(100) { picker1.pick }
+    ar2 = Array.new(100) { picker2.pick }
+    refute_equal ar1, ar2, 'if we randomize a picker, we get a new sequence'
+  end
 end

data/test/documentation_test.rb

@@ -21,6 +21,6 @@ class BasicTest < Minitest::Test
     picker = PickMeToo.new({ foo: 1, bar: 2, baz: 0.5 }, -> { rng.rand })
     counter = Hash.new 0
     32.times { counter[picker.pick] += 1 }
-    assert_equal({ foo: 13, bar: 12, baz: 7 }, counter)
+    assert_equal({:bar=>15, :foo=>12, :baz=>5}, counter)
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pick_me_too
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.1
 platform: ruby
 authors:
 - David F. Houghton
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-08-14 00:00:00.000000000 Z
+date: 2022-10-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -29,6 +29,9 @@ dependencies:
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
+      - !ruby/object:Gem::Version
+        version: '9.1'
+    - - ">="
       - !ruby/object:Gem::Version
         version: 9.1.0
   type: :development
@@ -36,6 +39,9 @@ dependencies:
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
+      - !ruby/object:Gem::Version
+        version: '9.1'
+    - - ">="
       - !ruby/object:Gem::Version
         version: 9.1.0
 - !ruby/object:Gem::Dependency