hazard 1.3.0 → 1.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e1e25f4c424287018d994674779d8d269c7fa6b4
-  data.tar.gz: 47c5f83f912a690514abdf59f6529412945ef82e
+  metadata.gz: ccb0217f3b63ffd8b667acb3ca8250145540120e
+  data.tar.gz: c0b892b16371e60d4e4a0c71e42c5319bba34ffb
 SHA512:
-  metadata.gz: 04f3188932596ec902ab3cd2fb30bceaa197cdc4f3f01284b2bfd9b84150080686d7478cf586202c7295b3bce11196feade4a6872e9066aed94e7f7a58237069
-  data.tar.gz: e370ad454d0865bf28ba73831695ffb19605a0b3a60b2c6e0c5a8194438fb34bdea7ba3fa321c38e31807cbda6ca2a6f0ea7d0ac8155241ba808d0ec4476bb7c
+  metadata.gz: 60f0e90c335352e3e2f9deac1c18f247bcd791727d751309fe25a41ce2f66d9f816e60e4c7c6bb9db9b3b2f90fffb2bd36a9463dd006e5373338a7944f20a955
+  data.tar.gz: 97cb2d1b0c0cad4616f7e0ab2b8d682fced257c545117b2bb488a66aad73f9a36f479926cb24c8b327e6102855aee9cc97cd75a99b9af519ccd114d718d44d0a

data/.travis.yml

@@ -15,7 +15,6 @@ rvm:
   - 2.2
   - 2.1
   - 2.0
-  - 1.9
 
 before_script:
   - curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter

data/README.md

@@ -28,7 +28,7 @@ Hazard is a very simple dice library for ruby that allows you to :
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'hazard', '~> 1.2'
+gem 'hazard', '~> 1.3', '>= 1.3.1'
 ```
 
 And then execute:
@@ -195,6 +195,21 @@ Examples :
     >> wt = WeightedTable.from_flat_table( :foo, :foo, :bar ]
     >> wt.sample
     # This ensure that you will get 66% foo and 33% bar
+    
+### Weighted tables can also be used with floating points numbers
+
+    >> wt = WeightedTable.new( floating_points: true )
+    >> wt.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( floating_points: true )
+    >> wt.from_weighted_table( [ 2.6, :foo ], [ 1.5, :bar ] ]
+    >> wt.sample
                
 ### Saving and loading
     

data/hazard.gemspec

@@ -28,6 +28,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'minitest', '~> 5.0'
 
-  spec.required_ruby_version = '>= 1.9'
+  spec.required_ruby_version = '>= 2.0'
 
 end

data/lib/hazard/version.rb

@@ -1,3 +1,3 @@
 class Hazard
-  VERSION = '1.3.0'
+  VERSION = '1.3.1'
 end

data/lib/weighted_table.rb

@@ -5,11 +5,14 @@ require 'yaml'
 # @author Cédric ZUGER
 class WeightedTable
 
-  BASE_WEIGHT = 1
+  BASE_WEIGHT = 0
 
-  def initialize
-    @weights = {}
+	# Initialize a WeightedTable
+	# setting floating_points to true indicate that you will work with floating points rather than integers.
+  def initialize( floating_points: false )
+    @weights = []
     @max_weight = BASE_WEIGHT
+		@floating_points = floating_points
   end
 
   # Load a WeightedTable with data
@@ -28,13 +31,23 @@ class WeightedTable
   # @return [WeightedTable] the current WeightedTable
   def from_weighted_table( table )
     raise 'Table must contain at least one element' if table.empty?
+
+		# We may call this method many time for an existing object, so we must clear it
+		@weights.clear
+
     base = BASE_WEIGHT
-    table.each do |t|
-      w = base+t[0]
+		w = nil
+
+    table.each do |weight, data|
+      w = base + weight
+			@weights << [base, w, data]
       base = w
-      @weights[ w ] = t[1]
-      @max_weight = [ @max_weight, w-1 ].max
-    end
+		end
+
+		@max_weight = w
+
+		# p @weights, @max_weight
+
     self
   end
 
@@ -51,16 +64,19 @@ class 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
+		# ... means that @max_weight is excluded
+		if @floating_points
+			r = Kernel.rand( 0.0...@max_weight.to_f )
+		else
+			r = Kernel.rand( 0...@max_weight )
+		end
 
-    until keys.empty?
-      high_mark = keys.shift
-      return @weights[high_mark] if r >= low_mark && r < high_mark
-      low_mark = high_mark
-    end
+		# p r
+
+    @weights.each do |base_weight, max_weight, data|
+			return data if r >= base_weight && r < max_weight
+		end
 
     raise 'Rand not in key range'
   end

data/test/weighted_table_test.rb

@@ -2,92 +2,162 @@ 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 'Rand not in key range' do
-      WeightedTable.from_weighted_table []
-    end
-    assert_raises 'Rand not in key range' do
-      WeightedTable.from_flat_table []
-    end
-  end
-
-  def test_three_element_table
-
-    Kernel.stubs( :rand ).returns( 1 )
-    assert_equal :foo, WeightedTable.from_weighted_table( [ [ 3, :foo ], [ 1, :bar ], [ 1, :foobar ] ] ).sample
-    assert_equal :foo, WeightedTable.from_flat_table(  [ :foo, :foo, :foo, :bar, :foobar ] ).sample
-
-    Kernel.stubs( :rand ).returns( 5 )
-    assert_equal :foobar, WeightedTable.from_weighted_table( [ [ 3, :foo ], [ 1, :bar ], [ 1, :foobar ] ] ).sample
-    assert_equal :foobar, WeightedTable.from_flat_table(  [ :foo, :foo, :foo, :bar, :foobar ] ).sample
-
-  end
-
-  def test_statistics
-    wt = WeightedTable.from_weighted_table [ [ 2, :foo ], [ 1, :bar ] ]
-    results = { foo: 0, bar: 0 }
-
-    rounds = 1000
-
-    1.upto(rounds).each do
-      results[ wt.sample ] += 1
-    end
-
-    assert_in_delta 0.33, (results[:bar].to_f/rounds), 0.1
-    assert_in_delta 0.66, (results[:foo].to_f/rounds), 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
-
-  def test_out_of_range
-    Kernel.stubs( :rand ).returns( 99 )
-    assert_raises do
-      WeightedTable.from_weighted_table( [ [ 3, :foo ], [ 1, :bar ], [ 1, :foobar ] ] ).sample
-    end
-  end
+	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( 0 )
+		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( 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 :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( 4 )
+		assert_raises 'Rand not in key range' do
+			WeightedTable.from_weighted_table []
+		end
+		assert_raises 'Rand not in key range' do
+			WeightedTable.from_flat_table []
+		end
+	end
+
+	def test_three_element_table
+
+		Kernel.stubs( :rand ).returns( 0 )
+		assert_equal :foo, WeightedTable.from_weighted_table( [ [ 3, :foo ], [ 1, :bar ], [ 1, :foobar ] ] ).sample
+		assert_equal :foo, WeightedTable.from_flat_table(  [ :foo, :foo, :foo, :bar, :foobar ] ).sample
+
+		Kernel.stubs( :rand ).returns( 4 )
+		assert_equal :foobar, WeightedTable.from_weighted_table( [ [ 3, :foo ], [ 1, :bar ], [ 1, :foobar ] ] ).sample
+		assert_equal :foobar, WeightedTable.from_flat_table(  [ :foo, :foo, :foo, :bar, :foobar ] ).sample
+	end
+
+	def test_floating_points
+		# 1 -> 4.5 => :foo
+		# 4.5 -> 6 => :bar
+		# 6 -> 7.5 => :foobar
+		wt = WeightedTable.from_weighted_table( [ [ 3.5, :foo ], [ 1.5, :bar ], [ 1.5, :foobar ] ] )
+
+		Kernel.stubs( :rand ).returns( 0.5 )
+		assert_raises 'Rand not in key range' do
+			WeightedTable.from_weighted_table []
+		end
+
+		Kernel.stubs( :rand ).returns( 1 )
+		assert_equal :foo, wt.sample
+
+		Kernel.stubs( :rand ).returns( 1.5 )
+		assert_equal :foo, wt.sample
+
+		Kernel.stubs( :rand ).returns( 4.5 )
+		assert_equal :bar, wt.sample
+
+		Kernel.stubs( :rand ).returns( 4.6 )
+		assert_equal :bar, wt.sample
+
+		Kernel.stubs( :rand ).returns( 6 )
+		assert_equal :foobar, wt.sample
+
+		Kernel.stubs( :rand ).returns( 6.3 )
+		assert_equal :foobar, wt.sample
+
+		Kernel.stubs( :rand ).returns( 7.1 )
+		assert_raises 'Rand not in key range' do
+			WeightedTable.from_weighted_table []
+		end
+	end
+
+	def test_floating_point_statistics
+		wt = WeightedTable.new( floating_points: true )
+
+		tests_arrays = [
+			[[ 2.3, :foo ], [ 1.6, :bar ]], [[ 6.4, :foo ], [ 8.2, :bar ]], [[ 35.7, :foo ], [ 678.9, :bar ]],
+			[[ 6.4, :foo ], [ 8.7, :bar ], [ 4.1, :foobar ]], [[ 56, :foo ], [ 4.9, :bar ], [ 665.4, :foobar ]]
+		]
+
+		tests_arrays.each do |t_a|
+
+			wt.from_weighted_table t_a
+			results = Hash[t_a.map{ |_, elem| [ elem, 0 ] }]
+
+			rounds = 100000
+			1.upto(rounds).each do
+				results[ wt.sample ] += 1
+			end
+
+			weights_sum = t_a.map{ |weight, elem| weight }.inject( :+ ).to_f
+
+			t_a.each do |weight, elem|
+				assert_in_delta weight/weights_sum, (results[elem].to_f/rounds), 0.01
+			end
+		end
+	end
+
+	def test_statistics
+		tests_arrays = [
+			[[ 2, :foo ], [ 1, :bar ]], [[ 6, :foo ], [ 8, :bar ]], [[ 35, :foo ], [ 678, :bar ]],
+			[[ 6, :foo ], [ 8, :bar ], [ 4, :foobar ]], [[ 56, :foo ], [ 4, :bar ], [ 665, :foobar ]]
+		]
+
+		tests_arrays.each do |t_a|
+			wt = WeightedTable.from_weighted_table t_a
+			results = Hash[t_a.map{ |_, elem| [ elem, 0 ] }]
+
+			rounds = 100000
+
+			1.upto(rounds).each do
+				results[ wt.sample ] += 1
+			end
+
+			weights_sum = t_a.map{ |weight, elem| weight }.inject( :+ ).to_f
+
+			t_a.each do |weight, elem|
+				assert_in_delta weight/weights_sum, (results[elem].to_f/rounds), 0.01
+			end
+		end
+	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
+
+	def test_out_of_range
+		Kernel.stubs( :rand ).returns( 99 )
+		assert_raises do
+			WeightedTable.from_weighted_table( [ [ 3, :foo ], [ 1, :bar ], [ 1, :foobar ] ] ).sample
+		end
+	end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hazard
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.3.1
 platform: ruby
 authors:
 - Cédric ZUGER
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-05-06 00:00:00.000000000 Z
+date: 2019-11-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -73,7 +73,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '1.9'
+      version: '2.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="