numerals 0.0.0 → 0.1.0

data/test/test_integer_conversions.rb

@@ -5,46 +5,46 @@ include Numerals
 
 class TestIntegerConversions <  Test::Unit::TestCase # < Minitest::Test
 
-  def test_special
-    assert_raise(ZeroDivisionError){ Conversions.numeral_to_number(Numeral.nan, Integer) }
-    assert_raise(ZeroDivisionError){ Conversions.numeral_to_number(Numeral.infinity, Integer) }
-    assert_raise(ZeroDivisionError){ Conversions.numeral_to_number(Numeral.infinity(-1), Integer) }
+  def test_read_special
+    assert_raise(ZeroDivisionError){ Conversions.read(Numeral.nan, type: Integer) }
+    assert_raise(ZeroDivisionError){ Conversions.read(Numeral.infinity, type: Integer) }
+    assert_raise(ZeroDivisionError){ Conversions.read(Numeral.infinity(-1), type: Integer) }
   end
 
-  def test_integer_to_numeral
-    exact = Rounding[:exact]
+  def test_write
+    exact = Rounding[:short]
     nine_digits = Rounding[:half_even, precision: 9]
 
-    assert_equal Numeral[1, point: 1], Conversions.number_to_numeral(1)
-    assert_equal Numeral[1, point: 1], Conversions.number_to_numeral(1, exact)
+    assert_equal Numeral[1, point: 1], Conversions.write(1)
+    assert_equal Numeral[1, point: 1], Conversions.write(1, rounding: exact)
     assert_equal Numeral[1, 0, 0, 0, 0, 0, 0, 0, 0, point: 1],
-                 Conversions.number_to_numeral(1, nine_digits)
+                 Conversions.write(1, rounding: nine_digits)
 
-    assert_equal Numeral[1, point: 1, sign: -1], Conversions.number_to_numeral(-1)
-    assert_equal Numeral[1, point: 1, sign: -1], Conversions.number_to_numeral(-1, exact)
+    assert_equal Numeral[1, point: 1, sign: -1], Conversions.write(-1)
+    assert_equal Numeral[1, point: 1, sign: -1], Conversions.write(-1, rounding: exact)
     assert_equal Numeral[1, 0, 0, 0, 0, 0, 0, 0, 0, point: 1, sign: -1],
-                 Conversions.number_to_numeral(-1, nine_digits)
+                 Conversions.write(-1, rounding: nine_digits)
 
-    assert_equal Numeral[4, 2, point: 2], Conversions.number_to_numeral(42)
-    assert_equal Numeral[4, 2, point: 2], Conversions.number_to_numeral(42, exact)
+    assert_equal Numeral[4, 2, point: 2], Conversions.write(42)
+    assert_equal Numeral[4, 2, point: 2], Conversions.write(42, rounding: exact)
     assert_equal Numeral[4, 2, 0, 0, 0, 0, 0, 0, 0, point: 2],
-                 Conversions.number_to_numeral(42, nine_digits)
+                 Conversions.write(42, rounding: nine_digits)
   end
 
-  def test_numeral_to_rational
+  def test_read
     assert_raise IntegerConversion::InvalidConversion do
-      Conversions.numeral_to_number(Numeral[3, point: 0, repeat: 0], Integer)
+      Conversions.read(Numeral[3, point: 0, repeat: 0], type: Integer)
     end
     assert_raise IntegerConversion::InvalidConversion do
-      Conversions.numeral_to_number(Numeral[[3]*9, point: 0, normalize: :approximate], Integer)
+      Conversions.read(Numeral[[3]*9, point: 0, normalize: :approximate], type: Integer)
     end
     assert_raise IntegerConversion::InvalidConversion do
-      Conversions.numeral_to_number(Numeral[1, point: 0], Integer)
+      Conversions.read(Numeral[1, point: 0], type: Integer)
     end
-    assert_equal 1, Conversions.numeral_to_number(Numeral[1, point: 1], Integer)
-    assert_equal -1, Conversions.numeral_to_number(Numeral[1, point: 1, sign: -1], Integer)
+    assert_equal 1, Conversions.read(Numeral[1, point: 1], type: Integer)
+    assert_equal -1, Conversions.read(Numeral[1, point: 1, sign: -1], type: Integer)
     assert_equal 42,
-                 Conversions.numeral_to_number(Numeral[4, 2, point: 2], Integer)
+                 Conversions.read(Numeral[4, 2, point: 2], type: Integer)
   end
 
 end

data/test/test_numeral.rb

@@ -196,6 +196,8 @@ class TestNumeral <  Test::Unit::TestCase # < Minitest::Test
     assert_equal Numeral[1,2,3,4,5,4,5, point: 1, repeat: 1], Numeral.from_quotient(1234544, 999999)
     assert_equal Numeral[1,2,3,4,5,4,5,2,3,4,5, point: 1, repeat: 9], Numeral.from_quotient(678999879, 550000000)
     assert_equal Numeral[1,2,3,4,5,4,5,2,3,4,5, point: 1, repeat: 9], Numeral.from_quotient(678999879, 550000000)
+    assert_equal Numeral[1, 1, point: -3, repeat: -2, base: 2],
+                 Numeral.from_quotient(Rational(1,10), base:2)
   end
 
   def test_numeral_to_quotient
@@ -245,7 +247,18 @@ class TestNumeral <  Test::Unit::TestCase # < Minitest::Test
 
     assert_equal Numeral.integer(1), Numeral[9, point: 0, repeat: 0]
     assert_equal Numeral[2, point: 0], Numeral[1,9, point: 0, repeat: 1]
+  end
 
+  def test_partial_unneeded_rep_normalization
+    numeral = Numeral[1, 0, 1, 1, 1, 0, base: 2, point: 2, repeat: 2]
+    assert_equal Numeral[1, 0, 1, 1, 1, base: 2, point: 2, repeat: 1, normalize: false], numeral
+    assert_equal Numeral[1,2,3,4,5, point: 1, repeat: 3, normalize: false], Numeral[1,2,3,4,5, point: 1, repeat: 3]
+    assert_equal Numeral[1,2,3,4,5, point: 1, repeat: 3, normalize: false], Numeral[1,2,3,4,5,4, point: 1, repeat: 4]
+    assert_equal Numeral[1,2,3,4,5, point: 1, repeat: 3, normalize: false], Numeral[1,2,3,4,5,4,5, point: 1, repeat: 5]
+    assert_equal Numeral[1,2,3,4,5,6,7,8, point: 1, repeat: 3, normalize: false], Numeral[1,2,3,4,5,6,7,8,4, point: 1, repeat: 4]
+    assert_equal Numeral[1,2,3,4,5,6,7,8, point: 1, repeat: 3, normalize: false], Numeral[1,2,3,4,5,6,7,8,4,5, point: 1, repeat: 5]
+    assert_equal Numeral[1,2,3,4,5,6,7,8, point: 1, repeat: 3, normalize: false], Numeral[1,2,3,4,5,6,7,8,4,5,6, point: 1, repeat: 6]
+    assert_equal Numeral[1,2,3,4,5,6,7,8,4,6, point: 1, repeat: 5, normalize: false], Numeral[1,2,3,4,5,6,7,8,4,6, point: 1, repeat: 5]
   end
 
   def test_quotient_conversion
@@ -363,4 +376,26 @@ class TestNumeral <  Test::Unit::TestCase # < Minitest::Test
     assert_equal Digits[1,2,3,4,5], exact.digits
   end
 
+  def test_digit_value_at
+    n = Numeral[1,2,3, repeat: -10, point: 1]
+    (-20...0).each do |i|
+      assert_equal 0, n.digit_value_at(i)
+    end
+    assert_equal 1, n.digit_value_at(0)
+    assert_equal 2, n.digit_value_at(1)
+    assert_equal 3, n.digit_value_at(2)
+    (3...13).each do |i|
+      assert_equal 0, n.digit_value_at(i)
+    end
+    assert_equal 1, n.digit_value_at(13)
+    assert_equal 2, n.digit_value_at(14)
+    assert_equal 3, n.digit_value_at(15)
+    (16...26).each do |i|
+      assert_equal 0, n.digit_value_at(i)
+    end
+    assert_equal 1, n.digit_value_at(26)
+    assert_equal 2, n.digit_value_at(27)
+    assert_equal 3, n.digit_value_at(28)
+  end
+
 end

data/test/test_rational_conversions.rb

@@ -5,70 +5,70 @@ include Numerals
 
 class TestRationalConversions <  Test::Unit::TestCase # < Minitest::Test
 
-  def test_special
-    assert_raise(ZeroDivisionError){ Conversions.numeral_to_number(Numeral.nan, Rational) }
-    assert_raise(ZeroDivisionError){ Conversions.numeral_to_number(Numeral.infinity, Rational) }
-    assert_raise(ZeroDivisionError){ Conversions.numeral_to_number(Numeral.infinity(-1), Rational) }
+  def test_read_special
+    assert_raise(ZeroDivisionError){ Conversions.read(Numeral.nan, type: Rational) }
+    assert_raise(ZeroDivisionError){ Conversions.read(Numeral.infinity, type: Rational) }
+    assert_raise(ZeroDivisionError){ Conversions.read(Numeral.infinity(-1), type: Rational) }
   end
 
-  def test_rational_to_numeral
+  def test_write
 
-    exact = Rounding[:exact]
+    exact = Rounding[:short]
     nine_digits = Rounding[:half_even, precision: 9]
 
     assert_equal Numeral[3, point: 0, repeat: 0],
-                 Conversions.number_to_numeral(Rational(1, 3))
+                 Conversions.write(Rational(1, 3))
     assert_equal Numeral[3, point: 0, repeat: 0],
-                 Conversions.number_to_numeral(Rational(1, 3), exact)
+                 Conversions.write(Rational(1, 3), rounding: exact)
     assert_equal Numeral[[3]*9, point: 0, normalize: :approximate],
-                 Conversions.number_to_numeral(Rational(1, 3), nine_digits)
+                 Conversions.write(Rational(1, 3), rounding: nine_digits)
 
     assert_equal Numeral[3, point: 0, repeat: 0, sign: -1],
-                 Conversions.number_to_numeral(Rational(-1, 3))
+                 Conversions.write(Rational(-1, 3))
     assert_equal Numeral[3, point: 0, repeat: 0, sign: -1],
-                 Conversions.number_to_numeral(Rational(-1, 3), exact)
+                 Conversions.write(Rational(-1, 3), rounding: exact)
     assert_equal Numeral[[3]*9, point: 0, sign: -1, normalize: :approximate],
-                 Conversions.number_to_numeral(Rational(-1, 3), nine_digits)
+                 Conversions.write(Rational(-1, 3), rounding: nine_digits)
 
     assert_equal Numeral[1, point: 0],
-                 Conversions.number_to_numeral(Rational(1, 10))
+                 Conversions.write(Rational(1, 10))
     assert_equal Numeral[1, point: 0],
-                 Conversions.number_to_numeral(Rational(1, 10), exact)
+                 Conversions.write(Rational(1, 10), rounding: exact)
     assert_equal Numeral[1,0,0,0,0,0,0,0,0, point: 0, normalize: :approximate],
-                 Conversions.number_to_numeral(Rational(1, 10), nine_digits)
+                 Conversions.write(Rational(1, 10), rounding: nine_digits)
 
     assert_equal Numeral[1, point: 0, sign: -1],
-                 Conversions.number_to_numeral(Rational(-1, 10))
+                 Conversions.write(Rational(-1, 10))
     assert_equal Numeral[1, point: 0, sign: -1],
-                 Conversions.number_to_numeral(Rational(-1, 10), exact)
+                 Conversions.write(Rational(-1, 10), rounding: exact)
     assert_equal Numeral[1,0,0,0,0,0,0,0,0, point: 0, sign: -1, normalize: :approximate],
-                 Conversions.number_to_numeral(Rational(-1, 10), nine_digits)
+                 Conversions.write(Rational(-1, 10), rounding: nine_digits)
 
     assert_equal Numeral[4,2, point: 2],
-                 Conversions.number_to_numeral(Rational(42, 1))
+                 Conversions.write(Rational(42, 1))
     assert_equal Numeral[4,2, point: 2],
-                 Conversions.number_to_numeral(Rational(42, 1), exact)
+                 Conversions.write(Rational(42, 1), rounding: exact)
     assert_equal Numeral[4,2,0,0,0,0,0,0,0, point: 2, normalize: :approximate],
-                 Conversions.number_to_numeral(Rational(42, 1), nine_digits)
+                 Conversions.write(Rational(42, 1), rounding: nine_digits)
 
   end
 
-  def test_numeral_to_rational
+  def test_read
 
     assert_equal Rational(1, 3),
-                 Conversions.numeral_to_number(Numeral[3, point: 0, repeat: 0], Rational)
+                 Conversions.read(Numeral[3, point: 0, repeat: 0], type: Rational)
     assert_equal Rational(333_333_333, 1_000_000_000),
-                 Conversions.numeral_to_number(Numeral[[3]*9, point: 0, normalize: :approximate], Rational)
+                 Conversions.read(Numeral[[3]*9, point: 0, normalize: :approximate], type: Rational)
 
     assert_equal Rational(1, 10),
-                 Conversions.numeral_to_number(Numeral[1, point: 0], Rational)
+                 Conversions.read(Numeral[1, point: 0], type: Rational)
     assert_equal Rational(1_000_000_000, 10_000_000_000),
-                 Conversions.numeral_to_number(Numeral[1,0,0,0,0,0,0,0,0, point: 0, normalize: :approximate], Rational)
+                 Conversions.read(Numeral[1,0,0,0,0,0,0,0,0, point: 0, normalize: :approximate], type: Rational)
 
     assert_equal Rational(42, 1),
-                 Conversions.numeral_to_number(Numeral[4, 2, point: 2], Rational)
+                 Conversions.read(Numeral[4, 2, point: 2], type: Rational)
    assert_equal Rational(42_000_000_000, 1_000_000_000),
-                Conversions.numeral_to_number(Numeral[4,2,0,0,0,0,0,0,0, point: 2, normalize: :approximate], Rational)
+                Conversions.read(Numeral[4,2,0,0,0,0,0,0,0, point: 2, normalize: :approximate], type: Rational)
 
   end
 

data/test/test_repeat_detector.rb

@@ -0,0 +1,72 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
+
+require 'numerals'
+include Numerals
+
+class TestRepeatDetector <  Test::Unit::TestCase # < Minitest::Test
+
+  def test_repeat_detector
+
+    assert_equal(
+      [[2, 5, 4, 3, 4, 2, 1, 2, 6, 7, 8], nil],
+      RepeatDetector.detect([2, 5, 4, 3, 4, 2, 1, 2, 6, 7, 8])
+    )
+
+    assert_equal(
+      [[2, 5, 4, 3, 4, 2, 1, 2, 6, 7, 8], 8],
+      RepeatDetector.detect([2, 5, 4, 3, 4, 2, 1, 2, 6, 7, 8, 6, 7, 8])
+    )
+
+    assert_equal(
+      [[2, 5, 4, 3, 4, 2, 1, 2, 6, 7, 8, 6, 7, 8], nil],
+      RepeatDetector.detect([2, 5, 4, 3, 4, 2, 1, 2, 6, 7, 8, 6, 7, 8], 2)
+    )
+
+    assert_equal(
+      [[2, 5, 4, 3, 4, 2, 1, 2, 6, 7, 8], 8],
+      RepeatDetector.detect([2, 5, 4, 3, 4, 2, 1, 2, 6, 7, 8, 6, 7, 8, 6, 7, 8], 2)
+    )
+
+    assert_equal(
+      [[2, 5, 4, 3, 4, 2, 1, 2, 6, 7, 8], 8],
+      RepeatDetector.detect([2, 5, 4, 3, 4, 2, 1, 2, 6, 7, 8, 6, 7, 8, 6, 7, 8])
+    )
+
+    assert_equal(
+      [[2, 5, 4, 3, 4, 2, 1, 2, 6, 7, 8, 6, 7, 8, 6, 7, 8], nil],
+      RepeatDetector.detect([2, 5, 4, 3, 4, 2, 1, 2, 6, 7, 8, 6, 7, 8, 6, 7, 8], 3)
+    )
+
+    assert_equal(
+      [[2, 5, 4, 3, 4, 2, 1, 2, 6, 7, 8], 8],
+      RepeatDetector.detect([2, 5, 4, 3, 4, 2, 1, 2, 6, 7, 8, 6, 7, 8, 6, 7, 8,6,7,8], 3)
+    )
+
+    assert_equal(
+      [[2, 5, 4, 3, 4, 2, 1, 2, 6, 7, 8], 8],
+      RepeatDetector.detect([2, 5, 4, 3, 4, 2, 1, 2, 6, 7, 8, 6, 7, 8, 6, 7, 8,6,7,8], 2)
+    )
+
+    assert_equal(
+      [[2, 5, 4, 3, 4, 2, 1, 2, 6, 7, 8], 8],
+      RepeatDetector.detect([2, 5, 4, 3, 4, 2, 1, 2, 6, 7, 8, 6, 7, 8, 6, 7, 8,6,7,8])
+    )
+
+    assert_equal(
+      [[3], 0],
+      RepeatDetector.detect([3, 3], 1)
+    )
+
+    assert_equal(
+      [[3, 3], nil],
+      RepeatDetector.detect([3, 3], 2)
+    )
+
+    assert_equal(
+      [[3], 0],
+      RepeatDetector.detect([3, 3, 3], 2)
+    )
+
+  end
+
+end

data/test/test_rounding.rb

@@ -74,4 +74,162 @@ class TestRounding <  Test::Unit::TestCase # < Minitest::Test
     assert_equal Numeral[1,0,1, point: 3, sign: -1, normalize: :approximate], r.round(Numeral[1,0,1,4,9,9,9, point: 3, sign: -1])
     assert_equal Numeral[1,0,0, point: 3, sign: -1, normalize: :approximate], r.round(Numeral[1,0,0,4,9,9,9,9,9,9,9,9,9,9,9,9, point: 3, sign: -1])
   end
+
+  def test_extended_rounding
+    # Rounding past the precision of a number
+    r = Rounding[:half_up, precision: 5]
+    assert_equal Numeral[1, 2, 3, 0, 0, point: 1, normalize: :approximate], r.round(Numeral[1, 2, 3, point: 1, normalize: :exact])
+    # currently, approximate numerals cannot be extended
+    assert_equal Numeral[1, 2, 3, point: 1, normalize: :approximate], r.round(Numeral[1, 2, 3, point: 1, normalize: :approximate])
+  end
+
+  def test_constructor
+    assert_equal Rounding[:short], Rounding[:simplify]
+    r = Rounding[:short]
+    assert r.free?
+    refute r.fixed?
+    assert r.simplifying?
+    assert r.short?
+    refute r.preserving?
+    refute r.full?
+    assert_equal :short, r.precision
+    assert_equal 10, r.base
+    assert_nil r.places
+
+    r = Rounding[:short, base: 2]
+    assert r.free?
+    refute r.fixed?
+    assert r.simplifying?
+    refute r.preserving?
+    assert_equal :short, r.precision
+    assert_equal 2, r.base
+    assert_nil r.places
+
+    assert_equal Rounding[:free], Rounding[:preserve]
+    r = Rounding[:free]
+    assert r.free?
+    refute r.fixed?
+    refute r.simplifying?
+    assert r.preserving?
+    assert_equal :free, r.precision
+    assert_equal 10, r.base
+    assert_nil r.places
+
+    r = Rounding[:free, base: 2]
+    assert r.free?
+    refute r.fixed?
+    refute r.simplifying?
+    assert r.preserving?
+    assert_equal :free, r.precision
+    assert_equal 2, r.base
+    assert_nil r.places
+
+    r = Rounding[precision: 5]
+    refute r.free?
+    assert r.fixed?
+    refute r.simplifying?
+    refute r.preserving?
+    assert r.relative?
+    refute r.absolute?
+    assert_equal :half_even, r.mode
+    assert_equal 10, r.base
+    assert_equal 5, r.precision
+    assert_nil r.places
+
+    r = Rounding[precision: 5, base: 2]
+    refute r.free?
+    assert r.fixed?
+    refute r.simplifying?
+    refute r.preserving?
+    assert r.relative?
+    refute r.absolute?
+    assert_equal :half_even, r.mode
+    assert_equal 2, r.base
+    assert_equal 5, r.precision
+    assert_nil r.places
+
+    r = Rounding[:down, precision: 5]
+    refute r.free?
+    assert r.fixed?
+    refute r.simplifying?
+    refute r.preserving?
+    assert r.relative?
+    refute r.absolute?
+    assert_equal :down, r.mode
+    assert_equal 10, r.base
+    assert_equal 5, r.precision
+    assert_nil r.places
+
+    r = Rounding[:down, precision: 5, base: 2]
+    refute r.free?
+    assert r.fixed?
+    refute r.simplifying?
+    refute r.preserving?
+    assert r.relative?
+    refute r.absolute?
+    assert_equal :down, r.mode
+    assert_equal 2, r.base
+    assert_equal 5, r.precision
+    assert_nil r.places
+
+    r = Rounding[mode: :down, precision: 5]
+    refute r.free?
+    assert r.fixed?
+    refute r.simplifying?
+    refute r.preserving?
+    assert r.relative?
+    refute r.absolute?
+    assert_equal :down, r.mode
+    assert_equal 10, r.base
+    assert_equal 5, r.precision
+    assert_nil r.places
+
+    r = Rounding[places: 5]
+    refute r.free?
+    assert r.fixed?
+    refute r.simplifying?
+    refute r.preserving?
+    refute r.relative?
+    assert r.absolute?
+    assert_equal :half_even, r.mode
+    assert_equal 10, r.base
+    assert_nil r.precision
+    assert_equal 5, r.places
+  end
+
+  def test_copy
+    r1 = Rounding[:short]
+    r2 = Rounding[r1]
+    assert_equal :short, r2.precision
+    r2.precision = :free
+    assert_equal :short, r1.precision
+    assert_equal :free, r2.precision
+
+    r2 = r1[:free]
+    assert_equal :short, r1.precision
+    assert_equal :free, r2.precision
+
+    r1 = Rounding[:short, :half_up, base: 2]
+    r2 = r1[precision: 10]
+    assert_equal 2, r2.base
+    assert_equal 10, r2.precision
+    assert_equal :short, r1.precision
+    assert_equal :half_up, r1.mode
+    assert_equal :half_up, r2.mode
+
+    r1 = Rounding[:short, base: 2]
+    r2 = r1.set(precision: 10)
+    assert_equal 2, r2.base
+    assert_equal 10, r2.precision
+    assert_equal :short, r1.precision
+  end
+
+  def test_mutators
+    r1 = Rounding[:free]
+    r2 = r1.set!(:short)
+    assert_equal :short, r1.precision
+    assert_equal :short, r2.precision
+    assert_equal r1.object_id, r2.object_id
+  end
+
 end

data/test/test_symbols.rb

@@ -0,0 +1,32 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
+
+require 'numerals/rounding'
+include Numerals
+
+class TestSymbols <  Test::Unit::TestCase # < Minitest::Test
+
+  def test_symbols
+    s = Format::Symbols[show_plus: false]
+    s2 = s[uppercase: true]
+    assert_equal true, s2.uppercase
+    assert_equal false, s.uppercase
+    assert_equal false, s.show_plus
+    assert_equal false, s2.show_plus
+    s3 = s2[show_plus: true]
+    assert_equal true, s3.show_plus
+    assert_equal false, s.show_plus
+    assert_equal false, s2.show_plus
+    assert_equal s3, s2.set_plus(true)
+    s4 = s3[plus: ' ']
+    assert_equal s4, s3.set_plus(' ')
+    s5 = s4[show_exponent_plus: true]
+    assert_equal s5, s4.set_plus(true, :exp)
+    s6 = s5[show_exponent_plus: true, plus: ' ']
+    assert_equal s6, s5.set_plus(' ', :exp)
+    s7 = s6[show_exponent_plus: true, show_plus: true]
+    assert_equal s6, s5.set_plus(:all)
+    s7 = s6[show_exponent_plus: true, show_plus: true, plus: ' ']
+    assert_equal s7, s6.set_plus(' ', :all)
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: numerals
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.1.0
 platform: ruby
 authors:
 - Javier Goizueta
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-02 00:00:00.000000000 Z
+date: 2015-03-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: flt
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.3.4
+        version: 1.4.6
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.3.4
+        version: 1.4.6
 - !ruby/object:Gem::Dependency
   name: modalsupport
   requirement: !ruby/object:Gem::Requirement
@@ -81,27 +81,51 @@ files:
 - lib/numerals.rb
 - lib/numerals/conversions.rb
 - lib/numerals/conversions/bigdecimal.rb
+- lib/numerals/conversions/context_conversion.rb
 - lib/numerals/conversions/float.rb
 - lib/numerals/conversions/flt.rb
 - lib/numerals/conversions/integer.rb
 - lib/numerals/conversions/rational.rb
 - lib/numerals/digits.rb
-- lib/numerals/formatting/digits_definition.rb
+- lib/numerals/format.rb
+- lib/numerals/format/base_scaler.rb
+- lib/numerals/format/exp_setter.rb
+- lib/numerals/format/format.rb
+- lib/numerals/format/input.rb
+- lib/numerals/format/mode.rb
+- lib/numerals/format/notation.rb
+- lib/numerals/format/notations/html.rb
+- lib/numerals/format/notations/latex.rb
+- lib/numerals/format/notations/text.rb
+- lib/numerals/format/output.rb
+- lib/numerals/format/symbols.rb
+- lib/numerals/format/text_parts.rb
 - lib/numerals/formatting/options.rb
+- lib/numerals/formatting_aspect.rb
 - lib/numerals/numeral.rb
+- lib/numerals/repeat_detector.rb
 - lib/numerals/rounding.rb
 - lib/numerals/support.rb
 - lib/numerals/version.rb
 - numerals.gemspec
 - test/data.yaml
 - test/helper.rb
+- test/test_base_scaler.rb
+- test/test_big_conversions.rb
 - test/test_digits_definition.rb
+- test/test_exp_setter.rb
 - test/test_float_conversions.rb
 - test/test_flt_conversions.rb
+- test/test_format.rb
+- test/test_format_input.rb
+- test/test_format_mode.rb
+- test/test_format_output.rb
 - test/test_integer_conversions.rb
 - test/test_numeral.rb
 - test/test_rational_conversions.rb
+- test/test_repeat_detector.rb
 - test/test_rounding.rb
+- test/test_symbols.rb
 homepage: https://github.com/jgoizueta/numerals
 licenses:
 - MIT
@@ -129,10 +153,19 @@ summary: Number representation as text.
 test_files:
 - test/data.yaml
 - test/helper.rb
+- test/test_base_scaler.rb
+- test/test_big_conversions.rb
 - test/test_digits_definition.rb
+- test/test_exp_setter.rb
 - test/test_float_conversions.rb
 - test/test_flt_conversions.rb
+- test/test_format.rb
+- test/test_format_input.rb
+- test/test_format_mode.rb
+- test/test_format_output.rb
 - test/test_integer_conversions.rb
 - test/test_numeral.rb
 - test/test_rational_conversions.rb
+- test/test_repeat_detector.rb
 - test/test_rounding.rb
+- test/test_symbols.rb

data/lib/numerals/formatting/digits_definition.rb

@@ -1,75 +0,0 @@
-module Numerals
-
-  # Digits definition (symbols used as digits)
-  class DigitsDefinition
-    include ModalSupport::StateEquivalent
-    include ModalSupport::BracketConstructor
-
-    DEFAULT_DIGITS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-    DEFAULT_BASE   = 10
-
-    def initialize(*args)
-      if String === args.first
-        digits = args.shift
-      end
-      options = args.shift || {}
-      raise NumeralError, "Invalid DigitsDefinition" unless args.empty? && Hash === options
-      digits ||= options[:digits]
-      base = options[:base]
-      if base
-        if digits
-          raise NumeralError, "Inconsistent DigitsDefinition" unless digits.size == base
-        end
-      elsif digits
-        base = digits.size
-      else
-        base = DEFAULT_BASE
-      end
-      digits ||= DEFAULT_DIGITS[0, base]
-
-      @radix = base
-      @digits = digits
-      @case_sensitive = options[:case_sensitive]
-      @downcase = options[:downcase] || (@digits.downcase == @digits)
-      @digits = @digits.downcase if @downcase
-    end
-
-    def is_digit?(digit)
-      digit = set_case(digit)
-      @digits.include?(digit)
-    end
-
-    def digit_value(digit)
-      digit = set_case(digit)
-      @digits.index(digit)
-    end
-
-    def digit_char(v)
-      v >= 0 && v < @radix ? @digits[v] : nil
-    end
-
-    def radix
-      @radix
-    end
-
-    def valid?
-      @digits.none?{|x| x.nil? || x<0 || x>=@radix}
-    end
-
-    private
-
-    def set_case(digit_char)
-      if digit_char
-        unless @case_sensitive
-          if @downcase
-            digit_char = digit_char.downcase
-          else
-            digit_char = digit_char.upcase
-          end
-        end
-      end
-      digit_char
-    end
-  end
-
-end