flt 1.0.0

data/test/test_bin.rb

@@ -0,0 +1,245 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
+
+class TestBin < Test::Unit::TestCase
+
+
+  def setup
+    initialize_context
+  end
+
+  def test_binfloat
+    assert_equal 2, Float::RADIX
+
+    BinNum.context = BinNum::FloatContext
+    assert_equal 23.0, (BinNum(20) + BinNum(3)).to_f
+    assert_equal 1.0/3, (BinNum(1) / BinNum(3)).to_f
+    assert_equal Math.sqrt(2), BinNum(2).sqrt.to_f
+    assert_equal 9, BinNum(345).number_of_digits
+    assert_equal 0.1, BinNum('0.1', :fixed).to_f
+
+    assert_equal 23.0, (BinNum(20) + BinNum(3))
+    assert_equal 1.0/3, (BinNum(1) / BinNum(3))
+    assert_equal Math.sqrt(2), BinNum(2).sqrt
+    assert_equal 0.1, BinNum('0.1', :fixed)
+
+    assert_equal Float::MAX, BinNum.context.maximum_finite
+    assert_equal Float::MIN, BinNum.context.minimum_normal
+
+    numbers = %w{
+      0.123437
+      0.123437E57
+      0.1
+      0.1111111111111111111111111
+      0.1E56
+      0.5 0.125 7333 0.126
+      1069756.78125
+      106975678125E-5
+      2.1E6
+      3E20
+    }
+    numbers += %w{0.12343749827397239423432 3423322.345} if Flt.float_correctly_rounded?
+
+    numbers.each do |n|
+      assert_equal Float(n), BinNum(n, :fixed).to_f
+    end
+
+  end
+
+  def test_text_to_float_rounding
+
+    BinNum.context.precision = 8
+    BinNum.context.rounding = :down
+    assert_equal "11001100", BinNum('0.1', :fixed).split[1].to_s(2)
+    BinNum.context.rounding = :floor
+    assert_equal "11001100", BinNum('0.1', :fixed).split[1].to_s(2)
+    BinNum.context.rounding = :ceiling
+    assert_equal "11001100", BinNum('-0.1', :fixed).split[1].to_s(2)
+    BinNum.context.rounding = :down
+    assert_equal "11001100", BinNum('-0.1', :fixed).split[1].to_s(2)
+
+    BinNum.context.rounding = :up
+    assert_equal "11001101", BinNum('0.1', :fixed).split[1].to_s(2)
+    BinNum.context.rounding = :ceiling
+    assert_equal "11001101", BinNum('0.1', :fixed).split[1].to_s(2)
+    BinNum.context.rounding = :floor
+    assert_equal "11001101", BinNum('-0.1', :fixed).split[1].to_s(2)
+    BinNum.context.rounding = :up
+    assert_equal "11001101", BinNum('-0.1', :fixed).split[1].to_s(2)
+
+    BinNum.context.rounding = :half_up
+    assert_equal "11001101", BinNum('0.1', :fixed).split[1].to_s(2)
+    BinNum.context.rounding = :half_down
+    assert_equal "11001101", BinNum('0.1', :fixed).split[1].to_s(2)
+    BinNum.context.rounding = :half_even
+    assert_equal "11001101", BinNum('0.1', :fixed).split[1].to_s(2)
+    BinNum.context.rounding = :half_up
+    assert_equal "11001101", BinNum('-0.1', :fixed).split[1].to_s(2)
+    BinNum.context.rounding = :half_down
+    assert_equal "11001101", BinNum('-0.1', :fixed).split[1].to_s(2)
+    BinNum.context.rounding = :half_even
+    assert_equal "11001101", BinNum('-0.1', :fixed).split[1].to_s(2)
+
+    BinNum.context.rounding = :half_up
+    assert_equal "10000001", BinNum('128.5', :fixed).split[1].to_s(2)
+    BinNum.context.rounding = :half_down
+    assert_equal "10000000", BinNum('128.5', :fixed).split[1].to_s(2)
+    BinNum.context.rounding = :half_even
+    assert_equal "10000000", BinNum('128.5', :fixed).split[1].to_s(2)
+    BinNum.context.rounding = :half_up
+    assert_equal "10000010", BinNum('129.5', :fixed).split[1].to_s(2)
+    BinNum.context.rounding = :half_down
+    assert_equal "10000001", BinNum('129.5', :fixed).split[1].to_s(2)
+    BinNum.context.rounding = :half_even
+    assert_equal "10000010", BinNum('129.5', :fixed).split[1].to_s(2)
+
+    BinNum.context.rounding = :half_up
+    assert_equal "10000001", BinNum('-128.5', :fixed).split[1].to_s(2)
+    BinNum.context.rounding = :half_down
+    assert_equal "10000000", BinNum('-128.5', :fixed).split[1].to_s(2)
+    BinNum.context.rounding = :half_even
+    assert_equal "10000000", BinNum('-128.5', :fixed).split[1].to_s(2)
+    BinNum.context.rounding = :half_up
+    assert_equal "10000010", BinNum('-129.5', :fixed).split[1].to_s(2)
+    BinNum.context.rounding = :half_down
+    assert_equal "10000001", BinNum('-129.5', :fixed).split[1].to_s(2)
+    BinNum.context.rounding = :half_even
+    assert_equal "10000010", BinNum('-129.5', :fixed).split[1].to_s(2)
+
+    BinNum.context.rounding = :up
+    assert_equal "10000001", BinNum('128.5', :fixed).split[1].to_s(2)
+    BinNum.context.rounding = :down
+    assert_equal "10000000", BinNum('128.5', :fixed).split[1].to_s(2)
+    BinNum.context.rounding = :ceiling
+    assert_equal "10000001", BinNum('128.5', :fixed).split[1].to_s(2)
+    BinNum.context.rounding = :floor
+    assert_equal "10000000", BinNum('128.5', :fixed).split[1].to_s(2)
+
+    BinNum.context.rounding = :up
+    assert_equal "10000001", BinNum('-128.5', :fixed).split[1].to_s(2)
+    BinNum.context.rounding = :down
+    assert_equal "10000000", BinNum('-128.5', :fixed).split[1].to_s(2)
+    BinNum.context.rounding = :ceiling
+    assert_equal "10000000", BinNum('-128.5', :fixed).split[1].to_s(2)
+    BinNum.context.rounding = :floor
+    assert_equal "10000001", BinNum('-128.5', :fixed).split[1].to_s(2)
+
+    BinNum.context.rounding = :up
+    assert_equal "10000010", BinNum('129.5', :fixed).split[1].to_s(2)
+    BinNum.context.rounding = :down
+    assert_equal "10000001", BinNum('129.5', :fixed).split[1].to_s(2)
+    BinNum.context.rounding = :ceiling
+    assert_equal "10000010", BinNum('129.5', :fixed).split[1].to_s(2)
+    BinNum.context.rounding = :floor
+    assert_equal "10000001", BinNum('129.5', :fixed).split[1].to_s(2)
+
+    BinNum.context.rounding = :up
+    assert_equal "10000010", BinNum('-129.5', :fixed).split[1].to_s(2)
+    BinNum.context.rounding = :down
+    assert_equal "10000001", BinNum('-129.5', :fixed).split[1].to_s(2)
+    BinNum.context.rounding = :ceiling
+    assert_equal "10000001", BinNum('-129.5', :fixed).split[1].to_s(2)
+    BinNum.context.rounding = :floor
+    assert_equal "10000010", BinNum('-129.5', :fixed).split[1].to_s(2)
+
+    BinNum.context.precision = 9
+    BinNum.context.rounding = :down
+    assert_equal "110011001", BinNum('0.1', :fixed).split[1].to_s(2)
+    BinNum.context.rounding = :floor
+    assert_equal "110011001", BinNum('0.1', :fixed).split[1].to_s(2)
+    BinNum.context.rounding = :ceiling
+    assert_equal "110011001", BinNum('-0.1', :fixed).split[1].to_s(2)
+    BinNum.context.rounding = :down
+    assert_equal "110011001", BinNum('-0.1', :fixed).split[1].to_s(2)
+
+    BinNum.context.rounding = :up
+    assert_equal "110011010", BinNum('0.1', :fixed).split[1].to_s(2)
+    BinNum.context.rounding = :ceiling
+    assert_equal "110011010", BinNum('0.1', :fixed).split[1].to_s(2)
+    BinNum.context.rounding = :floor
+    assert_equal "110011010", BinNum('-0.1', :fixed).split[1].to_s(2)
+    BinNum.context.rounding = :up
+    assert_equal "110011010", BinNum('-0.1', :fixed).split[1].to_s(2)
+
+    BinNum.context.rounding = :half_up
+    assert_equal "110011010", BinNum('0.1', :fixed).split[1].to_s(2)
+    BinNum.context.rounding = :half_down
+    assert_equal "110011010", BinNum('0.1', :fixed).split[1].to_s(2)
+    BinNum.context.rounding = :half_even
+    assert_equal "110011010", BinNum('0.1', :fixed).split[1].to_s(2)
+    BinNum.context.rounding = :half_up
+    assert_equal "110011010", BinNum('-0.1', :fixed).split[1].to_s(2)
+    BinNum.context.rounding = :half_down
+    assert_equal "110011010", BinNum('-0.1', :fixed).split[1].to_s(2)
+    BinNum.context.rounding = :half_even
+    assert_equal "110011010", BinNum('-0.1', :fixed).split[1].to_s(2)
+
+  end
+
+  def test_text_to_float_exact
+    BinNum.context.exact = :quiet
+    %w{
+      0.1
+      0.12343749827397239423432
+      0.123437
+      0.1111111111111111111111111
+      0.126
+      3423322.345
+    }.each do |n|
+      BinNum.context.flags[Num::Inexact] = false
+      b = BinNum(n, :fixed)
+      assert b.nan?, "BinNum('#{n}') is NaN in exact precision mode"
+      assert BinNum.context.flags[Num::Inexact], "BinNum('#{n}') sets Inexact flag"
+    end
+    %w{
+      0.123437E57
+      0.1E56
+      0.5 0.125 7333
+      1069756.78125
+      106975678125E-5
+      2.1E6
+      3E20
+    }.each do |n|
+      BinNum.context.flags[Num::Inexact] = false
+      b = BinNum(n, :fixed)
+      assert_equal Float(n), BinNum(n, :fixed).to_f
+      assert !b.nan?, "BinNum('#{n}') is not NaN in exact precision mode"
+      assert !BinNum.context.flags[Num::Inexact], "BinNum('#{n}') does not set Inexact flag"
+    end
+  end
+
+  def test_float_to_bin_float
+    %w{
+      0.12343749827397239423432
+      0.123437
+      0.123437E57
+      0.1
+      0.1111111111111111111111111
+      0.1E56
+      0.5 0.125 7333 0.126
+      3423322.345
+      1069756.78125
+      106975678125E-5
+      2.1E6
+      3E20
+      1.1
+      1.1E31
+      -1.1E31
+      0.0
+      -0.0
+    }.each do |n|
+      f = Float(n)
+      assert_equal f, BinNum(f).to_f
+    end
+    nan = 0.0/0.0
+    inf = 1.0/0.0
+    minf = -1.0/0.0
+    assert_equal(-1, BinNum(-0.0).sign)
+    assert_equal(-1, BinNum(minf).sign)
+    assert_equal(+1, BinNum(0.0).sign)
+    assert_equal(+1, BinNum(inf).sign)
+    assert BinNum(nan).nan?, "Float NaN to BinNum produces NaN"
+    assert BinNum(inf).infinite?, "Float +Infinity to BinNum produces Infinite"
+    assert BinNum(minf).infinite?, "Float -Infinity to BinNum produces Infinite"
+  end
+
+end

data/test/test_bin_arithmetic.rb

@@ -0,0 +1,94 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
+
+# These tests assume that Float arithmetic is correctly rounded
+# Random tests using Float as a reference
+class TestBinArithmetic < Test::Unit::TestCase
+
+  def setup
+    initialize_context
+    srand 93831
+    @test_float_data ||= Array.new(1000){random_num(Float)} + singular_nums(Float) # + special_nums(Float)
+  end
+
+  def test_addition
+    float_emulation_context
+    each_pair(@test_float_data) do |x, y|
+      z = x + y
+      assert_equal z, (BinNum(x)+BinNum(y)).to_f
+    end
+  end
+
+  def test_subtraction
+    float_emulation_context
+    each_pair(@test_float_data) do |x, y|
+      z = x - y
+      assert_equal z, (BinNum(x)-BinNum(y)).to_f
+    end
+  end
+
+  def test_multiplication
+    float_emulation_context
+    each_pair(@test_float_data) do |x, y|
+      z = x * y
+      assert_equal z, (BinNum(x)*BinNum(y)).to_f
+    end
+  end
+
+  def test_division
+    float_emulation_context
+    each_pair(@test_float_data) do |x, y|
+      # next if y.abs < Float::EPSILON*x.abs
+      next if y.zero?
+      z = x / y
+      # if z != (BinNum(x)/BinNum(y)).to_f
+      #   puts "x=#{float_split(x).inspect}"
+      #   puts "y=#{float_split(y).inspect}"
+      #   puts "z=#{float_split(z).inspect}"
+      #   puts "->#{(BinNum(x)/BinNum(y)).split.inspect}"
+      # end
+      assert_equal z, (BinNum(x)/BinNum(y)).to_f
+    end
+  end
+
+  def test_power
+    float_emulation_context
+    each_pair(@test_float_data) do |x, y|
+      next if x.zero? && y.zero?
+      x = x.abs
+      xx = BinNum(x)
+      yy = BinNum(y)
+      z = x**y
+      zz = nil
+      begin
+        zz = xx**yy
+      rescue=>err
+        if err.is_a?(Num::Overflow)
+          zz = BinNum.infinity
+        else
+          zz = err.to_s
+        end
+      end
+      ok = true
+      zzz = nil
+      if zz != z
+        # Math.power may not be accurate enough
+        zzz = +BinNum.context(:precision=>512) { xx**yy }
+        if zzz != zz
+          ok = false
+        end
+      end
+      assert ok, "#{x}**#{y} (#{Float.context.split(x).inspect}**#{Float.context.split(y).inspect}) Incorrect: #{zz.split.inspect} instead of #{zzz && zzz.split.inspect}"
+    end
+  end
+
+  def test_sqrt
+    float_emulation_context
+    @test_float_data.each do |x|
+      context = x.class.context
+      x = context.abs(x)
+      z = context.sqrt(x)
+      assert_equal z, BinNum(x).sqrt.to_f
+    end
+  end
+
+end

data/test/test_binfloat_conversion.rb

@@ -0,0 +1,24 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
+
+
+class TestBinfloatConversion < Test::Unit::TestCase
+
+  def setup
+    initialize_context
+  end
+
+  def test_conversions
+    float_emulation_context
+    srand 12322
+    [:half_even, :half_up, :half_down, :down, :up, :floor, :ceiling].each do |rounding|
+      BinNum.context.rounding = rounding
+      1000.times do
+        x = random_float
+        txt = BinNum(x).to_s
+        y = BinNum(txt, :fixed).to_f
+        assert_equal x, y, "FAIL #{Float.context.split(x).inspect} #{rounding} #{Float.context.split(y).inspect} #{x.class}"
+      end
+    end
+  end
+
+end

data/test/test_coercion.rb

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

data/test/test_comparisons.rb

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

data/test/test_dectest.rb

@@ -0,0 +1,216 @@
+require File.expand_path(File.join(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',
+  'power'=>'power',
+  'log10'=>'log10',
+  'exp'=>'exp',
+  'ln'=>'ln'
+}
+# Functions not yet implemented
+PENDING = %w{
+  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
+}
+
+# Excluded tests that we don't currently pass
+EXCEPTIONS = %w{
+  powx1183 powx1184
+  powx4001 powx4002 powx4003 powx4005
+  powx4008 powx4010 powx4012 powx4014
+  logx901  logx902  logx903  logx903  logx905
+  expx901  expx902  expx903  expx905
+  lnx901   lnx902   lnx903   lnx905
+}
+
+
+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| DecNum.class_eval(FLAG_NAMES[f.downcase].to_s)}.compact
+
+              next unless valstemp.grep(/#/).empty?
+
+              $test_id = id
+              funct = FUNCTIONS[original_funct=funct]
+              next if EXCEPTIONS.include?(id)
+              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
+                DecNum.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| DecNum(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 = DecNum(expected) unless result.is_a?(String)
+                end
+                result = 1 if result==true
+                result = 0 if result==false
+                expected_flags = DecNum::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'
+                    DecNum.context.send "#{funct}=", value
+                  when 'maxexponent'
+                    DecNum.context.emax = value
+                  when 'minexponent'
+                    DecNum.context.emin = value
+                  when 'clamp'
+                    DecNum.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