numerals 0.0.0 → 0.1.0

data/test/test_base_scaler.rb

@@ -0,0 +1,189 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
+
+require 'numerals'
+include Numerals
+
+class TestBaseScaler <  Test::Unit::TestCase # < Minitest::Test
+
+  def digits_string(part, base)
+    part.map{|d| d.to_s(base)}.join
+  end
+
+  def check_scaler(scaler)
+    "#{digits_string(scaler.integer_part, scaler.scaled_base)}.#{digits_string(scaler.fractional_part, scaler.scaled_base)}<#{digits_string(scaler.repeat_part, scaler.scaled_base)}>E#{scaler.exponent}"
+  end
+
+  def test_special
+    numeral = Numeral[:nan]
+    setter = Format::ExpSetter[numeral]
+    scaler = Format::BaseScaler[setter, 4]
+
+    assert_equal setter.base, scaler.exponent_base
+    assert_equal setter.sign, scaler.sign
+    assert_equal setter.exponent, scaler.exponent
+    assert_equal setter.special?, scaler.special?
+    assert_equal setter.special, scaler.special
+  end
+
+
+  def test_non_repeat
+    digits = [1,1,0,0]*12 + [1,1,0,1,0]
+    numeral = Numeral[digits, base: 2, point: -3]
+    setter = Format::ExpSetter[numeral]
+    setter.integer_part_size = 1
+    scaler = Format::BaseScaler[setter, 4]
+    assert_equal "1.999999999999a<>E-4", check_scaler(scaler)
+    setter.integer_part_size = 2
+    scaler = Format::BaseScaler[setter, 4]
+    assert_equal "3.3333333333334<>E-5", check_scaler(scaler)
+    setter.integer_part_size = 0
+    scaler = Format::BaseScaler[setter, 4]
+    assert_equal ".ccccccccccccd<>E-3", check_scaler(scaler)
+    setter.integer_part_size = 3
+    scaler = Format::BaseScaler[setter, 4]
+    assert_equal "6.6666666666668<>E-6", check_scaler(scaler)
+    setter.integer_part_size = 4
+    scaler = Format::BaseScaler[setter, 4]
+    assert_equal "c.cccccccccccd<>E-7", check_scaler(scaler)
+
+    assert_equal 16, scaler.scaled_base
+    assert_equal setter.base, scaler.exponent_base
+    assert_equal setter.sign, scaler.sign
+    assert_equal setter.exponent, scaler.exponent
+    assert_equal setter.special?, scaler.special?
+    assert_equal setter.special, scaler.special
+  end
+
+  def test_approx
+    digits = [1,1,0,0]*12 + [1,1,0,1,0]
+    numeral = Numeral[digits, base: 2, point: -3, normalize: :approximate]
+    setter = Format::ExpSetter[numeral]
+    setter.integer_part_size = 1
+    scaler = Format::BaseScaler[setter, 4]
+    assert_equal "1.999999999999a<>E-4", check_scaler(scaler)
+    setter.integer_part_size = 2
+    scaler = Format::BaseScaler[setter, 4]
+    assert_equal "3.3333333333334<>E-5", check_scaler(scaler)
+    setter.integer_part_size = 0
+    scaler = Format::BaseScaler[setter, 4]
+    assert_equal ".ccccccccccccd0<>E-3", check_scaler(scaler)
+    setter.integer_part_size = 3
+    scaler = Format::BaseScaler[setter, 4]
+    assert_equal "6.6666666666668<>E-6", check_scaler(scaler)
+    setter.integer_part_size = 4
+    scaler = Format::BaseScaler[setter, 4]
+    assert_equal "c.cccccccccccd0<>E-7", check_scaler(scaler)
+
+    assert_equal 16, scaler.scaled_base
+    assert_equal setter.base, scaler.exponent_base
+    assert_equal setter.sign, scaler.sign
+    assert_equal setter.exponent, scaler.exponent
+    assert_equal setter.special?, scaler.special?
+    assert_equal setter.special, scaler.special
+  end
+
+  def test_repeating_4
+    # 4 repeating bits
+    numeral = Numeral[1, 0, 1, 1, 1, 0, base: 2, point: 2, repeat: 2, normalize: false]
+    setter = Format::ExpSetter[numeral]
+    setter.integer_part_size = 2
+    scaler = Format::BaseScaler[setter, 4]
+    assert_equal '2.<e>E0', check_scaler(scaler)
+    setter.integer_part_size = 1
+    scaler = Format::BaseScaler[setter, 4]
+    # Next: not 1.<7> because we weren't eager defining binary repetition
+    # (we could have defined repetition one bit earlier)
+    assert_equal '1.7<7>E1', check_scaler(scaler)
+
+    numeral = Numeral[1, 0, 1, 1, 1, base: 2, point: 2, repeat: 1]
+    setter = Format::ExpSetter[numeral]
+    setter.integer_part_size = 2
+    scaler = Format::BaseScaler[setter, 4]
+    assert_equal '2.<e>E0', check_scaler(scaler)
+    setter.integer_part_size = 1
+    scaler = Format::BaseScaler[setter, 4]
+    assert_equal '1.<7>E1', check_scaler(scaler)
+
+    numeral = Numeral[1, 0, 1, 1, 1, base: 2, point: 0, repeat: 1]
+    setter = Format::ExpSetter[numeral]
+    setter.integer_part_size = 2
+    scaler = Format::BaseScaler[setter, 4]
+    assert_equal '2.<e>E-2', check_scaler(scaler)
+    setter.integer_part_size = 1
+    scaler = Format::BaseScaler[setter, 4]
+    assert_equal '1.<7>E-1', check_scaler(scaler)
+
+    numeral = Numeral[1, 0, 0, 1, 1, 1, base: 2, point: 2, repeat: 2]
+    setter = Format::ExpSetter[numeral]
+    setter.integer_part_size = 2
+    scaler = Format::BaseScaler[setter, 4]
+    assert_equal '2.<7>E0', check_scaler(scaler)
+    setter.integer_part_size = 1
+    scaler = Format::BaseScaler[setter, 4]
+    assert_equal '1.3<b>E1', check_scaler(scaler)
+
+    numeral = Numeral[1, 0, 0, 1, 1, 1, base: 2, point: 3, repeat: 2]
+    setter = Format::ExpSetter[numeral]
+    setter.integer_part_size = 2
+    scaler = Format::BaseScaler[setter, 4]
+    assert_equal '2.<7>E1', check_scaler(scaler)
+    setter.integer_part_size = 1
+    scaler = Format::BaseScaler[setter, 4]
+    assert_equal '1.3<b>E2', check_scaler(scaler)
+
+    numeral = Numeral[1, 0, 0, 1, 1, 1, base: 2, point: 1, repeat: 2]
+    setter = Format::ExpSetter[numeral]
+    setter.integer_part_size = 2
+    scaler = Format::BaseScaler[setter, 4]
+    assert_equal '2.<7>E-1', check_scaler(scaler)
+    setter.integer_part_size = 1
+    scaler = Format::BaseScaler[setter, 4]
+    assert_equal '1.3<b>E0', check_scaler(scaler)
+
+    assert_equal 16, scaler.scaled_base
+    assert_equal setter.base, scaler.exponent_base
+    assert_equal setter.sign, scaler.sign
+    assert_equal setter.exponent, scaler.exponent
+    assert_equal setter.special?, scaler.special?
+    assert_equal setter.special, scaler.special
+  end
+
+  def test_repeating_2
+    # 2 repeating bits
+    numeral = Numeral[1, 0, 1, 1, 1, 0, base: 2, point: 2, repeat: 4]
+    setter = Format::ExpSetter[numeral]
+    setter.integer_part_size = 2
+    scaler = Format::BaseScaler[setter, 4]
+    assert_equal '2.e<a>E0', check_scaler(scaler)
+    setter.integer_part_size = 1
+    scaler = Format::BaseScaler[setter, 4]
+    assert_equal '1.7<5>E1', check_scaler(scaler)
+
+    assert_equal 16, scaler.scaled_base
+    assert_equal setter.base, scaler.exponent_base
+    assert_equal setter.sign, scaler.sign
+    assert_equal setter.exponent, scaler.exponent
+    assert_equal setter.special?, scaler.special?
+    assert_equal setter.special, scaler.special
+  end
+
+  def test_repeating_3
+    # 3 repeating bits
+    numeral = Numeral[1, 0, 1, 1, 1, 0, 1, base: 2, point: 2, repeat: 4]
+    setter = Format::ExpSetter[numeral]
+    setter.integer_part_size = 2
+    scaler = Format::BaseScaler[setter, 4]
+    assert_equal '2.e<db6>E0', check_scaler(scaler)
+    setter.integer_part_size = 1
+    scaler = Format::BaseScaler[setter, 4]
+    assert_equal '1.7<6db>E1', check_scaler(scaler)
+
+    assert_equal 16, scaler.scaled_base
+    assert_equal setter.base, scaler.exponent_base
+    assert_equal setter.sign, scaler.sign
+    assert_equal setter.exponent, scaler.exponent
+    assert_equal setter.special?, scaler.special?
+    assert_equal setter.special, scaler.special
+  end
+
+end

data/test/test_big_conversions.rb

@@ -0,0 +1,105 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
+
+require 'numerals'
+require 'flt/bigdecimal'
+include Numerals
+
+class TestBigConversions <  Test::Unit::TestCase # < Minitest::Test
+
+
+  def test_write_special
+    context = BigDecimal.context
+    type = BigDecimal
+
+    assert_equal Numeral.nan, Conversions.write(context.nan)
+    assert_equal Numeral.nan, Conversions.write(context.nan, rounding: Rounding[:short, base: 2])
+    assert_equal Numeral.nan, Conversions.write(context.nan, rounding: Rounding[:short, base: 10])
+    assert_equal Numeral.nan, Conversions.write(context.nan, rounding: Rounding[precision: 10, base: 10])
+    assert_equal Numeral.nan, Conversions.write(context.nan)
+
+    assert_equal Numeral.infinity, Conversions.write(context.infinity)
+    assert_equal Numeral.infinity, Conversions.write(context.infinity, rounding: Rounding[:short, base: 2])
+    assert_equal Numeral.infinity, Conversions.write(context.infinity, rounding: Rounding[:short, base: 10])
+    assert_equal Numeral.infinity, Conversions.write(context.infinity, rounding: Rounding[precision: 10, base: 10])
+    assert_equal Numeral.infinity, Conversions.write(context.infinity)
+
+    assert_equal Numeral.infinity(-1), Conversions.write(context.infinity(-1))
+    assert_equal Numeral.infinity(-1), Conversions.write(context.infinity(-1), rounding: Rounding[:short, base: 2])
+    assert_equal Numeral.infinity(-1), Conversions.write(context.infinity(-1), rounding: Rounding[:short, base: 10])
+    assert_equal Numeral.infinity(-1), Conversions.write(context.infinity(-1), rounding: Rounding[precision: 10, base: 10])
+    assert_equal Numeral.infinity(-1), Conversions.write(context.infinity(-1))
+  end
+
+  def test_read_special
+    context = BigDecimal.context
+    type = BigDecimal
+
+    assert Conversions.read(Numeral.nan, type: type).nan?
+    assert_equal context.infinity, Conversions.read(Numeral.infinity, type: type)
+    assert_equal context.infinity(-1), Conversions.read(Numeral.infinity(-1), type: type)
+  end
+
+  def test_write_exact
+    l = BigDecimal.limit(9)
+
+    assert_equal Numeral[1,2,3,4,5,6,7,0,0, point: 3, normalize: :approximate],
+                 Conversions.write(BigDecimal('123.4567'))
+    assert_equal Numeral[1,2,3,4,5,6,7,0,0, point: 3, sign: -1, normalize: :approximate],
+                 Conversions.write(BigDecimal('-123.4567'))
+
+    BigDecimal.limit 0
+
+    assert_equal Numeral[1,2,3,4,5,6,7, point: 3],
+                 Conversions.write(BigDecimal('123.4567'))
+    assert_equal Numeral[1,2,3,4,5,6,7, point: 3, sign: -1],
+                 Conversions.write(BigDecimal('-123.4567'))
+
+    BigDecimal.limit l
+  end
+
+  def test_write_simple
+    l = BigDecimal.limit(9)
+
+    assert_equal Numeral[1,2,3,4,5,6,7, point: 3],
+                 Conversions.write(BigDecimal('123.4567'))
+    assert_equal Numeral[1,2,3,4,5,6,7, point: 3, sign: -1],
+                 Conversions.write(BigDecimal('-123.4567'))
+
+    BigDecimal.limit 0
+
+    assert_equal Numeral[1,2,3,4,5,6,7, point: 3],
+                 Conversions.write(BigDecimal('123.4567'))
+    assert_equal Numeral[1,2,3,4,5,6,7, point: 3, sign: -1],
+                 Conversions.write(BigDecimal('-123.4567'))
+
+    BigDecimal.limit l
+  end
+
+  def test_read
+
+    assert_equal BigDecimal('123.4567'),
+                 Conversions.read(
+                   Numeral[1,2,3,4,5,6,7, point: 3], type: BigDecimal
+                 )
+    assert_equal BigDecimal('123.4567'),
+                 Conversions.read(
+                   Numeral[1,2,3,4,5,6,7, point: 3, normalize: :approximate],
+                   type: BigDecimal
+                 )
+  end
+
+  def test_type_parameters
+    c = Conversions[BigDecimal, input_rounding: :down]
+    assert_equal Rounding[:down], c.input_rounding
+    c = Conversions[BigDecimal, input_rounding: :half_even]
+    assert_equal Rounding[:half_even], c.input_rounding
+
+    c = Conversions[BigDecimal, input_rounding: :half_even]
+    assert_equal Rounding[:half_even], c.input_rounding
+    c = Conversions[BigDecimal, input_rounding: Rounding[:half_up, precision: 7]]
+    assert_equal Rounding[:half_up, precision: 7], c.input_rounding
+    c = Conversions[BigDecimal, input_rounding: Rounding[:half_up, precision: 7, base: 3]]
+    assert_equal Rounding[:half_up], c.input_rounding
+  end
+
+end

data/test/test_digits_definition.rb

@@ -15,23 +15,19 @@ class TestDigitsDefinition < Test::Unit::TestCase
   end
 
   def define_from_digits(b)
-    DigitsDefinition[default_digits(b)]
-  end
-
-  def define_from_base(b)
-    DigitsDefinition[base: b]
+    Format::Symbols::Digits[default_digits(b)]
   end
 
   def check_base(b, digits)
-    assert_equal b, digits.radix
+    assert_equal b, digits.max_base
     (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)
+      digit_symbol = default_digits(b)[digit_value]
+      assert_equal digit_symbol, digits.digit_symbol(digit_value)
+      assert_equal digit_value, digits.digit_value(digit_symbol)
+      assert digits.is_digit?(digit_symbol)
     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)
+      assert_nil digits.digit_symbol(invalid_digit_value)
     end
     invalid_chars = %w(- / & ñ)
     if b < MAX_TEST_BASE
@@ -48,12 +44,11 @@ class TestDigitsDefinition < Test::Unit::TestCase
   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]
+    uppercase_digits = Format::Symbols::Digits[uppercase: true]
 
     assert_equal 10, uppercase_digits.digit_value('A')
     assert_equal 11, uppercase_digits.digit_value('B')
@@ -63,11 +58,11 @@ class TestDigitsDefinition < Test::Unit::TestCase
     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)
+    assert_equal 'A', uppercase_digits.digit_symbol(10)
+    assert_equal 'B', uppercase_digits.digit_symbol(11)
+    assert_equal 'F', uppercase_digits.digit_symbol(15)
 
-    downcase_digits = DigitsDefinition[base: 16, downcase: true]
+    downcase_digits = Format::Symbols::Digits[lowercase: true]
 
     assert_equal 10, downcase_digits.digit_value('A')
     assert_equal 11, downcase_digits.digit_value('B')
@@ -77,12 +72,12 @@ class TestDigitsDefinition < Test::Unit::TestCase
     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)
+    assert_equal 'a', downcase_digits.digit_symbol(10)
+    assert_equal 'b', downcase_digits.digit_symbol(11)
+    assert_equal 'f', downcase_digits.digit_symbol(15)
 
 
-    cs_uppercase_digits = DigitsDefinition[base: 16, downcase: false, case_sensitive: true]
+    cs_uppercase_digits = Format::Symbols::Digits[uppercase: true, case_sensitive: true]
 
     assert_equal 10,  cs_uppercase_digits.digit_value('A')
     assert_equal 11,  cs_uppercase_digits.digit_value('B')
@@ -90,11 +85,11 @@ class TestDigitsDefinition < Test::Unit::TestCase
     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)
+    assert_equal 'A', cs_uppercase_digits.digit_symbol(10)
+    assert_equal 'B', cs_uppercase_digits.digit_symbol(11)
+    assert_equal 'F', cs_uppercase_digits.digit_symbol(15)
 
-    cs_downcase_digits = DigitsDefinition[base: 16, downcase: true, case_sensitive: true]
+    cs_downcase_digits = Format::Symbols::Digits[lowercase: true, case_sensitive: true]
 
     assert_equal 10,  cs_downcase_digits.digit_value('a')
     assert_equal 11,  cs_downcase_digits.digit_value('b')
@@ -102,9 +97,9 @@ class TestDigitsDefinition < Test::Unit::TestCase
     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)
+    assert_equal 'a', cs_downcase_digits.digit_symbol(10)
+    assert_equal 'b', cs_downcase_digits.digit_symbol(11)
+    assert_equal 'f', cs_downcase_digits.digit_symbol(15)
   end
 
 end