Class: Dicey::SumFrequencyCalculators::BaseCalculator Abstract

Inherits:
Object
  • Object
show all
Defined in:
lib/dicey/sum_frequency_calculators/base_calculator.rb

Overview

This class is abstract.

Base frequencies calculator.

*Result types:*

  • :frequencies (default)

  • :probabilities

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.

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.

Constant Summary collapse

RESULT_TYPES =

Possible values for result_type argument in #call.

i[frequencies probabilities].freeze

Instance Method Summary collapse

Instance Method Details

#call(dice, result_type: :frequencies, **options) ⇒ Hash{Numeric => Numeric}

Calculate distribution (probability mass function) for the list of dice.

Returns empty hash for an empty list of dice.

Parameters:

  • dice (Enumerable<AbstractDie>)
  • result_type (Symbol) (defaults to: :frequencies) —

    one of RESULT_TYPES

  • options (Hash{Symbol => Any}) —

    calculator-specific options, refer to the calculator’s documentation to see what it accepts

Returns:

  • (Hash{Numeric => Numeric}) —

    frequencies or probabilities for each outcome

Raises:

  • (DiceyError) —

    if result_type is invalid

  • (DiceyError) —

    if dice list is invalid for the calculator

  • (DiceyError) —

    if calculator returned obviously wrong results



40
41
42
43
44
45
46
47
48
49
50
51
52
 
# File 'lib/dicey/sum_frequency_calculators/base_calculator.rb', line 40

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, **options)
  verify_result(frequencies, dice)
  frequencies = sort_result(frequencies)
  transform_result(frequencies, result_type)
end

#heuristic_complexity(dice) ⇒ Integer

Heuristic complexity of the calculator, used to determine best calculator.

Returns 0 for an empty list of dice.

Parameters:

Returns:

  • (Integer)

See Also:



70
71
72
73
74
 
# File 'lib/dicey/sum_frequency_calculators/base_calculator.rb', line 70

def heuristic_complexity(dice)
  return 0 if dice.empty?

  calculate_heuristic(dice.length, dice.map(&:sides_num).max).to_i
end

#valid_for?(dice) ⇒ Boolean

Whether this calculator can be used for the list of dice.

Parameters:

Returns:

  • (Boolean) 


58
59
60
 
# File 'lib/dicey/sum_frequency_calculators/base_calculator.rb', line 58

def valid_for?(dice)
  dice.is_a?(Enumerable) && dice.all?(AbstractDie) && validate(dice)
end