games_dice 0.2.3 → 0.2.4

data/.travis.yml

@@ -7,4 +7,8 @@ rvm:
   - rbx-19mode
   - ruby-head
   - ree
-
+  - jruby-18mode
+  - jruby-19mode
+env:
+  global:
+    - "JRUBY_OPTS=-Xcext.enabled=true"

data/lib/games_dice/bunch.rb

@@ -158,12 +158,8 @@ class GamesDice::Bunch
     return @probabilities if @probabilities
     @probabilities_complete = true
 
-    # TODO: It is possible to optimise this slightly by combining already-calculated values
-    # Adding dice is same as multiplying probability sets for that number of dice
-    # Combine(probabililities_3_dice, probabililities_single_die) == Combine(probabililities_2_dice, probabililities_2_dice)
-    # It is possible to minimise the total number of multiplications, gaining about 30% efficiency, with careful choices
-    single_roll_probs = @single_die.probabilities.to_h
     if @keep_mode && @ndice > @keep_number
+      single_roll_probs = @single_die.probabilities.to_h
       preadd_probs = {}
       single_roll_probs.each { |k,v| preadd_probs[k.to_s] = v }
 
@@ -180,15 +176,12 @@ class GamesDice::Bunch
         combined_probs[total] ||= 0.0
         combined_probs[total] += v
       end
+      @probabilities = GamesDice::Probabilities.from_h( combined_probs )
     else
-      combined_probs = single_roll_probs.clone
-      (@ndice-1).times do
-        combined_probs = prob_accumulate combined_probs, single_roll_probs
-      end
+      @probabilities = GamesDice::Probabilities.repeat_distribution( @single_die.probabilities, @ndice )
     end
 
-    @probabilities_min, @probabilities_max = combined_probs.keys.minmax
-    @probabilities = GamesDice::Probabilities.new( combined_probs )
+    return @probabilities
   end
 
   # Simulates rolling the bunch of identical dice
@@ -270,26 +263,10 @@ class GamesDice::Bunch
 
   private
 
-  # combines two sets of probabilities where the end result is the first set of keys plus
-  # the second set of keys, at the associated probailities of the values
-  def prob_accumulate first_probs, second_probs
-    accumulator = Hash.new
-
-    first_probs.each do |v1,p1|
-      second_probs.each do |v2,p2|
-        v3 = v1 + v2
-        p3 = p1 * p2
-        accumulator[v3] ||= 0.0
-        accumulator[v3] += p3
-      end
-    end
-
-    accumulator
-  end
-
   # combines two sets of probabilities, as above, except tracking unique permutations
   def prob_accumulate_combinations so_far, die_probs, keep_rule = nil
     accumulator = Hash.new
+    accumulator.default = 0.0
 
     so_far.each do |sig,p1|
       combo = sig.split(';').map { |s| s.to_i }
@@ -297,33 +274,32 @@ class GamesDice::Bunch
       case keep_rule
       when nil then
         die_probs.each do |v2,p2|
-          new_sig = (combo + [v2]).sort.join(';')
+          new_sig = (combo + [v2]).sort!.join(';')
           p3 = p1 * p2
-          accumulator[new_sig] ||= 0.0
           accumulator[new_sig] += p3
         end
       when :keep_best then
         need_more_than = combo.min
+        len = combo.size
         die_probs.each do |v2,p2|
           if v2 > need_more_than
-            new_sig = (combo + [v2]).sort[1..combo.size].join(';')
+            new_sig = (combo + [v2]).sort![1,len].join(';')
           else
             new_sig = sig
           end
           p3 = p1 * p2
-          accumulator[new_sig] ||= 0.0
           accumulator[new_sig] += p3
         end
       when :keep_worst then
         need_less_than = combo.max
+        len = combo.size
         die_probs.each do |v2,p2|
           if v2 < need_less_than
-            new_sig = (combo + [v2]).sort[0..(combo.size-1)].join(';')
+            new_sig = (combo + [v2]).sort![0,len].join(';')
           else
             new_sig = sig
           end
           p3 = p1 * p2
-          accumulator[new_sig] ||= 0.0
           accumulator[new_sig] += p3
         end
       end
@@ -332,34 +308,4 @@ class GamesDice::Bunch
     accumulator
   end
 
-  # Generates all sets of [throw_away,may_keep_exactly,keep_preferentially,combinations] that meet
-  # criteria for correct total number of dice and keep dice. These then need to be assessed for every
-  # die value by the caller to get a full set of probabilities
-  def generate_item_counts total_dice, keep_dice
-    # Constraints are:
-    # may_keep_exactly must be at least 1, and at most is all the dice
-    # keep_preferentially plus may_keep_exactly must be >= keep_dice, but keep_preferentially < keep dice
-    # sum of all three always == total_dice
-    item_counts = []
-    (1..total_dice).each do |may_keep_exactly|
-      min_kp = [keep_dice - may_keep_exactly, 0].max
-      max_kp = [keep_dice - 1, total_dice - may_keep_exactly].min
-      (min_kp..max_kp).each do |keep_preferentially|
-        counts = [ total_dice - may_keep_exactly - keep_preferentially, may_keep_exactly, keep_preferentially ]
-        counts << combinations(counts)
-        item_counts << counts
-      end
-    end
-    item_counts
-  end
-
-  # How many unique ways can a set of items, some of which are identical, be arranged?
-  def combinations item_counts
-    item_counts = item_counts.map { |i| Integer(i) }.select { |i| i > 0 }
-    total_items = item_counts.inject(:+)
-    numerator = 1.upto(total_items).inject(:*)
-    denominator = item_counts.map { |i| 1.upto(i).inject(:*) }.inject(:*)
-    numerator / denominator
-  end
-
 end # class Bunch

data/lib/games_dice/complex_die.rb

@@ -75,8 +75,10 @@ class GamesDice::ComplexDie
     @result.explain_value
   end
 
+  # The minimum possible result from a call to #roll. This is not always the same as the theoretical
+  # minimum, due to limits on the maximum number of rerolls.
   # @!attribute [r] min
-  # @return [Integer] Minimum possible result from a call to #roll
+  # @return [Integer]
   def min
     return @min_result if @min_result
     @min_result, @max_result = [probabilities.min, probabilities.max]
@@ -115,19 +117,17 @@ class GamesDice::ComplexDie
     elsif @rerolls
       prob_hash = recursive_probabilities
     elsif @maps
-      probs = @basic_die.probabilities.to_h
       prob_hash = {}
-      probs.each do |v,p|
+      @basic_die.probabilities.each do |v,p|
         m, n = calc_maps(v)
         prob_hash[m] ||= 0.0
         prob_hash[m] += p
       end
     else
-      prob_hash = @basic_die.probabilities.to_h
+      @probabilities = @basic_die.probabilities
+      return @probabilities
     end
-    @prob_ge = {}
-    @prob_le = {}
-    @probabilities = GamesDice::Probabilities.new( prob_hash )
+    @probabilities = GamesDice::Probabilities.from_h( prob_hash )
   end
 
   # Simulates rolling the die
@@ -250,9 +250,7 @@ class GamesDice::ComplexDie
 
     (1..@basic_die.sides).each do |v|
       # calculate value, recurse if there is a reroll
-      result_so_far = prior_result ? prior_result.clone : GamesDice::DieResult.new(v,roll_reason)
-      result_so_far.add_roll(v,roll_reason) if prior_result
-      rerolls_remaining = rerolls_left ? rerolls_left.clone : @rerolls.map { |rule| rule.limit }
+      result_so_far, rerolls_remaining = calc_result_so_far(prior_result, rerolls_left, v, roll_reason )
 
       # Find which rule, if any, is being triggered
       rule_idx = @rerolls.zip(rerolls_remaining).find_index do |rule,remaining|
@@ -279,7 +277,19 @@ class GamesDice::ComplexDie
       end
 
     end
-    probabilities.clone
+    probabilities
+  end
+
+  def calc_result_so_far prior_result, rerolls_left, v, roll_reason
+    if prior_result
+      result_so_far = prior_result.clone
+      result_so_far.add_roll(v,roll_reason)
+      rerolls_remaining = rerolls_left.clone
+    else
+      result_so_far = GamesDice::DieResult.new(v,roll_reason)
+      rerolls_remaining = @rerolls.map { |rule| rule.limit }
+    end
+    [result_so_far, rerolls_remaining]
   end
 
 end # class ComplexDie

data/lib/games_dice/dice.rb

@@ -102,7 +102,7 @@ class GamesDice::Dice
   # @return [GamesDice::Probabilities] Probability distribution of dice.
   def probabilities
     return @probabilities if @probabilities
-    probs = @bunch_multipliers.zip(@bunches).inject( GamesDice::Probabilities.new( { @offset => 1.0 } ) ) do |probs, mb|
+    probs = @bunch_multipliers.zip(@bunches).inject( GamesDice::Probabilities.new( [1.0], @offset ) ) do |probs, mb|
       m,b = mb
       GamesDice::Probabilities.add_distributions_mult( 1, probs, m, b.probabilities )
     end

data/lib/games_dice/die.rb

@@ -55,8 +55,7 @@ class GamesDice::Die
   # Calculates probability distribution for this die.
   # @return [GamesDice::Probabilities] probability distribution of the die
   def probabilities
-    return @probabilities if @probabilities
-    @probabilities = GamesDice::Probabilities.for_fair_die( @sides )
+    @probabilities ||= GamesDice::Probabilities.for_fair_die( @sides )
   end
 
   # Simulates rolling the die

data/lib/games_dice/probabilities.rb

@@ -21,52 +21,66 @@
 class GamesDice::Probabilities
 
   # Creates new instance of GamesDice::Probabilities.
-  # @param [Hash] prob_hash A hash representation of the distribution, each key is an integer result,
-  #   and the matching value is probability of getting that result
+  # @param [Array<Float>] probs Each entry in the array is the probability of getting a result
+  # @param [Integer] offset The result associated with index of 0 in the array
   # @return [GamesDice::Probabilities]
-  def initialize( prob_hash = { 0 => 1.0 } )
+  def initialize( probs = [1.0], offset = 0 )
     # This should *probably* be validated in future, but that would impact performance
-    @ph = prob_hash
+    @probs = probs
+    @offset = offset
   end
 
   # @!visibility private
-  # the Hash representation of probabilities.
-  attr_reader :ph
+  # the Array, Offset representation of probabilities.
+  def to_ao
+    [ @probs, @offset ]
+  end
+
+  # Iterates through value, probability pairs
+  # @yieldparam [Integer] result A result that may be possible in the dice scheme
+  # @yieldparam [Float] probability Probability of result, in range 0.0..1.0
+  # @return [GamesDice::Probabilities] this object
+  def each
+    @probs.each_with_index { |p,i| yield( i+@offset, p ) }
+    return self
+  end
 
   # A hash representation of the distribution. Each key is an integer result,
   # and the matching value is probability of getting that result. A new hash is generated on each
   # call to this method.
   # @return [Hash]
   def to_h
-    @ph.clone
+    GamesDice::Probabilities.prob_ao_to_h( @probs, @offset )
   end
 
   # @!attribute [r] min
   # Minimum result in the distribution
   # @return [Integer]
   def min
-    (@minmax ||= @ph.keys.minmax )[0]
+    @offset
   end
 
   # @!attribute [r] max
   # Maximum result in the distribution
   # @return [Integer]
   def max
-    (@minmax ||= @ph.keys.minmax )[1]
+    @offset + @probs.count() - 1
   end
 
   # @!attribute [r] expected
   # Expected value of distribution.
   # @return [Float]
   def expected
-    @expected ||= @ph.inject(0.0) { |accumulate,p| accumulate + p[0] * p[1] }
+    @expected ||= calc_expected
   end
 
   # Probability of result equalling specific target
   # @param [Integer] target
   # @return [Float] in range (0.0..1.0)
   def p_eql target
-    @ph[ Integer(target) ] || 0.0
+    i = Integer(target) - @offset
+    return 0.0 if i < 0 || i >= @probs.count
+    @probs[ i ]
   end
 
   # Probability of result being greater than specific target
@@ -86,7 +100,7 @@ class GamesDice::Probabilities
 
     return 1.0 if target <= min
     return 0.0 if target > max
-    @prob_ge[target] = @ph.select {|k,v| target <= k}.inject(0.0) {|so_far,pv| so_far + pv[1] }
+    @prob_ge[target] = @probs[target-@offset,@probs.count-1].inject(0.0) {|so_far,p| so_far + p }
   end
 
   # Probability of result being equal to or less than specific target
@@ -99,7 +113,7 @@ class GamesDice::Probabilities
 
     return 1.0 if target >= max
     return 0.0 if target < min
-    @prob_le[target] = @ph.select {|k,v| target >= k}.inject(0.0) {|so_far,pv| so_far + pv[1] }
+    @prob_le[target] = @probs[0,1+target-@offset].inject(0.0) {|so_far,p| so_far + p }
   end
 
   # Probability of result being less than specific target
@@ -109,16 +123,50 @@ class GamesDice::Probabilities
     p_le( Integer(target) - 1 )
   end
 
+  # Probability distribution derived from this one, where we know (or are only interested in
+  # situations where) the result is greater than or equal to target.
+  # @param [Integer] target
+  # @return [GamesDice::Probabilities] new distribution.
+  def given_ge target
+    target = Integer(target)
+    target = min if min > target
+    p = p_ge(target)
+    raise "There is no valid distribution given a result >= #{target}" unless p > 0.0
+    mult = 1.0/p
+    new_probs = @probs[target-@offset,@probs.count-1].map { |x| x * mult }
+    GamesDice::Probabilities.new( new_probs, target )
+  end
+
+  # Probability distribution derived from this one, where we know (or are only interested in
+  # situations where) the result is less than or equal to target.
+  # @param [Integer] target
+  # @return [GamesDice::Probabilities] new distribution.
+  def given_le target
+    target = Integer(target)
+    target = max if max < target
+    p = p_le(target)
+    raise "There is no valid distribution given a result <= #{target}" unless p > 0.0
+    mult = 1.0/p
+    new_probs = @probs[0..target-@offset].map { |x| x * mult }
+    GamesDice::Probabilities.new( new_probs, @offset )
+  end
+
+  # Creates new instance of GamesDice::Probabilities.
+  # @param [Hash] prob_hash A hash representation of the distribution, each key is an integer result,
+  #   and the matching value is probability of getting that result
+  # @return [GamesDice::Probabilities]
+  def self.from_h prob_hash
+    probs, offset = prob_h_to_ao( prob_hash )
+    GamesDice::Probabilities.new( probs, offset )
+  end
+
   # Distribution for a die with equal chance of rolling 1..N
   # @param [Integer] sides Number of sides on die
   # @return [GamesDice::Probabilities]
   def self.for_fair_die sides
     sides = Integer(sides)
     raise ArgumentError, "sides must be at least 1" unless sides > 0
-    h = {}
-    p = 1.0/sides
-    (1..sides).each { |x| h[x] = p }
-    GamesDice::Probabilities.new( h )
+    GamesDice::Probabilities.new( Array.new( sides, 1.0/sides ), 1 )
   end
 
   # Combines two distributions to create a third, that represents the distribution created when adding
@@ -127,15 +175,20 @@ class GamesDice::Probabilities
   # @param [GamesDice::Probabilities] pd_b Second distribution
   # @return [GamesDice::Probabilities]
   def self.add_distributions pd_a, pd_b
-    h = {}
-    pd_a.ph.each do |ka,pa|
-      pd_b.ph.each do |kb,pb|
-        kc = ka + kb
+    combined_min = pd_a.min + pd_b.min
+    combined_max = pd_a.max + pd_b.max
+    new_probs = Array.new( 1 + combined_max - combined_min, 0.0 )
+    probs_a, offset_a = pd_a.to_ao
+    probs_b, offset_b = pd_b.to_ao
+
+    probs_a.each_with_index do |pa,i|
+      probs_b.each_with_index do |pb,j|
+        k = i + j
         pc = pa * pb
-        h[kc] = h[kc] ? h[kc] + pc : pc
+        new_probs[ k ] += pc
       end
     end
-    GamesDice::Probabilities.new( h )
+    GamesDice::Probabilities.new( new_probs, combined_min )
   end
 
   # Combines two distributions with multipliers to create a third, that represents the distribution
@@ -146,15 +199,74 @@ class GamesDice::Probabilities
   # @param [GamesDice::Probabilities] pd_b Second distribution
   # @return [GamesDice::Probabilities]
   def self.add_distributions_mult m_a, pd_a, m_b, pd_b
-    h = {}
-    pd_a.ph.each do |ka,pa|
-      pd_b.ph.each do |kb,pb|
-        kc = m_a * ka + m_b * kb
+    combined_min, combined_max = [
+      m_a * pd_a.min + m_b * pd_b.min, m_a * pd_a.max + m_b * pd_b.min,
+      m_a * pd_a.min + m_b * pd_b.max, m_a * pd_a.max + m_b * pd_b.max,
+      ].minmax
+
+    new_probs = Array.new( 1 + combined_max - combined_min, 0.0 )
+    probs_a, offset_a = pd_a.to_ao
+    probs_b, offset_b = pd_b.to_ao
+
+    probs_a.each_with_index do |pa,i|
+      probs_b.each_with_index do |pb,j|
+        k = m_a * (i + offset_a) + m_b * (j + offset_b) - combined_min
         pc = pa * pb
-        h[kc] = h[kc] ? h[kc] + pc : pc
+        new_probs[ k ] += pc
+      end
+    end
+    GamesDice::Probabilities.new( new_probs, combined_min )
+  end
+
+
+  # Adds a distribution to itself repeatedly, to simulate a number of dice
+  # results being summed.
+  # @param [GamesDice::Probabilities] pd Distribution to repeat
+  # @param [Integer] n Number of repetitions, must be at least 1
+  # @return [GamesDice::Probabilities]
+  def self.repeat_distribution pd, n
+    n = Integer( n )
+    raise "Cannot combine probabilities less than once" if n < 1
+    revbin = n.to_s(2).reverse.each_char.to_a.map { |c| c == '1' }
+    pd_power = pd
+    pd_result = nil
+    max_power = revbin.count - 1
+
+    revbin.each_with_index do |use_power, i|
+      if use_power
+        if pd_result
+          pd_result = add_distributions( pd_result, pd_power )
+        else
+          pd_result = pd_power
+        end
       end
+      pd_power = add_distributions( pd_power, pd_power ) unless i == max_power
     end
-    GamesDice::Probabilities.new( h )
+    pd_result
+  end
+
+  private
+
+  # Convert hash to array,offset notation
+  def self.prob_h_to_ao h
+    rmin,rmax = h.keys.minmax
+    o = rmin
+    a = Array.new( 1 + rmax - rmin, 0.0 )
+    h.each { |k,v| a[k-rmin] = v }
+    [a,o]
+  end
+
+  # Convert array,offset notation to hash
+  def self.prob_ao_to_h a, o
+    h = Hash.new
+    a.each_with_index { |v,i| h[i+o] = v if v > 0.0 }
+    h
+  end
+
+  def calc_expected
+    total = 0.0
+    @probs.each_with_index { |v,i| total += (i+@offset)*v }
+    total
   end
 
 end # class GamesDice::Probabilities

data/lib/games_dice/version.rb

@@ -1,3 +1,3 @@
 module GamesDice
-  VERSION = "0.2.3"
+  VERSION = "0.2.4"
 end

data/spec/bunch_spec.rb

@@ -260,12 +260,10 @@ describe GamesDice::Bunch do
       end
 
       it "should have a mean value of roughly 18.986" do
-        pending "Too slow"
         bunch.probabilities.expected.should be_within(1e-9).of 18.9859925804
       end
 
       it "should calculate probabilities correctly" do
-        pending "Too slow"
         prob_hash = bunch.probabilities.to_h
         prob_hash[2].should be_within(1e-10).of 0.00001
         prob_hash[3].should be_within(1e-10).of 0.00005

data/spec/probability_spec.rb

@@ -2,12 +2,10 @@ require 'games_dice'
 require 'helpers'
 
 describe GamesDice::Probabilities do
-
   describe "class methods" do
-
     describe "#new" do
-      it "should create a new distribution from a hash" do
-        p = GamesDice::Probabilities.new( { 1 => 1.0 } )
+      it "should create a new distribution from an array and offset" do
+        p = GamesDice::Probabilities.new( [1.0], 1 )
         p.is_a?( GamesDice::Probabilities ).should be_true
         p.to_h.should be_valid_distribution
       end
@@ -31,8 +29,8 @@ describe GamesDice::Probabilities do
 
     describe "#add_distributions" do
       it "should combine two distributions to create a third one" do
-        d4a = GamesDice::Probabilities.new( { 1 => 1.0/4, 2 => 1.0/4, 3 => 1.0/4, 4 => 1.0/4 } )
-        d4b = GamesDice::Probabilities.new( { 1 => 1.0/10, 2 => 2.0/10, 3 => 3.0/10, 4 => 4.0/10 } )
+        d4a = GamesDice::Probabilities.new( [ 1.0/4, 1.0/4, 1.0/4, 1.0/4 ], 1 )
+        d4b = GamesDice::Probabilities.new( [ 1.0/10, 2.0/10, 3.0/10, 4.0/10], 1 )
         p = GamesDice::Probabilities.add_distributions( d4a, d4b )
         p.to_h.should be_valid_distribution
       end
@@ -40,18 +38,79 @@ describe GamesDice::Probabilities do
       it "should calculate a classic 2d6 distribution accurately" do
         d6 = GamesDice::Probabilities.for_fair_die( 6 )
         p = GamesDice::Probabilities.add_distributions( d6, d6 )
+        h = p.to_h
+        h.should be_valid_distribution
+        h[2].should be_within(1e-9).of 1.0/36
+        h[3].should be_within(1e-9).of 2.0/36
+        h[4].should be_within(1e-9).of 3.0/36
+        h[5].should be_within(1e-9).of 4.0/36
+        h[6].should be_within(1e-9).of 5.0/36
+        h[7].should be_within(1e-9).of 6.0/36
+        h[8].should be_within(1e-9).of 5.0/36
+        h[9].should be_within(1e-9).of 4.0/36
+        h[10].should be_within(1e-9).of 3.0/36
+        h[11].should be_within(1e-9).of 2.0/36
+        h[12].should be_within(1e-9).of 1.0/36
+      end
+    end
+
+    describe "#repeat_distribution" do
+      it "should output a valid distribution if params are valid" do
+        d4a = GamesDice::Probabilities.new( [ 1.0/4, 1.0/4, 1.0/4, 1.0/4 ], 1 )
+        d4b = GamesDice::Probabilities.new( [ 1.0/10, 2.0/10, 3.0/10, 4.0/10], 1 )
+        p = GamesDice::Probabilities.repeat_distribution( d4a, 7 )
+        p.to_h.should be_valid_distribution
+        p = GamesDice::Probabilities.repeat_distribution( d4b, 12 )
         p.to_h.should be_valid_distribution
-        p.to_h[2].should be_within(1e-9).of 1.0/36
-        p.to_h[3].should be_within(1e-9).of 2.0/36
-        p.to_h[4].should be_within(1e-9).of 3.0/36
-        p.to_h[5].should be_within(1e-9).of 4.0/36
-        p.to_h[6].should be_within(1e-9).of 5.0/36
-        p.to_h[7].should be_within(1e-9).of 6.0/36
-        p.to_h[8].should be_within(1e-9).of 5.0/36
-        p.to_h[9].should be_within(1e-9).of 4.0/36
-        p.to_h[10].should be_within(1e-9).of 3.0/36
-        p.to_h[11].should be_within(1e-9).of 2.0/36
-        p.to_h[12].should be_within(1e-9).of 1.0/36
+      end
+
+      it "should calculate a classic 3d6 distribution accurately" do
+        d6 = GamesDice::Probabilities.for_fair_die( 6 )
+        p = GamesDice::Probabilities.repeat_distribution( d6, 3 )
+        h = p.to_h
+        h.should be_valid_distribution
+        h[3].should be_within(1e-9).of 1.0/216
+        h[4].should be_within(1e-9).of 3.0/216
+        h[5].should be_within(1e-9).of 6.0/216
+        h[6].should be_within(1e-9).of 10.0/216
+        h[7].should be_within(1e-9).of 15.0/216
+        h[8].should be_within(1e-9).of 21.0/216
+        h[9].should be_within(1e-9).of 25.0/216
+        h[10].should be_within(1e-9).of 27.0/216
+        h[11].should be_within(1e-9).of 27.0/216
+        h[12].should be_within(1e-9).of 25.0/216
+        h[13].should be_within(1e-9).of 21.0/216
+        h[14].should be_within(1e-9).of 15.0/216
+        h[15].should be_within(1e-9).of 10.0/216
+        h[16].should be_within(1e-9).of 6.0/216
+        h[17].should be_within(1e-9).of 3.0/216
+        h[18].should be_within(1e-9).of 1.0/216
+      end
+    end # describe "#repeat_distribution"
+
+    describe "#add_distributions_mult" do
+      it "should combine two multiplied distributions to create a third one" do
+        d4a = GamesDice::Probabilities.new( [ 1.0/4, 1.0/4, 1.0/4, 1.0/4 ], 1 )
+        d4b = GamesDice::Probabilities.new( [ 1.0/10, 2.0/10, 3.0/10, 4.0/10], 1 )
+        p = GamesDice::Probabilities.add_distributions_mult( 2, d4a, -1, d4b )
+        p.to_h.should be_valid_distribution
+      end
+
+      it "should calculate a distribution for '1d6 - 1d4' accurately" do
+        d6 = GamesDice::Probabilities.for_fair_die( 6 )
+        d4 = GamesDice::Probabilities.for_fair_die( 4 )
+        p = GamesDice::Probabilities.add_distributions_mult( 1, d6, -1, d4 )
+        h = p.to_h
+        h.should be_valid_distribution
+        h[-3].should be_within(1e-9).of 1.0/24
+        h[-2].should be_within(1e-9).of 2.0/24
+        h[-1].should be_within(1e-9).of 3.0/24
+        h[0].should be_within(1e-9).of 4.0/24
+        h[1].should be_within(1e-9).of 4.0/24
+        h[2].should be_within(1e-9).of 4.0/24
+        h[3].should be_within(1e-9).of 3.0/24
+        h[4].should be_within(1e-9).of 2.0/24
+        h[5].should be_within(1e-9).of 1.0/24
       end
     end
 
@@ -62,7 +121,7 @@ describe GamesDice::Probabilities do
     let(:p4) { GamesDice::Probabilities.for_fair_die( 4 ) }
     let(:p6) { GamesDice::Probabilities.for_fair_die( 6 ) }
     let(:p10) { GamesDice::Probabilities.for_fair_die( 10 ) }
-    let(:pa) { GamesDice::Probabilities.new( { -1 => 0.4, 0 => 0.2, 1 => 0.4 } ) }
+    let(:pa) { GamesDice::Probabilities.new( [ 0.4, 0.2, 0.4 ], -1 ) }
 
     describe "#p_eql" do
       it "should return probability of getting a number inside the range" do
@@ -222,6 +281,26 @@ describe GamesDice::Probabilities do
       end
     end
 
-  end # describe "instance methods"
+    describe "#given_ge" do
+     it "should return a new distribution with probabilities calculated assuming value is >= target" do
+        pd = p2.given_ge(2)
+        pd.to_h.should == { 2 => 1.0 }
+        pd = p10.given_ge(4)
+        pd.to_h.should be_valid_distribution
+        pd.p_eql( 3 ).should == 0.0
+        pd.p_eql( 10 ).should be_within(1.0e-9).of 0.1/0.7
+      end
+    end
 
+    describe "#given_le" do
+     it "should return a new distribution with probabilities calculated assuming value is <= target" do
+        pd = p2.given_le(2)
+        pd.to_h.should == { 1 => 0.5, 2 => 0.5 }
+        pd = p10.given_le(4)
+        pd.to_h.should be_valid_distribution
+        pd.p_eql( 3 ).should be_within(1.0e-9).of 0.1/0.4
+        pd.p_eql( 10 ).should == 0.0
+      end
+    end
+  end # describe "instance methods"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: games_dice
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-12 00:00:00.000000000 Z
+date: 2013-06-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -144,7 +144,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1797445249921181101
+      hash: 1993011777003280822
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -153,7 +153,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1797445249921181101
+      hash: 1993011777003280822
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24