dicey 0.16.0 → 0.16.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1b590b1e43f4e265f3a8fab12a949de1cdd20cc39b1f4334d997520cdbc9efc4
-  data.tar.gz: 2c0e3c4577a3f22483296b3a6c238c54937c8b5a360b21c53ca2d0b9aa432fcb
+  metadata.gz: 86d934c5cf9455e15c42f84abe397c7c32ada670512969decd4e44c9eef1841f
+  data.tar.gz: bcba52a9d0e1bbb0308db1025ba2c723bf963aa02b323b631538bdbc722144e2
 SHA512:
-  metadata.gz: bed55910f504316de9f078f938f2a9a56e8dfbe65c3552eee330bc58f7559f699a0906837f4bda30fe098feed58469e8c7039e78864e79f4d263918729222ebb
-  data.tar.gz: 392b0c5c3b5e547d497092358769260b7b8e1c99bd98f1eb8759c389757386452720a173e619aea5bd2cebe996348c99f314bfc3b1e54fa068583fc083525cd9
+  metadata.gz: 46d142b6caed4432f4adede2d34214498e1bbfe02aadca4aaa58709c5fa9ce15d4c71e75ce37f599752c10f334da0acb616c7278ba5076d1ed4746b36fb7b35b
+  data.tar.gz: 14ad44e95941c5e7d94c71968a9f84105d1f6a64b50ab551c94ddea247dda77a80e5f83e2566bdea76ec912b799f1a05e3bbb160d0cc1b3af5211c795bc2b415

data/README.md

@@ -385,8 +385,8 @@ die.roll
 ### Distribution calculators
 
 Distribution 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 a 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::KroneckerSubstitution` is the recommended calculator, able to handle all `Dicey::RegularDie` and more. It is very fast, though sometimes slower than the next one.
+- `Dicey::SumFrequencyCalculators::MultinomialCoefficients` is specialized for repeated numeric dice, with performance on par with the previous one, depending on exact parameters. However, it is currently limited to dice with arithmetic sequences (this includes regular dice, however).
 - `Dicey::SumFrequencyCalculators::BruteForce` is the most generic and slowest one, but can work with *any* dice. It needs gem "**vector_number**" to be installed and available to work with non-numeric dice.
 - `Dicey::SumFrequencyCalculators::Empirical`... this is more of a tool than a calculator. It "calculates" probabilities by performing a large number of rolls and counting frequencies of outcomes. It can be interesting to play around with and see how practical results compare to theoretical ones. Due to its simplicity, it also works with *any* dice.
 
@@ -396,6 +396,8 @@ Calculators inherit from `Dicey::SumFrequencyCalculators::BaseCalculator` and pr
 
 See [Diving deeper](#diving-deeper) for more details on limitations and complexity considerations of different algorithms.
 
+When in doubt which calculator to use (and if a given one *can* be used), use `Dicey::SumFrequencyCalculators::AutoSelector`. Its `#call(dice)` method will return a valid calculator for the given dice or `nil` if none are acceptable.
+
 ### Distribution properties
 
 While distribution itself is already enough in most cases (we are talking just dice here, after all). it may be of interest to calculate properties of it: mode, mean, expected value, standard deviation, etc. `Dicey::DistributionPropertiesCalculator` provides this functionality:
@@ -464,10 +466,10 @@ For a further discussion of calculations, it is important to understand which cl
 > [!TIP]
 > 💡 If you only need to roll **regular** dice, this section will not contain anything important.
 
-- **Natural** die has sides with only positive integers or 0. For example, (1,2,3,4,5,6), (5,1,6,5), (1,10000), (1,1,1,1,1,1,1,0).
+- **Integer** die has sides with only integers. For example, (1,2,3,4,5,6), (-5,0,5), (1,10000), (1,1,1,1,1,1,1,0).
 - **Arithmetic** die's sides form an arithmetic sequence. For example, (1,2,3,4,5,6), (1,0,-1), (2.6,2.1,1.6,1.1).
 - **Numeric** die is limited by having sides confined to ℝ (or ℂ if you are feeling particularly adventurous).
-- **Abstract** die is not limited by anything other than not having partial sides (and how would that work anyway?).
+- **Abstract** die is unlimited!
 
 > [!NOTE]
 > 💡 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.
@@ -477,31 +479,40 @@ Dicey is in principle able to handle any real numeric dice and some abstract dic
 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.
+> 💡 Complexity is listed for **n** dice with at most **m** sides and is only an approximation.
 
 ### Kronecker substitution
 
 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.
+- Limitations: only **integer** dice are allowed, including **regular** dice.
 - Example: `dicey 5 3,4,1 0,`
-- Complexity: **O(m⋅n)** where **m** is the highest value
+- Complexity: **O(n<sup>3</sup>⋅m<sup>2</sup>)**
+- Running time examples:
+  - 6d1000 — 0.5 seconds
+  - 1000d6 — 18 seconds
 
 ### Multinomial coefficients
 
-This algorithm is based on raising a univariate polynomial to a power and using the coefficients of the result, though certain restrictions are lifted as they don't actually matter for the calculation.
+This algorithm is based on raising a univariate polynomial to a power and using the coefficients of the result, though certain restrictions are lifted as they don't actually matter for the calculation. It is usually faster than Kronecker substitution for many dice with few sides.
 
 - Limitations: only *equal* **arithmetic** dice are allowed.
 - Example: `dicey 1.5,3,4.5,6 1.5,3,4.5,6 1.5,3,4.5,6`
-- Complexity: **O(m⋅n²)**
+- Complexity: **O(n<sup>2</sup>⋅m<sup>2</sup>)**
+- Running time examples:
+  - 6d1000 — 1.65 seconds
+  - 1000d6 — 10.5 seconds
 
 ### Brute force
 
-As a last resort, there is a brute force algorithm which goes through every possible dice roll and adds results together. While quickly growing terrible in performace, it has the largest input space, allowing to work with completely nonsensical dice, including aforementioned dice with complex numbers.
+As a last resort, there is a brute force algorithm which goes through every possible dice roll and adds results together. While quickly growing terrible in performace (and memory usage), it has the largest input space, allowing to work with completely nonsensical dice, including complex numbers and altogether non-numeric values.
 
 - Limitations: without **vector_number** all values must be numbers, otherwise almost any values are viable.
-- Example: `dicey 5 1,0.1,2 1,-1,1,-1,0`
-- Complexity: **O(mⁿ)**
+- Example: `dicey 5 1,0.1,2 A,B,C`
+- Complexity: **O(m<sup>n</sup>)**
+- Running time examples:
+  - 6d10 — 0.25 seconds
+  - 10d6 — 9.5 seconds
 
 ## Development
 

data/lib/dicey/abstract_die.rb

@@ -2,7 +2,7 @@
 
 module Dicey
   # Asbtract die which may have an arbitrary list of sides,
-  # not even neccessarily numbers, but strings or other objects.
+  # not even neccessarily numbers but strings or other objects.
   class AbstractDie
     # rubocop:disable Style/ClassVars
 

data/lib/dicey/cli/blender.rb

@@ -10,13 +10,6 @@ module Dicey
     # Slice and dice everything in the Dicey module to produce a useful result.
     # This is the entry point for the CLI.
     class Blender
-      # List of calculators to use, ordered by efficiency.
-      ROLL_FREQUENCY_CALCULATORS = [
-        SumFrequencyCalculators::KroneckerSubstitution.new,
-        SumFrequencyCalculators::MultinomialCoefficients.new,
-        SumFrequencyCalculators::BruteForce.new,
-      ].freeze
-
       # How to transform option values from command-line arguments
       # to internally significant objects.
       OPTION_TRANSFORMATIONS = {
@@ -27,6 +20,7 @@ module Dicey
           "gnuplot" => OutputFormatters::GnuplotFormatter.new,
           "yaml" => OutputFormatters::YAMLFormatter.new,
           "json" => OutputFormatters::JSONFormatter.new,
+          "null" => OutputFormatters::NullFormatter.new,
         }.freeze,
       }.freeze
 
@@ -47,7 +41,6 @@ module Dicey
       def call(argv = ARGV)
         options, arguments = get_options_and_arguments(argv)
         require_optional_libraries(options)
-        options[:roll_calculators] = ROLL_FREQUENCY_CALCULATORS
         return_value = RUNNERS[options.delete(:mode)].call(arguments, **options)
         print return_value if return_value.is_a?(String)
         !!return_value

data/lib/dicey/cli/options.rb

@@ -11,7 +11,7 @@ module Dicey
       # Allowed result types (--result).
       RESULT_TYPES = %w[frequencies probabilities].freeze
       # Allowed output formats (--format).
-      FORMATS = %w[list gnuplot json yaml].freeze
+      FORMATS = %w[list gnuplot json yaml null].freeze
 
       # Default values for initial values of the options.
       DEFAULT_OPTIONS = { mode: "frequencies", format: "list", result: "frequencies" }.freeze

data/lib/dicey/mixins/rational_to_integer.rb

@@ -11,7 +11,7 @@ module Dicey
       # Convert +value+ to +Integer+ if it's a +Rational+ with denominator of 1.
       # Otherwise, return +value+ as-is.
       #
-      # @value [Numeric, Any]
+      # @param value [Numeric, Any]
       # @return [Numeric, Integer, Any]
       def rational_to_integer(value)
         (Rational === value && value.denominator == 1) ? value.numerator : value

data/lib/dicey/mixins/vectorize_dice.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module Dicey
+  # @api private
   module Mixins
     # Mix-in for converting dice with non-numeric sides into dice with +VectorNumber+ sides.
     module VectorizeDice

data/lib/dicey/output_formatters/null_formatter.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Dicey
+  module OutputFormatters
+    # Formatter that doesn't format anything and always returns an empty string.
+    class NullFormatter
+      # @param hash [Hash{Object => Object}]
+      # @param description [String] text to add as a comment.
+      # @return [String] always an empty string
+      def call(hash, description = nil) # rubocop:disable Lint/UnusedMethodArgument
+        ""
+      end
+    end
+  end
+end

data/lib/dicey/roller.rb

@@ -1,12 +1,5 @@
 # frozen_string_literal: true
 
-# Try to load "vector_number" pre-emptively.
-begin
-  require "vector_number"
-rescue LoadError
-  # VectorNumber not available, sad
-end
-
 require_relative "die_foundry"
 
 require_relative "mixins/rational_to_integer"

data/lib/dicey/sum_frequency_calculators/auto_selector.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "brute_force"
+require_relative "kronecker_substitution"
+require_relative "multinomial_coefficients"
+
+module Dicey
+  module SumFrequencyCalculators
+    # Tool to automatically select a calculator for a given set of dice.
+    #
+    # Calculator is guaranteed to be compatible, with a strong chance of being the most performant.
+    #
+    # @see BaseCalculator#heuristic_complexity
+    class AutoSelector
+      # Calculators to consider when selecting a match.
+      AVAILABLE_CALCULATORS = [
+        KroneckerSubstitution.new,
+        MultinomialCoefficients.new,
+        BruteForce.new,
+      ].freeze
+
+      # @param calculators [Array<BaseCalculator>]
+      #   calculators which this instance will consider
+      def initialize(calculators = AVAILABLE_CALCULATORS)
+        @calculators = calculators
+      end
+
+      # Determine best (or adequate) calculator for a given set of dice
+      # based on heuristics from the list of available calculators.
+      #
+      # @param dice [Enumerable<NumericDie>]
+      # @return [BaseCalculator, nil] +nil+ if no calculator is compatible
+      def call(dice)
+        compatible = @calculators.select { _1.valid_for?(dice) }
+        return if compatible.empty?
+
+        compatible.min_by { _1.heuristic_complexity(dice) }
+      end
+    end
+  end
+end

data/lib/dicey/sum_frequency_calculators/base_calculator.rb

@@ -55,6 +55,16 @@ module Dicey
         dice.is_a?(Enumerable) && dice.all?(AbstractDie) && validate(dice)
       end
 
+      # Heuristic complexity of the calculator, used to determine best calculator.
+      #
+      # @see AutoSelector
+      #
+      # @param dice [Enumerable<AbstractDie>]
+      # @return [Integer]
+      def heuristic_complexity(dice)
+        calculate_heuristic(dice.length, dice.map(&:sides_num).max).to_i
+      end
+
       private
 
       # Do additional validation on the dice list.
@@ -63,12 +73,19 @@ module Dicey
         true
       end
 
+      # Calculate heuristic complexity of the calculator.
+      #
+      # @param dice_count [Integer]
+      # @param sides_count [Integer] maximum number of sides
+      # @return [Numeric]
+      def calculate_heuristic(dice_count, sides_count)
+        raise NotImplementedError
+      end
+
       # Peform frequencies calculation.
       # (see #call)
       def calculate(dice, **nil)
-        # :nocov:
         raise NotImplementedError
-        # :nocov:
       end
 
       # Check that resulting frequencies actually add up to what they are supposed to be.

data/lib/dicey/sum_frequency_calculators/brute_force.rb

@@ -1,12 +1,5 @@
 # frozen_string_literal: true
 
-# Try to load "vector_number" pre-emptively.
-begin
-  require "vector_number"
-rescue LoadError
-  # VectorNumber not available, sad
-end
-
 require_relative "base_calculator"
 
 require_relative "../mixins/vectorize_dice"
@@ -33,46 +26,16 @@ module Dicey
         end
       end
 
-      def calculate(dice, **nil)
-        dice = vectorize_dice(dice) if defined?(VectorNumber)
-        combine_dice_enumerators(dice.map(&:sides_list)).map(&:sum).tally
+      def calculate_heuristic(dice_count, sides_count)
+        1000 * (sides_count**dice_count)
       end
 
-      if defined?(Enumerator::Product)
-        # Get an enumerator which goes through all possible permutations of dice sides.
-        #
-        # @param side_lists [Enumerable<Enumerable<Any>>]
-        # @return [Enumerator<Enumerable<Enumerable<Any>>>]
-        def combine_dice_enumerators(side_lists)
-          Enumerator::Product.new(*side_lists)
-        end
-      # :nocov:
-      else
-        # Get an enumerator which goes through all possible permutations of dice sides.
-        #
-        # @param side_lists [Enumerable<Enumerable<Any>>]
-        # @return [Enumerator<Array<Array<Any>>>]
-        def combine_dice_enumerators(side_lists)
-          product(side_lists)
-        end
-
-        # Simplified implementation of {Enumerator::Product}.
-        # Adapted from {https://bugs.ruby-lang.org/issues/18685#note-10}.
-        #
-        # @param enums [Enumerable<Enumerable<Any>>]
-        # @return [Enumerator<Array<Array<Any>>>]
-        def product(enums, &block)
-          return to_enum(__method__, enums) unless block_given?
-
-          enums
-            .reverse
-            .reduce(block) { |inner, enum|
-              ->(values) { enum.each_entry { inner.call([*values, _1]) } }
-            }
-            .call([])
-        end
+      def calculate(dice, **nil)
+        dice = vectorize_dice(dice) if defined?(VectorNumber)
+        dice.map(&:sides_list).reduce { |result, die|
+          result.flat_map { |roll| die.map { |side| roll + side } }
+        }.tally
       end
-      # :nocov:
     end
   end
 end

data/lib/dicey/sum_frequency_calculators/empirical.rb

@@ -1,12 +1,5 @@
 # frozen_string_literal: true
 
-# Try to load "vector_number" pre-emptively.
-begin
-  require "vector_number"
-rescue LoadError
-  # VectorNumber not available, sad
-end
-
 require_relative "base_calculator"
 
 require_relative "../mixins/vectorize_dice"
@@ -45,6 +38,10 @@ module Dicey
         end
       end
 
+      def calculate_heuristic(dice_count, sides_count)
+        N * dice_count * Math.log2(sides_count)
+      end
+
       def calculate(dice, rolls: N)
         dice = vectorize_dice(dice) if defined?(VectorNumber)
         statistics = rolls.times.with_object(Hash.new(0)) { |_, hash| hash[dice.sum(&:roll)] += 1 }

data/lib/dicey/sum_frequency_calculators/kronecker_substitution.rb

@@ -4,9 +4,9 @@ require_relative "base_calculator"
 
 module Dicey
   module SumFrequencyCalculators
-    # Calculator for lists of dice with non-negative integer sides (fast).
+    # Calculator for lists of dice with integer sides (fast).
     #
-    # Example dice: (1,2,3,4), (0,1,5,6), (5,4,5,4,5).
+    # Example dice: (1,2,3,4), (0,1,-5,6), (5,4,5,4,5).
     #
     # Based on Kronecker substitution method for polynomial multiplication.
     # @see https://en.wikipedia.org/wiki/Kronecker_substitution
@@ -17,15 +17,19 @@ module Dicey
       private
 
       def validate(dice)
-        dice.all? { |die| die.sides_list.all? { _1.is_a?(Integer) && _1 >= 0 } }
+        dice.all? { |die| die.sides_list.all?(Integer) }
+      end
+
+      def calculate_heuristic(dice_count, sides_count)
+        (dice_count**3.2) * 100 * (sides_count**1.9)
       end
 
       def calculate(dice, **nil)
-        polynomials = build_polynomials(dice)
+        polynomials, offset = build_polynomials(dice)
         evaluation_point = find_evaluation_point(polynomials)
         values = evaluate_polynomials(polynomials, evaluation_point)
         product = values.reduce(:*)
-        extract_coefficients(product, evaluation_point)
+        extract_coefficients(product, evaluation_point, offset, polynomials.count)
       end
 
       # Turn dice into hashes where keys are side values and values are numbers of those sides,
@@ -35,7 +39,8 @@ module Dicey
       # @param dice [Enumerable<NumericDie>]
       # @return [Array<Hash{Integer => Integer}>]
       def build_polynomials(dice)
-        dice.map { _1.sides_list.tally }
+        minimum = dice.map { |die| die.sides_list.min }.min
+        [dice.map { |die| die.sides_list.map { _1 - minimum }.tally }, minimum]
       end
 
       # Find a power of 2 which is larger in magnitude than any resulting polynomial coefficients,
@@ -67,13 +72,15 @@ module Dicey
       #
       # @param product [Integer]
       # @param evaluation_point [Integer]
+      # @param offset [Integer]
+      # @param number_of_dice [Integer]
       # @return [Hash{Integer => Integer}]
-      def extract_coefficients(product, evaluation_point)
+      def extract_coefficients(product, evaluation_point, offset, number_of_dice)
         window = evaluation_point - 1
         window_shift = window.bit_length
         (0..).each_with_object({}) do |power, result|
           coefficient = product & window
-          result[power] = coefficient unless coefficient.zero?
+          result[power + (offset * number_of_dice)] = coefficient unless coefficient.zero?
           product >>= window_shift
           break result if product.zero?
         end

data/lib/dicey/sum_frequency_calculators/multinomial_coefficients.rb

@@ -34,6 +34,12 @@ module Dicey
         true
       end
 
+      def calculate_heuristic(dice_count, sides_count)
+        # Fitting shows both coefficients to be around 500,
+        # but empirical runtime doesn't agree, so 150 it is.
+        150 * (dice_count**2.2) * 500 * (sides_count**1.9)
+      end
+
       def calculate(dice, **nil)
         first_die = dice.first
         number_of_sides = first_die.sides_num
@@ -72,7 +78,7 @@ module Dicey
       # @return [Array<Integer>]
       def next_row_of_coefficients(row_index, window_size, previous_row)
         length = (row_index * window_size) + 1
-        (0..length).map do |col_index|
+        (0...length).map do |col_index|
           # Have to clamp to 0 to prevent accessing array from the end.
           # 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)

data/lib/dicey/sum_frequency_calculators/runner.rb

@@ -13,17 +13,18 @@ module Dicey
       # Transform die definitions to roll frequencies.
       #
       # @param arguments [Array<String>] die definitions
-      # @param roll_calculators [Array<BaseCalculator>] list of calculators to use
       # @param format [#call] formatter for output
       # @param result [Symbol] result type selector
       # @return [nil]
       # @raise [DiceyError]
-      def call(arguments, roll_calculators:, format:, result:, **)
+      def call(arguments, format:, result:, **)
         raise DiceyError, "no dice!" if arguments.empty?
 
         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
+        calculator = calculator_selector.call(dice)
+        raise DiceyError, "no calculator could handle these dice!" unless calculator
+
+        frequencies = calculator.call(dice, result_type: result)
 
         format.call(frequencies, AbstractDie.describe(dice))
       end
@@ -33,6 +34,10 @@ module Dicey
       def die_foundry
         @die_foundry ||= DieFoundry.new
       end
+
+      def calculator_selector
+        @calculator_selector ||= AutoSelector.new
+      end
     end
   end
 end

data/lib/dicey/sum_frequency_calculators/test_runner.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "auto_selector"
 require_relative "brute_force"
 require_relative "kronecker_substitution"
 require_relative "multinomial_coefficients"
@@ -8,6 +9,8 @@ module Dicey
   module SumFrequencyCalculators
     # A simple testing facility for roll frequency calculators.
     class TestRunner
+      AVAILABLE_CALCULATORS = AutoSelector::AVAILABLE_CALCULATORS
+
       # These are manually calculated frequencies,
       # with test cases for pretty much all variations of what this program can handle.
       TEST_DATA = [
@@ -70,12 +73,11 @@ module Dicey
 
       # Check all tests defined in {TEST_DATA} with every passed calculator.
       #
-      # @param roll_calculators [Array<BaseCalculator>]
       # @param report_style [Symbol] one of: +:full+, +:quiet+;
       #   +:quiet+ style does not output any text
       # @return [Boolean] whether there are no failing tests
-      def call(*, roll_calculators:, report_style:, **)
-        results = TEST_DATA.to_h { |test| run_test(test, roll_calculators) }
+      def call(*, report_style:, **)
+        results = TEST_DATA.to_h { |test| run_test(test) }
         full_report(results) if report_style == :full
         results.values.none? do |test_result|
           test_result.values.any? { FAILURE_RESULTS.include?(_1) }
@@ -86,13 +88,12 @@ module Dicey
 
       # @param test [Array(Array<Integer, Array<Numeric>>, Hash{Numeric => Integer})]
       #   pair of a dice list definition and expected results
-      # @param calculators [Array<BaseCalculator>]
       # @return [Array(Array<NumericDie>, Hash{BaseCalculator => Symbol})]
       #   result of running the test in a format suitable for +#to_h+
-      def run_test(test, calculators)
+      def run_test(test)
         dice = build_dice(test.first)
         test_result =
-          calculators.each_with_object({}) do |calculator, hash|
+          AVAILABLE_CALCULATORS.each_with_object({}) do |calculator, hash|
             hash[calculator] = run_test_on_calculator(calculator, dice, test.last)
           end
         [dice, test_result]

data/lib/dicey/version.rb

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

data/lib/dicey.rb

@@ -1,5 +1,12 @@
 # frozen_string_literal: true
 
+# Try to load "vector_number" pre-emptively.
+begin
+  require "vector_number"
+rescue LoadError
+  # VectorNumber not available, sad
+end
+
 # A library for rolling dice and calculating roll frequencies.
 module Dicey
   # General error for Dicey.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dicey
 version: !ruby/object:Gem::Version
-  version: 0.16.0
+  version: 0.16.1
 platform: ruby
 authors:
 - Alexandr Bulancov
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-10-09 00:00:00.000000000 Z
+date: 2025-10-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: vector_number
@@ -58,9 +58,11 @@ files:
 - lib/dicey/output_formatters/json_formatter.rb
 - lib/dicey/output_formatters/key_value_formatter.rb
 - lib/dicey/output_formatters/list_formatter.rb
+- lib/dicey/output_formatters/null_formatter.rb
 - lib/dicey/output_formatters/yaml_formatter.rb
 - lib/dicey/regular_die.rb
 - lib/dicey/roller.rb
+- lib/dicey/sum_frequency_calculators/auto_selector.rb
 - lib/dicey/sum_frequency_calculators/base_calculator.rb
 - lib/dicey/sum_frequency_calculators/brute_force.rb
 - lib/dicey/sum_frequency_calculators/empirical.rb
@@ -75,9 +77,9 @@ licenses:
 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.16.0
-  source_code_uri: https://github.com/trinistr/dicey/tree/v0.16.0
-  changelog_uri: https://github.com/trinistr/dicey/blob/v0.16.0/CHANGELOG.md
+  documentation_uri: https://rubydoc.info/gems/dicey/0.16.1
+  source_code_uri: https://github.com/trinistr/dicey/tree/v0.16.1
+  changelog_uri: https://github.com/trinistr/dicey/blob/v0.16.1/CHANGELOG.md
   rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: