games_dice 0.4.2 → 0.6.0

data/spec/{bunch_spec.rb → games_dice/bunch_spec.rb}

@@ -2,7 +2,7 @@
 
 require 'helpers'
 
-describe GamesDice::Bunch do
+describe GamesDice::Bunch, :aggregate_failures do
   describe 'dice scheme' do
     before do
       srand(67_809)
@@ -35,18 +35,8 @@ describe GamesDice::Bunch do
       end
 
       it 'calculate probabilities correctly' do
-        prob_hash = bunch.probabilities.to_h
-        expect(prob_hash[1]).to be_within(1e-10).of 0.1
-        expect(prob_hash[2]).to be_within(1e-10).of 0.1
-        expect(prob_hash[3]).to be_within(1e-10).of 0.1
-        expect(prob_hash[4]).to be_within(1e-10).of 0.1
-        expect(prob_hash[5]).to be_within(1e-10).of 0.1
-        expect(prob_hash[6]).to be_within(1e-10).of 0.1
-        expect(prob_hash[7]).to be_within(1e-10).of 0.1
-        expect(prob_hash[8]).to be_within(1e-10).of 0.1
-        expect(prob_hash[9]).to be_within(1e-10).of 0.1
-        expect(prob_hash[10]).to be_within(1e-10).of 0.1
-        expect(prob_hash.values.sum).to be_within(1e-9).of 1.0
+        expected = (1..10).to_h { |result| [result, 0.1] }
+        expect_probability_values(bunch.probabilities.to_h, expected)
       end
     end
 
@@ -78,19 +68,8 @@ describe GamesDice::Bunch do
       end
 
       it 'calculate probabilities correctly' do
-        prob_hash = bunch.probabilities.to_h
-        expect(prob_hash[2]).to be_within(1e-10).of 1 / 36.0
-        expect(prob_hash[3]).to be_within(1e-10).of 2 / 36.0
-        expect(prob_hash[4]).to be_within(1e-10).of 3 / 36.0
-        expect(prob_hash[5]).to be_within(1e-10).of 4 / 36.0
-        expect(prob_hash[6]).to be_within(1e-10).of 5 / 36.0
-        expect(prob_hash[7]).to be_within(1e-10).of 6 / 36.0
-        expect(prob_hash[8]).to be_within(1e-10).of 5 / 36.0
-        expect(prob_hash[9]).to be_within(1e-10).of 4 / 36.0
-        expect(prob_hash[10]).to be_within(1e-10).of 3 / 36.0
-        expect(prob_hash[11]).to be_within(1e-10).of 2 / 36.0
-        expect(prob_hash[12]).to be_within(1e-10).of 1 / 36.0
-        expect(prob_hash.values.sum).to be_within(1e-9).of 1.0
+        expected = (2..12).to_h { |result| [result, (6 - (7 - result).abs) / 36.0] }
+        expect_probability_values(bunch.probabilities.to_h, expected)
       end
     end
 
@@ -162,24 +141,9 @@ describe GamesDice::Bunch do
       end
 
       it 'calculate probabilities correctly' do
-        prob_hash = bunch.probabilities.to_h
-        expect(prob_hash[3]).to be_within(1e-10).of 1 / 1296.0
-        expect(prob_hash[4]).to be_within(1e-10).of 4 / 1296.0
-        expect(prob_hash[5]).to be_within(1e-10).of 10 / 1296.0
-        expect(prob_hash[6]).to be_within(1e-10).of 21 / 1296.0
-        expect(prob_hash[7]).to be_within(1e-10).of 38 / 1296.0
-        expect(prob_hash[8]).to be_within(1e-10).of 62 / 1296.0
-        expect(prob_hash[9]).to be_within(1e-10).of 91 / 1296.0
-        expect(prob_hash[10]).to be_within(1e-10).of 122 / 1296.0
-        expect(prob_hash[11]).to be_within(1e-10).of 148 / 1296.0
-        expect(prob_hash[12]).to be_within(1e-10).of 167 / 1296.0
-        expect(prob_hash[13]).to be_within(1e-10).of 172 / 1296.0
-        expect(prob_hash[14]).to be_within(1e-10).of 160 / 1296.0
-        expect(prob_hash[15]).to be_within(1e-10).of 131 / 1296.0
-        expect(prob_hash[16]).to be_within(1e-10).of 94 / 1296.0
-        expect(prob_hash[17]).to be_within(1e-10).of 54 / 1296.0
-        expect(prob_hash[18]).to be_within(1e-10).of 21 / 1296.0
-        expect(prob_hash.values.sum).to be_within(1e-9).of 1.0
+        numerators = [1, 4, 10, 21, 38, 62, 91, 122, 148, 167, 172, 160, 131, 94, 54, 21]
+        expected = (3..18).zip(numerators.map { |numerator| numerator / 1296.0 }).to_h
+        expect_probability_values(bunch.probabilities.to_h, expected)
       end
     end
 
@@ -213,18 +177,12 @@ describe GamesDice::Bunch do
       end
 
       it 'calculate probabilities correctly' do
-        prob_hash = bunch.probabilities.to_h
-        expect(prob_hash[1]).to be_within(1e-10).of 0.6513215599
-        expect(prob_hash[2]).to be_within(1e-10).of 0.2413042577
-        expect(prob_hash[3]).to be_within(1e-10).of 0.0791266575
-        expect(prob_hash[4]).to be_within(1e-10).of 0.0222009073
-        expect(prob_hash[5]).to be_within(1e-10).of 0.0050700551
-        expect(prob_hash[6]).to be_within(1e-10).of 0.0008717049
-        expect(prob_hash[7]).to be_within(1e-10).of 0.0000989527
-        expect(prob_hash[8]).to be_within(1e-10).of 0.0000058025
-        expect(prob_hash[9]).to be_within(1e-10).of 0.0000001023
-        expect(prob_hash[10]).to be_within(1e-18).of 1e-10
-        expect(prob_hash.values.sum).to be_within(1e-9).of 1.0
+        expected = {
+          1 => 0.6513215599, 2 => 0.2413042577, 3 => 0.0791266575, 4 => 0.0222009073,
+          5 => 0.0050700551, 6 => 0.0008717049, 7 => 0.0000989527, 8 => 0.0000058025,
+          9 => 0.0000001023, 10 => 1e-10
+        }
+        expect_probability_values(bunch.probabilities.to_h, expected, tolerances: { 10 => 1e-18 })
       end
     end
 
@@ -263,18 +221,11 @@ describe GamesDice::Bunch do
       end
 
       it 'calculate probabilities correctly' do
-        prob_hash = bunch.probabilities.to_h
-        probs = prob_hash.values_at(*2..30)
-        expected_probs = [0.00001, 0.00005, 0.00031, 0.00080, 0.00211, 0.00405, 0.00781, 0.01280, 0.02101, 0.0312,
-                          0.045715, 0.060830, 0.077915, 0.090080, 0.097935, 0.091230, 0.070015, 0.020480, 0.032805,
-                          0.0328, 0.0334626451, 0.0338904805, 0.0338098781, 0.0328226480, 0.0304393461, 0.0260456005,
-                          0.0189361531, 0.0082804480, 0.0103524151]
-
-        probs.zip(expected_probs) do |got_prob, expected_prob|
-          expect(got_prob).to be_within(1e-10).of(expected_prob)
-        end
-
-        expect(prob_hash.values.sum).to be_within(1e-9).of 1.0
+        probabilities = [0.00001, 0.00005, 0.00031, 0.00080, 0.00211, 0.00405, 0.00781, 0.01280, 0.02101, 0.0312,
+                         0.045715, 0.060830, 0.077915, 0.090080, 0.097935, 0.091230, 0.070015, 0.020480, 0.032805,
+                         0.0328, 0.0334626451, 0.0338904805, 0.0338098781, 0.0328226480, 0.0304393461, 0.0260456005,
+                         0.0189361531, 0.0082804480, 0.0103524151]
+        expect_probability_values(bunch.probabilities.to_h, (2..30).zip(probabilities).to_h)
       end
     end
 
@@ -312,28 +263,8 @@ describe GamesDice::Bunch do
       end
 
       it 'calculate probabilities correctly' do
-        prob_hash = bunch.probabilities.to_h
-        expect(prob_hash[1]).to be_within(1e-10).of 1 / 400.0
-        expect(prob_hash[2]).to be_within(1e-10).of 3 / 400.0
-        expect(prob_hash[3]).to be_within(1e-10).of 5 / 400.0
-        expect(prob_hash[4]).to be_within(1e-10).of 7 / 400.0
-        expect(prob_hash[5]).to be_within(1e-10).of 9 / 400.0
-        expect(prob_hash[6]).to be_within(1e-10).of 11 / 400.0
-        expect(prob_hash[7]).to be_within(1e-10).of 13 / 400.0
-        expect(prob_hash[8]).to be_within(1e-10).of 15 / 400.0
-        expect(prob_hash[9]).to be_within(1e-10).of 17 / 400.0
-        expect(prob_hash[10]).to be_within(1e-10).of 19 / 400.0
-        expect(prob_hash[11]).to be_within(1e-10).of 21 / 400.0
-        expect(prob_hash[12]).to be_within(1e-10).of 23 / 400.0
-        expect(prob_hash[13]).to be_within(1e-10).of 25 / 400.0
-        expect(prob_hash[14]).to be_within(1e-10).of 27 / 400.0
-        expect(prob_hash[15]).to be_within(1e-10).of 29 / 400.0
-        expect(prob_hash[16]).to be_within(1e-10).of 31 / 400.0
-        expect(prob_hash[17]).to be_within(1e-10).of 33 / 400.0
-        expect(prob_hash[18]).to be_within(1e-10).of 35 / 400.0
-        expect(prob_hash[19]).to be_within(1e-10).of 37 / 400.0
-        expect(prob_hash[20]).to be_within(1e-10).of 39 / 400.0
-        expect(prob_hash.values.sum).to be_within(1e-9).of 1.0
+        expected = (1..20).to_h { |result| [result, ((2 * result) - 1) / 400.0] }
+        expect_probability_values(bunch.probabilities.to_h, expected)
       end
     end
 
@@ -371,29 +302,51 @@ describe GamesDice::Bunch do
       end
 
       it 'calculate probabilities correctly' do
-        prob_hash = bunch.probabilities.to_h
-        expect(prob_hash[1]).to be_within(1e-10).of 39 / 400.0
-        expect(prob_hash[2]).to be_within(1e-10).of 37 / 400.0
-        expect(prob_hash[3]).to be_within(1e-10).of 35 / 400.0
-        expect(prob_hash[4]).to be_within(1e-10).of 33 / 400.0
-        expect(prob_hash[5]).to be_within(1e-10).of 31 / 400.0
-        expect(prob_hash[6]).to be_within(1e-10).of 29 / 400.0
-        expect(prob_hash[7]).to be_within(1e-10).of 27 / 400.0
-        expect(prob_hash[8]).to be_within(1e-10).of 25 / 400.0
-        expect(prob_hash[9]).to be_within(1e-10).of 23 / 400.0
-        expect(prob_hash[10]).to be_within(1e-10).of 21 / 400.0
-        expect(prob_hash[11]).to be_within(1e-10).of 19 / 400.0
-        expect(prob_hash[12]).to be_within(1e-10).of 17 / 400.0
-        expect(prob_hash[13]).to be_within(1e-10).of 15 / 400.0
-        expect(prob_hash[14]).to be_within(1e-10).of 13 / 400.0
-        expect(prob_hash[15]).to be_within(1e-10).of 11 / 400.0
-        expect(prob_hash[16]).to be_within(1e-10).of 9 / 400.0
-        expect(prob_hash[17]).to be_within(1e-10).of 7 / 400.0
-        expect(prob_hash[18]).to be_within(1e-10).of 5 / 400.0
-        expect(prob_hash[19]).to be_within(1e-10).of 3 / 400.0
-        expect(prob_hash[20]).to be_within(1e-10).of 1 / 400.0
-        expect(prob_hash.values.sum).to be_within(1e-9).of 1.0
+        expected = (1..20).to_h { |result| [result, (41 - (2 * result)) / 400.0] }
+        expect_probability_values(bunch.probabilities.to_h, expected)
       end
     end
   end
+
+  it 'rejects invalid dice counts, side counts, keeper modes and random generators' do
+    defaults = { sides: 6, ndice: 2 }
+    [{ ndice: 0 }, { sides: 0 }, { keep_mode: :unknown }].each do |options|
+      expect { described_class.new(defaults.merge(options)) }.to raise_error(ArgumentError)
+    end
+    expect { described_class.new(sides: 6, ndice: 2, prng: Object.new) }.to raise_error(RuntimeError, /prng/)
+  end
+
+  it 'has no result details or explanation before rolling' do
+    expect(described_class.new(sides: 6, ndice: 2)).to have_attributes(result_details: nil, explain_result: nil)
+  end
+
+  it 'uses the supplied name as its label and exposes its rules' do
+    bunch = described_class.new(sides: 6, ndice: 2, name: 'Damage', rerolls: [[6, :==, :reroll_add]])
+    expect(bunch.label).to eq('Damage')
+    expect(bunch.rerolls.first).to have_attributes(type: :reroll_add, trigger_value: 6)
+    expect(bunch.maps).to be_nil
+  end
+
+  it 'reuses its calculated probability distribution' do
+    bunch = described_class.new(sides: 6, ndice: 2)
+    probabilities = bunch.probabilities
+    expect(bunch.probabilities).to equal(probabilities)
+    expect(probabilities.expected).to be_within(1e-10).of(7.0)
+  end
+
+  [2, 3].product(%i[keep_best keep_worst]).each do |number, mode|
+    it "keeps all dice when #{mode} requests #{number} of two dice" do
+      bunch = described_class.new(sides: 6, ndice: 2, keep_mode: mode, keep_number: number, prng: TestPRNGMax.new)
+      expect(bunch.roll).to eq(12)
+      expect(bunch.explain_result).to eq('6, 6. Keep: 6 + 6 = 12')
+      expect(bunch.probabilities.expected).to be_within(1e-10).of(7.0)
+    end
+  end
+
+  it 'explains mapped keeper results with their labels' do
+    bunch = described_class.new(sides: 6, ndice: 3, keep_mode: :keep_best, keep_number: 2,
+                                maps: [[4, :<=, 1, 'Success']], prng: TestPRNGMax.new)
+    expect(bunch.roll).to eq(2)
+    expect(bunch.explain_result).to eq('6 Success, 6 Success, 6 Success. Keep: 6 Success, 6 Success. Successes: 2')
+  end
 end

data/spec/games_dice/complex_die_budget_spec.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'helpers'
+
+describe GamesDice::ComplexDie, :aggregate_failures do
+  def observed_omissions(counts)
+    allow(GamesDice::ProbabilityBudget).to receive(:new).and_wrap_original do |constructor, *arguments|
+      constructor.call(*arguments).tap do |budget|
+        allow(budget).to receive(:omit?).and_wrap_original do |original, depth, probability|
+          original.call(depth, probability).tap { |omitted| counts[depth] += 1 if omitted }
+        end
+      end
+    end
+  end
+
+  [1, 10, 1000, 1_000_000].each do |count|
+    it "certifies the exact omitted mass when sharing a budget across #{count} dice" do
+      counts = Hash.new(0)
+      observed_omissions(counts)
+      die = described_class.new(2, rerolls: [[2, :==, :reroll_add]])
+      die.__send__(:probabilities_for_budget, GamesDice::ProbabilityBudget.share(1e-10.prev_float, count))
+      expect_certified_omission(die, counts, count)
+    end
+  end
+
+  def expect_certified_omission(die, counts, count)
+    exact = counts.sum { |depth, branches| Rational(branches, 2**depth) }
+    expect(exact).to be <= die.instance_variable_get(:@probability_error).to_r
+    expect(count * exact).to be <= Rational(1, 10**10)
+  end
+
+  it 'handles near-certain replacement triggers without traversing the reroll limit' do
+    die = described_class.new(100_000, rerolls: [[99_999, :>=, :reroll_replace, 1_000_000]])
+    expect(die.probabilities.to_h).to be_valid_distribution
+    expect(die.probabilities.p_eql(100_000)).to be_within(1e-12).of(1 - ((0.99999**1_000_000) * 0.99999))
+    expect(die.probabilities_complete).to be(true)
+  end
+
+  it 'provides cheap exact bounds even when a deterministic outcome exceeds native storage' do
+    die = described_class.new(1, rerolls: [[1, :==, :reroll_add, 2**31]])
+    expect(die).to have_attributes(min: (2**31) + 1, max: (2**31) + 1)
+    expect { die.probabilities }.to raise_error(RangeError)
+    expect(die.probabilities_complete).to be_nil
+  end
+
+  it 'preserves a previous roll while recomputing a tighter probability certificate' do
+    die = described_class.new(2, rerolls: [[2, :==, :reroll_add]])
+    previous = die.roll
+    die.probabilities
+    die.__send__(:probabilities_for_budget, 1e-14)
+    expect(die.result).to equal(previous)
+  end
+
+  it 'treats absent numerical certificates as requiring recomputation after restoration' do
+    die = described_class.new(2, rerolls: [[2, :==, :reroll_add]])
+    die.probabilities
+    die.remove_instance_variable(:@probability_error)
+    expect(marshal_round_trip(die).probabilities.to_h).to be_valid_distribution
+  end
+end

data/spec/games_dice/complex_die_limits_spec.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require 'helpers'
+
+describe GamesDice::ComplexDie, :aggregate_failures do
+  def exploding(sides, limit = 1000)
+    described_class.new(sides, rerolls: [[sides, :==, :reroll_add, limit]])
+  end
+
+  [2, 3, 6, 10].each do |sides|
+    it "bounds the omitted mass for an exploding d#{sides}" do
+      die = exploding(sides)
+      probabilities = die.probabilities
+      expect(probabilities.p_eql(1)).to be_within(1e-10).of(1.0 / sides)
+      expect(probabilities.to_h.keys).not_to include(sides)
+      expect(die.probabilities_complete).to be(false)
+    end
+  end
+
+  it 'treats terminal branches at the old depth cutoff as complete' do
+    die = exploding(2, 19)
+    expect(die.probabilities.p_eql(40)).to eq(2.0**-20)
+    expect(die.probabilities_complete).to be(true)
+  end
+
+  it 'calculates a deterministic singleton without enumerating its roll history' do
+    die = exploding(1, 1_000_000)
+    expect(die.probabilities.to_h).to eq({ 1_000_001 => 1.0 })
+    expect(die.probabilities_complete).to be(true)
+    expect(die).to have_attributes(min: 1_000_001, max: 1_000_001)
+  end
+
+  it 'keeps deterministic additions exact for nonmatching and nonpositive rules' do
+    [-1, 0].each { |limit| expect(exploding(1, limit).probabilities.to_h).to eq({ 1 => 1.0 }) }
+    expect(described_class.new(1, rerolls: [[2, :==, :reroll_add]]).probabilities.to_h).to eq({ 1 => 1.0 })
+  end
+
+  it 'maps an exact singleton after completing its additive rule' do
+    die = described_class.new(1, rerolls: [[1, :==, :reroll_add]], maps: [[1001, :==, 7]])
+    expect(die.probabilities.to_h).to eq({ 7 => 1.0 })
+  end
+
+  it 'uses the finite replacement formula for more than one triggering face' do
+    die = described_class.new(6, rerolls: [[1..2, :cover?, :reroll_replace, 3]])
+    probabilities = die.probabilities
+    expect(probabilities.p_eql(1)).to be_within(1e-15).of(Rational(8, 1296).to_f)
+    expect(probabilities.p_eql(6)).to be_within(1e-15).of(Rational(320, 1296).to_f)
+    expect(die.probabilities_complete).to be(true)
+  end
+
+  [[0, :>=, 1000], [6, :>=, 1000], [1, :==, 0], [1, :==, -3]].each do |trigger, op, limit|
+    it "keeps replacement edge case #{[trigger, op, limit]} exactly uniform" do
+      die = described_class.new(6, rerolls: [[trigger, op, :reroll_replace, limit]])
+      expect_fair_distribution(die.probabilities.to_h, 6)
+      expect(die.probabilities_complete).to be(true)
+    end
+  end
+
+  it 'refuses a branching recipe at the depth limit and leaves no partial distribution' do
+    die = described_class.new(4, rerolls: [[3, :<=, :reroll_add]])
+    expect { die.probabilities }.to raise_error(GamesDice::ProbabilityLimitError, /truncation error bound/)
+    expect(die.probabilities_complete).to be_nil
+    expect(die).to have_attributes(min: 1, max: 4004)
+  end
+
+  it 'refuses excessive work for the open-ended percentile example' do
+    die = described_class.new(100, rerolls: [[96, :<=, :reroll_add]])
+    expect { die.probabilities }.to raise_error(GamesDice::ProbabilityLimitError, /work limit/)
+    expect(die).to have_attributes(min: 1, max: 100_100)
+  end
+
+  it 'bounds subtracting recipes even when their distribution is refused' do
+    die = described_class.new(4, rerolls: [[3, :<=, :reroll_add], [1, :==, :reroll_subtract]])
+    expect { die.probabilities }.to raise_error(GamesDice::ProbabilityLimitError)
+    expect(die).to have_attributes(min: -4008, max: 4008)
+  end
+
+  it 'encloses every ordinary mapped value when the distribution is refused' do
+    die = described_class.new(4, rerolls: [[3, :<=, :reroll_add]], maps: [[1, :==, -4], [2, :<=, 7]])
+    expect(die).to have_attributes(min: -4, max: 7)
+  end
+
+  it 'refuses unprovable bounds for custom numeric mappings' do
+    die = described_class.new(4, rerolls: [[3, :<=, :reroll_add]], maps: [[->(value) { value * 2 }, :call]])
+    expect { die.min }.to raise_error(GamesDice::ProbabilityLimitError, /Cannot establish finite dice bounds/)
+  end
+
+  it 'enumerates custom predicates rather than assuming they return booleans' do
+    die = described_class.new(2, rerolls: [[->(face) { face == 1 }, :call, :reroll_replace, 1]])
+    expect(die.probabilities.to_h).to eq({ 1 => 0.25, 2 => 0.75 })
+  end
+
+  it 'propagates exceptions raised by custom callbacks' do
+    die = described_class.new(2, maps: [[->(_) { raise RangeError, 'custom failure' }, :call]])
+    expect { die.min }.to raise_error(RangeError, 'custom failure')
+  end
+
+  it 'reuses a tight cache for loose requests and recomputes for tighter budgets' do
+    die = exploding(2)
+    loose = die.probabilities
+    tight = die.__send__(:probabilities_for_budget, 1e-14)
+    expect(tight).not_to equal(loose)
+    expect(die.probabilities).to equal(tight)
+  end
+
+  it 'does not return a loose cache when a tighter request fails' do
+    die = exploding(2)
+    loose = die.probabilities
+    expect { die.__send__(:probabilities_for_budget, 1e-30) }.to raise_error(GamesDice::ProbabilityLimitError)
+    expect(die.probabilities_complete).to be_nil
+    expect(die.probabilities).to equal(loose)
+  end
+
+  it 'counts mapping predicates towards the work limit' do
+    stub_const('GamesDice::ProbabilityBudget::MAX_PREDICATES', 3)
+    die = described_class.new(6, maps: [[1, :==, 1]])
+    expect { die.probabilities }.to raise_error(GamesDice::ProbabilityLimitError, /work limit/)
+  end
+end

data/spec/games_dice/complex_die_spec.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+require 'helpers'
+
+describe GamesDice::ComplexDie, :aggregate_failures do
+  before do
+    # Set state of default PRNG
+    srand(4567)
+  end
+
+  it 'represent a basic die as an object' do
+    die = described_class.new(6)
+    expect(die.min).to be 1
+    expect(die.max).to be 6
+    expect(die.sides).to be 6
+  end
+
+  it "return results based on Ruby's internal rand() by default" do
+    die = described_class.new(10)
+    [5, 4, 10, 4, 7, 8, 1, 9].each do |expected|
+      expect(die.roll.value).to eql expected
+      expect(die.result.value).to eql expected
+    end
+  end
+
+  it 'use any object with a rand(Integer) method' do
+    die = described_class.new(20, prng: TestPRNG.new)
+    [16, 7, 3, 11, 16, 18, 20, 7].each do |expected|
+      expect(die.roll.value).to eql expected
+      expect(die.result.value).to eql expected
+    end
+  end
+
+  it 'optionally accept a rerolls param' do
+    valid = [[], [GamesDice::RerollRule.new(6, :<=, :reroll_add)],
+             [GamesDice::RerollRule.new(6, :<=, :reroll_add), GamesDice::RerollRule.new(1, :>=, :reroll_subtract)],
+             [[6, :<=, :reroll_add]], [[6, :<=, :reroll_add], [1, :>=, :reroll_subtract]]]
+    invalid = [[7, TypeError], [['hello'], TypeError],
+               [[GamesDice::RerollRule.new(6, :<=, :reroll_add), :reroll_add], TypeError], [[7], TypeError],
+               [[['hello']], ArgumentError], [[[6, :<=, :reroll_add], :reroll_add], TypeError]]
+    expect_rule_arguments(described_class, :rerolls, valid: valid, invalid: invalid)
+  end
+
+  it 'optionally accept a maps param' do
+    valid = [[], [GamesDice::MapRule.new(7, :<=, 1)],
+             [GamesDice::MapRule.new(7, :<=, 1), GamesDice::MapRule.new(1, :>, -1)],
+             [[7, :<=, 1]], [[7, :<=, 1], [1, :>, -1]]]
+    invalid = [[7, TypeError], [[7], TypeError], [[[7]], ArgumentError], [['hello'], TypeError],
+               [[GamesDice::MapRule.new(7, :<=, 1), GamesDice::RerollRule.new(6, :<=, :reroll_add)], TypeError]]
+    expect_rule_arguments(described_class, :maps, valid: valid, invalid: invalid)
+  end
+
+  describe 'with rerolls' do
+    it 'calculate correct minimum and maximum results' do
+      cases = [[[GamesDice::RerollRule.new(10, :<=, :reroll_add, 3)], [1, 40]],
+               [[[1, :>=, :reroll_subtract]], [-9, 10]],
+               [[GamesDice::RerollRule.new(10, :<=, :reroll_add)], [1, 10_010]]]
+      cases.each do |rerolls, expected|
+        die = described_class.new(10, rerolls: rerolls)
+        expect(die).to have_attributes(min: expected.first, max: expected.last)
+      end
+    end
+
+    it 'simulate a d10 that rerolls and adds on a result of 10' do
+      die = described_class.new(10, rerolls: [[10, :<=, :reroll_add]])
+      [5, 4, 14, 7, 8, 1, 9].each do |expected|
+        expect(die.roll.value).to eql expected
+        expect(die.result.value).to eql expected
+      end
+    end
+
+    it 'explain how it got results outside range 1 to 10 on a d10' do
+      die = described_class.new(10, rerolls: [[10, :<=, :reroll_add], [1, :>=, :reroll_subtract]])
+      ['5', '4', '[10+4] 14', '7', '8', '[1-9] -8'].each do |expected|
+        die.roll
+        expect(die.explain_result).to eql expected
+      end
+    end
+
+    it 'calculate an expected result' do
+      cases = [[10, [[10, :<=, :reroll_add], [1, :>=, :reroll_subtract]], 5.5],
+               [10, [GamesDice::RerollRule.new(1, :<=, :reroll_use_best, 1)], 7.15],
+               [10, [GamesDice::RerollRule.new(1, :<=, :reroll_use_worst, 2)], 3.025],
+               [6, [GamesDice::RerollRule.new(6, :<=, :reroll_add)], 4.2],
+               [8, [GamesDice::RerollRule.new(1, :>=, :reroll_use_best)], 5.0],
+               [4, [GamesDice::RerollRule.new(1, :>=, :reroll_replace, 1)], 2.875]]
+      cases.each do |sides, rerolls, expected|
+        die = described_class.new(sides, rerolls: rerolls)
+        expect(die.probabilities.expected).to be_within(1e-10).of(expected)
+      end
+    end
+
+    it 'calculate probabilities of each possible result' do
+      cases = [[6, [GamesDice::RerollRule.new(7, :>, :reroll_add, 1)], { 11 => 2 / 36.0, 8 => 5 / 36.0 }],
+               [10, [GamesDice::RerollRule.new(10, :<=, :reroll_add)],
+                { 8 => 0.1, 10 => nil, 13 => 0.01, 27 => 0.001 }],
+               [6, [GamesDice::RerollRule.new(1, :>=, :reroll_replace, 1)], { 1 => 1 / 36.0, 2 => 7 / 36.0 }]]
+      cases.each do |sides, rerolls, expected|
+        probabilities = described_class.new(sides, rerolls: rerolls).probabilities.to_h
+        expect_probability_values(probabilities, expected)
+      end
+    end
+
+    it 'calculate aggregate probabilities' do
+      die = described_class.new(6, rerolls: [GamesDice::RerollRule.new(7, :>, :reroll_add, 1)])
+      probs = die.probabilities
+      expected = { p_gt: { 7 => 15 / 36.0, -10 => 1.0, 12 => 0.0 },
+                   p_ge: { 7 => 21 / 36.0, 2 => 1.0, 15 => 0.0 },
+                   p_lt: { 7 => 15 / 36.0, -10 => 0.0, 13 => 1.0 },
+                   p_le: { 7 => 21 / 36.0, 1 => 0.0, 12 => 1.0 } }
+      expect_aggregate_probabilities(probs, expected)
+    end
+  end
+
+  describe 'with maps' do
+    it 'calculate correct minimum and maximum results' do
+      die = described_class.new(10, maps: [GamesDice::MapRule.new(7, :<=, 1, 'S')])
+      expect(die.min).to be 0
+      expect(die.max).to be 1
+    end
+
+    it 'simulate a d10 that scores 1 for success on a value of 7 or more' do
+      die = described_class.new(10, maps: [[7, :<=, 1, 'S']])
+      [0, 0, 1, 0, 1, 1, 0, 1].each do |expected|
+        expect(die.roll.value).to eql expected
+        expect(die.result.value).to eql expected
+      end
+    end
+
+    it 'label the mappings applied with the provided names' do
+      die = described_class.new(10, maps: [[7, :<=, 1, 'S'], [1, :>=, -1, 'F']])
+      ['5', '4', '10 S', '4', '7 S', '8 S', '1 F', '9 S'].each do |expected|
+        die.roll
+        expect(die.explain_result).to eql expected
+      end
+    end
+
+    it 'calculate an expected result' do
+      die = described_class.new(10,
+                                maps: [GamesDice::MapRule.new(7, :<=, 1, 'S'),
+                                       GamesDice::MapRule.new(1, :>=, -1, 'F')])
+      expect(die.probabilities.expected).to be_within(1e-10).of 0.3
+    end
+
+    it 'calculate probabilities of each possible result' do
+      die = described_class.new(10,
+                                maps: [GamesDice::MapRule.new(7, :<=, 1, 'S'),
+                                       GamesDice::MapRule.new(1, :>=, -1, 'F')])
+      expect_probability_values(die.probabilities.to_h, { 1 => 0.4, 0 => 0.5, -1 => 0.1 })
+    end
+
+    it 'calculate aggregate probabilities' do
+      die = described_class.new(10,
+                                maps: [GamesDice::MapRule.new(7, :<=, 1, 'S'),
+                                       GamesDice::MapRule.new(1, :>=, -1, 'F')])
+      probs = die.probabilities
+      expected = { p_gt: { -2 => 1.0, -1 => 0.9, 1 => 0.0 }, p_ge: { 1 => 0.4, -1 => 1.0, 2 => 0.0 },
+                   p_lt: { 1 => 0.6, -1 => 0.0, 2 => 1.0 }, p_le: { -1 => 0.1, -2 => 0.0, 1 => 1.0 } }
+      expect_aggregate_probabilities(probs, expected)
+    end
+  end
+
+  describe 'with rerolls and maps together' do
+    let(:die) do
+      described_class.new(6,
+                          rerolls: [[6, :<=, :reroll_add]],
+                          maps: [GamesDice::MapRule.new(9, :<=, 1, 'Success')])
+    end
+
+    it 'calculate correct minimum and maximum results' do
+      expect(die.min).to be 0
+      expect(die.max).to be 1
+    end
+
+    it 'calculate an expected result' do
+      expect(die.probabilities.expected).to be_within(1e-10).of 4 / 36.0
+    end
+
+    it 'calculate probabilities of each possible result' do
+      expect_probability_values(die.probabilities.to_h, { 1 => 4 / 36.0, 0 => 32 / 36.0 })
+    end
+
+    it 'calculate aggregate probabilities' do
+      expected = { p_gt: { 0 => 4 / 36.0, -2 => 1.0, 1 => 0.0 }, p_ge: { 1 => 4 / 36.0, -1 => 1.0, 2 => 0.0 },
+                   p_lt: { 1 => 32 / 36.0, 0 => 0.0, 2 => 1.0 }, p_le: { 0 => 32 / 36.0, -1 => 0.0, 1 => 1.0 } }
+      expect_aggregate_probabilities(die.probabilities, expected)
+    end
+
+    it 'apply mapping to final re-rolled result' do
+      [0, 1, 0, 0].each do |expected|
+        expect(die.roll.value).to eql expected
+        expect(die.result.value).to eql expected
+      end
+    end
+
+    it 'explain how it got each result' do
+      ['5', '[6+4] 10 Success', '[6+2] 8', '5'].each do |expected|
+        die.roll
+        expect(die.explain_result).to eql expected
+      end
+    end
+  end
+
+  it 'calculates bounds when maximum is queried first and reuses them' do
+    die = described_class.new(6)
+    expect(die.max).to eq(6)
+    expect(die.min).to eq(1)
+    expect(die.min).to eq(1)
+    expect(die.max).to eq(6)
+  end
+
+  it 'subtracts subsequent explosions after an initial subtracting reroll' do
+    prng = instance_double(TestPRNG)
+    allow(prng).to receive(:rand).with(6).and_return(0, 5, 3)
+    die = described_class.new(6, prng: prng, rerolls: [[1, :==, :reroll_subtract], [6, :==, :reroll_add]])
+    expect(die.roll).to have_attributes(value: -9, rolls: [1, 6, 4],
+                                        roll_reasons: %i[basic reroll_subtract reroll_subtract])
+    expect(die.explain_result).to eq('[1-6-4] -9')
+  end
+
+  it 'bounds open-ended additions and subtractions while ignoring impossible triggers' do
+    die = described_class.new(6, rerolls: [[1, :==, :reroll_subtract], [0, :==, :reroll_subtract],
+                                           [6, :==, :reroll_add], [7, :==, :reroll_add]])
+    expect(die.min).to eq(-5999)
+    expect(die.max).to eq(6006)
+    expect(die.probabilities_complete).to be(false)
+  end
+end