games_dice 0.3.9 → 0.3.10

data/CHANGELOG.md

@@ -1,59 +1,64 @@
 # GamesDice Changelog
 
-## 0.3.9
+## 0.3.10 ( 29 July 2013 )
+
+ * Non-functional changes to improve code quality metrics on CodeClimate
+ * Altered specs to improve accuracy of coverage metrics on Coveralls
+
+## 0.3.9  ( 23 July 2013 )
 
  * New methods for inspecting and iterating over potential values in GamesDice::Die
  * Code metric integration and badges for github
  * Non-functional changes to improve code quality metrics on CodeClimate
 
-## 0.3.7
+## 0.3.7  ( 17 July 2013 )
 
  * Compatibility between pure Ruby and native extension code when handling bad method params
  * Added this changelog to documentation
 
-## 0.3.6
+## 0.3.6  ( 15 July 2013 )
 
  * Extension building skipped, with fallback to pure Ruby, for JRuby compatibility
 
-## 0.3.5
+## 0.3.5  ( 14 July 2013 )
 
  * Adjust C code to avoid warnings about C90 compatibility (warnings seen on Travis)
  * Note MIT license in gemspec
  * Add class method GamesDice::Probabilities.implemented_in
 
-## 0.3.3
+## 0.3.3  ( 11 July 2013 )
 
  * Standardised code for Ruby 1.8.7 compatibility in GamesDice::Probabilities
  * Bug fix for probability calculations where distributions are added with mulipliers e.g. '2d6 - 1d8'
 
-## 0.3.2
+## 0.3.2  ( 10 July 2013 )
 
  * Bug fix for Ruby 1.8.7 compatibility in GamesDice::Probabilities
 
-## 0.3.1
+## 0.3.1  ( 10 July 2013 )
 
  * Bug fix for Ruby 1.8.7 compatibility in GamesDice::Probabilities
 
-## 0.3.0
+## 0.3.0  ( 10 July 2013 )
 
  * Implemented GamesDice::Probabilities as native extension
 
-## 0.2.4
+## 0.2.4  ( 18 June 2013 )
 
  * Minor speed improvements to GamesDice::Probabilities
 
-## 0.2.3
+## 0.2.3  ( 12 June 2013 )
 
  * More YARD documentation
 
-## 0.2.2
+## 0.2.2  ( 10 June 2013 )
 
  * Extended YARD documentation
 
-## 0.2.1
+## 0.2.1  ( 5 June 2013 )
 
  * Started basic YARD documentation
 
-## 0.2.0
+## 0.2.0  ( 30 May 2013 )
 
  * First version with a complete feature set

data/games_dice.gemspec

@@ -19,16 +19,16 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency "yard", ">= 0.8.6"
   gem.add_development_dependency "coveralls", ">= 0.6.7"
   gem.add_development_dependency "json", ">= 1.7.7"
-  gem.add_development_dependency "rake-compiler"
+  gem.add_development_dependency "rake-compiler", ">= 0.8.3"
 
   # Red Carpet renders README.md, and is optional even when developing the gem.
   # However, it has a C extension, and v3.0.0 is does not compile for 1.8.7. This only affects the gem build process, so
   # is only really used in environments like Travis, and is safe to wrap like this in the gemspec.
   if RUBY_DESCRIPTION !~ /jruby/
-    if RUBY_VERSION < "1.9.0"
-      gem.add_development_dependency "redcarpet", ">=2.3.0", "<3.0.0"
-    else
+    if RUBY_VERSION >= "1.9.0"
       gem.add_development_dependency "redcarpet", ">=2.3.0"
+    else
+      gem.add_development_dependency "redcarpet", ">=2.3.0", "<3.0.0"
     end
   end
 

data/lib/games_dice/complex_die.rb

@@ -1,3 +1,5 @@
+require "games_dice/complex_die_helpers"
+
 # This class models a die that is built up from a simpler unit by adding rules to re-roll
 # and interpret the value shown.
 #
@@ -20,6 +22,7 @@
 #
 
 class GamesDice::ComplexDie
+  include GamesDice::ComplexDieHelpers
 
   # @!visibility private
   # arbitrary limit to speed up probability calculations. It should
@@ -104,18 +107,14 @@ class GamesDice::ComplexDie
       reroll_probs = recursive_probabilities
       prob_hash = {}
       reroll_probs.each do |v,p|
-        m, n = calc_maps(v)
-        prob_hash[m] ||= 0.0
-        prob_hash[m] += p
+        add_mapped_to_prob_hash( prob_hash, v, p )
       end
     elsif @rerolls
       prob_hash = recursive_probabilities
     elsif @maps
       prob_hash = {}
       @basic_die.probabilities.each do |v,p|
-        m, n = calc_maps(v)
-        prob_hash[m] ||= 0.0
-        prob_hash[m] += p
+        add_mapped_to_prob_hash( prob_hash, v, p )
       end
     else
       @probabilities = @basic_die.probabilities
@@ -136,29 +135,42 @@ class GamesDice::ComplexDie
 
   private
 
+  def add_mapped_to_prob_hash prob_hash, v, p
+    m, n = calc_maps(v)
+    prob_hash[m] ||= 0.0
+    prob_hash[m] += p
+  end
+
   def roll_apply_rerolls
     return unless @rerolls
     subtracting = false
     rerolls_remaining = @rerolls.map { |rule| rule.limit }
 
     loop do
-      # Find which rule, if any, is being triggered
-      rule_idx = @rerolls.zip(rerolls_remaining).find_index do |rule,remaining|
-        next if rule.type == :reroll_subtract && @result.rolls.length > 1
-        remaining > 0 && rule.applies?( @basic_die.result )
-      end
+      rule_idx = find_matching_reroll_rule( @basic_die.result, @result.rolls.length ,rerolls_remaining )
       break unless rule_idx
 
       rule = @rerolls[ rule_idx ]
       rerolls_remaining[ rule_idx ] -= 1
       subtracting = true if rule.type == :reroll_subtract
+      roll_apply_reroll_rule rule, subtracting
+    end
+  end
 
-      # Apply the rule (note reversal for additions, after a subtract)
-      if subtracting && rule.type == :reroll_add
-        @result.add_roll( @basic_die.roll, :reroll_subtract )
-      else
-        @result.add_roll( @basic_die.roll, rule.type )
-      end
+  def roll_apply_reroll_rule rule, is_subtracting
+    # Apply the rule (note reversal for additions, after a subtract)
+    if is_subtracting && rule.type == :reroll_add
+      @result.add_roll( @basic_die.roll, :reroll_subtract )
+    else
+      @result.add_roll( @basic_die.roll, rule.type )
+    end
+  end
+
+  # Find which rule, if any, is being triggered
+  def find_matching_reroll_rule check_value, num_rolls, rerolls_remaining
+    @rerolls.zip(rerolls_remaining).find_index do |rule,remaining|
+      next if rule.type == :reroll_subtract && num_rolls > 1
+      remaining > 0 && rule.applies?( check_value )
     end
   end
 
@@ -214,6 +226,8 @@ class GamesDice::ComplexDie
   end
 
   # This isn't 100% accurate, but does cover most "normal" scenarios, and we're only falling back to it when we have to
+  # The inaccuracy is that min_result..max_result may contain 'holes' which have extreme map values that cannot actually
+  # occur. In practice it is likely a non-issue unless someone went out of their way to invent a dice scheme that broke it.
   def logical_minmax
     return [@basic_die.min,@basic_die.max] unless @rerolls || @maps
     return minmax_mappings( @basic_die.all_values ) unless @rerolls
@@ -225,79 +239,32 @@ class GamesDice::ComplexDie
   def logical_rerolls_minmax
     min_result = @basic_die.min
     max_result = @basic_die.max
-    min_subtract, max_add = find_add_subtract_extremes
+    min_subtract = find_minimum_possible_subtract
+    max_add = find_maximum_possible_adds
     if min_subtract
       min_result = [ min_subtract - max_add, min_subtract - max_result ].min
     end
     [ min_result, max_add + max_result ]
   end
 
-  def find_add_subtract_extremes
+  def find_minimum_possible_subtract
     min_subtract = nil
-    total_add = 0
-    @rerolls.select {|r| [:reroll_add, :reroll_subtract].member?( r.type ) }.each do |rule|
-      min_reroll,max_reroll = @basic_die.all_values.select { |v| rule.applies?( v ) }.minmax
+    @rerolls.select { |r| r.type == :reroll_subtract }.each do |rule|
+      min_reroll = @basic_die.all_values.select { |v| rule.applies?( v ) }.min
       next unless min_reroll
-      if rule.type == :reroll_subtract
-        min_subtract = min_reroll if min_subtract.nil?
-        min_subtract = min_reroll if min_subtract > min_reroll
-      else
-        total_add += max_reroll * rule.limit
-      end
-    end
-    [ min_subtract, total_add ]
-  end
-
-  def recursive_probabilities probabilities={},prior_probability=1.0,depth=0,prior_result=nil,rerolls_left=nil,roll_reason=:basic,subtracting=false
-    each_probability = prior_probability / @basic_die.sides
-    depth += 1
-    if depth >= 20 || each_probability < 1.0e-12
-      @probabilities_complete = false
-      stop_recursing = true
-    end
-
-    @basic_die.each_value do |v|
-      # calculate value, recurse if there is a reroll
-      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|
-        next if rule.type == :reroll_subtract && result_so_far.rolls.length > 1
-        remaining > 0 && rule.applies?( v )
-      end
-
-      if rule_idx && ! stop_recursing
-        rule = @rerolls[ rule_idx ]
-        rerolls_remaining[ rule_idx ] -= 1
-        is_subtracting = true if subtracting || rule.type == :reroll_subtract
-
-        # Apply the rule (note reversal for additions, after a subtract)
-        if subtracting && rule.type == :reroll_add
-          recursive_probabilities probabilities,each_probability,depth,result_so_far,rerolls_remaining,:reroll_subtract,is_subtracting
-        else
-          recursive_probabilities probabilities,each_probability,depth,result_so_far,rerolls_remaining,rule.type,is_subtracting
-        end
-      # just accumulate value on a regular roll
-      else
-        t = result_so_far.total
-        probabilities[ t ] ||= 0.0
-        probabilities[ t ] += each_probability
-      end
-
+      min_subtract = [min_reroll,min_subtract].compact.min
     end
-    probabilities
+    min_subtract
   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 }
+  def find_maximum_possible_adds
+    total_add = 0
+    @rerolls.select { |r| r.type == :reroll_add }.each do |rule|
+      max_reroll = @basic_die.all_values.select { |v| rule.applies?( v ) }.max
+      next unless max_reroll
+      total_add += max_reroll * rule.limit
     end
-    [result_so_far, rerolls_remaining]
+    total_add
   end
 
 end # class ComplexDie

data/lib/games_dice/complex_die_helpers.rb

@@ -0,0 +1,60 @@
+# @!visibility private
+module GamesDice::ComplexDieHelpers
+
+  private
+
+  def recursive_probabilities probabilities={},prior_probability=1.0,depth=0,prior_result=nil,rerolls_left=nil,roll_reason=:basic,subtracting=false
+    each_probability = prior_probability / @basic_die.sides
+    depth += 1
+    if depth >= 20 || each_probability < 1.0e-16
+      @probabilities_complete = false
+      stop_recursing = true
+    end
+
+    @basic_die.each_value do |v|
+      recurse_probs_for_value( v, roll_reason, probabilities, each_probability, depth, prior_result, rerolls_left, subtracting, stop_recursing )
+    end
+    probabilities
+  end
+
+  def recurse_probs_for_value v, roll_reason, probabilities, each_probability, depth, prior_result, rerolls_left, subtracting, stop_recursing
+    # calculate value, recurse if there is a reroll
+    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 = find_matching_reroll_rule( v, result_so_far.rolls.length, rerolls_remaining )
+
+    if rule_idx && ! stop_recursing
+      recurse_probs_with_rule( probabilities, each_probability, depth, result_so_far, rerolls_remaining, rule_idx, subtracting )
+    else
+      t = result_so_far.total
+      probabilities[ t ] ||= 0.0
+      probabilities[ t ] += each_probability
+    end
+  end
+
+  def recurse_probs_with_rule probabilities, each_probability, depth, result_so_far, rerolls_remaining, rule_idx, subtracting
+    rule = @rerolls[ rule_idx ]
+    rerolls_remaining[ rule_idx ] -= 1
+    is_subtracting = true if subtracting || rule.type == :reroll_subtract
+
+    # Apply the rule (note reversal for additions, after a subtract)
+    if subtracting && rule.type == :reroll_add
+      recursive_probabilities probabilities, each_probability, depth, result_so_far, rerolls_remaining, :reroll_subtract, is_subtracting
+    else
+      recursive_probabilities probabilities, each_probability, depth, result_so_far, rerolls_remaining, rule.type, is_subtracting
+    end
+  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

data/lib/games_dice/prob_helpers.rb

@@ -0,0 +1,259 @@
+# @!visibility private
+module GamesDice::ProbabilityValidations
+
+  # @!visibility private
+  # the Array, Offset representation of probabilities.
+  def to_ao
+    [ @probs, @offset ]
+  end
+
+  def self.included(klass)
+    klass.extend ClassMethods
+  end
+
+  private
+
+  def check_probs_array probs_array
+    raise TypeError unless probs_array.is_a?( Array )
+    probs_array.map!{ |n| Float(n) }
+    total = probs_array.inject(0.0) do |t,x|
+      if x < 0.0 || x > 1.0
+        raise ArgumentError, "Found probability value #{x} which is not in range 0.0..1.0"
+      end
+      t+x
+    end
+    if (total-1.0).abs > 1e-6
+      raise ArgumentError, "Total probabilities too far from 1.0 for a valid distribution"
+    end
+    probs_array
+  end
+
+  def check_keep_mode kmode
+    raise "Keep mode #{kmode.inspect} not recognised" unless [:keep_best,:keep_worst].member?( kmode )
+  end
+
+  module ClassMethods
+    # Convert hash to array,offset notation
+    def prob_h_to_ao h
+      rmin,rmax = h.keys.minmax
+      o = rmin
+      s = 1 + rmax - rmin
+      raise ArgumentError, "Range of possible results too large" if s > 1000000
+      a = Array.new( s, 0.0 )
+      h.each { |k,v| a[k-rmin] = Float(v) }
+      [a,o]
+    end
+
+    # Convert array,offset notation to hash
+    def 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
+
+    private
+
+    def check_is_gdp *probs
+      probs.each do |prob|
+        unless prob.is_a?( GamesDice::Probabilities )
+          raise TypeError, "parameter is not a GamesDice::Probabilities"
+        end
+      end
+    end
+  end
+end
+
+# @!visibility private
+# This module is a set of related private methods for GamesDice::Probabilities that
+# calculate how two distributions can be combined.
+module GamesDice::ProbabilityCalcAddDistributions
+  private
+
+  def calc_combined_extremes m_a, pd_a, m_b, pd_b
+    [ [ :min, :min ], [ :min, :max ], [ :max, :min ], [ :max, :max ] ].map do |pda_meth, pdb_meth|
+      m_a * pd_a.send(pda_meth) + m_b * pd_b.send(pdb_meth)
+    end
+  end
+
+  def add_distributions_internal combined_min, combined_max, m_a, pd_a, m_b, pd_b
+    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
+        new_probs[ k ] += pc
+      end
+    end
+    GamesDice::Probabilities.new( new_probs, combined_min )
+  end
+end
+
+
+# @!visibility private
+# This module is a set of related private methods for GamesDice::Probabilities that
+# calculate how a distribution can be combined with itself.
+module GamesDice::ProbabilityCalcSums
+
+  private
+
+  def repeat_sum_internal( n )
+    pd_power = self
+    pd_result = nil
+
+    use_power = 1
+    loop do
+      if ( use_power & n ) > 0
+        if pd_result
+          pd_result = GamesDice::Probabilities.add_distributions( pd_result, pd_power )
+        else
+          pd_result = pd_power
+        end
+      end
+      use_power = use_power << 1
+      break if use_power > n
+      pd_power = GamesDice::Probabilities.add_distributions( pd_power, pd_power )
+    end
+    pd_result
+  end
+
+  def repeat_n_sum_k_internal( n, k, kmode )
+    if k >= n
+      return repeat_sum_internal( n )
+    end
+    new_probs = Array.new( @probs.count * k, 0.0 )
+    new_offset = @offset * k
+    d = n - k
+
+    each do | q, p_maybe |
+      repeat_n_sum_k_each_q( q, p_maybe, n, k, kmode, d, new_probs, new_offset )
+    end
+
+    GamesDice::Probabilities.new( new_probs, new_offset )
+  end
+
+  def repeat_n_sum_k_each_q q, p_maybe, n, k, kmode, d, new_probs, new_offset
+    # keep_distributions is array of Probabilities, indexed by number of keepers > q, which is in 0...k
+    keep_distributions = calc_keep_distributions( k, q, kmode )
+    p_table = calc_p_table( q, p_maybe, kmode )
+    (0...k).each do |kn|
+      repeat_n_sum_k_each_q_kn( k, kn, d, new_probs, new_offset, keep_distributions, p_table )
+    end
+  end
+
+  def repeat_n_sum_k_each_q_kn k, kn, d, new_probs, new_offset, keep_distributions, p_table
+    keepers = [2] * kn + [1] * (k-kn)
+    p_so_far = keepers.inject(1.0) { |p,idx| p * p_table[idx] }
+    return unless p_so_far > 0.0
+    (0..d).each do |dn|
+      repeat_n_sum_k_each_q_kn_dn( keepers, kn, d, dn, p_so_far, new_probs, new_offset, keep_distributions, p_table )
+    end
+  end
+
+  def repeat_n_sum_k_each_q_kn_dn keepers, kn, d, dn, p_so_far, new_probs, new_offset, keep_distributions, p_table
+    discards = [1] * (d-dn) + [0] * dn
+    sequence = keepers + discards
+    p_sequence = discards.inject( p_so_far ) { |p,idx| p * p_table[idx] }
+    return unless p_sequence > 0.0
+    p_sequence *= GamesDice::Combinations.count_variations( sequence )
+    kd = keep_distributions[kn]
+    kd.each { |r,p_r| new_probs[r-new_offset] += p_r * p_sequence }
+  end
+
+  def calc_keep_distributions k, q, kmode
+    kd_probabilities = calc_keep_definite_distributions q, kmode
+
+    keep_distributions = [ GamesDice::Probabilities.new( [1.0], q * k ) ]
+    if kd_probabilities && k > 1
+      (1...k).each do |n|
+        extra_o = GamesDice::Probabilities.new( [1.0], q * ( k - n ) )
+        n_probs = kd_probabilities.repeat_sum( n )
+        keep_distributions[n] = GamesDice::Probabilities.add_distributions( extra_o, n_probs )
+      end
+    end
+
+    keep_distributions
+  end
+
+  def calc_keep_definite_distributions q, kmode
+    kd_probabilities = nil
+    case kmode
+    when :keep_best
+      p_definites = p_gt(q)
+      kd_probabilities = given_ge( q + 1 ) if p_definites > 0.0
+    when :keep_worst
+      p_definites = p_lt(q)
+      kd_probabilities = given_le( q - 1 ) if p_definites > 0.0
+    end
+    kd_probabilities
+  end
+
+  def calc_p_table q, p_maybe, kmode
+    case kmode
+    when :keep_best
+      p_kept = p_gt(q)
+      p_rejected = p_lt(q)
+    when :keep_worst
+      p_kept = p_lt(q)
+      p_rejected = p_gt(q)
+    end
+    [ p_rejected, p_maybe, p_kept ]
+  end
+
+end
+
+
+# @!visibility private
+# Helper module with optimised Ruby for counting variations of arrays, such as those returned by
+# Array#repeated_combination
+#
+# @example How many ways can [3,3,6] be arranged?
+#  GamesDice::Combinations.count_variations( [3,3,6] )
+#  => 3
+#
+# @example When prob( a ) and result( a ) are same for any arrangement of Array a
+#  items = [1,2,3,4,5,6]
+#  items.repeated_combination(5).each do |a|
+#    this_result = result( a )
+#    this_prob = prob( a ) * GamesDice::Combinations.count_variations( a )
+#    # Do something useful with this knowledge! E.g. save it to probability array.
+#  end
+#
+module GamesDice::Combinations
+  @@variations_cache = {}
+  @@factorial_cache = [1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800]
+
+  # Counts variations of an array. A unique variation is an arrangement of the array elements which
+  # is detectably different (using ==) from any other. So [1,1,1] has only 1 unique arrangement,
+  # but [1,2,3] has 6 possibilities.
+  # @param [Array] array List of things that can be arranged
+  # @return [Integer] Number of unique arrangements
+  def self.count_variations array
+    all_count = array.count
+    group_sizes = group_counts( array )
+    cache_key = all_count.to_s + ":" + group_sizes.join(',')
+    @@variations_cache[cache_key] ||= variations_of( all_count, group_sizes )
+  end
+
+  private
+
+  def self.variations_of all_count, groups
+    all_arrangements = factorial( all_count )
+    # The reject is an optimisation to avoid calculating and multplying by factorial(1) (==1)
+    identical_arrangements = groups.reject {|x| x==1 }.inject(1) { |prod,g| prod * factorial(g) }
+    all_arrangements/identical_arrangements
+  end
+
+  # Returns counts of unique items in array e.g. [8,8,8,7,6,6] returns [1,2,3]
+  # Sort is for caching
+  def self.group_counts array
+    array.group_by {|x| x}.values.map {|v| v.count}.sort
+  end
+
+  def self.factorial n
+    # Can start range from 2 because we have pre-cached the result for n=1
+    @@factorial_cache[n] ||= (2..n).inject(:*)
+  end
+end

data/lib/games_dice/probabilities.rb

@@ -1,3 +1,5 @@
+require 'games_dice/prob_helpers'
+
 # This class models probability distributions for dice systems.
 #
 # An object of this class represents a single distribution, which might be the result of a complex
@@ -19,6 +21,9 @@
 #  probs.p_ge( 10 ) # => 0.16666666666666669
 #
 class GamesDice::Probabilities
+  include GamesDice::ProbabilityValidations
+  include GamesDice::ProbabilityCalcSums
+  extend GamesDice::ProbabilityCalcAddDistributions
 
   # Creates new instance of GamesDice::Probabilities.
   # @param [Array<Float>] probs Each entry in the array is the probability of getting a result
@@ -30,12 +35,6 @@ class GamesDice::Probabilities
     @offset = Integer(offset)
   end
 
-  # @!visibility private
-  # 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
@@ -177,14 +176,11 @@ class GamesDice::Probabilities
   # @param [GamesDice::Probabilities] pd_b Second distribution
   # @return [GamesDice::Probabilities]
   def self.add_distributions pd_a, pd_b
-    unless pd_a.is_a?( GamesDice::Probabilities ) && pd_b.is_a?( GamesDice::Probabilities )
-      raise TypeError, "parameter to add_distributions is not a GamesDice::Probabilities"
-    end
-
+    check_is_gdp( pd_a, pd_b )
     combined_min = pd_a.min + pd_b.min
     combined_max = pd_a.max + pd_b.max
 
-    add_distributions_internal combined_min, combined_max, 1, pd_a, 1, pd_b
+    add_distributions_internal( combined_min, combined_max, 1, pd_a, 1, pd_b )
   end
 
   # Combines two distributions with multipliers to create a third, that represents the distribution
@@ -195,19 +191,13 @@ 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
-    unless pd_a.is_a?( GamesDice::Probabilities ) && pd_b.is_a?( GamesDice::Probabilities )
-      raise TypeError, "parameter to add_distributions_mult is not a GamesDice::Probabilities"
-    end
-
+    check_is_gdp( pd_a, pd_b )
     m_a = Integer(m_a)
     m_b = Integer(m_b)
 
-    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
+    combined_min, combined_max = calc_combined_extremes( m_a, pd_a, m_b, pd_b ).minmax
 
-    add_distributions_internal combined_min, combined_max, m_a, pd_a, m_b, pd_b
+    add_distributions_internal( combined_min, combined_max, m_a, pd_a, m_b, pd_b )
   end
 
   # Returns a symbol for the language name that this class is implemented in. The C version of the
@@ -225,23 +215,7 @@ class GamesDice::Probabilities
     n = Integer( n )
     raise "Cannot combine probabilities less than once" if n < 1
     raise "Probability distribution too large" if ( n * @probs.count ) > 1000000
-    pd_power = self
-    pd_result = nil
-
-    use_power = 1
-    loop do
-      if ( use_power & n ) > 0
-        if pd_result
-          pd_result = GamesDice::Probabilities.add_distributions( pd_result, pd_power )
-        else
-          pd_result = pd_power
-        end
-      end
-      use_power = use_power << 1
-      break if use_power > n
-      pd_power = GamesDice::Probabilities.add_distributions( pd_power, pd_power )
-    end
-    pd_result
+    repeat_sum_internal( n )
   end
 
   # Calculates distribution generated by summing best k results of n iterations
@@ -256,190 +230,15 @@ class GamesDice::Probabilities
     # Technically this is a limitation of C code, but Ruby version is most likely slow and inaccurate beyond 170
     raise "Too many dice to calculate numbers of arrangements" if n > 170
     check_keep_mode( kmode )
-
-    if k >= n
-      return repeat_sum( n )
-    end
-    new_probs = Array.new( @probs.count * k, 0.0 )
-    new_offset = @offset * k
-    d = n - k
-
-    each do | q, p_maybe |
-      next unless p_maybe > 0.0
-
-      # keep_distributions is array of Probabilities, indexed by number of keepers > q, which is in 0...k
-      keep_distributions = calc_keep_distributions( k, q, kmode )
-      p_table = calc_p_table( q, p_maybe, kmode )
-
-      (0...k).each do |n|
-        keepers = [2] * n + [1] * (k-n)
-        p_so_far = keepers.inject(1.0) { |p,idx| p * p_table[idx] }
-        next unless p_so_far > 0.0
-        (0..d).each do |dn|
-          discards = [1] * (d-dn) + [0] * dn
-          sequence = keepers + discards
-          p_sequence = discards.inject( p_so_far ) { |p,idx| p * p_table[idx] }
-          next unless p_sequence > 0.0
-          p_sequence *= GamesDice::Combinations.count_variations( sequence )
-          kd = keep_distributions[n]
-          kd.each { |r,p_r| new_probs[r-new_offset] += p_r * p_sequence }
-        end
-      end
-    end
-    GamesDice::Probabilities.new( new_probs, new_offset )
+    repeat_n_sum_k_internal( n, k, kmode )
   end
 
   private
 
-  def self.add_distributions_internal combined_min, combined_max, m_a, pd_a, m_b, pd_b
-    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
-        new_probs[ k ] += pc
-      end
-    end
-    GamesDice::Probabilities.new( new_probs, combined_min )
-  end
-
-  def check_probs_array probs_array
-    raise TypeError unless probs_array.is_a?( Array )
-    probs_array.map!{ |n| Float(n) }
-    total = probs_array.inject(0.0) do |t,x|
-      if x < 0.0 || x > 1.0
-        raise ArgumentError, "Found probability value #{x} which is not in range 0.0..1.0"
-      end
-      t+x
-    end
-    if (total-1.0).abs > 1e-6
-      raise ArgumentError, "Total probabilities too far from 1.0 for a valid distribution"
-    end
-    probs_array
-  end
-
-  def calc_keep_distributions k, q, kmode
-    kd_probabilities = calc_keep_definite_distributions q, kmode
-
-    keep_distributions = [ GamesDice::Probabilities.new( [1.0], q * k ) ]
-    if kd_probabilities && k > 1
-      (1...k).each do |n|
-        extra_o = GamesDice::Probabilities.new( [1.0], q * ( k - n ) )
-        n_probs = kd_probabilities.repeat_sum( n )
-        keep_distributions[n] = GamesDice::Probabilities.add_distributions( extra_o, n_probs )
-      end
-    end
-
-    keep_distributions
-  end
-
-  def calc_keep_definite_distributions q, kmode
-    kd_probabilities = nil
-    case kmode
-    when :keep_best
-      p_definites = p_gt(q)
-      kd_probabilities = given_ge( q + 1 ) if p_definites > 0.0
-    when :keep_worst
-      p_definites = p_lt(q)
-      kd_probabilities = given_le( q - 1 ) if p_definites > 0.0
-    end
-    kd_probabilities
-  end
-
-  def calc_p_table q, p_maybe, kmode
-    case kmode
-    when :keep_best
-      p_kept = p_gt(q)
-      p_rejected = p_lt(q)
-    when :keep_worst
-      p_kept = p_lt(q)
-      p_rejected = p_gt(q)
-    end
-    [ p_rejected, p_maybe, p_kept ]
-  end
-
-  # Convert hash to array,offset notation
-  def self.prob_h_to_ao h
-    rmin,rmax = h.keys.minmax
-    o = rmin
-    s = 1 + rmax - rmin
-    raise ArgumentError, "Range of possible results too large" if s > 1000000
-    a = Array.new( s, 0.0 )
-    h.each { |k,v| a[k-rmin] = Float(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
 
-  def check_keep_mode kmode
-    raise "Keep mode #{kmode.inspect} not recognised" unless [:keep_best,:keep_worst].member?( kmode )
-  end
-
 end # class GamesDice::Probabilities
-
-# @!visibility private
-# Helper module with optimised Ruby for counting variations of arrays, such as those returned by
-# Array#repeated_combination
-#
-# @example How many ways can [3,3,6] be arranged?
-#  GamesDice::Combinations.count_variations( [3,3,6] )
-#  => 3
-#
-# @example When prob( a ) and result( a ) are same for any arrangement of Array a
-#  items = [1,2,3,4,5,6]
-#  items.repeated_combination(5).each do |a|
-#    this_result = result( a )
-#    this_prob = prob( a ) * GamesDice::Combinations.count_variations( a )
-#    # Do something useful with this knowledge! E.g. save it to probability array.
-#  end
-#
-module GamesDice::Combinations
-  @@variations_cache = {}
-  @@factorial_cache = [1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800]
-
-  # Counts variations of an array. A unique variation is an arrangement of the array elements which
-  # is detectably different (using ==) from any other. So [1,1,1] has only 1 unique arrangement,
-  # but [1,2,3] has 6 possibilities.
-  # @param [Array] array List of things that can be arranged
-  # @return [Integer] Number of unique arrangements
-  def self.count_variations array
-    all_count = array.count
-    group_sizes = group_counts( array )
-    cache_key = all_count.to_s + ":" + group_sizes.join(',')
-    @@variations_cache[cache_key] ||= variations_of( all_count, group_sizes )
-  end
-
-  private
-
-  def self.variations_of all_count, groups
-    all_arrangements = factorial( all_count )
-    # The reject is an optimisation to avoid calculating and multplying by factorial(1) (==1)
-    identical_arrangements = groups.reject {|x| x==1 }.inject(1) { |prod,g| prod * factorial(g) }
-    all_arrangements/identical_arrangements
-  end
-
-  # Returns counts of unique items in array e.g. [8,8,8,7,6,6] returns [1,2,3]
-  # Sort is for caching
-  def self.group_counts array
-    array.group_by {|x| x}.values.map {|v| v.count}.sort
-  end
-
-  def self.factorial n
-    # Can start range from 2 because we have pre-cached the result for n=1
-    @@factorial_cache[n] ||= (2..n).inject(:*)
-  end
-end

data/lib/games_dice/version.rb

@@ -1,3 +1,3 @@
 module GamesDice
-  VERSION = "0.3.9"
+  VERSION = "0.3.10"
 end

data/spec/bunch_spec.rb

@@ -1,4 +1,3 @@
-require 'games_dice'
 require 'helpers'
 
 describe GamesDice::Bunch do

data/spec/complex_die_spec.rb

@@ -1,4 +1,3 @@
-require 'games_dice'
 require 'helpers'
 
 describe GamesDice::ComplexDie do

data/spec/dice_spec.rb

@@ -1,4 +1,4 @@
-require 'games_dice'
+require 'helpers'
 
 describe GamesDice::Dice do
 

data/spec/die_result_spec.rb

@@ -1,4 +1,4 @@
-require 'games_dice'
+require 'helpers'
 
 describe GamesDice::DieResult do
 

data/spec/die_spec.rb

@@ -1,4 +1,3 @@
-require 'games_dice'
 require 'helpers'
 
 describe GamesDice::Die do

data/spec/helpers.rb

@@ -1,9 +1,11 @@
 # games_dice/spec/helpers.rb
 require 'pathname'
 require 'coveralls'
-
 Coveralls.wear!
 
+require 'games_dice'
+
+
 def fixture name
   (Pathname.new(__FILE__).dirname + "fixtures" + name).to_s
 end

data/spec/map_rule_spec.rb

@@ -1,4 +1,4 @@
-require 'games_dice'
+require 'helpers'
 
 describe GamesDice::MapRule do
 

data/spec/parser_spec.rb

@@ -1,4 +1,4 @@
-require 'games_dice'
+require 'helpers'
 
 describe GamesDice::Parser do
 

data/spec/probability_spec.rb

@@ -1,4 +1,3 @@
-require 'games_dice'
 require 'helpers'
 
 describe GamesDice::Probabilities do

data/spec/readme_spec.rb

@@ -1,4 +1,3 @@
-require 'games_dice'
 require 'helpers'
 # This spec demonstrates that documentation from the README.md works as intended
 

data/spec/reroll_rule_spec.rb

@@ -1,4 +1,4 @@
-require 'games_dice'
+require 'helpers'
 
 describe GamesDice::RerollRule do
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: games_dice
 version: !ruby/object:Gem::Version
-  version: 0.3.9
+  version: 0.3.10
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-23 00:00:00.000000000 Z
+date: 2013-07-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -98,7 +98,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.8.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -106,7 +106,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.8.3
 - !ruby/object:Gem::Dependency
   name: redcarpet
   requirement: !ruby/object:Gem::Requirement
@@ -164,6 +164,7 @@ files:
 - lib/games_dice.rb
 - lib/games_dice/bunch.rb
 - lib/games_dice/complex_die.rb
+- lib/games_dice/complex_die_helpers.rb
 - lib/games_dice/constants.rb
 - lib/games_dice/dice.rb
 - lib/games_dice/die.rb
@@ -171,6 +172,7 @@ files:
 - lib/games_dice/map_rule.rb
 - lib/games_dice/marshal.rb
 - lib/games_dice/parser.rb
+- lib/games_dice/prob_helpers.rb
 - lib/games_dice/probabilities.rb
 - lib/games_dice/reroll_rule.rb
 - lib/games_dice/version.rb
@@ -201,7 +203,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -3597732090146629653
+      hash: -2123252871276968084
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -210,7 +212,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -3597732090146629653
+      hash: -2123252871276968084
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24