games_dice 0.3.7 → 0.3.8

data/.travis.yml

@@ -8,3 +8,7 @@ rvm:
   - ree
   - jruby-18mode
   - jruby-19mode
+  - jruby-head
+allow_failures:
+  rvm:
+    - ruby-head

data/README.md

@@ -1,6 +1,9 @@
 # GamesDice
-
+[![Gem Version](https://badge.fury.io/rb/games_dice.png)](http://badge.fury.io/rb/games_dice)
 [![Build Status](https://travis-ci.org/neilslater/games_dice.png?branch=master)](http://travis-ci.org/neilslater/games_dice)
+[![Coverage Status](https://coveralls.io/repos/neilslater/games_dice/badge.png?branch=master)](https://coveralls.io/r/neilslater/games_dice?branch=master)
+[![Code Climate](https://codeclimate.com/github/neilslater/games_dice.png)](https://codeclimate.com/github/neilslater/games_dice)
+[![Dependency Status](https://gemnasium.com/neilslater/games_dice.png)](https://gemnasium.com/neilslater/games_dice)
 
 A library for simulating dice. Use it to construct dice-rolling systems used in role-playing and board games.
 

data/ext/games_dice/probabilities.c

@@ -41,7 +41,7 @@ inline int min( int *a, int n ) {
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 //
-//  Quick factorials, that fit into unsigned longs . . . the size of this structure sets the
+//  Quick factorials, that fit into doubles. . . the size of this structure sets the
 //  maximum possible n in repeat_n_sum_k calculations
 //
 
@@ -744,11 +744,15 @@ VALUE probabilities_for_fair_die( VALUE self, VALUE sides ) {
 }
 
 VALUE probabilities_from_h( VALUE self, VALUE hash ) {
+  VALUE obj;
+  ProbabilityList *pl;
+  double error;
+
   Check_Type( hash, T_HASH );
 
-  VALUE obj = pl_alloc( Probabilities );
-  ProbabilityList *pl = get_probability_list( obj );
-  double error;
+  obj = pl_alloc( Probabilities );
+  pl = get_probability_list( obj );
+
 
   // Set these up so that they get adjusted during hash iteration
   pl->offset = 0x7fffffff;

data/games_dice.gemspec

@@ -17,6 +17,8 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency "rspec", ">= 2.13.0"
   gem.add_development_dependency "rake", ">= 1.9.1"
   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"
 
   # Red Carpet renders README.md, and is optional even when developing the gem.

data/lib/games_dice.rb

@@ -13,6 +13,7 @@ require "games_dice/complex_die"
 require "games_dice/bunch"
 require "games_dice/dice"
 require "games_dice/parser"
+require "games_dice/marshal"
 
 module GamesDice
   # @!visibility private

data/lib/games_dice/bunch.rb

@@ -32,50 +32,17 @@ class GamesDice::Bunch
   # @option options [Integer] :keep_number Optional number of dice to keep when :keep_mode is not nil
   # @return [GamesDice::Bunch]
   def initialize( options )
-    @name = options[:name].to_s
-    @ndice = Integer(options[:ndice])
-    raise ArgumentError, ":ndice must be 1 or more, but got #{@ndice}" unless @ndice > 0
-    @sides = Integer(options[:sides])
-    raise ArgumentError, ":sides must be 1 or more, but got #{@sides}" unless @sides > 0
-
-    attr = Hash.new
+    name_number_sides_from_hash( options )
+    keep_mode_from_hash( options )
 
     if options[:prng]
-      # We deliberately do not clone this object, it will often be intended that it is shared
-      prng = options[:prng]
       raise ":prng does not support the rand() method" if ! prng.respond_to?(:rand)
     end
 
-    needs_complex_die = false
-
-    if options[:rerolls]
-      needs_complex_die = true
-      attr[:rerolls] = options[:rerolls].clone
-    end
-
-    if options[:maps]
-      needs_complex_die = true
-      attr[:maps] = options[:maps].clone
-    end
-
-    if needs_complex_die
-      attr[:prng] = prng
-      @single_die = GamesDice::ComplexDie.new( @sides, attr )
-    else
-      @single_die = GamesDice::Die.new( @sides, prng )
-    end
-
-    case options[:keep_mode]
-    when nil then
-      @keep_mode = nil
-    when :keep_best then
-      @keep_mode = :keep_best
-      @keep_number = Integer(options[:keep_number] || 1)
-    when :keep_worst then
-      @keep_mode = :keep_worst
-      @keep_number = Integer(options[:keep_number] || 1)
+    if options[:rerolls] || options[:maps]
+      @single_die = GamesDice::ComplexDie.new( @sides, complex_die_params_from_hash( options ) )
     else
-      raise ArgumentError, ":keep_mode can be nil, :keep_best or :keep_worst. Got #{options[:keep_mode].inspect}"
+      @single_die = GamesDice::Die.new( @sides, options[:prng] )
     end
   end
 
@@ -243,4 +210,38 @@ class GamesDice::Bunch
     explanation
   end
 
+  private
+
+  def name_number_sides_from_hash options
+    @name = options[:name].to_s
+    @ndice = Integer(options[:ndice])
+    raise ArgumentError, ":ndice must be 1 or more, but got #{@ndice}" unless @ndice > 0
+    @sides = Integer(options[:sides])
+    raise ArgumentError, ":sides must be 1 or more, but got #{@sides}" unless @sides > 0
+  end
+
+  def keep_mode_from_hash options
+    case options[:keep_mode]
+    when nil then
+      @keep_mode = nil
+    when :keep_best then
+      @keep_mode = :keep_best
+      @keep_number = Integer(options[:keep_number] || 1)
+    when :keep_worst then
+      @keep_mode = :keep_worst
+      @keep_number = Integer(options[:keep_number] || 1)
+    else
+      raise ArgumentError, ":keep_mode can be nil, :keep_best or :keep_worst. Got #{options[:keep_mode].inspect}"
+    end
+  end
+
+  def complex_die_params_from_hash options
+    cd_hash = Hash.new
+    [:maps,:rerolls].each do |k|
+      cd_hash[k] = options[k].clone if options[k]
+    end
+    # We deliberately do not clone this object, it will often be intended that it is shared
+    cd_hash[:prng] = options[:prng]
+    cd_hash
+  end
 end # class Bunch

data/lib/games_dice/complex_die.rb

@@ -60,7 +60,7 @@ class GamesDice::ComplexDie
   # True if all possible results are represented and assigned a probability. Dice with open-ended re-rolls
   # may have calculations cut short, and will result in a false value of this attribute. Even when this
   # attribute is false, probabilities should still be accurate to nearest 1e-9.
-  # @return [Boolean, nil] Depending on completeness when generating #probabilites
+  # @return [Boolean, nil] Depending on completeness when generating #probabilities
   attr_reader :probabilities_complete
 
   # @!attribute [r] sides
@@ -81,10 +81,7 @@ class GamesDice::ComplexDie
   # @return [Integer]
   def min
     return @min_result if @min_result
-    @min_result, @max_result = [probabilities.min, probabilities.max]
-    return @min_result if @probabilities_complete
-    logical_min, logical_max = logical_minmax
-    @min_result, @max_result = [@min_result, @max_result, logical_min, logical_max].minmax
+    calc_minmax
     @min_result
   end
 
@@ -92,10 +89,7 @@ class GamesDice::ComplexDie
   # @return [Integer] Maximum possible result from a call to #roll
   def max
     return @max_result if @max_result
-    @min_result, @max_result = [probabilities.min, probabilities.max]
-    return @max_result if @probabilities_complete
-    logical_min, logical_max = logical_minmax
-    @min_result, @max_result = [@min_result, @max_result, logical_min, logical_max].minmax
+    calc_minmax
     @max_result
   end
 
@@ -134,66 +128,70 @@ class GamesDice::ComplexDie
   # @param [Symbol] reason Assign a reason for rolling the first die.
   # @return [GamesDice::DieResult] Detailed results from rolling the die, including resolution of rules.
   def roll( reason = :basic )
-    # Important bit - actually roll the die
     @result = GamesDice::DieResult.new( @basic_die.roll, reason )
+    roll_apply_rerolls
+    roll_apply_maps
+    @result
+  end
 
-    if @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
-        break unless rule_idx
+  private
 
-        rule = @rerolls[ rule_idx ]
-        rerolls_remaining[ rule_idx ] -= 1
-        subtracting = true if rule.type == :reroll_subtract
+  def roll_apply_rerolls
+    return unless @rerolls
+    subtracting = false
+    rerolls_remaining = @rerolls.map { |rule| rule.limit }
 
-        # 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
+    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
-    end
+      break unless rule_idx
+
+      rule = @rerolls[ rule_idx ]
+      rerolls_remaining[ rule_idx ] -= 1
+      subtracting = true if rule.type == :reroll_subtract
 
-    # apply any mapping
-    if @maps
-      m, n = calc_maps(@result.value)
-      @result.apply_map( m, n )
+      # 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
     end
+  end
 
-    @result
+  def roll_apply_maps
+    return unless @maps
+    m, n = calc_maps(@result.value)
+    @result.apply_map( m, n )
   end
 
-  private
+  def calc_minmax
+    @min_result, @max_result = [probabilities.min, probabilities.max]
+    return if @probabilities_complete
+    logical_min, logical_max = logical_minmax
+    @min_result, @max_result = [@min_result, @max_result, logical_min, logical_max].minmax
+  end
 
   def construct_rerolls rerolls_input
-    return nil unless rerolls_input
-    raise TypeError, "rerolls should be an Array, instead got #{rerolls_input.inspect}" unless rerolls_input.is_a?(Array)
-    rerolls_input.map do |reroll_item|
-      case reroll_item
-      when Array then GamesDice::RerollRule.new( reroll_item[0], reroll_item[1], reroll_item[2], reroll_item[3] )
-      when GamesDice::RerollRule then reroll_item
-      else
-        raise TypeError, "items in rerolls should be GamesDice::RerollRule or Array, instead got #{reroll_item.inspect}"
-      end
-    end
+    check_and_construct rerolls_input, GamesDice::RerollRule, 'rerolls'
   end
 
   def construct_maps maps_input
-    return nil unless maps_input
-    raise TypeError, "maps should be an Array, instead got #{maps_input.inspect}" unless maps_input.is_a?(Array)
-    maps_input.map do |map_item|
-      case map_item
-      when Array then GamesDice::MapRule.new( map_item[0], map_item[1], map_item[2], map_item[3] )
-      when GamesDice::MapRule then map_item
+    check_and_construct maps_input, GamesDice::MapRule, 'maps'
+  end
+
+  def check_and_construct input, klass, label
+    return nil unless input
+    raise TypeError, "#{label} should be an Array, instead got #{input.inspect}" unless input.is_a?(Array)
+    input.map do |i|
+      case i
+      when Array then klass.new( *i )
+      when klass then i
       else
-        raise TypeError, "items in maps should be GamesDice::MapRule or Array, instead got #{map_item.inspect}"
+        raise TypeError, "items in #{label} should be #{klass.name} or Array, instead got #{i.inspect}"
       end
     end
   end
@@ -217,27 +215,37 @@ class GamesDice::ComplexDie
 
   # This isn't 100% accurate, but does cover most "normal" scenarios, and we're only falling back to it when we have to
   def logical_minmax
-    min_result = 1
-    max_result = @basic_die.sides
-    return [min_result,max_result] unless @rerolls || @maps
-    return minmax_mappings( (min_result..max_result) ) unless @rerolls
-    can_subtract = false
-    @rerolls.each do |rule|
-      next unless rule.type == :reroll_add || rule.type == :reroll_subtract
-      min_reroll,max_reroll = (1..@basic_die.sides).select { |v| rule.applies?( v ) }.minmax
-      next unless min_reroll && max_reroll
+    return [@basic_die.min,@basic_die.max] unless @rerolls || @maps
+    return minmax_mappings( @basic_die.all_values ) unless @rerolls
+    min_result, max_result = logical_rerolls_minmax
+    return minmax_mappings( (min_result..max_result) ) if @maps
+    return [min_result,max_result]
+  end
+
+  def logical_rerolls_minmax
+    min_result = @basic_die.min
+    max_result = @basic_die.max
+    min_subtract, max_add = find_add_subtract_extremes
+    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
+    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
+      next unless min_reroll
       if rule.type == :reroll_subtract
-        can_subtract=true
-        min_result = min_reroll - @basic_die.sides
+        min_subtract = min_reroll if min_subtract.nil?
+        min_subtract = min_reroll if min_subtract > min_reroll
       else
-        max_result += max_reroll * rule.limit
+        total_add += max_reroll * rule.limit
       end
     end
-    if can_subtract
-      min_result -= max_result + @basic_die.sides
-    end
-    return minmax_mappings( (min_result..max_result) ) if @maps
-    return [min_result,max_result]
+    [ 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
@@ -248,7 +256,7 @@ class GamesDice::ComplexDie
       stop_recursing = true
     end
 
-    (1..@basic_die.sides).each do |v|
+    @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 )
 

data/lib/games_dice/dice.rb

@@ -63,30 +63,21 @@ class GamesDice::Dice
   # Simulates rolling dice
   # @return [Integer] Sum of all rolled dice
   def roll
-    @result = @offset + @bunch_multipliers.zip(@bunches).inject(0) do |total,mb|
-      m,b = mb
-      total += m * b.roll
-    end
+    @result = @offset + bunches_weighted_sum( :roll )
   end
 
   # @!attribute [r] min
   # Minimum possible result from a call to #roll
   # @return [Integer]
   def min
-    @min ||= @offset + @bunch_multipliers.zip(@bunches).inject(0) do |total,mb|
-      m,b = mb
-      total += m * b.min
-    end
+    @min ||= @offset + bunches_weighted_sum( :min )
   end
 
   # @!attribute [r] max
   # Maximum possible result from a call to #roll
   # @return [Integer]
   def max
-    @max ||= @offset + @bunch_multipliers.zip(@bunches).inject(0) do |total,mb|
-      m,b = mb
-      total += m * b.max
-    end
+    @max ||= @offset + bunches_weighted_sum( :max )
   end
 
   # @!attribute [r] minmax
@@ -135,10 +126,18 @@ class GamesDice::Dice
   private
 
   def array_to_sum array
-    sum_parts = [ array.first < 0 ? '-' + array.first.abs.to_s : array.first.to_s ]
-    sum_parts += array.drop(1).map { |n| n < 0 ? '- ' + n.abs.to_s : '+ ' + n.to_s }
-    sum_parts += [ '=', array.inject(:+) ]
-    sum_parts.join(' ')
+    ( numbers_to_strings(array) + [ '=', array.inject(:+) ] ).join(' ')
+  end
+
+  def numbers_to_strings array
+    [ array.first.to_s ] + array.drop(1).map { |n| n < 0 ? '- ' + n.abs.to_s : '+ ' + n.to_s }
+  end
+
+  def bunches_weighted_sum summed_method
+    @bunch_multipliers.zip(@bunches).inject(0) do |total,mb|
+      m,b = mb
+      total += m * b.send( summed_method )
+    end
   end
 
 end # class Dice

data/lib/games_dice/die.rb

@@ -68,6 +68,19 @@ class GamesDice::Die
     end
   end
 
+  # Iterates through all possible results on die.
+  # @yieldparam [Integer] result A potential result from the die
+  # @return [GamesDice::Die] this object
+  def each_value
+    (1..@sides).each { |r| yield(r) }
+    self
+  end
+
+  # @return [Array<Integer>] All potential results from the die
+  def all_values
+    (1..@sides).to_a
+  end
+
   # @!attribute [r] rerolls
   # Rules for when to re-roll this die.
   # @return [nil] always nil, available for interface equivalence with GamesDice::ComplexDie

data/lib/games_dice/marshal.rb

@@ -0,0 +1,13 @@
+class GamesDice::Probabilities
+  # @!visibility private
+  # Adds support for Marshal, via to_h and from_h methods
+  def _dump *ignored
+    Marshal.dump to_h
+  end
+
+  # @!visibility private
+  def self._load buf
+    h = Marshal.load buf
+    from_h h
+  end
+end

data/lib/games_dice/probabilities.rb

@@ -183,18 +183,8 @@ class GamesDice::Probabilities
 
     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
-        new_probs[ k ] += pc
-      end
-    end
-    GamesDice::Probabilities.new( new_probs, combined_min )
+    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
@@ -217,18 +207,7 @@ class GamesDice::Probabilities
       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
-        new_probs[ k ] += pc
-      end
-    end
-    GamesDice::Probabilities.new( new_probs, combined_min )
+    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
@@ -246,20 +225,21 @@ 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
-    revbin = n.to_s(2).reverse.each_char.to_a.map { |c| c == '1' }
     pd_power = self
     pd_result = nil
-    max_power = revbin.count - 1
 
-    revbin.each_with_index do |use_power, i|
-      if use_power
+    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
-      pd_power = GamesDice::Probabilities.add_distributions( pd_power, pd_power ) unless i == max_power
+      use_power = use_power << 1
+      break if use_power > n
+      pd_power = GamesDice::Probabilities.add_distributions( pd_power, pd_power )
     end
     pd_result
   end
@@ -275,6 +255,8 @@ class GamesDice::Probabilities
     raise "Cannot combine probabilities less than once" if n < 1
     # 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
@@ -309,6 +291,21 @@ class GamesDice::Probabilities
 
   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) }
@@ -325,41 +322,41 @@ class GamesDice::Probabilities
   end
 
   def calc_keep_distributions k, q, kmode
-    if kmode == :keep_best
-      keep_distributions = [ GamesDice::Probabilities.new( [1.0], q * k ) ]
-      if p_gt(q) > 0.0 && k > 1
-        kd_probabilities = given_ge( q + 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
+    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
-    elsif kmode == :keep_worst
-      keep_distributions = [ GamesDice::Probabilities.new( [1.0], q * k ) ]
-      if p_lt(q) > 0.0 && k > 1
-        kd_probabilities = given_le( q - 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
-    else
-      raise "Keep mode #{kmode.inspect} not recognised"
     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
-    if kmode == :keep_best
+    case kmode
+    when :keep_best
       p_kept = p_gt(q)
       p_rejected = p_lt(q)
-    elsif kmode == :keep_worst
+    when :keep_worst
       p_kept = p_lt(q)
       p_rejected = p_gt(q)
-    else
-      raise "Keep mode #{kmode.inspect} not recognised"
     end
     [ p_rejected, p_maybe, p_kept ]
   end
@@ -388,6 +385,10 @@ class GamesDice::Probabilities
     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

data/lib/games_dice/version.rb

@@ -1,3 +1,3 @@
 module GamesDice
-  VERSION = "0.3.7"
+  VERSION = "0.3.8"
 end

data/spec/complex_die_spec.rb

@@ -57,7 +57,7 @@ describe GamesDice::ComplexDie do
 
     lambda do
       GamesDice::ComplexDie.new( 10, :rerolls => [['hello']] )
-    end.should raise_error( TypeError )
+    end.should raise_error( ArgumentError )
 
     lambda do
       GamesDice::ComplexDie.new( 10, :rerolls =>  [ [6, :<=, :reroll_add ], :reroll_add] )
@@ -82,7 +82,7 @@ describe GamesDice::ComplexDie do
 
     lambda do
       GamesDice::ComplexDie.new( 10, :maps => [ [7] ] )
-    end.should raise_error( TypeError )
+    end.should raise_error( ArgumentError )
 
     lambda do
       GamesDice::ComplexDie.new( 10, :maps => ['hello'] )

data/spec/die_spec.rb

@@ -63,4 +63,20 @@ describe GamesDice::Die do
     end
   end
 
+  describe "#all_values" do
+    it "should return array with one result value per side" do
+      die = GamesDice::Die.new(8)
+      die.all_values.should == [1,2,3,4,5,6,7,8]
+    end
+  end
+
+  describe "#each_value" do
+    it "should iterate through all sides of the die" do
+      die = GamesDice::Die.new(10)
+      arr = []
+      die.each_value { |x| arr << x }
+      arr.should == [1,2,3,4,5,6,7,8,9,10]
+    end
+  end
+
 end

data/spec/fixtures/probs_fair_die_6.dat

@@ -0,0 +1,2 @@
+u:GamesDice::Probabilities
�{if0.16666666666666666if0.16666666666666666if0.16666666666666666i	f0.16666666666666666i
+f0.16666666666666666if0.16666666666666666

data/spec/helpers.rb

@@ -1,4 +1,12 @@
 # games_dice/spec/helpers.rb
+require 'pathname'
+require 'coveralls'
+
+Coveralls.wear!
+
+def fixture name
+  (Pathname.new(__FILE__).dirname + "fixtures" + name).to_s
+end
 
 # TestPRNG tests short predictable series
 class TestPRNG
@@ -17,7 +25,7 @@ class TestPRNGMax
   end
 end
 
-# TestPRNGMax checks behaviour of re-rolls
+# TestPRNGMin checks behaviour of re-rolls
 class TestPRNGMin
   def rand(n)
     1

data/spec/probability_spec.rb

@@ -516,4 +516,12 @@ describe GamesDice::Probabilities do
     end # describe "#repeat_n_sum_k"
 
   end # describe "instance methods"
+
+  describe "serialisation via Marshall" do
+    it "can load a saved GamesDice::Probabilities" do
+      pd6 = File.open( fixture('probs_fair_die_6.dat') ) { |file| Marshal.load(file) }
+      pd6.to_h.should be_valid_distribution
+      pd6.p_gt(4).should be_within(1e-10).of 1.0/3
+    end
+  end
 end

metadata

@@ -1,134 +1,153 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: games_dice
-version: !ruby/object:Gem::Version 
-  hash: 29
+version: !ruby/object:Gem::Version
+  version: 0.3.8
   prerelease: 
-  segments: 
-  - 0
-  - 3
-  - 7
-  version: 0.3.7
 platform: ruby
-authors: 
+authors:
 - Neil Slater
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2013-07-17 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2013-07-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: rspec
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 59
-        segments: 
-        - 2
-        - 13
-        - 0
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 2.13.0
   type: :development
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: rake
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 49
-        segments: 
-        - 1
-        - 9
-        - 1
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 1.9.1
   type: :development
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.9.1
+- !ruby/object:Gem::Dependency
   name: yard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.8.6
+  type: :development
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 51
-        segments: 
-        - 0
-        - 8
-        - 6
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 0.8.6
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.6.7
   type: :development
-  version_requirements: *id003
-- !ruby/object:Gem::Dependency 
-  name: rake-compiler
   prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.6.7
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.7.7
   type: :development
-  version_requirements: *id004
-- !ruby/object:Gem::Dependency 
-  name: redcarpet
   prerelease: false
-  requirement: &id005 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 2
-        - 3
-        - 0
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.7.7
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 2.3.0
-    - - <
-      - !ruby/object:Gem::Version 
-        hash: 7
-        segments: 
-        - 3
-        - 0
-        - 0
-        version: 3.0.0
   type: :development
-  version_requirements: *id005
-- !ruby/object:Gem::Dependency 
-  name: parslet
   prerelease: false
-  requirement: &id006 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 1
-        - 5
-        - 0
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.3.0
+- !ruby/object:Gem::Dependency
+  name: parslet
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 1.5.0
   type: :runtime
-  version_requirements: *id006
-description: A library for simulating dice. Use it to construct dice-rolling systems used in role-playing and board games.
-email: 
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+description: A library for simulating dice. Use it to construct dice-rolling systems
+  used in role-playing and board games.
+email:
 - slobo777@gmail.com
 executables: []
-
-extensions: 
+extensions:
 - ext/games_dice/extconf.rb
 extra_rdoc_files: []
-
-files: 
+files:
 - .gitignore
 - .travis.yml
 - .yardopts
@@ -150,6 +169,7 @@ files:
 - lib/games_dice/die.rb
 - lib/games_dice/die_result.rb
 - lib/games_dice/map_rule.rb
+- lib/games_dice/marshal.rb
 - lib/games_dice/parser.rb
 - lib/games_dice/probabilities.rb
 - lib/games_dice/reroll_rule.rb
@@ -159,6 +179,7 @@ files:
 - spec/dice_spec.rb
 - spec/die_result_spec.rb
 - spec/die_spec.rb
+- spec/fixtures/probs_fair_die_6.dat
 - spec/helpers.rb
 - spec/map_rule_spec.rb
 - spec/parser_spec.rb
@@ -166,44 +187,44 @@ files:
 - spec/readme_spec.rb
 - spec/reroll_rule_spec.rb
 homepage: https://github.com/neilslater/games_dice
-licenses: 
+licenses:
 - MIT
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
       - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+      hash: 4486838003822106921
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
       - 0
-      version: "0"
+      hash: 4486838003822106921
 requirements: []
-
 rubyforge_project: 
 rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
-summary: Simulates and explains dice rolls from simple "1d6" to complex "roll 7 ten-sided dice, take best 3, results of 10 roll again and add on".
-test_files: 
+summary: Simulates and explains dice rolls from simple "1d6" to complex "roll 7 ten-sided
+  dice, take best 3, results of 10 roll again and add on".
+test_files:
 - spec/bunch_spec.rb
 - spec/complex_die_spec.rb
 - spec/dice_spec.rb
 - spec/die_result_spec.rb
 - spec/die_spec.rb
+- spec/fixtures/probs_fair_die_6.dat
 - spec/helpers.rb
 - spec/map_rule_spec.rb
 - spec/parser_spec.rb