Module: Numerals::Conversions

Defined in:
lib/numerals/conversions.rb

Class Method Summary collapse

Class Method Details

.[](type, options = nil) ⇒ Object 



4
5
6
7
8
 
# File 'lib/numerals/conversions.rb', line 4

def [](type, options = nil)
  if type.respond_to?(:numerals_conversion)
    type.numerals_conversion(options || {})
  end
end

.exact?(number, options = {}) ⇒ Boolean

Returns:

  • (Boolean) 


85
86
87
 
# File 'lib/numerals/conversions.rb', line 85

def exact?(number, options = {})
  self[number.class, options[:type_options]].exact?(number, options)
end

.number_of_digits(number, options = {}) ⇒ Object 



14
15
16
 
# File 'lib/numerals/conversions.rb', line 14

def number_of_digits(number, options={})
  self[number.class, options[:type_options]].number_of_digits(number, options)
end

.order_of_magnitude(number, options = {}) ⇒ Object 



10
11
12
 
# File 'lib/numerals/conversions.rb', line 10

def order_of_magnitude(number, options={})
  self[number.class, options[:type_options]].order_of_magnitude(number, options)
end

.read(numeral, options = {}) ⇒ Object

Convert Numeral to Number

read numeral, options={}

If the input numeral is approximate and the destination type allows for arbitrary precision, then the destination context precision will be ignored and the precision of the input will be preserved. The :simplify option affects this case by generating only the mininimun number of digits needed.

The :exact option will prevent this behaviour and always treat input as exact.

Valid output options:

  • :type class of the output number

  • :context context (in the case of Flt::Num, Float) for the output

  • :simplify (for approximate input numeral/arbitrary precision type only)

  • :exact treat input numeral as if exact



38
39
40
41
42
43
44
 
# File 'lib/numerals/conversions.rb', line 38

def read(numeral, options={})
  selector = options[:context] || options[:type]
  exact_input = options[:exact]
  approximate_simplified = options[:simplify]
  conversions = self[selector, options[:type_options]]
  conversions.read(numeral, exact_input, approximate_simplified)
end

.write(number, options = {}) ⇒ Object

Convert Number to Numeral

write number, options={}

Valid options:

  • :rounding (a Rounding) (which defines output base as well)

  • :exact (exact input indicator)

Approximate mode:

If the input is treated as an approximation (which is the case for types such as Flt::Num, Float,… unless the :exact option is true) then no ‘spurious’ digits will be shown (digits that can take any value and the numeral still would convert to the original number if rounded to the same precision)

In approximate mode, if rounding is simplifying? (:short), the shortest representation which rounds back to the origina number with the same precision is used. If rounding is :free and the output base is the same as the number internal radix, the exact precision (trailing zeros) of the number is represented.

Exact mode:

Is used for ‘exact’ types (such as Integer, Rational) or when the :exact option is defined to be true.

The number is treated as an exact value, and converted according to Rounding. (in this case the :free and :short precision roundings are equivalent)



78
79
80
81
82
83
 
# File 'lib/numerals/conversions.rb', line 78

def write(number, options = {})
  output_rounding = Rounding[options[:rounding] || Rounding[]]
  conversion = self[number.class, options[:type_options]]
  exact_input = conversion.exact?(number, options)
  conversion.write(number, exact_input, output_rounding)
end