dicey 0.16.2 → 0.17.1

data/lib/dicey/roller.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "die_foundry"
-
-require_relative "mixins/rational_to_integer"
-require_relative "mixins/vectorize_dice"
-
-module Dicey
-  # Let the dice roll!
-  #
-  # This is the implementation of roll mode for the CLI.
-  class Roller
-    include Mixins::RationalToInteger
-    include Mixins::VectorizeDice
-
-    # @param arguments [Array<String>] die definitions
-    # @param format [#call] formatter for output
-    # @return [nil]
-    # @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 <<~TEXT
-        Dice with non-numeric sides need gem "vector_number" to be present and available.
-        If this is intended, please install the gem.
-      TEXT
-      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) if defined?(VectorNumber)
-      dice.sum(&:roll)
-    end
-  end
-end

data/lib/dicey/sum_frequency_calculators/auto_selector.rb

@@ -1,41 +0,0 @@
-# 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/brute_force.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "base_calculator"
-
-require_relative "../mixins/vectorize_dice"
-
-module Dicey
-  module SumFrequencyCalculators
-    # Calculator for a collection of {AbstractDie} using exhaustive search (very slow).
-    #
-    # If dice include non-numeric sides, gem +vector_number+ has to be installed.
-    class BruteForce < BaseCalculator
-      include Mixins::VectorizeDice
-
-      private
-
-      def validate(dice)
-        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
-        end
-      end
-
-      def calculate_heuristic(dice_count, sides_count)
-        1000 * (sides_count**dice_count)
-      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
-    end
-  end
-end