ruby-decimal 0.1.0

data/test/test_coercion.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/helper.rb'
+
+class TestCoercion < Test::Unit::TestCase
+
+
+  def setup
+    initialize_context
+  end
+
+  def test_coerce
+    assert_equal Decimal('7.1'), Decimal('0.1') + 7
+    assert_equal Decimal('7.1'), 7 + Decimal('0.1')
+    assert_equal Decimal('14'), Decimal(7) * 2
+    assert_equal Decimal('14'), 2 * Decimal(7)
+
+    assert_equal Decimal('7.1'), Decimal(7) + Rational(1,10)
+    assert_equal Decimal('7.1'), Rational(1,10) + Decimal(7)
+    assert_equal Decimal('1.4'), Decimal(7) * Rational(2,10)
+    assert_equal Decimal('1.4'), Rational(2,10) * Decimal(7)
+  end
+
+end

data/test/test_comparisons.rb

@@ -0,0 +1,53 @@
+require File.dirname(__FILE__) + '/helper.rb'
+
+class TestComparisons < Test::Unit::TestCase
+
+
+  def setup
+    initialize_context
+  end
+
+  def test_hash
+    assert_equal Decimal('1.1').hash, Decimal('1.1').hash
+    assert_equal Decimal('1.1').hash, (Decimal('1.0')+Decimal('0.1')).hash
+    assert_equal Decimal('1.1',:precision=>10).hash, Decimal('1.1',:precision=>3).hash
+    assert_not_equal Decimal('1.0').hash, Decimal('1.1').hash
+    assert_not_equal Decimal('1.0').hash, 1.0.hash
+    assert_not_equal Decimal('1.0').hash, 1.hash
+
+    assert Decimal('1.1').eql?(Decimal('1.1'))
+    assert Decimal('1.1').eql?(Decimal('1.0')+Decimal('0.1'))
+    assert Decimal('1.1',:precision=>10).eql?(Decimal('1.1',:precision=>3))
+    assert !Decimal('1.1').eql?(Decimal('1.0'))
+    assert !Decimal('1.0').eql?(1.0)
+    assert !Decimal('1.0').eql?(1)
+  end
+
+  def test_equality
+    assert Decimal('1.1') == Decimal('1.1')
+    assert Decimal('1.1') == (Decimal('1.0')+Decimal('0.1'))
+    assert Decimal('1.1',:precision=>10) == Decimal('1.1',:precision=>3)
+    assert !(Decimal('1.1') == Decimal('1.0'))
+    #assert Decimal('1.1') == 1.1
+    #assert Decimal('1.0') == 1.0
+    #assert Decimal('1.0') == BigDecimal.new('1.000')
+    assert Decimal('1.0') == 1
+    assert Decimal('0.1') == Rational(1)/Rational(10)
+
+    assert !(Decimal.nan == Decimal.nan)
+    assert !(Decimal.nan == Decimal('1'))
+    assert !(Decimal.nan == Decimal('0'))
+    assert !(Decimal.nan == Decimal.infinity)
+    #assert !(Decimal.nan == (0.0/0.0))
+
+    assert !(Decimal.infinity(+1) == Decimal.infinity(-1))
+    assert !(Decimal.infinity(+1) == Decimal('0'))
+    assert Decimal.infinity(+1) == Decimal.infinity
+    assert Decimal.infinity(+1) == Decimal('1')/Decimal('0')
+    assert Decimal.infinity(-1) == Decimal('-1')/Decimal('0')
+
+    # TODO: test <=> <= etc.
+  end
+
+
+end

data/test/test_dectest.rb

@@ -0,0 +1,207 @@
+require File.dirname(__FILE__) + '/helper.rb'
+
+ROUNDINGS = {
+  'ceiling' => :ceiling,
+  'down' => :down,
+  'floor' => :floor,
+  'half_down' => :half_down,
+  'half_even' => :half_even,
+  'half_up' => :half_up,
+  'up' => :up,
+  '05up' => :up05
+}
+FUNCTIONS = {
+  'add'=>'add',
+  'divide'=>'divide',
+  'multiply'=>'multiply',
+  'subtract'=>'subtract',
+  'compare'=>'compare',
+  'copyabs'=>'copy_abs',
+  'copynegate'=>'copy_negate',
+  'copysign'=>'copy_sign',
+  'divideint'=>'divide_int',
+  'logb'=>'logb',
+  'minus'=>'minus',
+  'plus'=>'plus',
+  'reduce'=>'reduce',
+  'remainder'=>'remainder',
+  'remaindernear'=>'remainder_near',
+  'scaleb'=>'scaleb',
+  'rescale'=>'rescale',
+  'quantize'=>'quantize',
+  'samequantum'=>'same_quantum?',
+  'tointegral'=>'to_integral_value',
+  'tointegralx'=>'to_integral_exact',
+  'fma'=>'fma',
+  'squareroot'=>'sqrt',
+  'abs'=>'abs',
+  'nextminus'=>'next_minus',
+  'nextplus'=>'next_plus',
+  'nexttoward'=>'next_toward',
+  'tosci'=>'to_sci_string',
+  'toeng'=>'to_eng_string',
+  'class'=>'number_class'
+}
+# Functions not yet implemented
+PENDING = %w{
+  exp
+  power
+  ln
+  log10
+
+  rotate
+  shift
+  trim
+
+  and
+  or
+  xor
+  invert
+
+  max
+  min
+  maxmag
+  minmag
+  comparetotal
+  comparetotmag
+}
+IGNORED = PENDING + %w{
+  copy
+  apply
+}
+
+FLAG_NAMES = {
+  'inexact'=>:Inexact,
+  'rounded'=>:Rounded,
+  'clamped'=>:Clamped,
+  'subnormal'=>:Subnormal,
+  'invalid_operation'=>:InvalidOperation,
+  'underflow'=>:Underflow,
+  'overflow'=>:Overflow,
+  'division_by_zero'=>:DivisionByZero,
+  'division_undefined'=>:InvalidOperation,
+  'division_impossible'=>:DivisionImpossible,
+  'conversion_syntax'=>:ConversionSyntax
+}
+
+
+
+def unquote(txt)
+  if txt[0,1]=="'" && txt[-1,1]=="'"
+    txt = txt[1...-1].gsub("''","'")
+  end
+  if txt[0,1]=='"' && txt[-1,1]=='"'
+    txt = txt[1...-1].gsub('""','"')
+  end
+  #txt = 'NaN' if txt=='#' || txt=='?'
+  txt = 'sNaN' if txt=='#'
+  txt = 'NaN' if txt=='?'
+  txt
+end
+
+class TestBasic < Test::Unit::TestCase
+
+  def test_dec
+   missing = []
+    dir = File.join(File.dirname(__FILE__), 'dectest')
+    dir = nil unless File.exists?(dir)
+    if dir
+      Dir[File.join(dir, '*.decTest')].each do |fn|
+
+        name = File.basename(fn,'.decTest').downcase
+        next if %w{ds dd dq}.include?(name[0,2]) ||
+                 %w{decsingle decdouble decquad testall}.include?(name)
+
+        initialize_context
+
+
+        File.open(fn,'r') do |file|
+          file.each_line do |line|
+            next if line[0,2]=='--' || line.strip.empty?
+
+            if line.include?(' -> ')
+              # test
+              # to do :remove inline comments --... on the right of ->
+              sides = line.split('->')
+              # now split by whitespace but avoid breaking quoted strings (and take care or repeated quotes!)
+              lhs = sides.first.strip.scan(/"(?:[^"]|"")*"|'(?:[^']|'')*'|\S+/)
+              id = lhs.first
+              funct = lhs[1].downcase
+              valstemp = lhs[2..-1]
+              rhs = sides.last.strip.split
+              ans = rhs.first
+              flags = rhs[1..-1].map{|f| Decimal.class_eval(FLAG_NAMES[f.downcase].to_s)}.compact
+
+              next unless valstemp.grep(/#/).empty?
+
+              $test_id = id
+              funct = FUNCTIONS[original_funct=funct]
+              if funct
+                # do test
+                msg = "Test #{id}: #{funct}(#{valstemp.join(',')}) = #{ans}"
+                #File.open('dectests.txt','a'){|f| f.puts msg}
+                expected = result = result_flags = nil
+                Decimal.local_context do |context|
+                  context.flags.clear!
+                  exact_input = !['apply','to_sci_string', 'to_eng_string'].include?(funct)
+                  if exact_input
+                    p = context.precision
+                    context.exact = true
+                  end
+                  valstemp.map!{|v| Decimal(unquote(v))}
+                  context.precision = p if exact_input
+                  result = context.send(funct, *valstemp)
+                  result_flags = context.flags.dup
+                  expected = unquote(ans)
+                  context.exact = true
+                  expected = Decimal(expected) unless result.is_a?(String)
+                end
+                result = 1 if result==true
+                result = 0 if result==false
+                expected_flags = Decimal::Flags(*flags)
+                if ans!='?'
+                  assert_equal expected.to_s, result.to_s, msg
+                end
+                assert_equal expected_flags, result_flags, msg
+
+              else
+                missing << original_funct unless IGNORED.include?(original_funct) || missing.include?(original_funct)
+              end
+
+            elsif line.include?(':')
+              # directive
+              funct,value = line.split(':').map{|x| x.strip.downcase}
+              case funct
+                when 'rounding'
+                  value = ROUNDINGS[value]
+                else
+                  value = value.to_i
+              end
+              if value.nil?
+                #raise "error"
+                # to do: skip untill next valid value of same funct
+              else
+                case funct
+                  when 'rounding','precision'
+                    Decimal.context.send "#{funct}=", value
+                  when 'maxexponent'
+                    Decimal.context.emax = value
+                  when 'minexponent'
+                    Decimal.context.emin = value
+                  when 'clamp'
+                    Decimal.context.clamp = (value==0 ? false : true)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+
+    # assert_empty missing
+    # In Ruby 1.8 there's no assert_empty
+    assert missing.empty?, "#{missing.inspect} is not empty"
+
+  end
+
+end

data/test/test_define_conversions.rb

@@ -0,0 +1,100 @@
+require File.dirname(__FILE__) + '/helper.rb'
+
+class TestDefineConversions < Test::Unit::TestCase
+
+
+  def setup
+    initialize_context
+  end
+
+  def test_convert_to
+    d = Decimal('1.1')
+    x = d.convert_to(Rational)
+    assert x.is_a?(Rational)
+    assert_equal d.to_r, x
+
+    d = Decimal('11')
+    x = d.convert_to(Integer)
+    assert x.is_a?(Integer)
+    assert_equal d.to_i, x
+
+    d = Decimal('11')
+    x = d.convert_to(Float)
+    assert x.is_a?(Float)
+    assert_equal d.to_f, x
+  end
+
+
+  def test_big_decimal_conversions
+
+    Decimal.local_context do
+
+      Decimal.context.define_conversion_from(BigDecimal) do |x, context|
+        Decimal(x.to_s) # or use x.split etc.
+      end
+      assert Decimal('0') == BigDecimal.new('0')
+      assert_equal BigDecimal.new('0'), Decimal('0')
+      assert_equal BigDecimal.new('1.2345'), Decimal('1.2345')
+      assert_equal BigDecimal.new('-1.2345'), Decimal('-1.2345')
+      assert_equal BigDecimal.new('1.2345'), Decimal('0.0012345000E3')
+      assert_equal Decimal('7.1'), BigDecimal.new('7')+Decimal('0.1')
+      assert_equal Decimal('7.1'), Decimal('7')+BigDecimal.new('0.1')
+      assert_equal Decimal('1.1'), Decimal(BigDecimal.new('1.1'))
+      assert Decimal(BigDecimal.new('1.1')).is_a?(Decimal)
+
+      Decimal.context.define_conversion_to(BigDecimal) do |x|
+        BigDecimal.new(x.to_s) # TODO: use x.split and handle special values
+      end
+
+      ['0.1', '-0.1', '0.0', '1234567.1234567', '-1234567.1234567', '1.234E7', '1.234E-7'].each do |n|
+        f = BigDecimal.new(n)
+        d = Decimal(n)
+        c = d.convert_to(BigDecimal)
+        assert c.is_a?(BigDecimal)
+        assert_equal f, c
+      end
+    end
+
+    assert_raise(TypeError) { Decimal('0') == BigDecimal.new('0') }
+    assert_not_equal BigDecimal.new('0'), Decimal('0')
+    assert_not_equal BigDecimal.new('1.2345'), Decimal('1.2345')
+    assert_not_equal BigDecimal.new('-1.2345'), Decimal('-1.2345')
+    assert_not_equal BigDecimal.new('1.2345'), Decimal('0.0012345000E3')
+    assert_raise(TypeError) { BigDecimal.new('7')+Decimal('0.1') }
+    assert_raise(TypeError) { Decimal('7')+BigDecimal.new('0.1') }
+    assert_raise(TypeError) { Decimal(BigDecimal.new('1.1')) }
+
+    ['0.1', '-0.1', '0.0', '1234567.1234567', '-1234567.1234567', '1.234E7', '1.234E-7'].each do |n|
+      assert_raise(TypeError) { Decimal(n).convert_to(BigDecimal) }
+    end
+
+  end
+
+  def test_float_conversions
+
+    # Exact Float to Decimal conversion limited to context precision
+    # => Decimal('0.1') != Decimal(0.1) unless precision is low enough
+    Decimal.context.define_conversion_from(Float) do |x, context|
+      s,e = Math.frexp(x)
+      significand = Math.ldexp(s, Float::MANT_DIG).to_i
+      exponent = e - Float::MANT_DIG
+      # the number is (as a Rational) significand * exponent**Float::RADIX
+      Decimal(significand*(Float::RADIX**exponent ))
+    end
+
+    assert_equal 0.0, Decimal('0')
+    assert_equal Decimal('0'), 0.0
+    assert_equal 1234.5, Decimal('1234.5')
+    assert_equal Decimal('1234.5'), 1234.5
+    assert_equal(-1234.5, Decimal('-1234.5'))
+    assert_equal 1234.5, Decimal('0.0012345000E6')
+    assert_equal Decimal('7.1'), 7.0+Decimal('0.1')
+    Decimal.local_context(:precision=>12) do
+      assert_equal Decimal('7.1'), Decimal('7')+0.1
+    end
+    assert_equal Decimal('11'), Decimal(11.0)
+    assert Decimal(11.0).is_a?(Decimal)
+
+  end
+
+end

data/test/test_exact.rb

@@ -0,0 +1,32 @@
+require File.dirname(__FILE__) + '/helper.rb'
+
+
+class TestExact < Test::Unit::TestCase
+
+
+  def setup
+    initialize_context
+  end
+
+
+  def test_exact
+
+    Decimal.context.exact = true
+
+    assert_equal Decimal("9"*100+"E-50"), Decimal('1E50')-Decimal('1E-50')
+    assert_equal Decimal(2),Decimal(6)/Decimal(3)
+    assert_equal Decimal('1.5'),Decimal(6)/Decimal(4)
+    assert_equal Decimal('15241578780673678546105778281054720515622620750190521'), Decimal('123456789123456789123456789')*Decimal('123456789123456789123456789')
+    assert_nothing_raised(Decimal::Inexact){ Decimal(6)/Decimal(4) }
+    assert_raise(Decimal::Inexact){ Decimal(1)/Decimal(3) }
+    # assert_raise(Decimal::Inexact){ Decimal(2).sqrt }
+
+    assert_equal Decimal(2), Decimal('4').sqrt
+    assert_equal Decimal(4), Decimal('16').sqrt
+    assert_raise(Decimal::Inexact){ Decimal(2).sqrt }
+
+
+  end
+
+
+end

data/test/test_flags.rb

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + '/helper.rb'
+
+
+class TestFlags < Test::Unit::TestCase
+
+  def test_flags
+    f = DecimalSupport::Flags(:flag_one, :flag_three)
+    assert_equal "[:flag_one, :flag_three]",  f.to_a.sort_by{|flg| flg.to_s}.inspect
+    f.values = DecimalSupport::FlagValues(:flag_one, :flag_two, :flag_three)
+    assert_equal "DecimalSupport::Flags[flag_one, flag_three] (0x5)", f.inspect
+    f[:flag_two] = true
+    assert_equal "DecimalSupport::Flags[flag_one, flag_two, flag_three] (0x7)", f.inspect
+    f[:flag_one] = false
+    assert_equal "DecimalSupport::Flags[flag_two, flag_three] (0x6)", f.inspect
+    f.clear!
+    assert_equal "DecimalSupport::Flags[] (0x0)", f.inspect
+    f << [:flag_one,:flag_two]
+    assert_equal "DecimalSupport::Flags[flag_one, flag_two] (0x3)", f.inspect
+    g = DecimalSupport::Flags(f.values)
+    g.bits = f.bits
+    assert_equal "DecimalSupport::Flags[flag_one, flag_two] (0x3)", g.inspect
+    assert g==f
+    g.set!
+    assert_equal "DecimalSupport::Flags[flag_one, flag_two, flag_three] (0x7)", g.inspect
+    assert g!=f
+
+    assert DecimalSupport::Flags(:flag_one, :flag_three)==DecimalSupport::Flags(:flag_three, :flag_one)
+    assert DecimalSupport::Flags(:flag_one, :flag_three)!=DecimalSupport::Flags(:flag_one)
+
+
+
+  end
+
+end