pick_me_too 1.1.0 → 1.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52db253007776ea2ede6caa43361e3e260660accdd4a0b1eb1439532f1ef92d3
-  data.tar.gz: 7f370bb747440c33062b8193a3edffb2fe0ac752493735366ea4d7161ded0c4a
+  metadata.gz: 070a1c66bfe69fe534fc449c39a0f187a7b46e3bbcf3bc9827953993cfa30e28
+  data.tar.gz: 41ea453f24ccb5a1602aca774f488295e68280ece7b44c0d12f060295c645d58
 SHA512:
-  metadata.gz: 4f70d7864e25ca65ea5ca660c1964f0e79229da429e2414539ffaf3a65da50b2a30f70f186266532adbf6115b4e7e7a9bbd7b0b8727994c690876e9648ff0ab7
-  data.tar.gz: bcf37dedb54b3304367799a16c3521541fa57c0db4dd4e819220dcb9ca85ff804c37e1b026e7867cf90a8990575d10e2b7ac0b452433d74760a358301b1eec8f
+  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,9 @@
 # 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*
 * added the `randomize!` method
 ## 1.0.0 *2022-8-14*

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
-# => {:foo=>13, :bar=>12, :baz=>7}
+# => {: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.0'
+  VERSION = '1.1.2'
 
   class Error < StandardError; end
 
@@ -42,11 +41,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 = optimize(frequencies)
       # compile everything into a nested ternary expression
-      @picker = eval "->(p) { #{ternarize(probability_tree)} }"
+      @picker = eval "->(p) { #{ternarize(root)} }"
     end
   end
 
@@ -82,94 +79,74 @@ 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] }
+    # 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
 
-  # reduce the probability tree to nested ternary expressions
-  def ternarize(ptree)
-    p, left, right = ptree.values_at :p, :left, :right
-    left = left.is_a?(Numeric) ? left : ternarize(left)
-    right = right.is_a?(Numeric) ? right : ternarize(right)
-    "(p > #{p} ? #{right} : #{left})"
-  end
-
-  def probabilities(frequencies, tree)
-    tree = sum_probabilities(tree, 0)
-    replace_frequencies_with_indices(tree, frequencies.each_with_index.to_a)
-    tree
+  # 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 } }
+    root = build_branch(frequencies)
+    add_thresholds(root, 0)
+    root
   end
 
-  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)
+  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 right.is_a?(Numeric)
-      i = frequencies.index { |v,| v == right }
-      *, i = frequencies.slice!(i)
-      tree[:right] = i
-    else
-      replace_frequencies_with_indices(right, frequencies)
+    if (r = node[:right])
+      acc = node[:right_threshold] = acc + node[:interval]
+      add_thresholds(r, acc)
     end
   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
-
-  # 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
+  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
-    half = total / 2.0
-    right = [nums.slice!(max_index)]
-    if max >= half
-      [bifurcate(nums), right]
+    node[:sum] = sum
+    node
+  end
+
+  # 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
-      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)]
+      left_branch?((index - 1) / 2)
     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)
+    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
   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({ foo: 13, bar: 12, baz: 7 }, 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.0
+  version: 1.1.2
 platform: ruby
 authors:
 - David F. Houghton
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-08-21 00:00:00.000000000 Z
+date: 2022-11-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -107,7 +107,7 @@ homepage: https://github.com/dfhoughton/pick_me_too
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -122,9 +122,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
-signing_key: 
+rubygems_version: 3.3.7
+signing_key:
 specification_version: 4
 summary: Randomly select items from a list with specified frequencies
 test_files: