long-decimal 0.01.00 → 0.01.01

data/test/testlongdeclib.rb

@@ -2,8 +2,8 @@
 #
 # library for testlongdecimal.rb
 #
-# CVS-ID:    $Header: /var/cvs/long-decimal/long-decimal/test/testlongdeclib.rb,v 1.7 2006/04/10 21:47:02 bk1 Exp $
-# CVS-Label: $Name: ALPHA_01_00 $
+# CVS-ID:    $Header: /var/cvs/long-decimal/long-decimal/test/testlongdeclib.rb,v 1.15 2006/05/01 12:22:12 bk1 Exp $
+# CVS-Label: $Name: ALPHA_01_01 $
 # Author:    $Author: bk1 $ (Karl Brodowsky)
 #
 
@@ -14,7 +14,7 @@ load "lib/long-decimal.rb"
 #
 module TestLongDecHelper
 
-  @RCS_ID='-$Id: testlongdeclib.rb,v 1.7 2006/04/10 21:47:02 bk1 Exp $-'
+  @RCS_ID='-$Id: testlongdeclib.rb,v 1.15 2006/05/01 12:22:12 bk1 Exp $-'
 
 
   #
@@ -42,13 +42,19 @@ module TestLongDecHelper
   #
   def assert_equal_rounded(expected, actual, message="")
     _wrap_assertion {
-      full_message = build_message(message, "Expected <?> to match <?>", actual, expected)
+      lhs = (expected - actual).abs()*2000
+      rhs = actual.unit.abs()*1001
+      full_message = build_message(message, "Expected <?> to match <?> (lhs=#{lhs} rhs=#{rhs})", actual, expected)
       assert_block(full_message) {
-        prec = actual.scale
-	ed   = expected.round_to_scale(prec, LongMath::ROUND_HALF_FLOOR)
-	eu   = expected.round_to_scale(prec, LongMath::ROUND_HALF_CEILING)
-	# puts("ed=#{ed} eu=#{eu} e=#{expected} a=#{actual}")
-	ed <= actual && actual <= eu
+        #       prec = actual.scale
+        #       ed   = expected.round_to_scale(prec, LongMath::ROUND_HALF_FLOOR)
+        #       eu   = expected.round_to_scale(prec, LongMath::ROUND_HALF_CEILING)
+        #       # puts("ed=#{ed} eu=#{eu} e=#{expected} a=#{actual}")
+        #       ed <= actual && actual <= eu
+
+        # (expected - actual).abs < (actual.unit()/2)*(1001/1000)
+        # (expected - actual).abs()*2000 < actual.unit()*1001
+        lhs < rhs
       }
     }
   end
@@ -61,12 +67,12 @@ module TestLongDecHelper
   def assert_small_interval(yd, yu, y, message="")
     _wrap_assertion {
       if (yu < yd) then
-	yd, yu = yu, yd
+        yd, yu = yu, yd
       end
       full_message = build_message(message, "Expected interval [<?>, <?>] to be one unit at most and to contain <?>", yd, yu, y)
       assert_block(full_message) {
         prec = y.scale
-	yd <= y && y <= yu && yu - yd <= y.unit
+        yd <= y && y <= yu && yu - yd <= y.unit
       }
     }
   end
@@ -168,6 +174,99 @@ module TestLongDecHelper
 
   end
 
+  #
+  # helper method for test_exp2
+  # tests if exp2(x) with precision prec is calculated correctly
+  #
+  def check_exp2_floated(x, prec)
+
+    print "."
+    $stdout.flush
+
+    # make sure x is LongDecimal
+    x0 = x
+    x = x.to_ld
+    # calculate y = exp(x)
+    # eprec = prec+1
+    y  = LongMath.exp2(x, prec)
+    yy = LongMath.exp2(x, prec+10)
+    #  assert_equal(yy.round_to_scale(y.scale, LongDecimal::ROUND_HALF_DOWN), y, "x=#{x} y=#{y} yy=#{yy}")
+    assert_equal_rounded(yy, y, "x=#{x} y=#{y} yy=#{yy}")
+
+    # compare y against z = exp(x) calculated using regular floating point arithmetic
+    zf = 2.0 ** (x.to_f)
+    yf = y.to_f
+    assert((yf - zf).abs <= [ y.unit, zf.abs / 1e9 ].max, "y=#{yf.to_s} and z=#{zf.to_s} should be almost equal x=#{x}")
+
+    # check by taking log(exp(x))
+    # we have to take into account that we might not have enough
+    # significant digits, so we have to go down with the precision
+    if (y > 0) then
+      lprec = prec - 1
+      if (y < 1) then
+        l10 = (Math.log(y.to_f) / Math.log(10)).round
+        lprec += l10
+      end
+      df = 1
+      if (lprec < 0)
+        df += lprec.abs
+        lprec = 0
+      end
+      z = LongMath.log2(y, lprec)
+      delta = z.unit * df
+      assert((x - z).abs <= delta, "x=#{x.to_s} and z=#{z.to_s} should be almost equal (#{(x-z).abs.inspect} < d=#{delta.inspect} y=#{y.to_s} lprec=#{lprec} prec=#{prec})")
+    end
+
+  end
+
+
+  #
+  # helper method for test_exp10
+  # tests if exp10(x) with precision prec is calculated correctly
+  #
+  def check_exp10_floated(x, prec)
+
+    print "."
+    $stdout.flush
+
+    # make sure x is LongDecimal
+    x0 = x
+    x = x.to_ld
+    # calculate y = exp(x)
+    # eprec = prec+1
+    y  = LongMath.exp10(x, prec)
+    yy = LongMath.exp10(x, prec+10)
+    #  assert_equal(yy.round_to_scale(y.scale, LongDecimal::ROUND_HALF_DOWN), y, "x=#{x} y=#{y} yy=#{yy}")
+    assert_equal_rounded(yy, y, "x=#{x} y=#{y} yy=#{yy}")
+
+    if (y.abs < LongMath::MAX_FLOATABLE) then
+      # compare y against z = exp(x) calculated using regular floating point arithmetic
+      zf = 10.0 ** (x.to_f)
+      yf = y.to_f
+      assert((yf - zf).abs <= [ y.unit, zf.abs / 1e9 ].max, "y=#{yf.to_s} and z=#{zf.to_s} should be almost equal x=#{x}")
+    end
+
+    # check by taking log(exp(x))
+    # we have to take into account that we might not have enough
+    # significant digits, so we have to go down with the precision
+    if (y > 0) then
+      lprec = prec - 1
+      if (y < 1) then
+        l10 = (Math.log(y.to_f) / Math.log(10)).round
+        lprec += l10
+      end
+      df = 1
+      if (lprec < 0)
+        df += lprec.abs
+        lprec = 0
+      end
+      z = LongMath.log10(y, lprec)
+      delta = z.unit * df
+      assert((x - z).abs <= delta, "x=#{x.to_s} and z=#{z.to_s} should be almost equal (#{(x-z).abs.inspect} < d=#{delta.inspect} y=#{y.to_s} lprec=#{lprec} prec=#{prec})")
+    end
+
+  end
+
   #
   # helper method for test_lm_power_xint
   # tests if exp(x) with precision prec is calculated correctly
@@ -283,11 +382,14 @@ module TestLongDecHelper
     end
 
     # check by doing calculation with different internal rounding modes.  They should not differ.
-    yd = LongMath.log_internal(x, prec, nil, nil, LongDecimal::ROUND_DOWN)
-    yu = LongMath.log_internal(x, prec, nil, nil, LongDecimal::ROUND_UP)
+    # yd = LongMath.log_internal(x, prec, nil, nil, LongDecimal::ROUND_DOWN)
+    # yu = LongMath.log_internal(x, prec, nil, nil, LongDecimal::ROUND_UP)
+    yd = LongMath.log_internal(x, prec, nil, nil, LongDecimal::ROUND_FLOOR)
+    yu = LongMath.log_internal(x, prec, nil, nil, LongDecimal::ROUND_CEILING)
     # assert_equal(yd, yu, "the result yd/yu should not depend on the internal rounding mode yd=#{yd} yu=#{yu} y=#{y} p=#{prec} d=#{(yd-yu).to_f.to_s}")
     # assert_equal(y,  yu, "the result y/yu  should not depend on the internal rounding mode yd=#{yd} yu=#{yu} y=#{y} p=#{prec} d=#{(y -yu).to_f.to_s}")
     assert_small_interval(yd, yu, y, "the result y/yu  should not depend on the internal rounding mode x0=#{x0} x=#{x} p=#{prec} d=#{(yd-yu).to_f.to_s}")
+    return y
   end
 
   #
@@ -296,7 +398,11 @@ module TestLongDecHelper
   #
   def check_power_floated(x, y, prec)
 
-    # puts("start: check_power_floated: x=#{x} y=#{y} prec=#{prec}\n")
+    print "."
+    # print("\nstart: check_power_floated: x=#{x} y=#{y} prec=#{prec}")
+    # t0 = Time.new
+    $stdout.flush
+
     # make sure x and y are LongDecimal
     x0 = x
     x = x.to_ld
@@ -305,11 +411,13 @@ module TestLongDecHelper
     # calculate z = x**y
     z = LongMath.power(x, y, prec)
 
-    # compare y against w = x**y calculated using regular floating point arithmetic
-    w = (x.to_f) ** (y.to_f)
-    zf = z.to_f
-    # assert((zf - w).abs / [zf.abs, w.abs, Float::MIN].max < 1e-9, "z=#{zf.to_s} and w=#{w.to_s} should be almost equal x=#{x} y=#{y}")
-    assert((zf - w).abs <= [ z.unit, zf.abs / 1e9 ].max, "z=#{zf.to_s} and w=#{w.to_s} should be almost equal x=#{x} y=#{y}")
+    if (z.abs < LongMath::MAX_FLOATABLE)
+      # compare y against w = x**y calculated using regular floating point arithmetic
+      w = (x.to_f) ** (y.to_f)
+      zf = z.to_f
+      # assert((zf - w).abs / [zf.abs, w.abs, Float::MIN].max < 1e-9, "z=#{zf.to_s} and w=#{w.to_s} should be almost equal x=#{x} y=#{y}")
+      assert((zf - w).abs <= [ z.unit, zf.abs / 1e9 ].max, "z=#{zf.to_s} and w=#{w.to_s} should be almost equal x=#{x} y=#{y}")
+    end
 
     # check by taking log(z) = y * log(x)
     # we have to take into account that we might not have enough
@@ -329,15 +437,15 @@ module TestLongDecHelper
         lprec = 0
       end
       l10y = 0
-      if (y > 1) then
-        l10y = (Math.log(y.to_f) / Math.log(10)).ceil
+      if (y.abs > 1) then
+        l10y = (Math.log(y.abs.to_f) / Math.log(10)).ceil
       end
       u = LongMath.log(z, lprec)
       v = LongMath.log(x, lprec+l10y)
       yv = (y*v).round_to_scale(lprec, LongDecimal::ROUND_HALF_DOWN)
       assert((u - yv).abs <= unit, "u=#{u} and yv=y*v=#{yv} should be almost equal (unit=#{unit} x=#{x.to_s} y=#{y.to_s} z=#{z.to_s} u=#{u.to_s} v=#{v.to_s} lprec=#{lprec} prec=#{prec})")
     end
-    # puts("ok check_power_floated: x=#{x} y=#{y} prec=#{prec}\n")
+    # puts("ok check_power_floated: x=#{x} y=#{y} prec=#{prec} t=#{Time.new - t0}\n")
 
   end
 
@@ -393,7 +501,7 @@ module TestLongDecHelper
         eprec = [ eprec - l10, 0 ].max
       end
 
-      z  = LongMath.power(10.to_ld, y, eprec)
+      z  = LongMath.power(10, y, eprec)
       zz = LongMath.exp10(y, eprec)
       u  = z.unit
       v  = y.unit
@@ -402,6 +510,8 @@ module TestLongDecHelper
       assert((x - z).abs <= delta, "x=#{x.to_s} and z=#{z.to_s} should be almost equal (y=#{y.to_s} eprec=#{eprec} prec=#{prec} delta=#{delta})")
       # assert((x - z).abs <= z.unit, "x=#{x.to_s} and z=#{z.to_s} should be almost equal (y=#{y.to_s} eprec=#{eprec} prec=#{prec})")
     end
+    
+    return y
 
   end
 
@@ -448,10 +558,10 @@ module TestLongDecHelper
         yf = y.to_f
         zl = z.to_ld(y.scale)
         df = [ 1e-13, z.abs / 1e10 ].max
-        dl = y.unit
+        dl = y.unit.abs
         delta = [ df, dl ].max
         # assert((yf - z).abs / [yf.abs, z.abs, Float::MIN].max < 1e-9, "y=#{yf.to_s} and z=#{z.to_s} should be almost equal x=#{x}")
-        assert((yf - z).abs < delta, "y=#{yf.to_s} and z=#{z.to_s} should be almost equal (x=#{x} delta=#{delta}")
+        assert((yf - z).abs < delta.to_f, "y=#{yf.to_s} and z=#{z.to_s} should be almost equal (x=#{x} delta=#{delta}")
       end
     end
 
@@ -480,6 +590,7 @@ module TestLongDecHelper
       delta = [ v*z, u ].max
       assert((x - z).abs <= delta, "x=#{x.to_s} and z=#{z.to_s} should be almost equal (y=#{y.to_s} eprec=#{eprec} prec=#{prec} delta=#{delta})")
     end
+    return y
 
   end
 

data/test/testrandlib.rb

@@ -0,0 +1,87 @@
+#!/usr/bin/env ruby
+#
+# testrandlib.rb -- runit test for long-decimal.rb
+#
+# CVS-ID:    $Header: /var/cvs/long-decimal/long-decimal/test/testrandlib.rb,v 1.3 2006/04/30 20:49:54 bk1 Exp $
+# CVS-Label: $Name: ALPHA_01_01 $
+# Author:    $Author: bk1 $ (Karl Brodowsky)
+#
+
+require "crypt/ISAAC"
+
+#
+# test class for LongDecimal and LongDecimalQuot
+#
+module TestRandomHelper
+
+  @RCS_ID='-$Id: testrandlib.rb,v 1.3 2006/04/30 20:49:54 bk1 Exp $-'
+
+  @@r1 = Crypt::ISAAC.new
+  @@r2 = Crypt::ISAAC.new
+  @@r3 = Crypt::ISAAC.new
+  @@r4 = Crypt::ISAAC.new
+
+  def arr_with_sq(arr)
+    result = arr.map do |x|
+      if (x >= 0) then
+	[ LongMath.sqrt(x, x.scale, LongMath::ROUND_HALF_UP), x, x.square ]
+      else
+	x
+      end
+    end
+    result.flatten
+  end
+
+  def arr_with_neg(arr)
+    arr.map { |x| [x, -x] }.flatten
+  end
+
+  def arr_with_inv(arr)
+    result = arr.map do |x|
+      if (x.zero? || x.one?) then
+        x
+      else
+        [x, x.inverse.to_ld(x.scale*2)]
+      end
+    end
+    result.flatten
+  end
+
+  #
+  # get random numbers in an array
+  # xb is between 0 and 1000
+  # xm is between 1 and 2
+  # xs is between 0 and 1
+  # all three are LongDecimal and have the same digits after the decimal point
+  # out of these an array of up to 36 values is formed and returned as a[0]
+  # are found by adding sqrt and square of of these to the array, if >= 0
+  # adding the reciprocal of each non-zero entry of this array to array
+  # and adding negated value of each entry to the array, then sorting
+  # array and removing duplicates
+  # a[1] is an integer between 0 and 120 used as precision for exp
+  # a[2] is an integer between 1 and 121 used as precision for log
+  # a[3] is an integer between 0 and 120+(x.scale)/2 used as precision for sqrt
+  # a[4] is an integer between 0 and 60 used as precision for power
+  #
+  def random_arr
+    x0 = @@r1.rand(1000)
+    x1 = @@r2.rand(1000)
+    x2 = @@r2.rand(100)+3
+    x3 = @@r3.rand(1000)
+    x4 = @@r3.rand(100)+4
+    x5 = @@r4.rand(1000)
+    x6 = @@r4.rand(100)+5
+    xs = LongDecimal(x1, x2) + LongDecimal(x3, x4) + LongDecimal(x5, x6)
+    xm = 1 + xs
+    xb = x0 + xs
+    eprec = @@r1.rand(120)
+    lprec = eprec+1
+    sprec = eprec+((xb.scale+1)>>1)
+    pprec = lprec >> 1
+    arr = arr_with_neg(arr_with_inv(arr_with_sq([xb, xm, xs]))).sort.uniq
+    return [ arr, eprec, lprec, sprec, pprec, xb.scale ]
+  end
+
+end
+
+# end of file testrandlib.rb

data/test/testrandom.rb

@@ -1,9 +1,9 @@
 #!/usr/bin/env ruby
 #
-# testlongdecimal.rb -- runit test for long-decimal.rb
+# testrandom.rb -- runit test for long-decimal.rb
 #
-# CVS-ID:    $Header: /var/cvs/long-decimal/long-decimal/test/testrandom.rb,v 1.5 2006/04/10 21:47:02 bk1 Exp $
-# CVS-Label: $Name: ALPHA_01_00 $
+# CVS-ID:    $Header: /var/cvs/long-decimal/long-decimal/test/testrandom.rb,v 1.10 2006/04/30 20:49:54 bk1 Exp $
+# CVS-Label: $Name: ALPHA_01_01 $
 # Author:    $Author: bk1 $ (Karl Brodowsky)
 #
 
@@ -13,39 +13,39 @@ require "runit/testsuite"
 require "crypt/ISAAC"
 
 load "test/testlongdeclib.rb"
+load "test/testrandlib.rb"
 
 #
 # test class for LongDecimal and LongDecimalQuot
 #
-class TestLongDecimal_class < RUNIT::TestCase
+class TestRandom_class < RUNIT::TestCase
   include TestLongDecHelper
+  include TestRandomHelper
 
-  @RCS_ID='-$Id: testrandom.rb,v 1.5 2006/04/10 21:47:02 bk1 Exp $-'
+  @RCS_ID='-$Id: testrandom.rb,v 1.10 2006/04/30 20:49:54 bk1 Exp $-'
 
   # for how many seconds should this test run? change to different
   # value on demand
   @@duration = 1000000
 
-  @@r1 = Crypt::ISAAC.new
-  @@r2 = Crypt::ISAAC.new
-  @@r3 = Crypt::ISAAC.new
-  @@r4 = Crypt::ISAAC.new
-
-  def check_exp_log_rand(x, eprec, lprec)
-    check_exp_log_half(x, eprec, lprec)
-    xx = x.inverse.to_ld(x.scale*2)
-    check_exp_log_half(xx, eprec, lprec)
-  end
-
-  def check_exp_log_half(x, eprec, lprec)
-    if (x <= LongMath::MAX_EXP_ABLE)
-      check_exp_floated(x, eprec)
-      check_exp_floated(-x, eprec)
-    end
-    if (x > 0)
-      check_log_floated(x, lprec)
-      check_log2_floated(x, lprec)
-      check_log10_floated(x, lprec)
+  def check_exp_log_rand(arr, eprec, lprec, pprec, sprec, sc, cnt)
+    arr.each do |x|
+      @scnt += 1
+      puts("\ncnt=#{cnt} scnt=#{@scnt} x=#{x} ep=#{eprec} lp=#{lprec} sp=#{sprec} pp=#{pprec}\n")
+      if (x.abs <= LongMath::MAX_EXP_ABLE)
+	check_exp_floated(x, eprec)
+	check_exp2_floated(x, pprec)
+	check_exp10_floated(x, pprec)
+      end
+      if (x > 0)
+	check_log_floated(x, lprec)
+	check_log2_floated(x, lprec)
+	check_log10_floated(x, lprec)
+      end
+      if (x > 0)
+	xr = x.round_to_scale(sc, LongMath::ROUND_HALF_UP)
+	check_sqrt_with_remainder(xr, sprec, "x=#{x} p=#{sprec}")
+      end
     end
   end
 
@@ -54,28 +54,13 @@ class TestLongDecimal_class < RUNIT::TestCase
   #
   def test_random
     cnt = 0
+    @scnt = 0
     t0  = Time.new
     while (true) do
       d = Time.new - t0
       break if d >= @@duration
-      x0 = @@r1.rand(1000)
-      x1 = @@r2.rand(1000)
-      x2 = @@r2.rand(100)+3
-      x3 = @@r3.rand(1000)
-      x4 = @@r3.rand(100)+4
-      x5 = @@r4.rand(1000)
-      x6 = @@r4.rand(100)+5
-      xs = LongDecimal(x1, x2) + LongDecimal(x3, x4) + LongDecimal(x5, x6)
-      xm = 1 + xs
-      x  = x0 + xs
-      eprec = @@r1.rand(120)
-      lprec = eprec+1
-      sprec = eprec+((x.scale+1)>>1)
-      puts("cnt=#{cnt} x=#{x} sc=#{x.scale} ep=#{eprec} lp=#{lprec} sp=#{sprec}\n")
-      check_exp_log_rand(xs, eprec, lprec)
-      check_exp_log_rand(xm, eprec, lprec)
-      check_exp_log_rand(x , eprec, lprec)
-      check_sqrt_with_remainder(x, sprec, "x=#{x} p=#{sprec}")
+      arr, eprec, lprec, sprec, pprec, sc = random_arr
+      check_exp_log_rand(arr, eprec, lprec, pprec, sprec, sc, cnt)
       cnt += 1
     end
     puts("done #{cnt} tests\n")
@@ -83,6 +68,6 @@ class TestLongDecimal_class < RUNIT::TestCase
 
 end
 
-RUNIT::CUI::TestRunner.run(TestLongDecimal_class.suite)
+RUNIT::CUI::TestRunner.run(TestRandom_class.suite)
 
-# end of file testlongdecimal.rb
+# end of file testrandom.rb