dicey 0.16.2 → 0.17.0

data/lib/dicey/cli/formatters/yaml_formatter.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "base_map_formatter"
+
+module Dicey
+  module CLI
+    module Formatters
+      # Formats a hash as a YAML document under +results+ key, with optional +description+ key.
+      class YAMLFormatter < BaseMapFormatter
+        METHOD = :to_yaml
+      end
+    end
+  end
+end

data/lib/dicey/cli/options.rb

@@ -7,19 +7,19 @@ module Dicey
     # Helper class for parsing command-line options and generating help.
     class Options
       # Allowed modes (--mode) (only directly selectable).
-      MODES = %w[frequencies roll].freeze
+      MODES = %w[distribution roll].freeze
       # Allowed result types (--result).
-      RESULT_TYPES = %w[frequencies probabilities].freeze
+      RESULT_TYPES = %w[weights probabilities].freeze
       # Allowed output formats (--format).
       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
+      DEFAULT_OPTIONS = { mode: "distribution", format: "list", result: "weights" }.freeze
 
       def initialize(initial_options = DEFAULT_OPTIONS.dup)
         @options = initial_options
         @parser = ::OptionParser.new
-        @parser.program_name = "dicey"
+        @parser.program_name = "Dicey"
         @parser.version = Dicey::VERSION
 
         add_banner_and_version
@@ -53,9 +53,9 @@ 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]
+          Usage: dicey [options] <die> [<die> ...]
+                 dicey [options] -- <die> [<die> ...]
+                 dicey --test [full|short|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
@@ -64,15 +64,15 @@ module Dicey
       def add_common_options
         easy_option("-m", "--mode MODE", MODES, "What kind of action or calculation to perform.")
         easy_option("-r", "--result RESULT_TYPE", RESULT_TYPES,
-                    "Select type of result to calculate (only for frequencies).")
+                    "Select type of result to calculate (only for distribution).")
         easy_option("-f", "--format FORMAT", FORMATS, "Select output format for results.")
       end
 
       def add_test_options
         @parser.on_tail(
-          "--test [REPORT_STYLE]", %w[full quiet],
+          "--test [REPORT_STYLE]", %w[full short quiet],
           "Check predefined calculation cases and exit.",
-          "REPORT_STYLE can be: `full`, `quiet`.", "`full` is default."
+          "REPORT_STYLE can be: `full`, `short`, `quiet`.", "`full` is default."
         ) do |report_style|
           @options[:mode] = :test
           @options[:report_style] = report_style&.to_sym || :full
@@ -84,7 +84,11 @@ module Dicey
           puts @parser.help
           exit
         end
-        @parser.on_tail("-v", "--version", "Show program version and exit.") do
+        @parser.on_tail("-V", "--version", "Show program version and exit.") do
+          puts @parser.ver
+          exit
+        end
+        @parser.on_tail("-v", "(Deprecated) Show program version and exit.") do
           puts @parser.ver
           exit
         end

data/lib/dicey/cli/roller.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "../die_foundry"
+
+require_relative "../mixins/rational_to_integer"
+require_relative "../mixins/vectorize_dice"
+require_relative "../mixins/warn_about_vector_number"
+
+module Dicey
+  module CLI
+    # Let the dice roll!
+    #
+    # This is the implementation of roll mode for the CLI.
+    class Roller
+      include Mixins::RationalToInteger
+      include Mixins::VectorizeDice
+      include Mixins::WarnAboutVectorNumber
+
+      # @param arguments [Array<String>] die definitions
+      # @param format [#call] formatter for output
+      # @return [String]
+      # @raise [DiceyError]
+      def call(arguments, format:, **)
+        raise DiceyError, "no dice!" if arguments.empty?
+
+        dice = arguments.flat_map { |definition| die_foundry.cast(definition) }
+        result = roll_dice(dice)
+
+        format.call({ "roll" => rational_to_integer(result) }, AbstractDie.describe(dice))
+      rescue TypeError
+        warn_about_vector_number
+        raise DiceyError, "can not roll dice with non-numeric sides!"
+      end
+
+      private
+
+      def die_foundry
+        @die_foundry ||= DieFoundry.new
+      end
+
+      def roll_dice(dice)
+        dice = vectorize_dice(dice)
+        dice.sum(&:roll)
+      end
+    end
+  end
+end

data/lib/dicey/cli.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Dicey
+  # @api private
+  # Classes pertaining to CLI. These are not intended to be used by API consumers.
+  #
+  # If you *really* need to simulate CLI from inside your code, use {.call}.
+  #
+  # @note Not loaded by default, use +require "dicey/cli"+ as needed.
+  module CLI
+    require_relative "cli/blender"
+
+    # @api public
+    # Parse options and arguments and run calculations, printing results.
+    #
+    # @param argv [Array<String>] arguments for the program
+    # @return [Boolean]
+    # @raise [DiceyError] anything can happen
+    def self.call(argv = ARGV)
+      Blender.new.call(argv)
+    end
+  end
+end

data/lib/dicey/die_foundry.rb

@@ -6,7 +6,8 @@ require_relative "regular_die"
 require_relative "mixins/rational_to_integer"
 
 module Dicey
-  # Helper class to define die definitions and automatically select the best one.
+  # Helper to create dice from string definitions.
+  # See {#call} and constants for available formats.
   class DieFoundry
     include Mixins::RationalToInteger
 
@@ -42,7 +43,7 @@ module Dicey
     # 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 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 +Rational+ for values to maintain precise results;
     # - list of strings, possibly mixed with numbers (like "0.5,asdf" or "(👑,♠️,♥️,♣️,♦️,⚓️)"),

data/lib/dicey/distribution_calculators/auto_selector.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require_relative "binomial"
+require_relative "iterative"
+require_relative "multinomial_coefficients"
+require_relative "polynomial_convolution"
+require_relative "trivial"
+
+module Dicey
+  # Calculators for probability distributions of dice.
+  #
+  # All calculators are subclasses of {BaseCalculator} which implements
+  # the core logic and public methods.
+  #
+  # Following calculators are available:
+  # - {Iterative}
+  # - {PolynomialConvolution}
+  # - {MultinomialCoefficients}
+  # - {Empirical} (manual selection only)
+  #
+  # You will probably want to use {AutoSelector} and not bother
+  # with selecting a calculator manually.
+  #
+  # @example
+  #   dice = Dicey::NumericDie.from_list([1, 4, 6], [2, 3, 5])
+  #   calculator = Dicey::DistributionCalculators::AutoSelector.call(dice)
+  #   calculator&.call(dice) or raise
+  module DistributionCalculators
+    # 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 = [
+        Trivial.new,
+        Binomial.new,
+        PolynomialConvolution.new,
+        MultinomialCoefficients.new,
+        Iterative.new,
+      ].freeze
+
+      # (see #call)
+      # Uses shared {INSTANCE} for calls.
+      def self.call(dice)
+        INSTANCE.call(dice)
+      end
+
+      # @param calculators [Array<BaseCalculator>]
+      #   calculators which this instance will consider
+      def initialize(calculators = AVAILABLE_CALCULATORS)
+        @calculators = calculators
+      end
+
+      # Instance to be used through {.call}.
+      INSTANCE = new.freeze # rubocop:disable Layout/ClassStructure
+      # Have to call .new after defining #initialize.
+
+      # 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 → distribution_calculators}/base_calculator.rb

@@ -1,17 +1,21 @@
 # frozen_string_literal: true
 
 module Dicey
-  # Calculators for probability distributions of dice.
-  module SumFrequencyCalculators
-    # Base frequencies calculator.
+  module DistributionCalculators
+    # Base class for implementing distribution calculators.
     #
-    # *Result types:*
-    # - +:frequencies+ (default)
-    # - +:probabilities+
+    # Calculators have the following methods, each taking an array of dice:
+    # - {#call} to actually calculate the distribution;
+    # - {#valid_for?} to check if the calculator can handle the dice;
+    # - {#heuristic_complexity} to determine the complexity of calculation,
+    #   mostly useful for {AutoSelector}.
     #
-    # By default, returns frequencies as they are easier to calculate and
-    # can be represented with integers.
-    # Probabilities are calculated using +Rational+ numbers to return exact results.
+    # By default, {#call} returns weights as they are easier to calculate and
+    # can be represented with integers (except for {Empirical} calculator).
+    # If probabilities are requested, they are calculated using +Rational+ numbers
+    # to produce exact results.
+    #
+    # An empty list of dice is considered a degenerate case, always valid for any calculator.
     #
     # *Options:*
     #
@@ -23,7 +27,7 @@ module Dicey
     # @abstract
     class BaseCalculator
       # Possible values for +result_type+ argument in {#call}.
-      RESULT_TYPES = %i[frequencies probabilities].freeze
+      RESULT_TYPES = %i[weights probabilities].freeze
 
       # Calculate distribution (probability mass function) for the list of dice.
       #
@@ -33,22 +37,25 @@ module Dicey
       # @param result_type [Symbol] one of {RESULT_TYPES}
       # @param options [Hash{Symbol => Any}] calculator-specific options,
       #   refer to the calculator's documentation to see what it accepts
-      # @return [Hash{Numeric => Numeric}] frequencies or probabilities for each outcome
+      # @return [Hash{Any => Numeric}] weight or probability for each outcome,
+      #   sorted by outcome if possible
       # @raise [DiceyError] if +result_type+ is invalid
-      # @raise [DiceyError] if dice list is invalid for the calculator
+      # @raise [DiceyError] if +dice+ list is invalid for the calculator
       # @raise [DiceyError] if calculator returned obviously wrong results
-      def call(dice, result_type: :frequencies, **options)
+      #   (should not happen in released versions)
+      def call(dice, result_type: :weights, **options)
         unless RESULT_TYPES.include?(result_type)
           raise DiceyError, "#{result_type} is not a valid result type!"
         end
+        raise DiceyError, "#{self.class} can not handle these dice!" unless valid_for?(dice)
+
         # 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, **options)
-        verify_result(frequencies, dice)
-        frequencies = sort_result(frequencies)
-        transform_result(frequencies, result_type)
+        distribution = calculate(dice, **options)
+        verify_result(distribution, dice)
+        distribution = sort_result(distribution)
+        transform_result(distribution, result_type)
       end
 
       # Whether this calculator can be used for the list of dice.
@@ -56,17 +63,17 @@ module Dicey
       # @param dice [Enumerable<AbstractDie>]
       # @return [Boolean]
       def valid_for?(dice)
-        dice.is_a?(Enumerable) && dice.all?(AbstractDie) && validate(dice)
+        dice.is_a?(Enumerable) && (dice.empty? || (dice.all?(AbstractDie) && validate(dice)))
       end
 
       # Heuristic complexity of the calculator, used to determine best calculator.
       #
-      # Returns 0 for an empty list of dice.
+      # Will always return a value, even if the calculator is not valid for the dice.
       #
       # @see AutoSelector
       #
       # @param dice [Enumerable<AbstractDie>]
-      # @return [Integer]
+      # @return [Integer] 0 if +dice+ is empty, otherwise can be any value
       def heuristic_complexity(dice)
         return 0 if dice.empty?
 
@@ -90,43 +97,43 @@ module Dicey
         raise NotImplementedError
       end
 
-      # Peform frequencies calculation.
+      # Calculate weights of outcomes for the dice.
       # (see #call)
       def calculate(dice, **nil)
         raise NotImplementedError
       end
 
-      # Check that resulting frequencies actually add up to what they are supposed to be.
+      # Check that resulting weights actually add up to what they are supposed to be.
       #
-      # @param frequencies [Hash{Numeric => Integer}]
+      # @param distribution [Hash{Numeric => Integer}]
       # @param dice [Enumerable<AbstractDie>]
       # @return [void]
       # @raise [DiceyError] if result is wrong
-      def verify_result(frequencies, dice)
-        valid = frequencies.values.sum == (dice.map(&:sides_num).reduce(:*) || 0)
+      def verify_result(distribution, dice)
+        valid = distribution.values.sum == (dice.map(&:sides_num).reduce(:*) || 0)
         raise DiceyError, "calculator #{self.class} returned invalid results!" unless valid
       end
 
       # Depending on the order of sides, result may not be in an ascending order,
       # so it's best to fix that for presentation (if possible).
-      def sort_result(frequencies)
-        frequencies.sort.to_h
+      def sort_result(distribution)
+        distribution.sort.to_h
       rescue
-        # Probably Complex numbers got into the mix, leave as is.
-        frequencies
+        # Sort failed, leave as is.
+        distribution
       end
 
-      # Transform calculated frequencies to requested result_type, if needed.
+      # Transform calculated weights to requested result type, if needed.
       #
-      # @param frequencies [Hash{Numeric => Integer}]
+      # @param distribution [Hash{Numeric => Integer}]
       # @param result_type [Symbol] one of {RESULT_TYPES}
       # @return [Hash{Numeric => Numeric}]
-      def transform_result(frequencies, result_type)
-        if result_type == :frequencies
-          frequencies
+      def transform_result(distribution, result_type)
+        if result_type == :weights
+          distribution
         else
-          total = frequencies.values.sum
-          frequencies.transform_values { Rational(_1, total) }
+          total = distribution.values.sum
+          distribution.transform_values { Rational(_1, total) }
         end
       end
     end

data/lib/dicey/distribution_calculators/binomial.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative "base_calculator"
+
+require_relative "../mixins/missing_math"
+require_relative "../mixins/vectorize_dice"
+
+module Dicey
+  module DistributionCalculators
+    # Calculator for a collection of equal {AbstractDie} with two sides, like coins,
+    # using binomial distribution (very fast).
+    #
+    # If dice include non-numeric sides, gem +vector_number+ has to be installed.
+    class Binomial < BaseCalculator
+      include Mixins::MissingMath
+      include Mixins::VectorizeDice
+
+      private
+
+      def validate(dice)
+        dice.first.sides_num == 2 && dice.all? { _1 == dice.first }
+      end
+
+      def calculate_heuristic(dice_count, _sides_count)
+        384 * dice_count**2 + 6_760_000
+      end
+
+      def calculate(dice, **nil)
+        die = vectorize_dice(dice.first)
+
+        coefficients = recurrent_combinations(dice.size)
+        first, second = die.sides_list
+        sliding_sums(first, second, coefficients)
+      end
+
+      def recurrent_combinations(dice_count)
+        # Calculating three factorials for each combination is pretty expensive.
+        # As the actual formulas just go through factorials in order,
+        # we can drastically reduce the complexity by reusing previous values.
+        count_factorial = factorial(dice_count)
+        index_factorial = 1
+        reverse_factorial = count_factorial
+        combinations = Array.new(dice_count + 1, 1)
+        (1..dice_count).each do |i|
+          index_factorial *= i
+          reverse_factorial /= (dice_count + 1 - i)
+          combinations[i] = count_factorial / (index_factorial * reverse_factorial)
+        end
+        combinations
+      end
+
+      def sliding_sums(side_a, side_b, coefficients)
+        length = coefficients.size - 1
+        coefficients.each_with_index.with_object({}) do |(coefficient, i), hash|
+          outcome = (side_a * (length - i)) + (side_b * i)
+          hash[outcome] ||= 0
+          hash[outcome] += coefficient
+        end
+      end
+    end
+  end
+end

data/lib/dicey/{sum_frequency_calculators → distribution_calculators}/empirical.rb

@@ -3,16 +3,17 @@
 require_relative "base_calculator"
 
 require_relative "../mixins/vectorize_dice"
+require_relative "../mixins/warn_about_vector_number"
 
 module Dicey
-  module SumFrequencyCalculators
+  module DistributionCalculators
     # "Calculator" for a collection of {AbstractDie} 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.
+    #   or to verify results of {Iterative} when in doubt. It is not used automatically.
     #
     # Does a number of rolls and calculates approximate probabilities from that.
-    # Even if frequencies are requested, results are non-integer.
+    # Even if weights are requested, results are non-integer.
     #
     # If dice include non-numeric sides, gem +vector_number+ has to be installed.
     #
@@ -20,6 +21,7 @@ module Dicey
     # - *rolls* (Integer) (_defaults_ _to:_ _N_) — number of rolls to perform
     class Empirical < BaseCalculator
       include Mixins::VectorizeDice
+      include Mixins::WarnAboutVectorNumber
 
       # Default number of rolls to perform.
       N = 10_000
@@ -30,20 +32,17 @@ module Dicey
         if defined?(VectorNumber) || dice.all?(NumericDie)
           true
         else
-          warn <<~TEXT
-            Dice with non-numeric sides need gem "vector_number" to be present and available.
-            If this is intended, please install the gem.
-          TEXT
-          false
+          warn_about_vector_number
         end
       end
 
       def calculate_heuristic(dice_count, sides_count)
-        N * dice_count * Math.log2(sides_count)
+        (39100 * dice_count + 196_000_000) + (412_000 * sides_count - 9_360_000)
       end
 
       def calculate(dice, rolls: N)
-        dice = vectorize_dice(dice) if defined?(VectorNumber)
+        dice = vectorize_dice(dice)
+
         statistics = rolls.times.with_object(Hash.new(0)) { |_, hash| hash[dice.sum(&:roll)] += 1 }
         total_results = dice.map(&:sides_num).reduce(:*)
         statistics.transform_values { Rational(_1 * total_results, rolls) }

data/lib/dicey/distribution_calculators/iterative.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative "base_calculator"
+
+require_relative "../mixins/vectorize_dice"
+require_relative "../mixins/warn_about_vector_number"
+
+module Dicey
+  module DistributionCalculators
+    # Calculator for a collection of {AbstractDie} which goes through
+    # every possible combination of dice (somewhat slow).
+    #
+    # If dice include non-numeric sides, gem +vector_number+ has to be installed.
+    class Iterative < BaseCalculator
+      include Mixins::VectorizeDice
+      include Mixins::WarnAboutVectorNumber
+
+      private
+
+      def validate(dice)
+        if defined?(VectorNumber) || dice.all?(NumericDie)
+          true
+        else
+          warn_about_vector_number
+        end
+      end
+
+      def calculate_heuristic(dice_count, sides_count)
+        (157_000 * dice_count**2 + 12_500_000) + (195_000 * sides_count**2 + 257_000_000)
+      end
+
+      def calculate(dice, **nil)
+        dice = vectorize_dice(dice)
+
+        dice[1..].reduce(dice.first.sides_list.tally) do |previous_distribution, die|
+          convolve_with_die(previous_distribution, die.sides_list.tally)
+        end
+      end
+
+      def convolve_with_die(previous_distribution, die_sides)
+        previous_distribution.each_with_object({}) do |(outcome, weight), next_distribution|
+          die_sides.each do |side, side_weight|
+            next_outcome = outcome + side
+            next_distribution[next_outcome] ||= 0
+            next_distribution[next_outcome] += weight * side_weight
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dicey/{sum_frequency_calculators → distribution_calculators}/multinomial_coefficients.rb

@@ -3,15 +3,26 @@
 require_relative "base_calculator"
 
 module Dicey
-  module SumFrequencyCalculators
-    # Calculator for multiple equal dice with sides forming an arithmetic sequence (fast).
+  module DistributionCalculators
+    # Calculator for multiple equal dice with sides forming an arithmetic sequence,
+    # including all regular dice (fast).
     #
     # 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.
+    # Rolling multiple of the same dice is the same thing as rolling a single die
+    # multiple times and summing the results.
+    # This arrangement corresponds to a multinomial distribution.
+    #
+    # The usual way to calculate probabilities for such distribution involves
+    # way too many factorials for large numbers for comfort.
+    # (`Math.gamma` doesn't even handle large enough numbers, and produces Floats anyway).
+    # Instead, we use a Pascal's triangle extension for a higher number of coefficients.
+    # Currently, algorithm is limited to arithmetic sequences as I'm not sure
+    # how to calculate values for other cases.
+    #
+    # @see https://en.wikipedia.org/wiki/Multinomial_distribution
     # @see https://en.wikipedia.org/wiki/Pascal's_triangle
     # @see https://en.wikipedia.org/wiki/Trinomial_triangle
-    # @see https://en.wikipedia.org/wiki/Multinomial_distribution
     class MultinomialCoefficients < BaseCalculator
       private
 
@@ -35,9 +46,7 @@ module Dicey
       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)
+        (784 * dice_count**2 - 809_000) + (100 * sides_count**2 - 38200)
       end
 
       def calculate(dice, **nil)
@@ -45,8 +54,8 @@ module Dicey
         number_of_sides = first_die.sides_num
         number_of_dice = dice.size
 
-        frequencies = multinomial_coefficients(number_of_dice, number_of_sides)
-        result_sums_list(first_die.sides_list, number_of_dice).zip(frequencies).to_h
+        weights = multinomial_coefficients(number_of_dice, number_of_sides)
+        outcomes_list(first_die.sides_list, number_of_dice).zip(weights).to_h
       end
 
       # Calculate coefficients for a multinomial of the form
@@ -80,18 +89,18 @@ 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.
-          # BUG: TruffleRuby can't handle endless range in #clamp (see https://github.com/oracle/truffleruby/issues/3945)
+          # 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
 
-      # Get sequence of sums which correspond to calculated frequencies.
+      # Get sequence of outcomes which correspond to calculated weights.
       #
       # @param sides_list [Enumerable<Numeric>]
       # @param number_of_dice [Integer]
       # @return [Array<Numeric>]
-      def result_sums_list(sides_list, number_of_dice)
+      def outcomes_list(sides_list, number_of_dice)
         first = number_of_dice * sides_list.first
         last = number_of_dice * sides_list.last
         return [first] if first == last