hazard 1.0.4 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d73a6ac407a313337a1309b8f85680c2acdf9a36
-  data.tar.gz: f26d0073ed98e7d10483815e6b16f6456e582142
+  metadata.gz: f9ae47cda73390cc30cd6d81a594879a0f142308
+  data.tar.gz: 7eb73440367d32076ddbef3b9d2ded4ecb772fe5
 SHA512:
-  metadata.gz: 9b6aa19cf68606574fca81bbb5c3242fbabc44833806078de8a883de43fba72c16df8a10f42b163a0c18e829d70d873bb3e3450634cf30115c08254e43fe4fa4
-  data.tar.gz: 4decd66c91587ad5a1eba94d94d575432c874589801fd9a087e7ba88c50930e6feb1ca1d11a8dfe8d40bdf7cbb221393d0dcc531b6785febcb02f915bbbcd960
+  metadata.gz: 7678295f955f7d2ddc157951b5da6d91746092eaf4f6eaad5c10dfbba7b19505bc676aa3d0baef9be415804e2ee5427d78802d45965ba486d94459d4453ada2d
+  data.tar.gz: 9c000fc08c2bd6debd467784dd728cd106f87958add39c9d8ab28d4b51d24a3f65930e22b55c9d80dee3e3f6b5f77a865b6a427a966552f3cf51da717ac976bb

data/README.md

@@ -5,8 +5,23 @@
 [![Code Climate](https://codeclimate.com/github/czuger/hazard/badges/gpa.svg)](https://codeclimate.com/github/czuger/hazard)
 [![Test Coverage](https://codeclimate.com/github/czuger/hazard/badges/coverage.svg)](https://codeclimate.com/github/czuger/hazard/coverage)
 
-Hazard is a very simple dice library for ruby (see [usage](#usage)).
-
+Hazard is a very simple dice library for ruby that allows you to : 
+* Roll dice and get the sum
+* Roll dice and work with the detail
+* Random pick elements from weighted lists
+
+1. [Installation](#installation)
+1. [Basic Usage](#basic-usage)
+    1. [Roll a simple die](#roll-a-simple-die)
+    1. [Roll multiple dice](#roll-multiple-dice)
+1. [Advanced Usage](#advanced-usage)
+    1. [Roll dice and get the details](#roll-dice-and-get-the-details)
+    1. [Some real cases](#some-real-cases)
+1. [Weighted Tables](#weighted-Tables)
+    1. [If you have the weights](#if-you-have-the-weights)
+    1. [If you don't have the weights (or are to lazy to get them)](#if-you-dont-have-the-weights-or-are-to-lazy-to-get-them)
+    1. [Saving and loading](#saving-and-loading)    
+    
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -27,9 +42,9 @@ If needed :
 
     $ require 'hazard'  
 
-## Usage
+## Basic Usage
 
-**Roll a simple die**
+### Roll a simple die
 
     >> Hazard.d<n>        # where n is an number
     => Roll a n-sided die
@@ -46,7 +61,7 @@ Examples :
     => 38
      
     
-**Roll multiple dice**
+### Roll multiple dice
 
     >> Hazard.r<m>d<n>    # where m and n are numbers
     => Roll m n-sided dice and return the sum
@@ -72,8 +87,9 @@ Examples :
     >> Hazard.d2d6
     => 8      
     
+## Advanced Usage
         
-**Roll dice and get the details**
+### Roll dice and get the details
 
     >> Hazard.s<m>d<n>    # where m and n are numbers
     => Roll m n-sided dice and return a RolledDice object
@@ -100,9 +116,9 @@ Examples :
     >> Hazard.s2d6
     => #<RolledDice:0x007f62e55a0010 @rolls=[1, 6], @result=7>
     
-**Some real cases**
+### Some real cases
          
-    # Assuming you are playing DD Next
+Assuming you are playing DD Next
     
     # You may want to roll 2 d20 dice with advantage (take the greatest)
     # This will rolls 2 d20, get the rolls and get the best of them
@@ -120,8 +136,50 @@ Examples :
     # Should you have the Elemental Adept feat, which mean that you treat all 1 as 2
     # If you cast a fireball, this will do the trick : 
     >> Hazard.s8d6.rolls.map{ |d| d == 1 ? 2 : d }.reduce(:+)
-    => 24                   
+    => 24   
+        
+## Weighted Tables
 
+Weighted tables are object that allow to get weighted random. 
+Example : if you have two time foo and one time bar in your table.
+ 
+### If you have the weights
+
+    >> wt = WeightedTable.from_weighted_table( [ <weight1>, <object1> ], [ <weight2>, <object2> ], ... ]
+    # Create a weighted table storing objects according to theire weights
+    
+    >> wt.sample
+    # Return weighted random object
+    
+Examples : 
+
+    >> wt = WeightedTable.new.from_weighted_table( [ 2, :foo ], [ 1, :bar ] ]
+    >> wt.sample
+    # This ensure that you will get 66% foo and 33% bar
+    
+    
+### If you don't have the weights (or are to lazy to get them)
+    
+    >> wt = WeightedTable.from_flat_table( <object1>, <object1>, <object2>, ... ]
+    # Create a weighted table storing objects computing the weight of the objects according to theire occurences
+    
+    >> wt.sample
+    # Return weighted random object
+        
+Examples : 
+        
+    >> wt = WeightedTable.new.from_flat_table( :foo, :foo, :bar ]
+    >> wt.sample
+    # This ensure that you will get 66% foo and 33% bar
+               
+### Saving and loading
+    
+    # You can save your builded table for future usage
+    >> wt.to_file( filename )
+    
+    # And load it
+    >> wt = WeightedTable.from_file( filename )   
+                                      
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/czuger/hazard. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.

data/lib/hazard/version.rb

@@ -1,3 +1,3 @@
 class Hazard
-  VERSION = '1.0.4'
+  VERSION = '1.1.0'
 end

data/lib/hazard.rb

@@ -1,4 +1,5 @@
 require_relative 'rolled_dice'
+require_relative 'weighted_table'
 
 class Hazard
 

data/lib/weighted_table.rb

@@ -0,0 +1,88 @@
+require 'yaml'
+
+class WeightedTable
+
+  BASE_WEIGHT = 1
+
+  def initialize
+    @weights = {}
+    @max_weight = BASE_WEIGHT
+  end
+
+  # Load a WeightedTable with data
+  # Data format must be : [ [ weight, data ], [ weight, data ], ... ]
+  # Example : [ [ 2, :foo ], [ 1, :bar ] ]
+  #
+  # @return [WeightedTable] the current WeightedTable
+  def self.from_weighted_table( table )
+    WeightedTable.new.from_weighted_table( table )
+  end
+
+  # Load a WeightedTable with data
+  # Data format must be : [ [ weight, data ], [ weight, data ], ... ]
+  # Example : [ [ 2, :foo ], [ 1, :bar ] ]
+  #
+  # @return [WeightedTable] the current WeightedTable
+  def from_weighted_table( table )
+    raise 'Table must contain at least one element' if table.empty?
+    base = BASE_WEIGHT
+    table.each do |t|
+      w = base+t[0]
+      base = w
+      @weights[ w ] = t[1]
+      @max_weight = [ @max_weight, w-1 ].max
+    end
+    self
+  end
+
+  # Load a WeightedTable with data
+  # Data format must be : [ data, data, data ]
+  # Example : [ :foo, :foo, :bar ]
+  #
+  # @return [WeightedTable] the current WeightedTable
+  def self.from_flat_table( table )
+    from_weighted_table( table.group_by{ |e| e }.map{ |k, v| [ v.count, k ] } )
+  end
+
+  # Return a random item from a WeightedTable
+  #
+  # @return [Object] a random object given at the building of the table.
+  def sample
+    r = Kernel.rand( 1..@max_weight )
+    keys = @weights.keys.sort
+
+    low_mark = BASE_WEIGHT
+
+    until keys.empty?
+      high_mark = keys.shift
+      return @weights[high_mark] if r >= low_mark && r < high_mark
+      low_mark = high_mark
+    end
+
+    raise 'Rand not in key range'
+  end
+
+  # Load a WeightedTable with data
+  # Data format must be : [ data, data, data ]
+  # Example : [ :foo, :foo, :bar ]
+  #
+  # @return [WeightedTable] the current WeightedTable
+  def from_flat_table( table )
+    from_weighted_table( table.group_by{ |e| e }.map{ |k, v| [ v.count, k ] } )
+  end
+
+  # Save the table to a file
+  # @param filename [String] the filename where to save the table
+  def to_file( filename )
+    File.open( filename, 'w' ) do |f|
+      f.write( to_yaml )
+    end
+  end
+
+  # Read the table from a file
+  # @param filename [String] the filename from which to read the table
+  def self.from_file( filename )
+    YAML.load_file( filename )
+  end
+
+end

data/test/test_helper.rb

@@ -7,4 +7,5 @@ require 'hazard'
 
 require 'minitest/autorun'
 require 'mocha/mini_test'
+require 'pp'
 

data/test/weighted_table_test.rb

@@ -0,0 +1,73 @@
+require 'test_helper'
+
+class HazardTest < Minitest::Test
+
+  def test_empty_table
+    assert_raises do
+      WeightedTable.from_weighted_table []
+    end
+    assert_raises do
+      WeightedTable.from_flat_table []
+    end
+  end
+
+  def test_one_element_table
+    assert_equal :foo, WeightedTable.from_weighted_table( [ [ 3, :foo ] ] ).sample
+    assert_equal :foo, WeightedTable.from_flat_table(  [ :foo, :foo, :foo ] ).sample
+  end
+
+  def test_two_element_table
+    Kernel.stubs( :rand ).returns( 0 )
+    assert_raises do
+      WeightedTable.from_weighted_table []
+    end
+    assert_raises do
+      WeightedTable.from_flat_table []
+    end
+
+    Kernel.stubs( :rand ).returns( 1 )
+    assert_equal :foo, WeightedTable.from_weighted_table( [ [ 3, :foo ], [ 1, :bar ] ] ).sample
+    assert_equal :foo, WeightedTable.from_flat_table(  [ :foo, :foo, :foo, :bar ] ).sample
+    Kernel.stubs( :rand ).returns( 2 )
+    assert_equal :foo, WeightedTable.from_weighted_table( [ [ 3, :foo ], [ 1, :bar ] ] ).sample
+    assert_equal :foo, WeightedTable.from_flat_table(  [ :foo, :foo, :foo, :bar ] ).sample
+    Kernel.stubs( :rand ).returns( 3 )
+    assert_equal :foo, WeightedTable.from_weighted_table( [ [ 3, :foo ], [ 1, :bar ] ] ).sample
+    assert_equal :foo, WeightedTable.from_flat_table(  [ :foo, :foo, :foo, :bar ] ).sample
+    Kernel.stubs( :rand ).returns( 4 )
+    assert_equal :bar, WeightedTable.from_weighted_table( [ [ 3, :foo ], [ 1, :bar ] ] ).sample
+    assert_equal :bar, WeightedTable.from_flat_table(  [ :foo, :foo, :foo, :bar ] ).sample
+
+    Kernel.stubs( :rand ).returns( 5 )
+    assert_raises do
+      WeightedTable.from_weighted_table []
+    end
+    assert_raises do
+      WeightedTable.from_flat_table []
+    end
+  end
+
+  def test_statistics
+
+    wt = WeightedTable.from_weighted_table [ [ 2, :foo ], [ 1, :bar ] ]
+    results = { foo: 0, bar: 0 }
+    1.upto(100).each do
+      results[ wt.sample ] += 1
+    end
+
+    assert_in_delta 0.33, (results[:bar]*0.01), 0.1
+    assert_in_delta 0.66, (results[:foo]*0.01), 0.1
+  end
+
+  def test_save_and_load
+    wt = WeightedTable.from_weighted_table [ [ 2, :foo ], [ 1, :bar ] ]
+    wt.to_file( 'wt.yaml' )
+    wt = nil
+    wt = WeightedTable.from_file( 'wt.yaml' )
+    Kernel.stubs( :rand ).returns( 1 )
+    assert_equal :foo, wt.sample
+    assert_equal :foo, wt.sample
+    `rm wt.yaml`
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hazard
 version: !ruby/object:Gem::Version
-  version: 1.0.4
+  version: 1.1.0
 platform: ruby
 authors:
 - Cédric ZUGER
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-03-20 00:00:00.000000000 Z
+date: 2018-04-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -71,8 +71,10 @@ files:
 - lib/hazard.rb
 - lib/hazard/version.rb
 - lib/rolled_dice.rb
+- lib/weighted_table.rb
 - test/hazard_test.rb
 - test/test_helper.rb
+- test/weighted_table_test.rb
 homepage: https://github.com/czuger/hazard
 licenses:
 - MIT
@@ -100,3 +102,4 @@ summary: Dice library for ruby
 test_files:
 - test/hazard_test.rb
 - test/test_helper.rb
+- test/weighted_table_test.rb