numerals 0.0.0

data/lib/numerals/rounding.rb

@@ -0,0 +1,229 @@
+# Rounding of Numerals
+class Rounding
+
+  # Rounding is defined by the rounding mode and the precision,
+  # and is used to stablish the desired accuracy of a Numeral result.
+  #
+  # The rounding mode may be any of the valid Flt rounding modes
+  # (:half_even, :half_down, :half_up, :floor, :ceiling, :down, :up or :up05)
+  # or :exact for no rounding at all (to represent the situation where
+  # we want to get an exact numeral result.
+  #
+  # The precision may be defined either as a relative :precision value
+  # (number of significant digits of the result numeral) or as an :absolute
+  # :places that indicate the number of digits to the right of the fractional
+  # point. Negative values of :places will round to digits in integral positions.
+  #
+  # The base of the numerals to be rounded must also be defined (10 by default)
+  #
+  def initialize(*args)
+    if Hash === args.last
+      options = args.pop.dup
+    else
+      options = {}
+    end
+    args.each do |arg|
+      if Symbol === arg
+        options[:mode] = arg
+      elsif Integer === arg
+        options[:precision] = arg
+      else
+        raise "Invalid Rounding definition"
+      end
+    end
+    assign! options
+  end
+
+  attr_reader :mode, :base
+
+  include ModalSupport::BracketConstructor
+  include ModalSupport::StateEquivalent
+
+  def [](options={})
+    assign! options
+  end
+
+  def assign!(options)
+    @mode      = options[:mode]      || @mode
+    @precision = options[:precision] || @precision
+    @places    = options[:places]    || @places
+    @base      = options[:base]      || @base
+
+    if (@precision == 0 || @precision.nil?) && @places.nil?
+      @precision = 0
+      @mode = :exact
+    else
+      @mode ||= :half_even
+    end
+    if @mode == :exact
+      @precision = 0
+      @places    = nil
+    end
+    @base ||= 10
+    self
+  end
+
+  def parameters
+    if exact?
+      { mode: :exact }
+    elsif relative?
+      { mode: @mode, precision: @precision }
+    elsif absolute?
+      { mode: @mode, places: @places }
+    end
+  end
+
+  def to_s
+    if exact?
+      "Rounding[:exact]"
+    elsif relative?
+      "Rounding[#{@mode.inspect}, precision: #{@precision}]"
+    elsif absolute?
+      "Rounding[#{@mode.inspect}, places: #{@places}]"
+    end
+  end
+
+  def inspect
+    to_s
+  end
+
+  def exact?
+    @mode == :exact
+  end
+
+  def absolute?
+    !exact? && !@precision
+  end
+
+  def relative?
+    !exact? && !absolute?
+  end
+
+  # Number of significant digits for a given numerical/numeral value
+  def precision(value)
+    if relative? || exact?
+      @precision
+    else
+      @places + num_integral_digits(value)
+    end
+  end
+
+  # Number of fractional placesfor a given numerical/numeral value
+  def places(value)
+    if absolute? || exact?
+      @places
+    else
+      @precision - num_integral_digits(value)
+    end
+  end
+
+  # Round a numeral. If the numeral has been truncated
+  # the :round_up option must be used to pass the information
+  # about the discarded digits:
+  # * nil if all discarded digits where 0 (the truncated value is exact)
+  # * :lo if there where non-zero discarded digits, but the first discarded digit
+  #   is below half the base.
+  # * :tie if the first discarded was half the base and there where no more nonzero digits,
+  #   i.e. the original value was a 'tie', exactly halfway between the truncated value
+  #   and the next value with the same number of digits.
+  # * :hi if the original value was above the tie value.
+  def round(numeral, options={})
+    round_up = options[:round_up]
+    numeral, round_up = truncate(numeral, round_up)
+    adjust(numeral, round_up)
+  end
+
+  private
+
+  def check_base(numeral)
+    if numeral.base != @base
+      raise "Invalid Numeral (base #{numeral.base}) for a base #{@base} Rounding"
+    end
+  end
+
+  # Truncate a numeral and return also a round_up value with information about
+  # the digits beyond the truncation point that can be used to round the truncated
+  # numeral. If the numeral has already been truncated, the round_up result of
+  # that truncation should be passed as the second argument.
+  def truncate(numeral, round_up=nil)
+    check_base numeral
+    if exact?
+      round_up = nil
+    else
+      n = precision(numeral)
+      unless n==numeral.digits.size && numeral.approximate?
+        if n < numeral.digits.size - 1
+          rest_digits = numeral.digits[n+1..-1]
+        else
+          rest_digits = []
+        end
+        if numeral.repeating? && numeral.repeat < numeral.digits.size && n >= numeral.repeat
+          rest_digits += numeral.digits[numeral.repeat..-1]
+        end
+        digits = numeral.digits[0, n]
+        if digits.size < n
+          digits += (digits.size...n).map{|i| numeral.digit_value_at(i)}
+        end
+        if numeral.base % 2 == 0
+          tie_digit = numeral.base / 2
+          max_lo = tie_digit - 1
+        else
+          max_lo = numeral.base / 2
+        end
+        next_digit = numeral.digit_value_at(n)
+        if next_digit == 0
+          unless round_up.nil? && rest_digits.all?{|d| d == 0}
+            round_up = :lo
+          end
+        elsif next_digit <= max_lo # next_digit < tie_digit
+          round_up = :lo
+        elsif next_digit == tie_digit
+          if round_up || rest_digits.any?{|d| d != 0}
+            round_up = :hi
+          else
+            round_up = :tie
+          end
+        else # next_digit > tie_digit
+          round_up = :hi
+        end
+        numeral = Numeral[digits, point: numeral.point, sign: numeral.sign, normalize: :approximate]
+      end
+    end
+    [numeral, round_up]
+  end
+
+  # Adjust a truncated numeral using the round-up information
+  def adjust(numeral, round_up)
+    check_base numeral
+    point, digits = Flt::Support.adjust_digits(
+      numeral.point, numeral.digits.digits_array,
+      round_mode: @mode,
+      negative: numeral.sign == -1,
+      round_up: round_up,
+      base: numeral.base
+    )
+    Numeral[digits, point: point, base: numeral.base, sign: numeral.sign, normalize: :approximate]
+  end
+
+  ZERO_DIGITS = 0 # 1?
+
+  # Number of digits in the integer part of the value (excluding leading zeros).
+  def num_integral_digits(value)
+    case value
+    when 0
+      ZERO_DIGITS
+    when Numeral
+      if value.zero?
+        ZERO_DIGITS
+      else
+        if @base != value.base
+          value = value.to_base(@base)
+        end
+        value.normalized(remove_trailing_zeros: true).point
+      end
+    else
+      Conversions.order_of_magnitude(value, base: @base)
+    end
+  end
+
+end

data/lib/numerals/support.rb

@@ -0,0 +1,10 @@
+module Numerals
+
+  def self.gcd(a,b)
+    while b!=0 do
+      a,b = b, a.modulo(b)
+    end
+    return a.abs
+  end
+
+end

data/lib/numerals/version.rb

@@ -0,0 +1,3 @@
+module Numerals
+  VERSION = "0.0.0"
+end

data/lib/numerals.rb

@@ -0,0 +1,12 @@
+require 'modalsupport'
+
+require "numerals/version"
+require 'numerals/numeral'
+require 'numerals/rounding'
+require 'numerals/conversions/float'
+require 'numerals/conversions/integer'
+require 'numerals/conversions/rational'
+require 'numerals/conversions/bigdecimal'
+require 'numerals/conversions/flt'
+require 'numerals/formatting/digits_definition'
+require 'numerals/formatting/options'

data/numerals.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'numerals/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "numerals"
+  spec.version       = Numerals::VERSION
+  spec.authors       = ["Javier Goizueta"]
+  spec.email         = ["jgoizueta@gmail.com"]
+  spec.summary       = %q{Number representation as text.}
+  spec.description   = %q{Number formatting and reading.}
+  spec.homepage      = "https://github.com/jgoizueta/numerals"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'flt', "~> 1.3.4"
+  spec.add_dependency 'modalsupport', "~> 0.9.2"
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+end

data/test/data.yaml

@@ -0,0 +1,101 @@
+--- 
+- A91C2BB757F72141
+- D84014519CD8253F
+- BF30A46FFF51ED3F
+- 91D03B54623CC03E
+- D403F243699B4B3F
+- 6D1F99449A26D540
+- 92817CDBC7715E3F
+- 72696E8F13BB323F
+- 683C16C10F79FE3E
+- 22801BA12A074740
+- 7081D3172A53E5BF
+- C0DE790FC0FBE9BF
+- 3AE5F0923E55D33F
+- 92B6BEEC140A8FBF
+- CE66ABACDBD80F3F
+- ACC70B95DCFF6BC0
+- 1461EF81707378BF
+- AE09EC08D0F1ADBF
+- 34DA3FFF72E9D83F
+- C664AD3F9AC4BFBF
+- 2101BE78DFDC74BE
+- 7EE9B042D4628140
+- 90368189CC8D753F
+- 337C9D874DC4C5BE
+- 0CFDA79A7FDCED3F
+- EC94C739F2CFB3BF
+- 1D5436848A1AEBBE
+- B725B6C420034640
+- 48C692FEAA59DEBF
+- BC4CB816B0BAB5BF
+- C2D835BC80B99A40
+- 6A565C2E720847BF
+- 050189AF84C84EC1
+- 0060B28B63B5DC3F
+- 18A387F2A64E5FC0
+- FBC8B0D428E302C1
+- A30DD43ED762B4C0
+- 3D85522EC70AFDBE
+- FCF62D2923F0583F
+- DB588C2A9C26FBC0
+- BA4E1863DBE6FCBE
+- 5C34946E1A12D33F
+- 90E63D7E81888740
+- 82541C0DE9F1443F
+- 9F2A7781EE4B683F
+- 0082C4B6393EA7BF
+- 768EDD6B97D19540
+- 87BA76258BEBFBBE
+- 7A6580A6639DD7BF
+- 26DDD435F13B12BF
+- 1AF857C69682DBBF
+- E731C0DCDAAE51BF
+- DB9DB0551A511F3F
+- 04977B9C4C73D13F
+- 44D5BB96C84587C0
+- CE3DE8C2DF9942BF
+- 23F12DE055F30C3F
+- C10951998E1B7440
+- 1CC3F51802F309C0
+- FB97E7DB6B081DC1
+- 5C811354280FEA3F
+- A405ED0A749718BF
+- 322939F71F7A51BF
+- F3E06C6EEB2342BF
+- 5A6D9DF3F879D3C0
+- BC466E35C5AF9940
+- EB4571E54EB7CD3F
+- BBA9A8401CD4D13F
+- 6A565DEA5E4F8A40
+- 20586794310B93BF
+- 80B8449C203B9BC0
+- 0E9C461358F4AABF
+- 469E0A1D42DEA73F
+- 711DA636DD2C41BF
+- 414A9E166BE2A0C0
+- 407FF9F39253F2BE
+- BAD158256942D4C0
+- 2D4424FE12BE94BF
+- 7F0F15B537E997C0
+- 4ADF1BD93C66F1BF
+- 2DAF002ADBC1E0BF
+- 3739FF3C2BE601C0
+- 38ACCEAE7B88083F
+- 7C2D9D7FA150C23F
+- B726087920E8EA3F
+- C075B44F459250BE
+- 9EDAB9C61F7D783F
+- 2FE6362CACE5153F
+- 98A24B93A2F4C33E
+- 6FD39CEB5C7F15C0
+- C5BE550840E4503F
+- 214EA7E4F9619640
+- 4DEF9253DE1C10C0
+- B8C76C5B85E4FDBF
+- 07D21EB7A400F13F
+- DB103669202EAEBF
+- 9F59E7B3EA71E63F
+- 83712959474BF440
+- 8D5B7FA245A650BF
+- 16FAF25CCBB8ECBE

data/test/helper.rb

@@ -0,0 +1,40 @@
+require 'test/unit'
+# require 'minitest/spec'
+# require 'minitest/unit'
+$: << "." unless $:.include?(".") # for Ruby 1.9.2
+require File.expand_path(File.join(File.dirname(__FILE__),'/../lib/numerals'))
+
+require 'yaml'
+
+module PrepareData
+
+    @@data = []
+
+    def self.add(x)
+      @@data << [x].pack('E').unpack('H*')[0].upcase
+    end
+
+    def self.init
+      unless File.exist?('test/data.yaml')
+        100.times do
+           x = rand
+           x *= rand(1000) if rand<0.5
+           x /= rand(1000) if rand<0.5
+           x *= rand(9999) if rand<0.5
+           x /= rand(9999) if rand<0.5
+           x = -x if rand<0.5
+           #puts x
+           add x
+         end
+         add 1.0/3
+         add 0.1
+         File.open('test/data.yaml','w') { |out| out << @@data.to_yaml }
+       end
+    end
+end
+
+PrepareData.init
+
+def BigDec(x)
+  BigDecimal.new(x.to_s)
+end

data/test/test_digits_definition.rb

@@ -0,0 +1,110 @@
+# encoding: utf-8
+
+require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
+require 'test/unit'
+include Numerals
+require 'yaml'
+
+class TestDigitsDefinition < Test::Unit::TestCase
+
+  DEFAULT_DIGITS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+  MAX_TEST_BASE  = DEFAULT_DIGITS.size
+
+  def default_digits(b)
+    DEFAULT_DIGITS[0,b]
+  end
+
+  def define_from_digits(b)
+    DigitsDefinition[default_digits(b)]
+  end
+
+  def define_from_base(b)
+    DigitsDefinition[base: b]
+  end
+
+  def check_base(b, digits)
+    assert_equal b, digits.radix
+    (0...b).each do |digit_value|
+      digit_char = default_digits(b)[digit_value]
+      assert_equal digit_char, digits.digit_char(digit_value)
+      assert_equal digit_value, digits.digit_value(digit_char)
+      assert digits.is_digit?(digit_char)
+    end
+    [-10,-5,-2,-1,b,b+1,b+2,b+10].each do |invalid_digit_value|
+      assert_nil digits.digit_char(invalid_digit_value)
+    end
+    invalid_chars = %w(- / & ñ)
+    if b < MAX_TEST_BASE
+      (b+1...MAX_TEST_BASE).each do |i|
+        invalid_chars << DEFAULT_DIGITS[i]
+      end
+    end
+    invalid_chars.each do |invalid_digit_char|
+      assert_nil digits.digit_value(invalid_digit_char)
+      assert !digits.is_digit?(invalid_digit_char)
+    end
+  end
+
+  def test_digits_definition
+    (0..MAX_TEST_BASE).each do |base|
+      check_base base, define_from_digits(base)
+      check_base base, define_from_base(base)
+    end
+  end
+
+  def test_digits_case
+    uppercase_digits = DigitsDefinition[base: 16, downcase: false]
+
+    assert_equal 10, uppercase_digits.digit_value('A')
+    assert_equal 11, uppercase_digits.digit_value('B')
+    assert_equal 15, uppercase_digits.digit_value('F')
+
+    assert_equal 10, uppercase_digits.digit_value('a')
+    assert_equal 11, uppercase_digits.digit_value('b')
+    assert_equal 15, uppercase_digits.digit_value('f')
+
+    assert_equal 'A', uppercase_digits.digit_char(10)
+    assert_equal 'B', uppercase_digits.digit_char(11)
+    assert_equal 'F', uppercase_digits.digit_char(15)
+
+    downcase_digits = DigitsDefinition[base: 16, downcase: true]
+
+    assert_equal 10, downcase_digits.digit_value('A')
+    assert_equal 11, downcase_digits.digit_value('B')
+    assert_equal 15, downcase_digits.digit_value('F')
+
+    assert_equal 10, downcase_digits.digit_value('a')
+    assert_equal 11, downcase_digits.digit_value('b')
+    assert_equal 15, downcase_digits.digit_value('f')
+
+    assert_equal 'a', downcase_digits.digit_char(10)
+    assert_equal 'b', downcase_digits.digit_char(11)
+    assert_equal 'f', downcase_digits.digit_char(15)
+
+
+    cs_uppercase_digits = DigitsDefinition[base: 16, downcase: false, case_sensitive: true]
+
+    assert_equal 10,  cs_uppercase_digits.digit_value('A')
+    assert_equal 11,  cs_uppercase_digits.digit_value('B')
+    assert_equal 15,  cs_uppercase_digits.digit_value('F')
+    assert_nil        cs_uppercase_digits.digit_value('a')
+    assert_nil        cs_uppercase_digits.digit_value('b')
+    assert_nil        cs_uppercase_digits.digit_value('f')
+    assert_equal 'A', cs_uppercase_digits.digit_char(10)
+    assert_equal 'B', cs_uppercase_digits.digit_char(11)
+    assert_equal 'F', cs_uppercase_digits.digit_char(15)
+
+    cs_downcase_digits = DigitsDefinition[base: 16, downcase: true, case_sensitive: true]
+
+    assert_equal 10,  cs_downcase_digits.digit_value('a')
+    assert_equal 11,  cs_downcase_digits.digit_value('b')
+    assert_equal 15,  cs_downcase_digits.digit_value('f')
+    assert_nil        cs_downcase_digits.digit_value('A')
+    assert_nil        cs_downcase_digits.digit_value('B')
+    assert_nil        cs_downcase_digits.digit_value('F')
+    assert_equal 'a', cs_downcase_digits.digit_char(10)
+    assert_equal 'b', cs_downcase_digits.digit_char(11)
+    assert_equal 'f', cs_downcase_digits.digit_char(15)
+  end
+
+end

data/test/test_float_conversions.rb

@@ -0,0 +1,58 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
+
+require 'numerals'
+include Numerals
+
+class TestFloatConversions <  Test::Unit::TestCase # < Minitest::Test
+
+  def test_special
+    assert_equal Numeral.nan, Conversions.number_to_numeral(Float.context.nan)
+    assert_equal Numeral.nan, Conversions.number_to_numeral(Float.context.nan, :fixed, Rounding[:exact, base: 2])
+    assert_equal Numeral.nan, Conversions.number_to_numeral(Float.context.nan, :fixed, Rounding[:exact, base: 10])
+    assert_equal Numeral.nan, Conversions.number_to_numeral(Float.context.nan, :fixed, Rounding[precision: 10, base: 10])
+    assert_equal Numeral.nan, Conversions.number_to_numeral(Float.context.nan, :free)
+
+    assert_equal Numeral.infinity, Conversions.number_to_numeral(Float.context.infinity)
+    assert_equal Numeral.infinity, Conversions.number_to_numeral(Float.context.infinity, :fixed, Rounding[:exact, base: 2])
+    assert_equal Numeral.infinity, Conversions.number_to_numeral(Float.context.infinity, :fixed, Rounding[:exact, base: 10])
+    assert_equal Numeral.infinity, Conversions.number_to_numeral(Float.context.infinity, :fixed, Rounding[precision: 10, base: 10])
+    assert_equal Numeral.infinity, Conversions.number_to_numeral(Float.context.infinity, :free)
+
+    assert_equal Numeral.infinity(-1), Conversions.number_to_numeral(Float.context.infinity(-1))
+    assert_equal Numeral.infinity(-1), Conversions.number_to_numeral(Float.context.infinity(-1), :fixed, Rounding[:exact, base: 2])
+    assert_equal Numeral.infinity(-1), Conversions.number_to_numeral(Float.context.infinity(-1), :fixed, Rounding[:exact, base: 10])
+    assert_equal Numeral.infinity(-1), Conversions.number_to_numeral(Float.context.infinity(-1), :fixed, Rounding[precision: 10, base: 10])
+    assert_equal Numeral.infinity(-1), Conversions.number_to_numeral(Float.context.infinity(-1), :free)
+
+    assert       Conversions.numeral_to_number(Numeral.nan, Float).nan?
+    assert_equal Float.context.infinity, Conversions.numeral_to_number(Numeral.infinity, Float)
+    assert_equal Float.context.infinity(-1), Conversions.numeral_to_number(Numeral.infinity(-1), Float)
+  end
+
+  def test_exact
+    assert_equal Numeral[1,point:1], Conversions.number_to_numeral(1.0, :fixed, Rounding[:exact, base: 10])
+    assert_equal Numeral[1,point:1, sign: -1], Conversions.number_to_numeral(-1.0, :fixed, Rounding[:exact, base: 10])
+
+    assert_equal Numeral[1,point:1, base: 2], Conversions.number_to_numeral(1.0, :fixed, Rounding[:exact, base: 2])
+    assert_equal Numeral[1,point:1, sign: -1, base: 2], Conversions.number_to_numeral(-1.0, :fixed, Rounding[:exact, base: 2])
+
+    [0.1, 0.01, 0.001, 1/3.0, 10/3.0, 100/3.0, Math::PI, 0.5, 123.0, 123.45, 1.23E32, 1.23E-32].each do |x|
+      [x, -x].each do |y|
+        numeral = exact_decimal(y)
+        tmp = Conversions.number_to_numeral(y, :fixed, Rounding[:exact, base: 10])
+        assert_equal numeral, Conversions.number_to_numeral(y, :fixed, Rounding[:exact, base: 10]), "#{y} to base 10 exact numeral"
+        assert_equal y, Conversions.numeral_to_number(numeral, Float), "#{x} base 10 numeral to float"
+      end
+    end
+  end
+
+  def exact_decimal(x)
+    Flt::DecNum.context(exact: true){
+      Flt::BinNum.context(Flt::BinNum::FloatContext){
+        d = Flt::BinNum(x).to_decimal_exact
+        Numeral[d.coefficient.to_s.chars.map(&:to_i), sign: d.sign, point: d.fractional_exponent, normalize: :exact]
+      }
+    }
+  end
+
+end