numerals 0.0.0 → 0.1.0

data/test/test_format.rb

@@ -0,0 +1,124 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
+include Numerals
+require 'yaml'
+
+class TestFormat <  Test::Unit::TestCase # < Minitest::Test
+
+  def test_mutated_copy
+    f1 = Format[Rounding[precision: 3, base: 2]]
+
+    f2 = f1.set(rounding: :short)
+    assert_equal Rounding[precision: 3, base: 2], f1.rounding
+    assert_equal Rounding[:short, base: 2], f2.rounding
+
+    f2 = f1.set_rounding(:short)
+    assert_equal Rounding[precision: 3, base: 2], f1.rounding
+    assert_equal Rounding[:short, base: 2], f2.rounding
+
+    f2 = f1.set(rounding: { precision: 4 })
+    assert_equal Rounding[precision: 3, base: 2], f1.rounding
+    assert_equal Rounding[precision: 4, base: 2], f2.rounding
+
+    f2 = f1.set_rounding(precision: 4)
+    assert_equal Rounding[precision: 3, base: 2], f1.rounding
+    assert_equal Rounding[precision: 4, base: 2], f2.rounding
+
+    f2 = f1.set(rounding: Rounding[:short])
+    assert_equal Rounding[precision: 3, base: 2], f1.rounding
+    assert_equal Rounding[:short, base: 10], f2.rounding
+
+    f2 = f1.set(Rounding[:short])
+    assert_equal Rounding[precision: 3, base: 2], f1.rounding
+    assert_equal Rounding[:short, base: 10], f2.rounding
+
+    f2 = f1.set_rounding(Rounding[:short])
+    assert_equal Rounding[precision: 3, base: 2], f1.rounding
+    assert_equal Rounding[:short, base: 10], f2.rounding
+  end
+
+  def test_set_base
+    f = Format[base: 2, rounding: :short]
+    assert_equal 2, f.base
+    assert_equal Rounding[:short, base: 2], f.rounding
+    f.set_base! 5
+    assert_equal 5, f.base
+    assert_equal Rounding[:short, base: 5], f.rounding
+    f = f[base: 6]
+    assert_equal 6, f.base
+    assert_equal Rounding[:short, base: 6], f.rounding
+  end
+
+  def test_aspects
+    f = Format[exact_input: true, rounding: Rounding[precision: 5]]
+    assert_equal true, f.exact_input
+    assert_equal Rounding[precision: 5], f.rounding
+    assert_equal Format::Mode[], f.mode
+
+    f = Format[:exact_input, Rounding[precision: 5]]
+    assert_equal true, f.exact_input
+    assert_equal Rounding[precision: 5], f.rounding
+    assert_equal Format::Mode[], f.mode
+
+    f = Format[Rounding[precision: 5], exact_input: false]
+    assert_equal false, f.exact_input
+    assert_equal Rounding[precision: 5], f.rounding
+    assert_equal Format::Mode[], f.mode
+
+    f = Format[Rounding[precision: 5], mode: :fixed]
+    assert_equal false, f.exact_input
+    assert_equal Rounding[precision: 5], f.rounding
+    assert_equal Format::Mode[:fixed], f.mode
+
+    f = f[exact_input: true]
+    assert_equal true, f.exact_input
+    assert_equal Rounding[precision: 5], f.rounding
+    assert_equal Format::Mode[:fixed], f.mode
+
+    f = f[rounding: { precision: 6 }]
+    assert_equal true, f.exact_input
+    assert_equal Rounding[precision: 6], f.rounding
+    assert_equal Format::Mode[:fixed], f.mode
+
+    f = f.set_exact_input(false)
+    assert_equal false, f.exact_input
+    assert_equal Rounding[precision: 6], f.rounding
+    assert_equal Format::Mode[:fixed], f.mode
+
+    f = f.set_rounding(precision: 10)
+    assert_equal false, f.exact_input
+    assert_equal Rounding[precision: 10], f.rounding
+    assert_equal Format::Mode[:fixed], f.mode
+
+    f = f.set_rounding(precision: 10).set_mode(:engineering)
+    assert_equal false, f.exact_input
+    assert_equal Rounding[precision: 10], f.rounding
+    assert_equal Format::Mode[:engineering], f.mode
+  end
+
+  def test_redefine_aspects
+    f = Format[Format::Mode[max_leading: 10]]
+    f2 = f[Format::Mode[:scientific]]
+    assert_equal :scientific, f2.mode.mode
+    assert_equal Format[].mode.max_leading, f2.mode.max_leading
+    f2 = f[mode: :scientific]
+    assert_equal :scientific, f2.mode.mode
+    assert_equal 10, f2.mode.max_leading
+
+    f = Format[Rounding[base: 2]]
+    f2 = f[Rounding[:short]]
+    assert_equal :short, f2.rounding.precision
+    assert_equal 10, f2.rounding.base
+    f2 = f[rounding: :short]
+    assert_equal :short, f2.rounding.precision
+    assert_equal 2, f2.rounding.base
+
+    f = Format[Format::Symbols[plus: 'PLUS']]
+    f2 = f[Format::Symbols[nan: 'Not a Number']]
+    assert_equal 'Not a Number', f2.symbols.nan
+    assert_equal '+', f2.symbols.plus
+    f2 = f[symbols: { nan: 'Not a Number' }]
+    assert_equal 'Not a Number', f2.symbols.nan
+    assert_equal 'PLUS', f2.symbols.plus
+  end
+
+end

data/test/test_format_input.rb

@@ -0,0 +1,226 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
+include Numerals
+require 'yaml'
+
+class TestFormatInput <  Test::Unit::TestCase # < Minitest::Test
+
+  def assert_same_flt(x, y)
+    assert_equal x.class, y.class, x.to_s
+    assert_equal x.split, y.split, x.to_s
+  end
+
+  def assert_same_float(x, y)
+    assert_equal x.class, y.class, x.to_s
+    assert_equal Float.context.split(x), Float.context.split(y), x.to_s
+  end
+
+  def test_read_special_float
+    f = Format[]
+    assert f.read('NaN', type: Float).nan?
+    assert f.read('NAN', type: Float).nan?
+    assert_raise(RuntimeError) { f[case_sensitive: true].read('NAN', type: Float) }
+    assert_equal Float::INFINITY, f.read('Infinity', type: Float)
+    assert_equal Float::INFINITY, f.read('+Infinity', type: Float)
+    assert_equal Float::INFINITY, f.read('+INFINITY', type: Float)
+    assert_equal -Float::INFINITY, f.read('-Infinity', type: Float)
+    assert_equal -Float::INFINITY, f.read('-INFINITY', type: Float)
+  end
+
+  def test_read_float
+    f = Format[]
+    assert_same_float 1.0, f.read('1', type: Float)
+    assert_same_float 1.2345e-23, f.read('1.2345e-23', type: Float)
+    assert_same_float -1.2345e-23, f.read('-1.2345e-23', type: Float)
+    assert_same_float 1.2345e-23, f.read('1.2345E-23', type: Float)
+    assert_same_float 1.2345e23, f.read('1.2345E23', type: Float)
+    assert_same_float 1.2345e23, f.read('1.2345E+23', type: Float)
+    assert_same_float -1/3.0 - 123456, f.read('-123,456.<3>', type: Float)
+    assert_same_float 4/3.0, f.read('+1.<3>', type: Float)
+    assert_same_float 4/3.0, f.read('+1.333...', type: Float)
+    assert_same_float 0.1, f.read('0.1', type: Float)
+  end
+
+  def test_read_rational
+    f = Format[]
+    assert_equal Rational(1,1), f.read('1.0', type: Rational)
+    assert_equal Rational(-370369,3), f.read('-123,456.<3>', type: Rational)
+    assert_equal Rational(4,3), f.read('+1.<3>', type: Rational)
+    assert_equal Rational(1,10), f.read('0.1', type: Rational)
+    assert_equal Rational(41000000000,333), f.read('1,23123123...', type: Rational)
+  end
+
+  def test_read_decnum
+    f = Format[]
+    Flt::DecNum.context(precision: 20) do
+      assert_same_flt Flt::DecNum('123123123.12312312312'), f.read('1,23123123...', type: Flt::DecNum)
+      assert_same_flt Flt::DecNum('-123456.33333333333333'), f.read('-123,456.<3>', type: Flt::DecNum)
+      assert_same_flt Flt::DecNum('1.3333333333333333333'), f.read('+1.<3>', type: Flt::DecNum)
+      assert_same_flt Flt::DecNum('0.1'), f.read('0.1', type: Flt::DecNum)
+      assert_same_flt Flt::DecNum('0.10000000000000000000'), f[:exact_input].read('0.1', type: Flt::DecNum)
+      assert_same_flt Flt::DecNum('0.10000000000000000000'), f[:exact_input].read('0.1000', type: Flt::DecNum)
+      assert_same_flt Flt::DecNum('0.1'), f[:short].read('0.1000', type: Flt::DecNum)
+      assert_same_flt Flt::DecNum('0.1000'), f[:free].read('0.1000', type: Flt::DecNum)
+    end
+    context = Flt::DecNum.context(precision: 19)
+    assert_same_flt Flt::DecNum('123123123.1231231231'), f.read('1,23123123...', type: context)
+    assert_same_flt Flt::DecNum('-123456.3333333333333'), f.read('-123,456.<3>', type: context)
+    assert_same_flt Flt::DecNum('1.333333333333333333'), f.read('+1.<3>', type: context)
+    assert_same_flt Flt::DecNum('0.1'), f.read('0.1', type: context)
+    assert_same_flt Flt::DecNum('0.1000000000000000000'), f[:exact_input].read('0.1', type: context)
+    assert_same_flt Flt::DecNum('0.1000000000000000000'), f[:exact_input].read('0.1000', type: context)
+    assert_same_flt Flt::DecNum('0.1'), f[:short].read('0.1000', type: context)
+    assert_same_flt Flt::DecNum('0.1000'), f[:free].read('0.1000', type: context)
+  end
+
+  def test_read_binnum
+    f = Format[]
+    Flt::BinNum.context(Flt::BinNum::IEEEDoubleContext) do
+      assert_same_flt Flt::BinNum('1', :short), f.read('1', type: Flt::BinNum)
+      assert_same_flt Flt::BinNum('1', :free), f[:free].read('1', type: Flt::BinNum)
+      assert_same_flt Flt::BinNum('1.00', :free), f[:free].read('1.00', type: Flt::BinNum)
+      assert_same_flt Flt::BinNum('1.2345E-23', :short), f.read('1.2345E-23', type: Flt::BinNum)
+      assert_same_flt Flt::BinNum('-123456.333333333333333', :fixed), f.read('-123,456.<3>', type: Flt::BinNum)
+      assert_same_flt Flt::BinNum('1.33333333333333333333', :fixed), f.read('+1.<3>', type: Flt::BinNum)
+      assert_same_flt Flt::BinNum('0.1', :short), f.read('0.1', type: Flt::BinNum)
+    end
+  end
+
+  def test_read_hexbin
+    context = Flt::BinNum::IEEEDoubleContext
+    Flt::BinNum.context(context) do
+      f = Format[:free, :hexbin]
+      x = Flt::BinNum('0.1', :fixed)
+      assert_same_flt x, f.read("1.999999999999Ap-4", type: Flt::BinNum)
+      assert_same_flt -x, f.read("-1.999999999999Ap-4", type: Flt::BinNum)
+      assert_same_flt x, f.read("19.99999999999Ap-8", type: Flt::BinNum)
+      %w(1.52d02c7e14af6p+76 1.52d02c7e14af7p+76 1.0066666666666p+6 1.0066666666667p+6).each do |txt|
+        x =  Flt::BinNum("0x#{txt}", :fixed)
+        assert_same_flt x, f.read(txt, type: Flt::BinNum)
+      end
+    end
+  end
+
+  def test_read_equidistant_flt
+    # In IEEEDoubleContext
+    # 1E23 is equidistant from 2 Floats: lo & hi
+    # one or the other will be chosen based on the rounding mode
+
+    context = Flt::BinNum::IEEEDoubleContext
+
+    lo = hi = nil
+    Flt::BinNum.context(context) do
+      lo = Flt::BinNum('0x1.52d02c7e14af6p+76', :fixed) # 9.999999999999999E22
+      hi = Flt::BinNum('0x1.52d02c7e14af7p+76', :fixed) # 1.0000000000000001E23
+    end
+
+    f = Format[:exact_input]
+
+    # define rounding mode with :type_options
+    x = f.read('1E23', type: context, type_options: { input_rounding: :half_even })
+    assert_same_flt lo, x
+    x = f.read('1E23', type: context, type_options: { input_rounding: :half_down })
+    assert_equal lo, x
+    x = f.read('1E23', type: context, type_options: { input_rounding: :half_up })
+    assert_equal hi, x
+
+    x = f.read('-1E23', type: context, type_options: { input_rounding: :half_even })
+    assert_equal -lo, x
+    x = f.read('-1E23', type: context, type_options: { input_rounding: :half_down })
+    assert_equal -lo, x
+    x = f.read('-1E23', type: context, type_options: { input_rounding: :half_up })
+    assert_equal -hi, x
+
+    # define rounding mode with Format's Rounding
+    x = f[:half_even].read('1E23', type: context)
+    assert_same_flt lo, x
+    x = f[:half_down].read('1E23', type: context)
+    assert_equal lo, x
+    x = f[:half_up].read('1E23', type: context)
+    assert_equal hi, x
+
+    x = f[:half_even].read('-1E23', type: context)
+    assert_equal -lo, x
+    x = f[:half_down].read('-1E23', type: context)
+    assert_equal -lo, x
+    x = f[:half_up].read('-1E23', type: context)
+    assert_equal -hi, x
+
+    # define rounding mode with Format's input_rounding
+    x = f[input_rounding: :half_even].read('1E23', type: context)
+    assert_same_flt lo, x
+    x = f[input_rounding: :half_down].read('1E23', type: context)
+    assert_equal lo, x
+    x = f[input_rounding: :half_up].read('1E23', type: context)
+    assert_equal hi, x
+
+    x = f[input_rounding: :half_even].read('-1E23', type: context)
+    assert_equal -lo, x
+    x = f[input_rounding: :half_down].read('-1E23', type: context)
+    assert_equal -lo, x
+    x = f[input_rounding: :half_up].read('-1E23', type: context)
+    assert_equal -hi, x
+  end
+
+  def test_read_single_nearest
+    # In IEEEDoubleContext
+    # 64.1 between the floats lo, hi, but is closer to lo
+    # So there's a closet Float that should be chosen for rounding
+
+    context = Flt::BinNum::IEEEDoubleContext
+
+    lo = hi = nil
+    Flt::BinNum.context(context) do
+      lo = Flt::BinNum('0x1.0066666666666p+6', :fixed) # this is nearer to the 64.1 Float
+      hi = Flt::BinNum('0x1.0066666666667p+6', :fixed)
+    end
+
+    f = Format[:exact_input]
+
+    # define rounding mode with type_optoins
+    x = f.read('64.1', type: context, type_options: { input_rounding: :half_even })
+    assert_equal lo, x
+    x = f.read('64.1', type: context, type_options: { input_rounding: :half_down })
+    assert_equal lo, x
+    x = f.read('64.1', type: context, type_options: { input_rounding: :half_up })
+    assert_equal lo, x
+
+    x = f.read('-64.1', type: context, type_options: { input_rounding: :half_even })
+    assert_equal -lo, x
+    x = f.read('-64.1', type: context, type_options: { input_rounding: :half_even })
+    assert_equal -lo, x
+    x = f.read('-64.1', type: context, type_options: { input_rounding: :half_up })
+    assert_equal -lo, x
+
+    # define rounding mode with Format's Rounding
+    x = f[:half_even].read('64.1', type: context)
+    assert_equal lo, x
+    x = f[:half_down].read('64.1', type: context)
+    assert_equal lo, x
+    x = f[:half_up].read('64.1', type: context)
+    assert_equal lo, x
+
+    x = f[:half_even].read('-64.1', type: context)
+    assert_equal -lo, x
+    x = f[:half_down].read('-64.1', type: context)
+    assert_equal -lo, x
+    x = f[:half_up].read('-64.1', type: context)
+    assert_equal -lo, x
+
+    # define rounding mode with Format's input_rounding
+    x = f[input_rounding: :half_even].read('64.1', type: context)
+    assert_equal lo, x
+    x = f[input_rounding: :half_down].read('64.1', type: context)
+    assert_equal lo, x
+    x = f[input_rounding: :half_up].read('64.1', type: context)
+    assert_equal lo, x
+
+    x = f[input_rounding: :half_even].read('-64.1', type: context)
+    assert_equal -lo, x
+    x = f[input_rounding: :half_down].read('-64.1', type: context)
+    assert_equal -lo, x
+    x = f[input_rounding: :half_up].read('-64.1', type: context)
+    assert_equal -lo, x
+
+  end
+
+end

data/test/test_format_mode.rb

@@ -0,0 +1,124 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
+
+require 'numerals/rounding'
+include Numerals
+
+class TestFormatMode <  Test::Unit::TestCase # < Minitest::Test
+
+  def test_format_mode_constructor
+    mode = Format::Mode[:scientific]
+    assert mode.scientific?
+    refute mode.engineering?
+    refute mode.fixed?
+    refute mode.general?
+    assert_equal :scientific, mode.mode
+    assert_equal 1, mode.sci_int_digits
+    assert_equal 1, mode.base_scale
+    assert_equal Format::Mode[:scientific], Format::Mode[:sci]
+    assert_equal Format::Mode[:scientific, sci_int_digits: 2], Format::Mode[:sci, sci_int_digits: 2]
+    assert_equal Format::Mode[:scientific, sci_int_digits: :engineering], Format::Mode[:sci, sci_int_digits: :engineering]
+    assert_equal Format::Mode[:scientific, sci_int_digits: :eng], Format::Mode[:sci, sci_int_digits: :eng]
+
+    mode = Format::Mode[:scientific, sci_int_digits: 0]
+    assert mode.scientific?
+    refute mode.engineering?
+    refute mode.fixed?
+    refute mode.general?
+    assert_equal :scientific, mode.mode
+    assert_equal 0, mode.sci_int_digits
+    assert_equal 1, mode.base_scale
+
+    mode = Format::Mode[:scientific, base_scale: 4]
+    assert mode.scientific?
+    refute mode.engineering?
+    refute mode.fixed?
+    refute mode.general?
+    assert_equal :scientific, mode.mode
+    assert_equal 1, mode.sci_int_digits
+    assert_equal 4, mode.base_scale
+
+    mode = Format::Mode[:engineering]
+    assert mode.engineering?
+    assert mode.scientific?
+    refute mode.fixed?
+    refute mode.general?
+    assert_equal :engineering, mode.sci_int_digits
+    assert_equal :scientific, mode.mode
+    assert_equal 1, mode.base_scale
+    assert_equal Format::Mode[:engineering], Format::Mode[:eng]
+    assert_equal Format::Mode[:engineering], Format::Mode[:scientific, sci_int_digits: :engineering]
+    assert_equal Format::Mode[:engineering], Format::Mode[:scientific, sci_int_digits: :eng]
+
+    mode = Format::Mode[:fixed]
+    refute mode.scientific?
+    refute mode.engineering?
+    assert mode.fixed?
+    refute mode.general?
+    assert_equal :fixed, mode.mode
+    assert_equal 1, mode.base_scale
+    assert_equal Format::Mode[:fixed], Format::Mode[:fix]
+    assert_equal Format::Mode[:fixed, base_scale: 4], Format::Mode[:fix, base_scale: 4]
+
+    mode = Format::Mode[:general]
+    refute mode.scientific?
+    refute mode.engineering?
+    refute mode.fixed?
+    assert mode.general?
+    assert_equal :general, mode.mode
+    assert_equal 1, mode.sci_int_digits
+    assert_equal Format::Mode::DEFAULTS[:max_leading], mode.max_leading
+    assert_equal Format::Mode::DEFAULTS[:max_trailing], mode.max_trailing
+    assert_equal 1, mode.base_scale
+    assert_equal Format::Mode[:general], Format::Mode[]
+    assert_equal Format::Mode[:general], Format::Mode[:gen]
+    assert_equal Format::Mode[:general, sci_int_digits: 0], Format::Mode[:gen, sci_int_digits: 0]
+    assert_equal Format::Mode[:general, sci_int_digits: :engineering], Format::Mode[:gen, sci_int_digits: :engineering]
+    assert_equal Format::Mode[:general, sci_int_digits: :eng], Format::Mode[:gen, sci_int_digits: :eng]
+
+    mode = Format::Mode[:general, max_leading: 8, max_trailing: 2, base_scale: 2, sci_int_digits: 0]
+    refute mode.scientific?
+    refute mode.engineering?
+    refute mode.fixed?
+    assert mode.general?
+    assert_equal :general, mode.mode
+    assert_equal 0, mode.sci_int_digits
+    assert_equal 8, mode.max_leading
+    assert_equal 2, mode.max_trailing
+    assert_equal 2, mode.base_scale
+  end
+
+  def test_copy
+    m1 = Format::Mode[:fixed]
+    m2 = Format::Mode[m1]
+    assert_equal :fixed, m2.mode
+    m2.mode = :scientific
+    assert_equal :fixed, m1.mode
+    assert_equal :scientific, m2.mode
+
+    m2 = m1[:scientific]
+    assert_equal :fixed, m1.mode
+    assert_equal :scientific, m2.mode
+
+    m1 = Format::Mode[:scientific, sci_int_digits: 0]
+    m2 = m1[sci_int_digits: 2]
+    assert_equal 0, m1.sci_int_digits
+    assert_equal 2, m2.sci_int_digits
+    assert_equal :scientific, m1.mode
+    assert_equal :scientific, m2.mode
+
+    m1 = Format::Mode[:scientific, sci_int_digits: 0]
+    m2 = m1.set(sci_int_digits: 2)
+    assert_equal 0, m1.sci_int_digits
+    assert_equal 2, m2.sci_int_digits
+    assert_equal :scientific, m1.mode
+    assert_equal :scientific, m2.mode
+  end
+
+  def test_mutators
+    m1 = Format::Mode[:fixed]
+    m2 = m1.set!(:scientific)
+    assert_equal :scientific, m1.mode
+    assert_equal :scientific, m2.mode
+    assert_equal m1.object_id, m2.object_id
+  end
+end