dicey 0.13.1 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 13602eca86dfef1610dd824ffcab19809d7416418f077ea7b51f8f2fc713ec17
-  data.tar.gz: 7a24922897bad67486e72592189a51358bc861e53c332a0780901ef7ddf66e2f
+  metadata.gz: a269ac8baf4bf849781175b605d92c23ff95fae3e53baa540519ece9947cec0d
+  data.tar.gz: af8f74b92b35a2818d18dc91d9917d8af6e91e16f8674f02eebfb5e56b1759fd
 SHA512:
-  metadata.gz: 336cdbe4078db28e015ed393a65b358c9df13873b70da3f215cb75af95c84a67ae7ff6ec0939cd66c9f12b281e792d1acb9a0d00ec4e3f9c107b446e70cad703
-  data.tar.gz: 964b1502f92086c86b2861bd2eec432effec526b5aecbeb056f82a59cc2be83b1fe7fbe39482350d6764f994f432ebaef3f6e76b70f824adcc2cd630e9decaaf
+  metadata.gz: 1b031d4ee67b9c3b1ebe0ba23ac2289f7d14536af4fda1b98b7f481fd9e027ef3b57d8911f7d3c78ca46da0554b63226312e7ae4fa136fc34431bf7f86b7f349
+  data.tar.gz: ac52115c59f846e4662ed055e871bf31f2e87b2080acb07042730698d5fa6d107daaf64792645752b47bced701ace913b58464a7a96e56dffe6d3aba3a0af2d8

data/README.md

@@ -1,55 +1,92 @@
 # Dicey
 
+[![Gem Version](https://badge.fury.io/rb/dicey.svg?icon=si%3Arubygems)](https://rubygems.org/gems/dicey)
+[![CI](https://github.com/trinistr/dicey/actions/workflows/CI.yaml/badge.svg)](https://github.com/trinistr/dicey/actions/workflows/CI.yaml)
+
 > [!TIP]
 > You may be viewing documentation for an older (or newer) version of the gem than intended. Look at [Changelog](https://github.com/trinistr/dicey/blob/main/CHANGELOG.md) to see all versions, including unreleased changes.
 
-<!-- Latest: [![Gem Version](https://badge.fury.io/rb/dicey.svg?icon=si%3Arubygems)](https://rubygems.org/gems/dicey) -->
-<!-- [![CI](https://github.com/trinistr/dicey/actions/workflows/CI.yaml/badge.svg)](https://github.com/trinistr/dicey/actions/workflows/CI.yaml) -->
-
 ***
 
 The premier solution in total paradigm shift for resolving dicey problems of tomorrow, today, used by industry-leading professionals around the world!
 
-In seriousness, this program produces total frequency (probability) distributions of all possible dice rolls for a given set of dice. Dice in such a set can be different or even have arbitrary numbers on the sides.
+In seriousness, this program is mainly useful for calculating total frequency (probability) distributions of all possible dice rolls for a given set of dice. Dice in such a set can be different or even have arbitrary numbers on the sides. It can also be used to roll any dice that it supports.
+
+## Table of contents
+
+- [Online (no installation)](#online-no-installation)
+  - [Recommended](#recommended)
+  - [For those who want the full command line experience](#for-those-who-want-the-full-command-line-experience)
+- [Installation](#installation)
+  - [Requirements](#requirements)
+- [Usage: CLI (command line)](#usage-cli-command-line)
+  - [Example 1: Basic distribution](#example-1-basic-distribution)
+  - [Example 2: Complex distribution with different dice](#example-2-complex-distribution-with-different-dice)
+  - [Example 3: Custom dice](#example-3-custom-dice)
+  - [Example 4: Rolling even more custom dice](#example-4-rolling-even-more-custom-dice)
+  - [All ways to define dice](#all-ways-to-define-dice)
+- [Usage: API](#usage-api)
+  - [Dice](#dice)
+  - [Rolling](#rolling)
+  - [Calculators](#calculators)
+- [Diving deeper](#diving-deeper)
+- [Development](#development)
+- [Contributing](#contributing)
+- [License](#license)
+
+## Online (no installation)
+
+### Recommended
+
+Use online version of **Dicey** on its own website: [dicey.bulancov.tech](https://dicey.bulancov.tech)!
+
+It does not provide quite all features, but it's easy to use and quick to get started.
 
-## No installation
+### For those who want the full command line experience
 
-Thanks to the efforts of Ruby developers, you can try **Dicey** online!
-1. Head over to https://runruby.dev/gist/476679a55c24520782613d9ceb89d9a3
-2. Make sure that "*-main.rb*" is open
-3. Input arguments between "ARGUMENTS" lines, separated by spaces.
+Thanks to the efforts of Ruby developers, you can run full **Dicey** online!
+1. Head over to the prepared [RunRuby page](https://runruby.dev/gist/476679a55c24520782613d9ceb89d9a3).
+2. Make sure that "*-main.rb*" is open.
+3. Input arguments between "ARGUMENTS" lines, separated by spaces. Refer to [Usage / CLI](#usage--cli-command-line) section.
 4. Click "**Run code**" button below the editor.
+5. Results will be printed to the "Logs" tab.
+
+If familiar with Ruby, you can also use **RunRuby** to explore the API. Refer to [Usage / API](#usage--api) section for documentation.
 
 ## Installation
 
-Install via `gem`:
+Install manually via `gem`:
 ```sh
 gem install dicey
 ```
 
 Or, if using Bundler, add it to your `Gemfile`:
 ```rb
-gem "dicey", "~> 0.13"
+gem "dicey", "~> 0.14"
 ```
 
 > [!TIP]
 > Versions upto 0.12.1 were packaged as a single executable file. You can still download it from the [release](https://github.com/trinistr/dicey/releases/tag/v0.12.1).
 
 > [!NOTE]
-> `dicey` 0.0.1 was a completely separate project by [Adam Rogers](https://github.com/rodreegez). Big thanks for transfering the name!
+> `dicey` 0.0.1 was a completely separate [project](https://github.com/rodreegez/dicey) by [Adam Rogers](https://github.com/rodreegez). Big thanks for transfering the name!
 
 ### Requirements
 
-**Dicey** is developed on Ruby 3.2, but should work fine on 3.1 and later versions. There are no dependencies aside from standard library (`json`, `yaml`, `bigdecimal`) and common usage will not even load them.
+**Dicey** is tested to work on CRuby 3.0+, latest JRuby and TruffleRuby. Compatible implementations should work too.
+- JSON and YAML formatting require `json` and `yaml`.
+- Decimal dice require `bigdecimal`.
+
+Otherwise, there are no direct dependencies.
 
-## Usage
+## Usage: CLI (command line)
 
-Following examples assume that `dicey` (or `dicey-to-gnuplot`) is executable and is in `$PATH`. You can also run it with `ruby dicey` instead.
+Following examples assume that `dicey` (or `dicey-to-gnuplot`) is executable and is in `$PATH`.
 
 > [!NOTE]
 > 💡 Run `dicey --help` to get a list of all possible options.
 
-### Example 1
+### Example 1: Basic distribution
 
 Let's start with something simple. Imagine that your Bard character has Vicious Mockery cantrip with 2d4 damage, and you would like to know the distribution of possible damage rolls. Run **Dicey** with two 4s as arguments:
 ```sh
@@ -58,7 +95,7 @@ $ dicey 4 4
 
 It should output the following:
 ```sh
-# ⚃;⚃
+# D4+D4
 2 => 1
 3 => 2
 4 => 3
@@ -73,7 +110,7 @@ First line is a comment telling you that calculation ran for two D4s. Every line
 If probability is preferred, there is an option for that:
 ```sh
 $ dicey 4 4 --result probabilities # or -r p for short
-# ⚃;⚃
+# D4+D4
 2 => 0.0625
 3 => 0.125
 4 => 0.1875
@@ -85,12 +122,13 @@ $ dicey 4 4 --result probabilities # or -r p for short
 
 This shows that 5 will probably be rolled a quarter of the time.
 
-### Example 2
+### Example 2: Complex distribution with different dice
 
 During your quest to end all ends you find a cool Burning Sword which deals 1d8 slashing damage and 2d4 fire damage on attack. You run **Dicey** with these dice:
 ```sh
-$ dicey 8 4 4
-# [8];⚃;⚃
+# Note the shorthand notation for two dice!
+$ dicey 8 2d4
+# D8+D4+D4
 3 => 1
 4 => 3
 5 => 6
@@ -109,26 +147,55 @@ $ dicey 8 4 4
 
 Results show that while the total range is 3–16, it is much more likely to roll numbers in the 6–13 range. That's pretty fire, huh?
 
+#### Example 2.1: Graph
+
 If you downloaded `dicey-to-gnuplot` and have [gnuplot](http://gnuplot.info) installed, it is possible to turn these results into a graph with a somewhat clunky command:
 ```sh
-$ dicey 8 4 4 --format gnuplot | dicey-to-gnuplot
-# --format gnuplot can be abbreviated to -f g
+$ dicey 8 2d4 -f g | dicey-to-gnuplot
+# `--format gnuplot` is shortened to `-f g`
 ```
 
-This will create a PNG image named `[8];⚃;⚃.png`:
-![Graph of damage roll frequencies for Burning Sword]([8];⚃;⚃.png)
+This will create a PNG image named "*D8+D4+D4.png*":
+![Graph of damage roll frequencies for Burning Sword](D8+D4+D4.png)
 
-> [!NOTE]
-> 💡 It is possible to output JSON or YAML with `--format json` and `--format yaml` respectively.
+#### Example 2.2: JSON and YAML
+
+If you find that you need to export results for further processing, it would be great if a common data interchange format was used. **Dicey** supports output as JSON and YAML with `--format json` (or `-f j`) and `--format yaml` (or `-f y`) respectively.
+
+JSON via `dicey 8 2d4 --format json`:
+```json
+{"description":"D8+D4+D4","results":{"3":1,"4":3,"5":6,"6":10,"7":13,"8":15,"9":16,"10":16,"11":15,"12":13,"13":10,"14":6,"15":3,"16":1}}
+```
 
-### Example 3
+YAML via `dicey 8 2d4 --format yaml`:
+```yaml
+---
+description: D8+D4+D4
+results:
+  3: 1
+  4: 3
+  5: 6
+  6: 10
+  7: 13
+  8: 15
+  9: 16
+  10: 16
+  11: 15
+  12: 13
+  13: 10
+  14: 6
+  15: 3
+  16: 1
+```
+
+### Example 3: Custom dice
 
 While walking home from work you decide to take a shortcut through a dark alleyway. Suddenly, you notice a die lying on the ground. Looking closer, it turns out to be a D4, but its 3 side was erased from reality. You just have to learn what impact this has on a roll together with a normal D4. Thankfully, you know just the program for the job.
 
 Having ran to a computer as fast as you can, you sic **Dicey** on the problem:
 ```sh
 $ dicey 1,2,4 4
-# (1,2,4);⚃
+# (1,2,4)+D4
 2 => 1
 3 => 2
 4 => 2
@@ -140,30 +207,150 @@ $ dicey 1,2,4 4
 
 Hmm, this looks normal, doesn't it? But wait, why are there two 2s in a row? Turns out that not having one of the sides just causes the roll frequencies to slightly dip in the middle. Good to know.
 
+But what if you had TWO weird D4s?
+```sh
+$ dicey 2d1,2,4
+# (1,2,4)+(1,2,4)
+2 => 1
+3 => 2
+4 => 1
+5 => 2
+6 => 2
+8 => 1
+```
+
+Hah, now this is a properly cursed distribution!
+
 > [!TIP]
-> 💡 A single integer argument N practically is a shorthand for listing every side from 1 to N.
+> 💡 A single positive integer argument N practically is a shorthand for listing every side from 1 to N.
 
-### Example 4
+### Example 4: Rolling even more custom dice
 
 You have a sudden urge to roll dice while only having boring integer dice at home. Where to find *the cool* dice though?
 
 Look no further than **roll** mode introduced in **Dicey** 0.12:
 ```sh
-dicey 0.5,1.5,2.5 4 --mode roll # As always, can be abbreviated to -m r
-# (0.5e0,0.15e1,0.25e1);⚃
+$ dicey 0.5,1.5,2.5 4 --mode roll # As always, can be abbreviated to -m r
+# (0.5e0,0.15e1,0.25e1)+D4
 roll => 0.35e1 # You probably will get a different value here.
 ```
 
 > [!NOTE]
-> 💡 Roll mode is compatible with `--format`, but not `--result`.
+> 💡 Roll mode is compatible with `--format` option.
+
+### All ways to define dice
+
+There are three *main* ways to define dice:
+- *"5", "25", or "525"*: a single positive integer makes a regular die (like a D20).
+- *"3-6", "-5..5", "(0-1)"*: a pair of integers with a separator, possibly in round brackets, makes a numeric die with integers in the range.
+  - Accepted separators: "-", "..", "...", "–" (en dash), "—" (em dash), "…" (ellipsis).
+- *"1,2,4", "(-1.5,0,1.5)", or "2,"*: a list of any numbers separated by commas, possibly in round brackets, makes an arbitrary numeric die.
+  - Lists can end in a comma, allowing single-number lists.
+
+*"D6", "d(-1,3)", or "d2..4"*: any definitions can be prefixed with "d" or "D". While this doesn't do anything on its own, it can be useful to not start a definition with "-".
+
+*"2D6", "5d-1,3", or "277D(2..4)"*: any definitions can be prefixed with "*N*d" or "*N*D", where *N* is a positive integer. This creates *N* copies of the die.
+
+## Usage: API
+
+> [!Note]
+> - Latest API documentation from `main` branch is automatically deployed to [GitHub Pages](https://trinistr.github.io/dicey).
+> - Documentation for published versions is available on [RubyDoc](https://rubydoc.info/gems/dicey).
+
+### Dice
+
+There are 3 classes of dice currently:
+- `Dicey::AbstractDie` is the base class for other dice, but can be used on its own. It has no restrictions on values of sides. For now, it is *only* useful for rolling and can't be used for distribution calculations.
+- `Dicey::NumericDie` behaves much the same as `Dicey::AbstractDie` (being its subclass), except for checking that all values are instances of `Numeric`. It can be initialized with an Array or Range.
+- `Dicey::RegularDie` is a specialized subclass of `Dicey::NumericDie`. It is defined by a single integer *N* which is expanded to a range (1..*N*).
+
+All dice classes have constructor methods aside from `.new`:
+- `.from_list` takes a list of definitions and calls `.new` with each one;
+- `.from_count` takes a count and a definition and calls `.new` with it specified number of times.
+
+See [Diving deeper](#diving-deeper) for more theoretical information.
+
+> [!NOTE]
+> 💡 Using `Float` values is liable to cause precision issues. Due to in-built result verification, this **will** raise errors. Use `Rational` or `BigDecimal` instead. 
+
+#### DieFoundry
+
+`Dicey::DieFoundry#call` provides the interface for creating dice from Strings as available in CLI:
+```rb
+Dicey::DieFoundry.new.call("100")
+  # same as Dicey::RegularDie.new(100)
+Dicey::DieFoundry.new.call("2d6")
+  # same as Dicey::RegularDie.from_count(2, 6)
+Dicey::DieFoundry.new.call("1d1,2,4")
+  # same as Dicey::NumericDie.from_list([1,2,4])
+```
+
+It only takes a single argument and may return both an array of dice and a single die. You will probably want to use `Enumerable#flat_map`:
+```rb
+foundry = Dicey::DieFoundry.new
+%w[8 2d4].flat_map { foundry.call(_1) }
+  # same as [Dicey::RegularDie.new(8), *Dicey::RegularDie.from_count(2, 4)]
+```
+
+### Rolling
+
+`Dicey::AbstractDie#roll` implements the rolling:
+```rb
+Dicey::AbstractDie.new([0, 1, 5, "10"]).roll
+  # almost same as [0, 1, 5, "10"].sample
+Dicey::RegularDie.new(6).roll
+  # almost same as rand(1..6)
+```
+
+Dice retain their roll state, with `#current` returning the last roll (or initial side if never rolled):
+```rb
+die = Dicey::RegularDie.new(6)
+die.current
+  # => 1
+die.roll
+  # => 3
+die.current
+  # => 3
+```
+
+Rolls can be reproducible if a specific seed is set:
+```rb
+Dicey::AbstractDie.srand(493_525)
+die = Dicey::RegularDie.new(6)
+die.roll
+  # => 4
+die.roll
+  # => 1
+# Repeat:
+Dicey::AbstractDie.srand(493_525)
+die = Dicey::RegularDie.new(6)
+die.roll
+  # => 4
+die.roll
+  # => 1
+```
+
+> [!NOTE]
+> 💡 Randomness source is *global*, shared between all dice and probably not thread-safe.
+
+### Calculators
+
+Frequency calculators live in `Dicey::SumFrequencyCalculators` module. There are four calculators currently:
+- `Dicey::SumFrequencyCalculators::KroneckerSubstitution` is the recommended calculator, able to handle all `Dicey::RegularDie`. It is very fast, calculating distribution for *100d6* in about 0.1 seconds on my laptop.
+- `Dicey::SumFrequencyCalculators::MultinomialCoefficients` is specialized for repeated numeric dice, with performance only slightly worse. However, it is currently limited to dice with arithmetic sequences.
+- `Dicey::SumFrequencyCalculators::BruteForce` is the most generic and slowest one, but can in principle work with any dice. Currently, it is also limited to `Dicey::NumericDie`, as it's unclear how to handle other values.
+- `Dicey::SumFrequencyCalculators::Empirical`. This is more of a tool than a calculator. It can be interesting to play around with and see how practical results compare to theoretical ones.
+
+Calculators inherit from `Dicey::SumFrequencyCalculators::BaseCalculator` and provide the following public interface:
+- `#call(dice, result_type: {:frequencies | :probabilities}, **options) : Hash`
+- `#valid_for?(dice) : Boolean`
+
+See [next section](#diving-deeper) for more details on limitations and complexity considerations.
 
 ## Diving deeper
 
 For a further discussion of calculations, it is important to understand which classes of dice exist.
-- **Regular** die — a die with N sides with sequential integers from 1 to N,
-  like a classic cubic D6, D20, or even a coin if you assume that it rolls 1 and 2.
-  These are dice used for many tabletop games, including role-playing games.
-  Most probably, you will only ever need these and not anything beyond.
+- **Regular** die — a die with N sides with sequential integers from 1 to N, like a classic cubic D6, D20, or even a coin if you assume that it rolls 1 and 2. These are dice used for many tabletop games, including role-playing games. Most probably, you will only ever need these and not anything beyond.
 
 > [!TIP]
 > 💡 If you only need to roll **regular** dice, this section will not contain anything important.
@@ -174,11 +361,11 @@ For a further discussion of calculations, it is important to understand which cl
 - **Abstract** die is not limited by anything other than not having partial sides (and how would that work anyway?).
 
 > [!NOTE]
-> 💡 If your die starts with a negative number or only has a single natural side, brackets can be employed to force treating it as a sides list, e.g. `dicey '(-1)'` (quotation is required due to shell processing).
+> 💡 If your die definition starts with a negative number, it can be bracketed, prefixed with "d", or put after "--" pseudo-argument to avoid processing as an option.
 
-Dicey is in principle able to handle any numeric dice and some abstract dice with well-defined summation (tested on complex numbers), though not every possibility is exposed through command-line interface: that is limited to floating-point values.
+Dicey is in principle able to handle any real numeric dice and some abstract dice with well-defined summation (tested on complex numbers), though not every possibility is exposed through command-line interface: that is limited to floating-point values.
 
-Currently, three algorithms are implemented, with different possibilities and trade-offs.
+Currently, three algorithms for calculating frequencies are implemented, with different possibilities and trade-offs.
 
 > [!NOTE]
 > 💡 Complexity is listed for `n` dice with at most `m` sides and has not been rigorously proven.
@@ -188,7 +375,7 @@ Currently, three algorithms are implemented, with different possibilities and tr
 An algorithm based on fast polynomial multiplication. This is the default algorithm, used for most reasonable dice.
 
 - Limitations: only **natural** dice are allowed, including **regular** dice.
-- Example: `dicey 5 3,4,1 '(0)'`
+- Example: `dicey 5 3,4,1 0,`
 - Complexity: `O(m⋅n)` where `m` is the highest value
 
 ### Multinomial coefficients
@@ -209,7 +396,7 @@ As a last resort, there is a brute force algorithm which goes through every poss
 
 ## Development
 
-After checking out the repo, run `bundle` (or `bundle install`) to install dependencies. Then, run `rake spec` to run the tests, `rake rubocop` to lint code and check style compliance, `rake rbs` to validate signatures or just `rake` to do everything above. There is also `rake steep` to check typing, and `rake docs` to generate YARD documentation.
+After checking out the repo, run `bundle install` to install dependencies. Then, run `rake spec` to run the tests, `rake rubocop` to lint code and check style compliance, `rake rbs` to validate signatures or just `rake` to do everything above. There is also `rake steep` to check typing, and `rake docs` to generate YARD documentation.
 
 You can also run `bin/console` for an interactive prompt that will allow you to experiment, or `bin/benchmark` to run a benchmark script and generate a StackProf flamegraph.
 
@@ -223,13 +410,13 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/trinis
 
 ### Checklist for a new or updated feature
 
-- Running `rspec` reports 100% coverage (unless it's impossible to achieve in one run).
-- Running `rubocop` reports no offenses.
+- Running `rake spec` reports 100% coverage (unless it's impossible to achieve in one run).
+- Running `rake rubocop` reports no offenses.
 - Running `rake steep` reports no new warnings or errors.
-- Tests cover the behavior and its interactions. 100% coverage *is not enough*, as it does not guarantee that all code paths are covered.
+- Tests cover the behavior and its interactions. 100% coverage *is not enough*, as it does not guarantee that all code paths are tested.
 - Documentation is up-to-date: generate it with `rake docs` and read it.
-- `CHANGELOG.md` lists the change if it has impact on users.
-- `README.md` is updated if the feature should be visible there.
+- "*CHANGELOG.md*" lists the change if it has impact on users.
+- "*README.md*" is updated if the feature should be visible there, including the Kanban board.
 
 ## License
 

data/lib/dicey/abstract_die.rb

@@ -6,6 +6,7 @@ module Dicey
   class AbstractDie
     # rubocop:disable Style/ClassVars
 
+    # @api private
     # Get a random value using a private instance of Random.
     # @see Random#rand
     def self.rand(...)
@@ -20,72 +21,129 @@ module Dicey
 
     # Yes, class variable is actually useful here.
     # TODO: Allow supplying a custom Random.
+
+    # Shared randomness source, accessed through {.rand} and {.srand}.
     @@random = Random.new
 
     # rubocop:enable Style/ClassVars
 
     # Get a text representation of a list of dice.
     #
-    # @param dice [Enumerable<AbstractDie>]
+    # @param dice [Enumerable<AbstractDie>, AbstractDie]
     # @return [String]
     def self.describe(dice)
-      dice.join(";")
+      return dice.to_s if AbstractDie === dice
+
+      dice.to_a.join("+")
+    end
+
+    # Create a bunch of different dice at once.
+    #
+    # @param definitions [Array<Enumerable<Any>>, Array<Any>]
+    #   list of definitions suitable for the dice class
+    # @return [Array<AbstractDie>]
+    def self.from_list(*definitions)
+      definitions.map { new(_1) }
     end
 
-    attr_reader :sides_list, :sides_num
+    # Create a number of equal dice.
+    #
+    # @param count [Integer] number of dice to create
+    # @param definition [Enumerable<Any>, Any]
+    #   definition suitable for the dice class
+    # @return [Array<AbstractDie>]
+    def self.from_count(count, definition)
+      Array.new(count) { new(definition) }
+    end
 
-    # @param sides_list [Enumerable<Object>]
+    # Die's list of sides.
+    #
+    # @return [Array<Any>]
+    attr_reader :sides_list
+
+    # Number of sides of the die.
+    #
+    # @return [Integer]
+    attr_reader :sides_num
+
+    # @param sides_list [Enumerable<Any>]
     # @raise [DiceyError] if +sides_list+ is empty
     def initialize(sides_list)
-      @sides_list = sides_list.is_a?(Array) ? sides_list.dup.freeze : sides_list.to_a.freeze
+      @sides_list = (Array === sides_list) ? sides_list.dup.freeze : sides_list.to_a.freeze
       raise DiceyError, "dice must have at least one side!" if @sides_list.empty?
 
       @sides_num = @sides_list.size
-
-      sides_enum = @sides_list.to_enum
-      @enum =
-        Enumerator.produce do
-          sides_enum.next
-        rescue StopIteration
-          sides_enum.rewind
-          retry
-        end
+      @current_side_index = 0
     end
 
     # Get current side of the die.
-    # @return [Object] current side
+    #
+    # @return [Any] current side
     def current
-      @enum.peek
+      @sides_list[@current_side_index]
     end
 
-    # Get next side of the die, advancing internal enumerator state.
-    # Wraps from last to first side.
-    # @return [Object] next side
+    # Get next side of the die, advancing internal state.
+    # Starts from first side, wraps from last to first side.
+    #
+    # @return [Any] next side
     def next
-      @enum.next
+      ret = current
+      @current_side_index = (@current_side_index + 1) % @sides_num
+      ret
     end
 
-    # Advance internal enumerator state by a random number using {#next}.
-    # @return [Object] rolled side
+    # Move internal state to a random side.
+    #
+    # @return [Any] rolled side
     def roll
-      self.class.rand(0...sides_num).times { self.next }
+      @current_side_index = self.class.rand(0...@sides_num)
       current
     end
 
+    # Return a string representing the die.
+    #
+    # Default representation is a list of sides in round brackets.
+    #
     # @return [String]
     def to_s
-      "(#{sides_list.join(",")})"
+      (@sides_list.size > 1) ? "(#{@sides_list.join(",")})" : "(#{@sides_list.first},)"
     end
 
     # Determine if this die and the other one have the same list of sides.
     # Be aware that differently ordered sides are not considered equal.
     #
-    # @param other [AbstractDie, Object]
+    # @param other [AbstractDie, Any]
     # @return [Boolean]
     def ==(other)
-      return false unless other.is_a?(AbstractDie)
+      AbstractDie === other && same_sides?(other)
+    end
+
+    # Determine if this die and the other one are of the same class
+    # and have the same list of sides.
+    # Be aware that differently ordered sides are not considered equal.
+    #
+    # +die_1.eql?(die_2)+ implies +die_1.hash == die_2.hash+.
+    #
+    # @param other [AbstractDie, Any]
+    # @return [Boolean]
+    def eql?(other)
+      self.class === other && same_sides?(other)
+    end
 
-      sides_list == other.sides_list
+    # Generates an Integer hash value for this object.
+    #
+    # @return [Integer]
+    def hash
+      [self.class, @sides_list].hash
+    end
+
+    private
+
+    # @param other [AbstractDie]
+    # @return [Boolean]
+    def same_sides?(other)
+      @sides_list == other.sides_list
     end
   end
 end

data/lib/dicey/cli/options.rb

@@ -19,6 +19,9 @@ module Dicey
       def initialize(initial_options = DEFAULT_OPTIONS.dup)
         @options = initial_options
         @parser = ::OptionParser.new
+        @parser.program_name = "dicey"
+        @parser.version = Dicey::VERSION
+
         add_banner_and_version
         add_common_options
         add_test_options
@@ -51,10 +54,11 @@ module Dicey
       def add_banner_and_version
         @parser.banner = <<~TEXT
           Usage: #{@parser.program_name} [options] <die> [<die> ...]
+                 #{@parser.program_name} [options] -- <die> [<die> ...]
                  #{@parser.program_name} --test [full|quiet]
           All option names and arguments can be abbreviated if abbreviation is unambiguous.
+          A lone "--" separates options and die definitions, allowing definitions to start with "-".
         TEXT
-        @parser.version = Dicey::VERSION
       end
 
       def add_common_options
@@ -86,13 +90,14 @@ module Dicey
         end
       end
 
-      def easy_option(short, long, values, description, &)
-        values = values.keys if values.respond_to?(:keys)
+      def easy_option(short, long, values, description, &block)
         option_name = long[/[a-z_]+/].to_sym
         argument_name = long[/[A-Z_]+/]
         listed_values = "#{argument_name} can be: #{values.map { "`#{_1}`" }.join(", ")}."
-        default_value = "`#{@options[option_name]}` is default." if @options[option_name]
-        @parser.on(*[short, long, values, description, listed_values, default_value].compact, &)
+        default_value = "`#{@options[option_name]}` is default."
+        @parser.on(
+          *[short, long, values, description, listed_values, default_value].compact, &block
+        )
       end
     end
   end

data/lib/dicey/die_foundry.rb

@@ -6,52 +6,81 @@ require_relative "regular_die"
 module Dicey
   # Helper class to define die definitions and automatically select the best one.
   class DieFoundry
+    # Regexp for matching a possible count.
+    PREFIX = /(?>(?<count>[1-9]\d*+)?d)?+/i
+
     # Possible molds for the dice. They are matched in the order as written.
-    MOLDS = {
+    MOLDS = [
       # Positive integer goes into the RegularDie mold.
-      ->(d) { /\A[1-9]\d*\z/.match?(d) } => :regular_mold,
+      [/\A#{PREFIX}(?<sides>[1-9]\d*+)\z/, :regular_mold].freeze,
+      # Integer range goes into the NumericDie mold.
+      [/\A#{PREFIX}\(?(?<begin>-?\d++)(?>[-–—…]|\.{2,3})(?<end>-?\d++)\)?\z/, :range_mold].freeze,
       # List of numbers goes into the NumericDie mold.
-      ->(d) { /\A\(?-?\d++(?:,-?\d++)*\)?\z/.match?(d) } => :weirdly_shaped_mold,
-      # Real numbers require arbitrary precision arithmetic, which is not enabled by default.
-      ->(d) {
-        /\A\(?-?\d++(?:\.\d++)?(?:,-?\d++(?:\.\d++)?)*+\)?\z/.match?(d)
-      } => :weirdly_precise_mold,
+      [/\A#{PREFIX}\(?(?<sides>-?\d++(?>,(?>-?\d++)?)+|,)\)?\z/, :weirdly_shaped_mold].freeze,
+      # Non-integers require arbitrary precision arithmetic, which is not enabled by default.
+      [/\A#{PREFIX}\(?(?<sides>-?\d++(?>\.\d++)?(?>,(?>-?\d++(?>\.\d++)?)?)+|,)\)?\z/,
+       :weirdly_precise_mold].freeze,
       # Anything else is spilled on the floor.
-      ->(*) { true } => :broken_mold,
-    }.freeze
-
-    # Regexp for removing brackets from lists.
-    BRACKET_STRIPPER = /\A\(?(.+)\)?\z/
+    ].freeze
 
     # Cast a die definition into a mold to make a die.
     #
-    # @param definition [String] die shape, refer to {MOLDS} for possible variants
-    # @return [NumericDie, RegularDie]
+    # Following definitions are recognized:
+    # - positive integer (like "6" or "20"), which produces a {RegularDie};
+    # - integer range (like "3-6" or "(-5..5)"), which produces a {NumericDie};
+    # - list of integers (like "3,4,5", "(-1,0,1)", or "2,"), which produces a {NumericDie};
+    # - list of decimal numbers (like "0.5,0.2,0.8" or "(2.0,)"), which produces a {NumericDie},
+    #   but uses +BigDecimal+ for values to maintain precise results.
+    #
+    # Any die definition can be prefixed with a count, like "2D6" or "1d1,3,5" to create an array.
+    # A plain "d" without an explicit count is ignored instead, creating a single die.
+    #
+    # @param definition [String] die shape
+    # @return [NumericDie, RegularDie, Array<NumericDie>, Array<RegularDie>]
     # @raise [DiceyError] if no mold fits the definition
-    def cast(definition)
-      _shape, mold = MOLDS.find { |shape, _mold| shape.call(definition) }
-      __send__(mold, definition)
+    def call(definition)
+      matched, name =
+        MOLDS.reduce(nil) do |_, (shape, mold)|
+          match = shape.match(definition)
+          break [match, mold] if match
+        end
+      raise DiceyError, "can not cast die from `#{definition}`!" unless name
+
+      __send__(name, matched)
     end
 
+    alias cast call
+
     private
 
     def regular_mold(definition)
-      RegularDie.new(definition.to_i)
+      build_dice(RegularDie, definition[:count], definition[:sides].to_i)
+    end
+
+    def range_mold(definition)
+      first = definition[:begin].to_i
+      last = definition[:end].to_i
+      first, last = last, first if first > last
+      build_dice(NumericDie, definition[:count], first..last)
     end
 
     def weirdly_shaped_mold(definition)
-      definition = definition.match(BRACKET_STRIPPER)[1]
-      NumericDie.new(definition.split(",").map(&:to_i))
+      build_dice(NumericDie, definition[:count], definition[:sides].split(",").map(&:to_i))
     end
 
     def weirdly_precise_mold(definition)
-      require "bigdecimal"
-      definition = definition.match(BRACKET_STRIPPER)[1]
-      NumericDie.new(definition.split(",").map { BigDecimal(_1) })
+      require "bigdecimal" unless defined?(BigDecimal)
+
+      sides = definition[:sides].split(",").map { BigDecimal(_1) }
+      build_dice(NumericDie, definition[:count], sides)
     end
 
-    def broken_mold(definition)
-      raise DiceyError, "can not cast die from `#{definition}`!"
+    def build_dice(die_class, count, sides)
+      if count
+        die_class.from_count(count.to_i, sides)
+      else
+        die_class.new(sides)
+      end
     end
   end
 end

data/lib/dicey/numeric_die.rb

@@ -8,9 +8,16 @@ module Dicey
     # @param sides_list [Enumerable<Numeric>]
     # @raise [DiceyError] if +sides_list+ contains non-numerical values or is empty
     def initialize(sides_list)
-      sides_list.each do |value|
-        raise DiceyError, "`#{value}` is not a number!" unless value.is_a?(Numeric)
+      if Range === sides_list
+        unless Numeric === sides_list.begin && Numeric === sides_list.end
+          raise DiceyError, "`#{sides_list.inspect}` is not a numerical range!"
+        end
+      else
+        sides_list.each do |value|
+          raise DiceyError, "`#{value.inspect}` is not a number!" unless Numeric === value
+        end
       end
+
       super
     end
   end

data/lib/dicey/output_formatters/hash_formatter.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module Dicey
+  # Processors which turn data to text.
   module OutputFormatters
     # Base formatter for outputting in formats which can be converted from a Hash directly.
     # Can add an optional description into the result.

data/lib/dicey/regular_die.rb

@@ -5,28 +5,22 @@ require_relative "numeric_die"
 module Dicey
   # Regular die, which has N sides with numbers from 1 to N.
   class RegularDie < NumericDie
-    # Characters to use for small dice.
-    D6 = "⚀⚁⚂⚃⚄⚅"
+    # @param max [Integer] maximum side / number of sides
+    def initialize(max)
+      unless Integer === max && max.positive?
+        raise DiceyError, "regular dice can contain only positive integers, #{max.inspect} is not"
+      end
 
-    # Create a list of regular dice with the same number of sides.
-    #
-    # @param dice [Integer]
-    # @param sides [Integer]
-    # @return [Array<RegularDie>]
-    def self.create_dice(dice, sides)
-      (1..dice).map { new(sides) }
-    end
-
-    # @param sides [Integer]
-    def initialize(sides)
-      super((1..sides))
+      super((1..max))
     end
 
-    # Dice with 1–6 sides are displayed with a single character.
-    # More than that, and we get into the square bracket territory.
+    # Return a string representing the die.
+    #
+    # Regular dice are represented with a "D" followed by the number of sides.
+    #
     # @return [String]
     def to_s
-      (sides_num <= D6.size) ? D6[sides_num - 1] : "[#{sides_num}]"
+      "D#{sides_num}"
     end
   end
 end

data/lib/dicey/roller.rb

@@ -12,10 +12,9 @@ module Dicey
     def call(arguments, format:, **)
       raise DiceyError, "no dice!" if arguments.empty?
 
-      dice = arguments.map { |definition| die_foundry.cast(definition) }
-      dice.each(&:roll)
+      dice = arguments.flat_map { |definition| die_foundry.cast(definition) }
+      result = dice.sum(&:roll)
 
-      result = dice.sum(&:current)
       format.call({ "roll" => result }, AbstractDie.describe(dice))
     end
 

data/lib/dicey/sum_frequency_calculators/base_calculator.rb

@@ -1,8 +1,17 @@
 # frozen_string_literal: true
 
 module Dicey
+  # Calculators for probability distributions of dice.
   module SumFrequencyCalculators
     # Base frequencies calculator.
+    #
+    # *Options:*
+    #
+    # Calculators may have calculator-specific options,
+    # passed as extra keyword arguments to {#call}.
+    # If present, they will be documented under *Options* heading
+    # on the class itself.
+    #
     # @abstract
     class BaseCalculator
       # Possible values for +result_type+ argument in {#call}.
@@ -10,17 +19,20 @@ module Dicey
 
       # @param dice [Enumerable<AbstractDie>]
       # @param result_type [Symbol] one of {RESULT_TYPES}
+      # @param options [Hash{Symbol => Any}] calculator-specific options
       # @return [Hash{Numeric => Numeric}] frequencies of each sum
       # @raise [DiceyError] if +result_type+ is invalid
       # @raise [DiceyError] if dice list is invalid for the calculator
       # @raise [DiceyError] if calculator returned obviously wrong results
-      def call(dice, result_type: :frequencies)
+      def call(dice, result_type: :frequencies, **options)
         unless RESULT_TYPES.include?(result_type)
           raise DiceyError, "#{result_type} is not a valid result type!"
         end
+        # Short-circuit for a degenerate case.
+        return {} if dice.empty?
         raise DiceyError, "#{self.class} can not handle these dice!" unless valid_for?(dice)
 
-        frequencies = calculate(dice)
+        frequencies = calculate(dice, **options)
         verify_result(frequencies, dice)
         frequencies = sort_result(frequencies)
         transform_result(frequencies, result_type)
@@ -31,7 +43,7 @@ module Dicey
       # @param dice [Enumerable<AbstractDie>]
       # @return [Boolean]
       def valid_for?(dice)
-        dice.is_a?(Enumerable) && dice.all? { _1.is_a?(AbstractDie) } && validate(dice)
+        dice.is_a?(Enumerable) && dice.all?(AbstractDie) && validate(dice)
       end
 
       private
@@ -44,8 +56,10 @@ module Dicey
 
       # Peform frequencies calculation.
       # (see #call)
-      def calculate(dice)
+      def calculate(dice, **nil)
+        # :nocov:
         raise NotImplementedError
+        # :nocov:
       end
 
       # Check that resulting frequencies actually add up to what they are supposed to be.
@@ -55,7 +69,7 @@ module Dicey
       # @return [void]
       # @raise [DiceyError] if result is wrong
       def verify_result(frequencies, dice)
-        valid = frequencies.values.sum == dice.map(&:sides_num).reduce(:*)
+        valid = frequencies.values.sum == (dice.map(&:sides_num).reduce(:*) || 0)
         raise DiceyError, "calculator #{self.class} returned invalid results!" unless valid
       end
 
@@ -74,14 +88,11 @@ module Dicey
       # @param result_type [Symbol] one of {RESULT_TYPES}
       # @return [Hash{Numeric => Numeric}]
       def transform_result(frequencies, result_type)
-        case result_type
-        when :frequencies
+        if result_type == :frequencies
           frequencies
-        when :probabilities
+        else
           total = frequencies.values.sum
           frequencies.transform_values { _1.fdiv(total) }
-        else
-          # Invalid, but was already checked in #call.
         end
       end
     end

data/lib/dicey/sum_frequency_calculators/brute_force.rb

@@ -8,51 +8,49 @@ module Dicey
     class BruteForce < BaseCalculator
       private
 
-      # def validate(dice)
-      #   dice.all? { |die| die.is_a?(NumericDie) }
-      # end
+      def validate(dice)
+        dice.all?(NumericDie)
+      end
 
-      def calculate(dice)
-        # TODO: Replace `combine_dice_enumerators` with `Enumerator.product`.
+      def calculate(dice, **nil)
         combine_dice_enumerators(dice).map(&:sum).tally
       end
 
-      # Get an enumerator which goes through all possible permutations of dice sides.
-      #
-      # @param dice [Enumerable<NumericDie>]
-      # @return [Enumerator<Array>]
-      def combine_dice_enumerators(dice)
-        sides_num_list = dice.map(&:sides_num)
-        total = sides_num_list.reduce(:*)
-        Enumerator.new(total) do |yielder|
-          current_values = dice.map(&:next)
-          remaining_iterations = sides_num_list
-          total.times do
-            yielder << current_values
-            iterate_dice(dice, remaining_iterations, current_values)
-          end
+      if defined?(Enumerator::Product)
+        # Get an enumerator which goes through all possible permutations of dice sides.
+        #
+        # @param dice [Enumerable<NumericDie>]
+        # @return [Enumerator<Array<Numeric>>]
+        def combine_dice_enumerators(dice)
+          Enumerator::Product.new(*dice.map(&:sides_list))
+        end
+      # :nocov:
+      else
+        # Get an enumerator which goes through all possible permutations of dice sides.
+        #
+        # @param dice [Enumerable<NumericDie>]
+        # @return [Enumerator<Array<Numeric>>]
+        def combine_dice_enumerators(dice)
+          product(dice.map(&:sides_list))
         end
-      end
 
-      # Iterate through dice, getting next side for first die,
-      # then getting next side for second die, resetting first die, and so on.
-      # This is analogous to incrementing by 1 in a positional system
-      # where each position is a die.
-      #
-      # @param dice [Enumerable<NumericDie>]
-      # @param remaining_iterations [Array<Integer>]
-      # @param current_values [Array<Numeric>]
-      # @return [void]
-      def iterate_dice(dice, remaining_iterations, current_values)
-        dice.each_with_index do |die, i|
-          value = die.next
-          current_values[i] = value
-          remaining_iterations[i] -= 1
-          break if remaining_iterations[i].nonzero?
+        # Simplified implementation of {Enumerator::Product}.
+        # Adapted from {https://bugs.ruby-lang.org/issues/18685#note-10}.
+        #
+        # @param enums [Enumerable<Enumerable<Numeric>>]
+        # @return [Enumerator<Array<Numeric>>]
+        def product(enums, &block)
+          return to_enum(__method__, enums) unless block_given?
 
-          remaining_iterations[i] = die.sides_num
+          enums
+            .reverse
+            .reduce(block) { |inner, enum|
+              ->(values) { enum.each_entry { inner.call([*values, _1]) } }
+            }
+            .call([])
         end
       end
+      # :nocov:
     end
   end
 end

data/lib/dicey/sum_frequency_calculators/empirical.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "base_calculator"
+
+module Dicey
+  module SumFrequencyCalculators
+    # "Calculator" for a collection of {NumericDie} using empirically-obtained statistics.
+    #
+    # @note This calculator is mostly a joke. It can be useful for educational purposes,
+    #   or to verify results of {BruteForce} when in doubt. It is not used by default.
+    #
+    # Does a number of rolls and calculates approximate probabilities from that.
+    # Even if frequencies are requested, results are non-integer.
+    #
+    # *Options:*
+    # - *rolls* (Integer) (_defaults_ _to:_ _N_) — number of rolls to perform
+    class Empirical < BaseCalculator
+      # Default number of rolls to perform.
+      N = 10_000
+
+      private
+
+      def validate(dice)
+        dice.all?(NumericDie)
+      end
+
+      def calculate(dice, rolls: N)
+        statistics = rolls.times.with_object(Hash.new(0)) { |_, hash| hash[dice.sum(&:roll)] += 1 }
+        total_results = dice.map(&:sides_num).reduce(:*)
+        statistics.transform_values { (_1 * total_results).fdiv(rolls) }
+      end
+
+      def verify_result(*)
+        # Ignore verification, as this is inherently imprecise.
+        true
+      end
+    end
+  end
+end

data/lib/dicey/sum_frequency_calculators/kronecker_substitution.rb

@@ -10,7 +10,9 @@ module Dicey
     #
     # Based on Kronecker substitution method for polynomial multiplication.
     # @see https://en.wikipedia.org/wiki/Kronecker_substitution
-    # @see https://arxiv.org/pdf/0712.4046v1.pdf in particular section 3
+    # @see https://arxiv.org/pdf/0712.4046v1.pdf
+    #   David Harvey, Faster polynomial multiplication via multi-point Kronecker substitution
+    #   (in particular section 3)
     class KroneckerSubstitution < BaseCalculator
       private
 
@@ -18,7 +20,7 @@ module Dicey
         dice.all? { |die| die.sides_list.all? { _1.is_a?(Integer) && _1 >= 0 } }
       end
 
-      def calculate(dice)
+      def calculate(dice, **nil)
         polynomials = build_polynomials(dice)
         evaluation_point = find_evaluation_point(polynomials)
         values = evaluate_polynomials(polynomials, evaluation_point)

data/lib/dicey/sum_frequency_calculators/multinomial_coefficients.rb

@@ -9,7 +9,7 @@ module Dicey
     # Example dice: (1,2,3,4), (-2,-1,0,1,2), (0,0.2,0.4,0.6), (-1,-2,-3).
     #
     # Based on extension of Pascal's triangle for a higher number of coefficients.
-    # @see https://en.wikipedia.org/wiki/Pascal%27s_triangle
+    # @see https://en.wikipedia.org/wiki/Pascal's_triangle
     # @see https://en.wikipedia.org/wiki/Trinomial_triangle
     class MultinomialCoefficients < BaseCalculator
       private
@@ -30,11 +30,10 @@ module Dicey
         return false if increment.zero?
 
         sides_list.each_cons(2) { return false if _1 + increment != _2 }
+        true
       end
 
-      # @param dice [Array<NumericDie>]
-      # @return [Hash{Numeric => Integer}]
-      def calculate(dice)
+      def calculate(dice, **nil)
         first_die = dice.first
         number_of_sides = first_die.sides_num
         number_of_dice = dice.size
@@ -48,27 +47,22 @@ module Dicey
       #
       # @param dice [Integer] number of dice, must be positive
       # @param sides [Integer] number of sides, must be positive
-      # @param throw_away_garbage [Boolean] whether to discard unused coefficients (debug option)
       # @return [Array<Integer>]
-      def multinomial_coefficients(dice, sides, throw_away_garbage: true)
-        # This builds a triangular matrix where each first element is a 1.
-        # Each element is a sum of +m+ elements in the previous row
-        # with indices less or equal to its, with out-of-bounds indices corresponding to 0s.
-        # Example for m=3:
+      def multinomial_coefficients(dice, sides)
+        # This builds a triangular matrix where first elements are always 1s
+        # and other elements are sums of +sides+ elements in the previous row
+        # with indices less or equal, with out-of-bounds indices corresponding to 0s.
+        # Example for sides=3:
         # 1
         # 1 1 1
         # 1 2 3 2 1
         # 1 3 6 7 6 3 1, etc.
-        coefficients = [[1]]
-        (1..dice).each do |row_index|
-          row = next_row_of_coefficients(row_index, sides - 1, coefficients.last)
-          if throw_away_garbage
-            coefficients[0] = row
-          else
-            coefficients << row
-          end
+        # We start directly from second row, which corresponds to 1 die.
+        coefficients = Array.new(sides, 1)
+        (2..dice).each do |row_index|
+          coefficients = next_row_of_coefficients(row_index, sides - 1, coefficients)
         end
-        coefficients.last
+        coefficients
       end
 
       # @param row_index [Integer]
@@ -79,7 +73,8 @@ module Dicey
         length = (row_index * window_size) + 1
         (0..length).map do |col_index|
           # Have to clamp to 0 to prevent accessing array from the end.
-          window_range = ((col_index - window_size).clamp(0..)..col_index)
+          # BUG: TruffleRuby can't handle endless range in #clamp (see https://github.com/oracle/truffleruby/issues/3945)
+          window_range = ((col_index - window_size).clamp(0..col_index)..col_index)
           window_range.sum { |i| previous_row.fetch(i, 0) }
         end
       end

data/lib/dicey/sum_frequency_calculators/runner.rb

@@ -21,7 +21,7 @@ module Dicey
       def call(arguments, roll_calculators:, format:, result:, **)
         raise DiceyError, "no dice!" if arguments.empty?
 
-        dice = arguments.map { |definition| die_foundry.cast(definition) }
+        dice = arguments.flat_map { |definition| die_foundry.cast(definition) }
         frequencies = roll_calculators.find { _1.valid_for?(dice) }&.call(dice, result_type: result)
         raise DiceyError, "no calculator could handle these dice!" unless frequencies
 

data/lib/dicey/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Dicey
-  VERSION = "0.13.1"
+  VERSION = "0.15.0"
 end

data/lib/dicey.rb

@@ -5,7 +5,7 @@ module Dicey
   # General error for Dicey.
   class DiceyError < StandardError; end
 
-  Dir["#{__dir__}/dicey/*.rb"].each { require _1 }
-  Dir["#{__dir__}/dicey/output_formatters/*.rb"].each { require _1 }
-  Dir["#{__dir__}/dicey/sum_frequency_calculators/*.rb"].each { require _1 }
+  Dir["dicey/*.rb", base: __dir__].each { require_relative _1 }
+  Dir["dicey/output_formatters/*.rb", base: __dir__].each { require_relative _1 }
+  Dir["dicey/sum_frequency_calculators/*.rb", base: __dir__].each { require_relative _1 }
 end

metadata

@@ -1,14 +1,25 @@
 --- !ruby/object:Gem::Specification
 name: dicey
 version: !ruby/object:Gem::Version
-  version: 0.13.1
+  version: 0.15.0
 platform: ruby
 authors:
 - Alexandr Bulancov
+autorequire:
 bindir: exe
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2025-09-22 00:00:00.000000000 Z
 dependencies: []
+description: |
+  Dicey provides a CLI executable and a Ruby API for fast calculation of
+  frequency/probability distributions of dice rolls,
+  with support for all kinds of numeric dice, even Complex ones!
+  Results can be exported as JSON, YAML or a gnuplot data file.
+
+  It can also be used to roll dice. While not the primary focus,
+  rolling is well supported, including ability to seed random source
+  for reproducible results.
+email:
 executables:
 - dicey
 - dicey-to-gnuplot
@@ -35,22 +46,23 @@ files:
 - lib/dicey/roller.rb
 - lib/dicey/sum_frequency_calculators/base_calculator.rb
 - lib/dicey/sum_frequency_calculators/brute_force.rb
+- lib/dicey/sum_frequency_calculators/empirical.rb
 - lib/dicey/sum_frequency_calculators/kronecker_substitution.rb
 - lib/dicey/sum_frequency_calculators/multinomial_coefficients.rb
 - lib/dicey/sum_frequency_calculators/runner.rb
 - lib/dicey/sum_frequency_calculators/test_runner.rb
 - lib/dicey/version.rb
-- sig/dicey.rbs
 homepage: https://github.com/trinistr/dicey
 licenses:
 - MIT
 metadata:
   homepage_uri: https://github.com/trinistr/dicey
   bug_tracker_uri: https://github.com/trinistr/dicey/issues
-  documentation_uri: https://rubydoc.info/gems/dicey/0.13.1
-  source_code_uri: https://github.com/trinistr/dicey/tree/v0.13.1
-  changelog_uri: https://github.com/trinistr/dicey/blob/v0.13.1/CHANGELOG.md
+  documentation_uri: https://rubydoc.info/gems/dicey/0.15.0
+  source_code_uri: https://github.com/trinistr/dicey/tree/v0.15.0
+  changelog_uri: https://github.com/trinistr/dicey/blob/v0.15.0/CHANGELOG.md
   rubygems_mfa_required: 'true'
+post_install_message:
 rdoc_options:
 - "--main"
 - README.md
@@ -60,14 +72,16 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.1.0
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.7.1
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
-summary: Calculator of dice roll frequencies/probabilities. Also rolls dice.
+summary: Calculator for dice roll frequency/probability distributions. Also rolls
+  dice.
 test_files: []

data/sig/dicey.rbs

@@ -1,3 +0,0 @@
-module Dicey
-  VERSION: String
-end