pick_me_too 1.1.1 → 1.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0b52966a03f64a0e479d224c5c93abed4ca6e3316ae05b88a86f1c9742da799c
-  data.tar.gz: 912417eb4f4c70b4d5211ed0e706f6fbd5be43b518ae4f3be8b198e52d9072b5
+  metadata.gz: 070a1c66bfe69fe534fc449c39a0f187a7b46e3bbcf3bc9827953993cfa30e28
+  data.tar.gz: 41ea453f24ccb5a1602aca774f488295e68280ece7b44c0d12f060295c645d58
 SHA512:
-  metadata.gz: f9391158418a645aa5886a86934d695251e22168870c7df05946dfbc9d4a2a64253f8476574dbe44e3bf40fc6f9f9b4e6c9e1d8a466586baef29c4c729c41a03
-  data.tar.gz: 3e77cab8f0ce92f2ef30434ad5d45eb99003eae157aad21be287636b71ec16a1f373e3018941c8a8094882053806a1d5749667fec9ae9734a137392806a9075d
+  metadata.gz: 7f15740e07eaf7c91548df5cae303e598a13c0e03c9f2af514b6368a497ff60741dfb6b957ee9b4b72cc222575be7ece4faaa5582753e1486fd5f84d2256c734
+  data.tar.gz: 751c64c9aece6e27fd53ecd52af26eec09883542b78077259487804e056594a8f5ab95e4c614fbc8b6dfa206d91e2d4271bec570153487f1da8d4968f0c53030

data/.gitignore

@@ -1,4 +1,4 @@
 .byebug_history
 *.swp
 .ruby-version
-
+pkg

data/CHANGES.md

@@ -1,5 +1,7 @@
 # Change Log
 
+## 1.1.2 *2022-11-6*
+* optimized ternerization code still further
 ## 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*

data/README.md

@@ -18,7 +18,7 @@ picker = PickMeToo.new([["prevention", 1], ["cure", 16]], -> { rng.rand })
 counter = Hash.new 0
 32.times { counter[picker.pick] += 1 }
 counter
-# => {"cure"=>29, "prevention"=>3}
+# => {"cure"=>31, "prevention"=>1}
 
 # you can also use a hash to map items to frequencies
 # frequencies don't need to be whole numbers
@@ -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
-# => {:bar=>15, :foo=>12, :baz=>5}
+# => {:bar=>22, :foo=>5, :baz=>5}
 
 # you don't need to provide your own random number sequence
 picker = PickMeToo({a: 1, b: 2, c: 3})

data/lib/pick_me_too.rb

@@ -10,14 +10,13 @@
 #   # => [:goblin, :orc, :bugbear, :orc, :goblin, :bugbear, :goblin, :goblin, :orc, :goblin]
 #
 #   irrational = PickMeToo.new({e: Math::E, pi: Math::PI})
-#   to.times.map { irrational.pick }
+#   10.times.map { irrational.pick }
 #   # => [:e, :e, :e, :pi, :e, :e, :e, :pi, :pi, :e]
 #
 # Items once picked are "placed back in the urn", so if you pick a cat this doesn't reduce the
-# 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.)
+# probability the next thing you pick is also a cat, and the urn will never be picked empty.
 class PickMeToo
-  VERSION = '1.1.1'
+  VERSION = '1.1.2'
 
   class Error < StandardError; end
 
@@ -42,9 +41,9 @@ class PickMeToo
     if @objects.length == 1
       @picker = ->(_p) { 0 }
     else
-      root = balanced_binary_tree(frequencies)
+      root = optimize(frequencies)
       # compile everything into a nested ternary expression
-      @picker = eval "->(p) { #{ternarize(root, 0)} }"
+      @picker = eval "->(p) { #{ternarize(root)} }"
     end
   end
 
@@ -80,49 +79,74 @@ class PickMeToo
     raise Error, "the following have non-positive frequencies: #{bad.inspect}" if bad.any?
 
     total = good.map(&:last).sum.to_f
-    # sort by size of probability interval -- optimization step
+    # sort by size of probability interval
+    # in general we will want to consider wide intervals before narrow ones
     good.sort_by(&:last).reverse.map { |o, n| [o, n / total] }
   end
 
-  # treat the frequencies as a heap
-  # returns the root of this binary tree
-  def balanced_binary_tree(frequencies)
+  # optimize the order of threshold comparisons to map a random number to an index in the array
+  # of choices
+  def optimize(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])
+    root = build_branch(frequencies)
+    add_thresholds(root, 0)
+    root
+  end
 
-      obj[:left] = left
-      right_idx = left_idx + 1
-      if (right = frequencies[right_idx])
-        obj[:right] = right
-      end
+  def add_thresholds(node, acc)
+    # acc represents the accumulated probability mass known to be before anything in the tree
+    # currently under consideration
+    if (l = node[:left])
+      add_thresholds(l, acc)
+      node[:left_threshold] = acc += l[:sum]
+    end
+    if (r = node[:right])
+      acc = node[:right_threshold] = acc + node[:interval]
+      add_thresholds(r, acc)
     end
-    frequencies[0]
   end
 
-  # what is the sum of all intervals under this node?
-  def sum(obj)
-    return 0 unless obj
+  def build_branch(frequencies)
+    sum = frequencies.sum { |o| o[:interval] }
+    node = frequencies.shift
+    if frequencies.any?
+      if node[:interval] * 3 >= sum
+        # a binary search would be wasteful because the frequencies are so skewed
+        node[:right] = build_branch(frequencies)
+      else
+        # build a binary-branching search tree
+        left, right = frequencies.each_with_index.partition { |*, i| left_branch?(i + 1) }
+        node[:left] = build_branch(left.map(&:first))
+        node[:right] = build_branch(right.map(&:first)) if right.any?
+      end
+    end
+    node[:sum] = sum
+    node
+  end
 
-    obj[:sum] ||= begin
-      left = sum(obj[:left])
-      right = sum(obj[:right])
-      left + right + obj[:interval]
+  # this implements the heap rule for matching a node to its parent
+  # our binary-branching trees are heaps with wider intervals towards the root
+  def left_branch?(index)
+    if index == 1
+      true
+    elsif index < 1
+      false
+    else
+      left_branch?((index - 1) / 2)
     end
   end
 
   # 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]
+  def ternarize(node)
+    l, r = node.values_at :left, :right
+    if l && r
+      "(p > #{node[:left_threshold]} ? (p > #{node[:right_threshold]} ? #{ternarize(r)} : #{node[:index]}) : #{ternarize(l)})"
+    elsif l
+      "(p > #{node[:left_threshold]} ? #{node[:index]} : #{ternarize(l)})"
+    elsif r
+      "(p > #{node[:right_threshold]} ? #{ternarize(r)} : #{node[:index]})"
+    else
+      node[:index]
     end
-    "(p < #{left + acc} ? #{ternarize(node[:left], acc)} : #{right})"
   end
 end

data/test/basic_test.rb

@@ -71,6 +71,30 @@ class BasicTest < Minitest::Test
     end
   end
 
+  # force unary branching
+  def test_big
+    rnd = Random.new 1
+    frequencies = %w[a b c d e f g h].each_with_index.map { |k, i| [k, 2**i] }
+    picker = PickMeToo.new(frequencies, -> { rnd.rand })
+    counter = Hash.new(0)
+    (frequencies.map(&:last).sum * 6000).times { counter[picker.pick] += 1 }
+    frequencies.each do |key, n|
+      assert_equal n, (counter[key] / 6000.0).round, "right number of #{key}"
+    end
+  end
+
+  # force binary branching
+  def test_small
+    rnd = Random.new 1
+    frequencies = %w[a b c d e f g h].each_with_index.map { |k, _i| [k, 1] }
+    picker = PickMeToo.new(frequencies, -> { rnd.rand })
+    counter = Hash.new(0)
+    (frequencies.map(&:last).sum * 6000).times { counter[picker.pick] += 1 }
+    frequencies.each do |key, n|
+      assert_equal n, (counter[key] / 6000.0).round, "right number of #{key}"
+    end
+  end
+
   def test_randomize
     rnd1 = Random.new 1
     rnd2 = Random.new 1

data/test/documentation_test.rb

@@ -13,7 +13,7 @@ class BasicTest < Minitest::Test
     picker = PickMeToo.new([['prevention', 1], ['cure', 16]], -> { rng.rand })
     counter = Hash.new 0
     32.times { counter[picker.pick] += 1 }
-    assert_equal({ 'cure' => 29, 'prevention' => 3 }, counter)
+    assert_equal({ 'cure' => 31, 'prevention' => 1 }, counter)
   end
 
   def test_synopsis_hash
@@ -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({:bar=>15, :foo=>12, :baz=>5}, counter)
+    assert_equal({ bar: 22, foo: 5, 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.1.1
+  version: 1.1.2
 platform: ruby
 authors:
 - David F. Houghton
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-10-30 00:00:00.000000000 Z
+date: 2022-11-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler