games_dice 0.4.0 → 0.5.0

data/spec/probability_spec.rb

@@ -1,39 +1,41 @@
 # frozen_string_literal: true
 
 require 'helpers'
+require 'objspace'
 
 describe GamesDice::Probabilities do
   describe 'class methods' do
     describe '#new' do
-      it 'should create a new distribution from an array and offset' do
-        pr = GamesDice::Probabilities.new([1.0], 1)
-        expect(pr).to be_a GamesDice::Probabilities
+      it 'create a new distribution from an array and offset' do
+        pr = described_class.new([1.0], 1)
+        expect(pr).to be_a described_class
         expect(pr.to_h).to be_valid_distribution
       end
 
-      it 'should raise an error if passed incorrect parameter types' do
-        expect(-> { GamesDice::Probabilities.new([nil], 20) }).to raise_error TypeError
-        expect(-> { GamesDice::Probabilities.new([0.3, nil, 0.5], 7) }).to raise_error TypeError
-        expect(-> { GamesDice::Probabilities.new([0.3, 0.2, 0.5], {}) }).to raise_error TypeError
-        expect(-> { GamesDice::Probabilities.new({ x: :y }, 17) }).to raise_error TypeError
+      it 'raise an error if passed incorrect parameter types' do
+        expect { described_class.new([nil], 20) }.to raise_error TypeError
+        expect { described_class.new([0.3, nil, 0.5], 7) }.to raise_error TypeError
+        expect { described_class.new([0.3, 0.2, 0.5], {}) }.to raise_error TypeError
+        expect { described_class.new({ x: :y }, 17) }.to raise_error TypeError
       end
 
-      it 'should raise an error if distribution is incomplete or inaccurate' do
-        expect(-> { GamesDice::Probabilities.new([0.3, 0.2, 0.6], 3) }).to raise_error ArgumentError
-        expect(-> { GamesDice::Probabilities.new([], 1) }).to raise_error ArgumentError
-        expect(-> { GamesDice::Probabilities.new([0.9], 1) }).to raise_error ArgumentError
-        expect(-> { GamesDice::Probabilities.new([-0.9, 0.2, 0.9], 1) }).to raise_error ArgumentError
+      it 'raise an error if distribution is incomplete or inaccurate' do
+        expect { described_class.new([0.3, 0.2, 0.6], 3) }.to raise_error ArgumentError
+        expect { described_class.new([], 1) }.to raise_error ArgumentError
+        expect { described_class.new([0.9], 1) }.to raise_error ArgumentError
+        expect { described_class.new([-0.9, 0.2, 0.9], 1) }.to raise_error ArgumentError
+        expect { described_class.new([1.1], 1) }.to raise_error ArgumentError
       end
     end
 
     describe '#for_fair_die' do
-      it 'should create a new distribution based on number of sides' do
-        pr2 = GamesDice::Probabilities.for_fair_die(2)
-        expect(pr2).to be_a GamesDice::Probabilities
+      it 'create a new distribution based on number of sides' do
+        pr2 = described_class.for_fair_die(2)
+        expect(pr2).to be_a described_class
         expect(pr2.to_h).to eql({ 1 => 0.5, 2 => 0.5 })
         (1..20).each do |sides|
-          pr = GamesDice::Probabilities.for_fair_die(sides)
-          expect(pr).to be_a GamesDice::Probabilities
+          pr = described_class.for_fair_die(sides)
+          expect(pr).to be_a described_class
           h = pr.to_h
           expect(h).to be_valid_distribution
           expect(h.keys.count).to eql sides
@@ -41,27 +43,27 @@ describe GamesDice::Probabilities do
         end
       end
 
-      it 'should raise an error if number of sides is not an integer' do
-        expect(-> { GamesDice::Probabilities.for_fair_die({}) }).to raise_error TypeError
+      it 'raise an error if number of sides is not an integer' do
+        expect { described_class.for_fair_die({}) }.to raise_error TypeError
       end
 
-      it 'should raise an error if number of sides is too low or too high' do
-        expect(-> { GamesDice::Probabilities.for_fair_die(0) }).to raise_error ArgumentError
-        expect(-> { GamesDice::Probabilities.for_fair_die(1_000_001) }).to raise_error ArgumentError
+      it 'raise an error if number of sides is too low or too high' do
+        expect { described_class.for_fair_die(0) }.to raise_error ArgumentError
+        expect { described_class.for_fair_die(1_000_001) }.to raise_error ArgumentError
       end
     end
 
     describe '#add_distributions' do
-      it 'should combine two distributions to create a third one' do
-        d4a = GamesDice::Probabilities.new([1.0 / 4, 1.0 / 4, 1.0 / 4, 1.0 / 4], 1)
-        d4b = GamesDice::Probabilities.new([1.0 / 10, 2.0 / 10, 3.0 / 10, 4.0 / 10], 1)
-        pr = GamesDice::Probabilities.add_distributions(d4a, d4b)
+      it 'combine two distributions to create a third one' do
+        d4a = described_class.new([1.0 / 4, 1.0 / 4, 1.0 / 4, 1.0 / 4], 1)
+        d4b = described_class.new([1.0 / 10, 2.0 / 10, 3.0 / 10, 4.0 / 10], 1)
+        pr = described_class.add_distributions(d4a, d4b)
         expect(pr.to_h).to be_valid_distribution
       end
 
-      it 'should calculate a classic 2d6 distribution accurately' do
-        d6 = GamesDice::Probabilities.for_fair_die(6)
-        pr = GamesDice::Probabilities.add_distributions(d6, d6)
+      it 'calculate a classic 2d6 distribution accurately' do
+        d6 = described_class.for_fair_die(6)
+        pr = described_class.add_distributions(d6, d6)
         h = pr.to_h
         expect(h).to be_valid_distribution
         expect(h[2]).to be_within(1e-9).of 1.0 / 36
@@ -77,26 +79,26 @@ describe GamesDice::Probabilities do
         expect(h[12]).to be_within(1e-9).of 1.0 / 36
       end
 
-      it 'should raise an error if either parameter is not a GamesDice::Probabilities object' do
-        d10 = GamesDice::Probabilities.for_fair_die(10)
-        expect(-> { GamesDice::Probabilities.add_distributions('', 6) }).to raise_error TypeError
-        expect(-> { GamesDice::Probabilities.add_distributions(d10, 6) }).to raise_error TypeError
-        expect(-> { GamesDice::Probabilities.add_distributions('', d10) }).to raise_error TypeError
+      it 'raise an error if either parameter is not a GamesDice::Probabilities object' do
+        d10 = described_class.for_fair_die(10)
+        expect { described_class.add_distributions('', 6) }.to raise_error TypeError
+        expect { described_class.add_distributions(d10, 6) }.to raise_error TypeError
+        expect { described_class.add_distributions('', d10) }.to raise_error TypeError
       end
     end
 
     describe '#add_distributions_mult' do
-      it 'should combine two multiplied distributions to create a third one' do
-        d4a = GamesDice::Probabilities.new([1.0 / 4, 1.0 / 4, 1.0 / 4, 1.0 / 4], 1)
-        d4b = GamesDice::Probabilities.new([1.0 / 10, 2.0 / 10, 3.0 / 10, 4.0 / 10], 1)
-        pr = GamesDice::Probabilities.add_distributions_mult(2, d4a, -1, d4b)
+      it 'combine two multiplied distributions to create a third one' do
+        d4a = described_class.new([1.0 / 4, 1.0 / 4, 1.0 / 4, 1.0 / 4], 1)
+        d4b = described_class.new([1.0 / 10, 2.0 / 10, 3.0 / 10, 4.0 / 10], 1)
+        pr = described_class.add_distributions_mult(2, d4a, -1, d4b)
         expect(pr.to_h).to be_valid_distribution
       end
 
-      it "should calculate a distribution for '1d6 - 1d4' accurately" do
-        d6 = GamesDice::Probabilities.for_fair_die(6)
-        d4 = GamesDice::Probabilities.for_fair_die(4)
-        pr = GamesDice::Probabilities.add_distributions_mult(1, d6, -1, d4)
+      it "calculate a distribution for '1d6 - 1d4' accurately" do
+        d6 = described_class.for_fair_die(6)
+        d4 = described_class.for_fair_die(4)
+        pr = described_class.add_distributions_mult(1, d6, -1, d4)
         h = pr.to_h
         expect(h).to be_valid_distribution
         expect(h[-3]).to be_within(1e-9).of 1.0 / 24
@@ -110,10 +112,10 @@ describe GamesDice::Probabilities do
         expect(h[5]).to be_within(1e-9).of 1.0 / 24
       end
 
-      it 'should add asymmetric distributions accurately' do
-        da = GamesDice::Probabilities.new([0.7, 0.0, 0.3], 2)
-        db = GamesDice::Probabilities.new([0.5, 0.3, 0.2], 2)
-        pr = GamesDice::Probabilities.add_distributions_mult(1, da, 2, db)
+      it 'add asymmetric distributions accurately' do
+        da = described_class.new([0.7, 0.0, 0.3], 2)
+        db = described_class.new([0.5, 0.3, 0.2], 2)
+        pr = described_class.add_distributions_mult(1, da, 2, db)
         h = pr.to_h
         expect(h).to be_valid_distribution
         expect(h[6]).to be_within(1e-9).of 0.7 * 0.5
@@ -122,70 +124,83 @@ describe GamesDice::Probabilities do
         expect(h[12]).to be_within(1e-9).of 0.3 * 0.2
       end
 
-      it 'should raise an error if passed incorrect objects for distributions' do
-        d10 = GamesDice::Probabilities.for_fair_die(10)
-        expect(-> { GamesDice::Probabilities.add_distributions_mult(1, '', -1, 6) }).to raise_error TypeError
-        expect(-> { GamesDice::Probabilities.add_distributions_mult(2, d10, 3, 6) }).to raise_error TypeError
-        expect(-> { GamesDice::Probabilities.add_distributions_mult(1, '', -1, d10) }).to raise_error TypeError
+      it 'raise an error if passed incorrect objects for distributions' do
+        d10 = described_class.for_fair_die(10)
+        expect { described_class.add_distributions_mult(1, '', -1, 6) }.to raise_error TypeError
+        expect { described_class.add_distributions_mult(2, d10, 3, 6) }.to raise_error TypeError
+        expect { described_class.add_distributions_mult(1, '', -1, d10) }.to raise_error TypeError
       end
 
-      it 'should raise an error if passed incorrect objects for multipliers' do
-        d10 = GamesDice::Probabilities.for_fair_die(10)
-        expect(-> { GamesDice::Probabilities.add_distributions_mult({}, d10, [], d10) }).to raise_error TypeError
-        expect(-> { GamesDice::Probabilities.add_distributions_mult([7], d10, 3, d10) }).to raise_error TypeError
-        expect(-> { GamesDice::Probabilities.add_distributions_mult(1, d10, {}, d10) }).to raise_error TypeError
+      it 'raise an error if passed incorrect objects for multipliers' do
+        d10 = described_class.for_fair_die(10)
+        expect { described_class.add_distributions_mult({}, d10, [], d10) }.to raise_error TypeError
+        expect { described_class.add_distributions_mult([7], d10, 3, d10) }.to raise_error TypeError
+        expect { described_class.add_distributions_mult(1, d10, {}, d10) }.to raise_error TypeError
       end
     end
 
     describe '#from_h' do
-      it 'should create a Probabilities object from a valid hash' do
-        pr = GamesDice::Probabilities.from_h({ 7 => 0.5, 9 => 0.5 })
-        expect(pr).to be_a GamesDice::Probabilities
+      it 'create a Probabilities object from a valid hash' do
+        pr = described_class.from_h({ 7 => 0.5, 9 => 0.5 })
+        expect(pr).to be_a described_class
       end
 
-      it 'should raise an ArgumentError when called with a non-valid hash' do
-        expect(-> { GamesDice::Probabilities.from_h({ 7 => 0.5, 9 => 0.6 }) }).to raise_error ArgumentError
+      it 'create the same distribution when hash keys descend' do
+        pr = described_class.from_h({ 9 => 0.5, 7 => 0.5 })
+        expect(pr.to_h).to eql({ 7 => 0.5, 9 => 0.5 })
       end
 
-      it 'should raise an TypeError when called with data that is not a hash' do
-        expect(-> { GamesDice::Probabilities.from_h(:foo) }).to raise_error TypeError
+      it 'raise an ArgumentError when called with a non-valid hash' do
+        expect { described_class.from_h({ 7 => 0.5, 9 => 0.6 }) }.to raise_error ArgumentError
+        expect { described_class.from_h({ 7 => 0.4, 9 => 0.5 }) }.to raise_error ArgumentError
       end
 
-      it 'should raise a TypeError when called when keys and values are not all integers and floats' do
-        expect(-> { GamesDice::Probabilities.from_h({ 'x' => 0.5, 9 => 0.5 }) }).to raise_error TypeError
-        expect(-> { GamesDice::Probabilities.from_h({ 7 => [], 9 => 0.5 }) }).to raise_error TypeError
+      it 'raise an TypeError when called with data that is not a hash' do
+        expect { described_class.from_h(:foo) }.to raise_error TypeError
       end
 
-      it 'should raise an ArgumentError when results are spread very far apart' do
-        expect(-> { GamesDice::Probabilities.from_h({ 0 => 0.5, 2_000_000 => 0.5 }) }).to raise_error ArgumentError
+      it 'raise a TypeError when called when keys and values are not all integers and floats' do
+        expect { described_class.from_h({ 'x' => 0.5, 9 => 0.5 }) }.to raise_error TypeError
+        expect { described_class.from_h({ 7 => [], 9 => 0.5 }) }.to raise_error TypeError
       end
-    end
 
-    describe '#implemented_in' do
-      it 'should be either :c or :ruby' do
-        lang = GamesDice::Probabilities.implemented_in
-        expect(lang).to be_a Symbol
-        expect(%i[c ruby].member?(lang)).to eql true
+      it 'raise an ArgumentError when results are spread very far apart' do
+        expect { described_class.from_h({ 0 => 0.5, 2_000_000 => 0.5 }) }.to raise_error ArgumentError
       end
     end
   end
 
   describe 'instance methods' do
-    let(:pr2) { GamesDice::Probabilities.for_fair_die(2) }
-    let(:pr4) { GamesDice::Probabilities.for_fair_die(4) }
-    let(:pr6) { GamesDice::Probabilities.for_fair_die(6) }
-    let(:pr10) { GamesDice::Probabilities.for_fair_die(10) }
-    let(:pra) { GamesDice::Probabilities.new([0.4, 0.2, 0.4], -1) }
+    let(:pr2) { described_class.for_fair_die(2) }
+    let(:pr4) { described_class.for_fair_die(4) }
+    let(:pr6) { described_class.for_fair_die(6) }
+    let(:pr10) { described_class.for_fair_die(10) }
+    let(:pra) { described_class.new([0.4, 0.2, 0.4], -1) }
+
+    describe '#clone' do
+      it 'create an independent object with the same distribution' do
+        copy = pra.clone
+        expect(copy).not_to equal(pra)
+        expect(copy.to_h).to eql(pra.to_h)
+      end
+    end
+
+    describe 'native memory accounting' do
+      it 'include allocated probability arrays' do
+        empty = described_class.allocate
+        expect(ObjectSpace.memsize_of(pr10)).to be > ObjectSpace.memsize_of(empty)
+      end
+    end
 
     describe '#each' do
-      it 'should iterate through all result/probability pairs' do
+      it 'iterate through all result/probability pairs' do
         yielded = []
         pr4.each { |r, p| yielded << [r, p] }
         expect(yielded).to eql [[1, 0.25], [2, 0.25], [3, 0.25], [4, 0.25]]
       end
 
-      it 'should skip zero probabilities' do
-        pr_plus_minus = GamesDice::Probabilities.new([0.5, 0.0, 0.5], -1)
+      it 'skip zero probabilities' do
+        pr_plus_minus = described_class.new([0.5, 0.0, 0.5], -1)
         yielded = []
         pr_plus_minus.each { |r, p| yielded << [r, p] }
         expect(yielded).to eql [[-1, 0.5], [1, 0.5]]
@@ -193,7 +208,7 @@ describe GamesDice::Probabilities do
     end
 
     describe '#p_eql' do
-      it 'should return probability of getting a number inside the range' do
+      it 'return probability of getting a number inside the range' do
         expect(pr2.p_eql(2)).to be_within(1.0e-9).of 0.5
         expect(pr4.p_eql(1)).to be_within(1.0e-9).of 0.25
         expect(pr6.p_eql(6)).to be_within(1.0e-9).of 1.0 / 6
@@ -201,21 +216,21 @@ describe GamesDice::Probabilities do
         expect(pra.p_eql(-1)).to be_within(1.0e-9).of 0.4
       end
 
-      it 'should return 0.0 for values not covered by distribution' do
-        expect(pr2.p_eql(3)).to eql 0.0
-        expect(pr4.p_eql(-1)).to eql 0.0
-        expect(pr6.p_eql(8)).to eql 0.0
-        expect(pr10.p_eql(11)).to eql 0.0
-        expect(pra.p_eql(2)).to eql 0.0
+      it 'return 0.0 for values not covered by distribution' do
+        expect(pr2.p_eql(3)).to be 0.0
+        expect(pr4.p_eql(-1)).to be 0.0
+        expect(pr6.p_eql(8)).to be 0.0
+        expect(pr10.p_eql(11)).to be 0.0
+        expect(pra.p_eql(2)).to be 0.0
       end
 
-      it 'should raise a TypeError if asked for probability of non-Integer' do
-        expect(-> { pr2.p_eql([]) }).to raise_error TypeError
+      it 'raise a TypeError if asked for probability of non-Integer' do
+        expect { pr2.p_eql([]) }.to raise_error TypeError
       end
     end
 
     describe '#p_gt' do
-      it 'should return probability of getting a number greater than target' do
+      it 'return probability of getting a number greater than target' do
         expect(pr2.p_gt(1)).to be_within(1.0e-9).of 0.5
         expect(pr4.p_gt(3)).to be_within(1.0e-9).of 0.25
         expect(pr6.p_gt(2)).to be_within(1.0e-9).of 4.0 / 6
@@ -228,111 +243,111 @@ describe GamesDice::Probabilities do
         expect(pra.p_gt(1)).to be_within(1.0e-9).of 0.0
       end
 
-      it 'should return 0.0 when the target number is equal or higher than maximum possible' do
-        expect(pr2.p_gt(2)).to eql 0.0
-        expect(pr4.p_gt(5)).to eql 0.0
-        expect(pr6.p_gt(6)).to eql 0.0
-        expect(pr10.p_gt(20)).to eql 0.0
-        expect(pra.p_gt(3)).to eql 0.0
+      it 'return 0.0 when the target number is equal or higher than maximum possible' do
+        expect(pr2.p_gt(2)).to be 0.0
+        expect(pr4.p_gt(5)).to be 0.0
+        expect(pr6.p_gt(6)).to be 0.0
+        expect(pr10.p_gt(20)).to be 0.0
+        expect(pra.p_gt(3)).to be 0.0
       end
 
-      it 'should return 1.0 when the target number is lower than minimum' do
-        expect(pr2.p_gt(0)).to eql 1.0
-        expect(pr4.p_gt(-5)).to eql 1.0
-        expect(pr6.p_gt(0)).to eql 1.0
-        expect(pr10.p_gt(-200)).to eql 1.0
-        expect(pra.p_gt(-2)).to eql 1.0
+      it 'return 1.0 when the target number is lower than minimum' do
+        expect(pr2.p_gt(0)).to be 1.0
+        expect(pr4.p_gt(-5)).to be 1.0
+        expect(pr6.p_gt(0)).to be 1.0
+        expect(pr10.p_gt(-200)).to be 1.0
+        expect(pra.p_gt(-2)).to be 1.0
       end
 
-      it 'should raise a TypeError if asked for probability of non-Integer' do
-        expect(-> { pr2.p_gt({}) }).to raise_error TypeError
+      it 'raise a TypeError if asked for probability of non-Integer' do
+        expect { pr2.p_gt({}) }.to raise_error TypeError
       end
     end
 
     describe '#p_ge' do
-      it 'should return probability of getting a number greater than or equal to target' do
+      it 'return probability of getting a number greater than or equal to target' do
         expect(pr2.p_ge(2)).to be_within(1.0e-9).of 0.5
         expect(pr4.p_ge(3)).to be_within(1.0e-9).of 0.5
         expect(pr6.p_ge(2)).to be_within(1.0e-9).of 5.0 / 6
         expect(pr10.p_ge(6)).to be_within(1.0e-9).of 0.5
       end
 
-      it 'should return 0.0 when the target number is higher than maximum possible' do
-        expect(pr2.p_ge(6)).to eql 0.0
-        expect(pr4.p_ge(5)).to eql 0.0
-        expect(pr6.p_ge(7)).to eql 0.0
-        expect(pr10.p_ge(20)).to eql 0.0
+      it 'return 0.0 when the target number is higher than maximum possible' do
+        expect(pr2.p_ge(6)).to be 0.0
+        expect(pr4.p_ge(5)).to be 0.0
+        expect(pr6.p_ge(7)).to be 0.0
+        expect(pr10.p_ge(20)).to be 0.0
       end
 
-      it 'should return 1.0 when the target number is lower than or equal to minimum possible' do
-        expect(pr2.p_ge(1)).to eql 1.0
-        expect(pr4.p_ge(-5)).to eql 1.0
-        expect(pr6.p_ge(1)).to eql 1.0
-        expect(pr10.p_ge(-200)).to eql 1.0
+      it 'return 1.0 when the target number is lower than or equal to minimum possible' do
+        expect(pr2.p_ge(1)).to be 1.0
+        expect(pr4.p_ge(-5)).to be 1.0
+        expect(pr6.p_ge(1)).to be 1.0
+        expect(pr10.p_ge(-200)).to be 1.0
       end
 
-      it 'should raise a TypeError if asked for probability of non-Integer' do
-        expect(-> { pr4.p_ge({}) }).to raise_error TypeError
+      it 'raise a TypeError if asked for probability of non-Integer' do
+        expect { pr4.p_ge({}) }.to raise_error TypeError
       end
     end
 
     describe '#p_le' do
-      it 'should return probability of getting a number less than or equal to target' do
+      it 'return probability of getting a number less than or equal to target' do
         expect(pr2.p_le(1)).to be_within(1.0e-9).of 0.5
         expect(pr4.p_le(2)).to be_within(1.0e-9).of 0.5
         expect(pr6.p_le(2)).to be_within(1.0e-9).of 2.0 / 6
         expect(pr10.p_le(6)).to be_within(1.0e-9).of 0.6
       end
 
-      it 'should return 1.0 when the target number is higher than or equal to maximum possible' do
-        expect(pr2.p_le(6)).to eql 1.0
-        expect(pr4.p_le(4)).to eql 1.0
-        expect(pr6.p_le(7)).to eql 1.0
-        expect(pr10.p_le(10)).to eql 1.0
+      it 'return 1.0 when the target number is higher than or equal to maximum possible' do
+        expect(pr2.p_le(6)).to be 1.0
+        expect(pr4.p_le(4)).to be 1.0
+        expect(pr6.p_le(7)).to be 1.0
+        expect(pr10.p_le(10)).to be 1.0
       end
 
-      it 'should return 0.0 when the target number is lower than minimum possible' do
-        expect(pr2.p_le(0)).to eql 0.0
-        expect(pr4.p_le(-5)).to eql 0.0
-        expect(pr6.p_le(0)).to eql 0.0
-        expect(pr10.p_le(-200)).to eql 0.0
+      it 'return 0.0 when the target number is lower than minimum possible' do
+        expect(pr2.p_le(0)).to be 0.0
+        expect(pr4.p_le(-5)).to be 0.0
+        expect(pr6.p_le(0)).to be 0.0
+        expect(pr10.p_le(-200)).to be 0.0
       end
 
-      it 'should raise a TypeError if asked for probability of non-Integer' do
-        expect(-> { pr4.p_le([]) }).to raise_error TypeError
+      it 'raise a TypeError if asked for probability of non-Integer' do
+        expect { pr4.p_le([]) }.to raise_error TypeError
       end
     end
 
     describe '#p_lt' do
-      it 'should return probability of getting a number less than target' do
+      it 'return probability of getting a number less than target' do
         expect(pr2.p_lt(2)).to be_within(1.0e-9).of 0.5
         expect(pr4.p_lt(3)).to be_within(1.0e-9).of 0.5
         expect(pr6.p_lt(2)).to be_within(1.0e-9).of 1 / 6.0
         expect(pr10.p_lt(6)).to be_within(1.0e-9).of 0.5
       end
 
-      it 'should return 1.0 when the target number is higher than maximum possible' do
-        expect(pr2.p_lt(6)).to eql 1.0
-        expect(pr4.p_lt(5)).to eql 1.0
-        expect(pr6.p_lt(7)).to eql 1.0
-        expect(pr10.p_lt(20)).to eql 1.0
+      it 'return 1.0 when the target number is higher than maximum possible' do
+        expect(pr2.p_lt(6)).to be 1.0
+        expect(pr4.p_lt(5)).to be 1.0
+        expect(pr6.p_lt(7)).to be 1.0
+        expect(pr10.p_lt(20)).to be 1.0
       end
 
-      it 'should return 0.0 when the target number is lower than or equal to minimum possible' do
-        expect(pr2.p_lt(1)).to eql 0.0
-        expect(pr4.p_lt(-5)).to eql 0.0
-        expect(pr6.p_lt(1)).to eql 0.0
-        expect(pr10.p_lt(-200)).to eql 0.0
+      it 'return 0.0 when the target number is lower than or equal to minimum possible' do
+        expect(pr2.p_lt(1)).to be 0.0
+        expect(pr4.p_lt(-5)).to be 0.0
+        expect(pr6.p_lt(1)).to be 0.0
+        expect(pr10.p_lt(-200)).to be 0.0
       end
 
-      it 'should raise a TypeError if asked for probability of non-Integer' do
-        expect(-> { pr6.p_lt({}) }).to raise_error TypeError
+      it 'raise a TypeError if asked for probability of non-Integer' do
+        expect { pr6.p_lt({}) }.to raise_error TypeError
       end
     end
 
     describe '#to_h' do
       # This is used loads in other tests
-      it 'should represent a valid distribution with each integer result associated with its probability' do
+      it 'represent a valid distribution with each integer result associated with its probability' do
         expect(pr2.to_h).to be_valid_distribution
         expect(pr4.to_h).to be_valid_distribution
         expect(pr6.to_h).to be_valid_distribution
@@ -341,87 +356,101 @@ describe GamesDice::Probabilities do
     end
 
     describe '#min' do
-      it 'should return lowest possible result allowed by distribution' do
-        expect(pr2.min).to eql 1
-        expect(pr4.min).to eql 1
-        expect(pr6.min).to eql 1
-        expect(pr10.min).to eql 1
-        expect(GamesDice::Probabilities.add_distributions(pr6, pr10).min).to eql 2
+      it 'return lowest possible result allowed by distribution' do
+        expect(pr2.min).to be 1
+        expect(pr4.min).to be 1
+        expect(pr6.min).to be 1
+        expect(pr10.min).to be 1
+        expect(described_class.add_distributions(pr6, pr10).min).to be 2
       end
     end
 
     describe '#max' do
-      it 'should return highest possible result allowed by distribution' do
-        expect(pr2.max).to eql 2
-        expect(pr4.max).to eql 4
-        expect(pr6.max).to eql 6
-        expect(pr10.max).to eql 10
-        expect(GamesDice::Probabilities.add_distributions(pr6, pr10).max).to eql 16
+      it 'return highest possible result allowed by distribution' do
+        expect(pr2.max).to be 2
+        expect(pr4.max).to be 4
+        expect(pr6.max).to be 6
+        expect(pr10.max).to be 10
+        expect(described_class.add_distributions(pr6, pr10).max).to be 16
       end
     end
 
     describe '#expected' do
-      it 'should return the weighted mean value' do
+      it 'return the weighted mean value' do
         expect(pr2.expected).to be_within(1.0e-9).of 1.5
         expect(pr4.expected).to be_within(1.0e-9).of 2.5
         expect(pr6.expected).to be_within(1.0e-9).of 3.5
         expect(pr10.expected).to be_within(1.0e-9).of 5.5
-        expect(GamesDice::Probabilities.add_distributions(pr6, pr10).expected).to be_within(1.0e-9).of 9.0
+        expect(described_class.add_distributions(pr6, pr10).expected).to be_within(1.0e-9).of 9.0
       end
     end
 
     describe '#given_ge' do
-      it 'should return a new distribution with probabilities calculated assuming value is >= target' do
+      it 'return a new distribution with probabilities calculated assuming value is >= target' do
         pd = pr2.given_ge(2)
         expect(pd.to_h).to eql({ 2 => 1.0 })
         pd = pr10.given_ge(4)
         expect(pd.to_h).to be_valid_distribution
-        expect(pd.p_eql(3)).to eql 0.0
+        expect(pd.p_eql(3)).to be 0.0
         expect(pd.p_eql(10)).to be_within(1.0e-9).of 0.1 / 0.7
       end
 
-      it 'should raise a TypeError if asked for probability of non-Integer' do
-        expect(-> { pr10.given_ge([]) }).to raise_error TypeError
+      it 'raise a TypeError if asked for probability of non-Integer' do
+        expect { pr10.given_ge([]) }.to raise_error TypeError
+      end
+
+      it 'clamp targets below the minimum and reject targets above the maximum' do
+        expect(pr10.given_ge(0).to_h).to eql(pr10.to_h)
+        expect { pr10.given_ge(11) }.to raise_error(RuntimeError, /divide by zero/)
       end
     end
 
     describe '#given_le' do
-      it 'should return a new distribution with probabilities calculated assuming value is <= target' do
+      it 'return a new distribution with probabilities calculated assuming value is <= target' do
         pd = pr2.given_le(2)
         expect(pd.to_h).to eql({ 1 => 0.5, 2 => 0.5 })
         pd = pr10.given_le(4)
         expect(pd.to_h).to be_valid_distribution
         expect(pd.p_eql(3)).to be_within(1.0e-9).of 0.1 / 0.4
-        expect(pd.p_eql(10)).to eql 0.0
+        expect(pd.p_eql(10)).to be 0.0
+      end
+
+      it 'raise a TypeError if asked for probability of non-Integer' do
+        expect { pr10.given_le({}) }.to raise_error TypeError
       end
 
-      it 'should raise a TypeError if asked for probability of non-Integer' do
-        expect(-> { pr10.given_le({}) }).to raise_error TypeError
+      it 'clamp targets above the maximum and reject targets below the minimum' do
+        expect(pr10.given_le(11).to_h).to eql(pr10.to_h)
+        expect { pr10.given_le(0) }.to raise_error(RuntimeError, /divide by zero/)
       end
     end
 
     describe '#repeat_sum' do
-      it 'should output a valid distribution if params are valid' do
-        d4a = GamesDice::Probabilities.new([1.0 / 4, 1.0 / 4, 1.0 / 4, 1.0 / 4], 1)
-        d4b = GamesDice::Probabilities.new([1.0 / 10, 2.0 / 10, 3.0 / 10, 4.0 / 10], 1)
+      it 'output a valid distribution if params are valid' do
+        d4a = described_class.new([1.0 / 4, 1.0 / 4, 1.0 / 4, 1.0 / 4], 1)
+        d4b = described_class.new([1.0 / 10, 2.0 / 10, 3.0 / 10, 4.0 / 10], 1)
         pr = d4a.repeat_sum(7)
         expect(pr.to_h).to be_valid_distribution
         pr = d4b.repeat_sum(12)
         expect(pr.to_h).to be_valid_distribution
       end
 
-      it 'should raise an error if any param is unexpected type' do
-        d6 = GamesDice::Probabilities.for_fair_die(6)
-        expect(-> { d6.repeat_sum({}) }).to raise_error TypeError
+      it 'raise an error if any param is unexpected type' do
+        d6 = described_class.for_fair_die(6)
+        expect { d6.repeat_sum({}) }.to raise_error TypeError
+      end
+
+      it 'raise an error if repetitions are not positive' do
+        expect { pr6.repeat_sum(0) }.to raise_error(RuntimeError, /n < 1/)
       end
 
-      it 'should raise an error if distribution would have more than a million results' do
-        d1000 = GamesDice::Probabilities.for_fair_die(1000)
-        expect(-> { d1000.repeat_sum(11_000) }).to raise_error(RuntimeError, /Too many probability slots/)
+      it 'raise an error if distribution would have more than a million results' do
+        d1000 = described_class.for_fair_die(1000)
+        expect { d1000.repeat_sum(11_000) }.to raise_error(RuntimeError, /Too many probability slots/)
       end
 
-      it "should calculate a '3d6' distribution accurately" do
-        d6 = GamesDice::Probabilities.for_fair_die(6)
+      it "calculate a '3d6' distribution accurately" do
+        d6 = described_class.for_fair_die(6)
         pr = d6.repeat_sum(3)
         h = pr.to_h
         expect(h).to be_valid_distribution
@@ -445,28 +474,46 @@ describe GamesDice::Probabilities do
     end
 
     describe '#repeat_n_sum_k' do
-      it 'should output a valid distribution if params are valid' do
-        d4a = GamesDice::Probabilities.new([1.0 / 4, 1.0 / 4, 1.0 / 4, 1.0 / 4], 1)
-        d4b = GamesDice::Probabilities.new([1.0 / 10, 2.0 / 10, 3.0 / 10, 4.0 / 10], 1)
+      it 'output a valid distribution if params are valid' do
+        d4a = described_class.new([1.0 / 4, 1.0 / 4, 1.0 / 4, 1.0 / 4], 1)
+        d4b = described_class.new([1.0 / 10, 2.0 / 10, 3.0 / 10, 4.0 / 10], 1)
         pr = d4a.repeat_n_sum_k(3, 2)
         expect(pr.to_h).to be_valid_distribution
         pr = d4b.repeat_n_sum_k(12, 4)
         expect(pr.to_h).to be_valid_distribution
       end
 
-      it 'should raise an error if any param is unexpected type' do
-        d6 = GamesDice::Probabilities.for_fair_die(6)
-        expect(-> { d6.repeat_n_sum_k({}, 10) }).to raise_error TypeError
-        expect(-> { d6.repeat_n_sum_k(10, {}) }).to raise_error TypeError
+      it 'raise an error if any param is unexpected type' do
+        d6 = described_class.for_fair_die(6)
+        expect { d6.repeat_n_sum_k({}, 10) }.to raise_error TypeError
+        expect { d6.repeat_n_sum_k(10, {}) }.to raise_error TypeError
       end
 
-      it 'should raise an error if n is greater than 170' do
-        d6 = GamesDice::Probabilities.for_fair_die(6)
-        expect(-> { d6.repeat_n_sum_k(171, 10) }).to raise_error(RuntimeError, /Too many dice/)
+      it 'raise an error if repetitions or keepers are not positive' do
+        expect { pr6.repeat_n_sum_k(0, 1) }.to raise_error(RuntimeError, /n < 1/)
+        expect { pr6.repeat_n_sum_k(2, 0) }.to raise_error(RuntimeError, /k < 1/)
       end
 
-      it "should calculate a '4d6 keep best 3' distribution accurately" do
-        d6 = GamesDice::Probabilities.for_fair_die(6)
+      it 'sum every repetition when the keeper count is at least the repetition count' do
+        expect(pr6.repeat_n_sum_k(3, 3).to_h).to eql(pr6.repeat_sum(3).to_h)
+      end
+
+      it 'raise an error if the kept distribution would have more than a million results' do
+        d1000 = described_class.for_fair_die(1000)
+        expect { d1000.repeat_n_sum_k(1003, 1002) }.to raise_error(RuntimeError, /Too many probability slots/)
+      end
+
+      it 'raise an error for an unknown keep mode' do
+        expect { pr6.repeat_n_sum_k(3, 2, :middle) }.to raise_error(ArgumentError, /Keep mode/)
+      end
+
+      it 'raise an error if n is greater than 170' do
+        d6 = described_class.for_fair_die(6)
+        expect { d6.repeat_n_sum_k(171, 10) }.to raise_error(RuntimeError, /Too many dice/)
+      end
+
+      it "calculate a '4d6 keep best 3' distribution accurately" do
+        d6 = described_class.for_fair_die(6)
         pr = d6.repeat_n_sum_k(4, 3)
         h = pr.to_h
         expect(h).to be_valid_distribution
@@ -488,8 +535,8 @@ describe GamesDice::Probabilities do
         expect(h[18]).to be_within(1e-10).of 21 / 1296.0
       end
 
-      it "should calculate a '2d20 keep worst result' distribution accurately" do
-        d20 = GamesDice::Probabilities.for_fair_die(20)
+      it "calculate a '2d20 keep worst result' distribution accurately" do
+        d20 = described_class.for_fair_die(20)
         pr = d20.repeat_n_sum_k(2, 1, :keep_worst)
         h = pr.to_h
         expect(h).to be_valid_distribution
@@ -514,6 +561,13 @@ describe GamesDice::Probabilities do
         expect(h[19]).to be_within(1e-10).of 3 / 400.0
         expect(h[20]).to be_within(1e-10).of 1 / 400.0
       end
+
+      it "calculate a '4d6 keep worst 3' distribution accurately at its bounds" do
+        h = pr6.repeat_n_sum_k(4, 3, :keep_worst).to_h
+        expect(h).to be_valid_distribution
+        expect(h[3]).to be_within(1e-10).of 21 / 1296.0
+        expect(h[18]).to be_within(1e-10).of 1 / 1296.0
+      end
     end
   end