long-decimal 0.00.21 → 0.00.22

data/test/testlongdecimal.rb

@@ -2,8 +2,8 @@
 #
 # testlongdecimal.rb -- runit test for long-decimal.rb
 #
-# CVS-ID:    $Header: /var/cvs/long-decimal/long-decimal/test/testlongdecimal.rb,v 1.28 2006/04/05 23:33:54 bk1 Exp $
-# CVS-Label: $Name: PRE_ALPHA_0_21 $
+# CVS-ID:    $Header: /var/cvs/long-decimal/long-decimal/test/testlongdecimal.rb,v 1.32 2006/04/07 22:26:08 bk1 Exp $
+# CVS-Label: $Name: PRE_ALPHA_0_22 $
 # Author:    $Author: bk1 $ (Karl Brodowsky)
 #
 
@@ -11,47 +11,16 @@ require "runit/testcase"
 require "runit/cui/testrunner"
 require "runit/testsuite"
 
-load "lib/long-decimal.rb"
+# load "lib/long-decimal.rb"
+load "test/testlongdeclib.rb"
 
 #
 # test class for LongDecimal and LongDecimalQuot
 #
 class TestLongDecimal_class < RUNIT::TestCase
+  include TestLongDecHelper
 
-  @RCS_ID='-$Id: testlongdecimal.rb,v 1.28 2006/04/05 23:33:54 bk1 Exp $-'
-
-  #
-  # convenience method for comparing two numbers. true if and only if
-  # they express the same value
-  #
-  def assert_val_equal(expected, actual, message="")
-    _wrap_assertion {
-      full_message = build_message(message, "Expected <?> to match <?>", actual, expected)
-      assert_block(full_message) {
-        (expected <=> actual).zero?
-      }
-    }
-  end
-
-  #
-  # convenience method for comparing Float with LongDecimal
-  # using a delta coming from these
-  #
-  def assert_mixed_equal(expected_f, actual_ld, message="")
-    delta = [ actual_ld.unit, expected_f.abs / 1e10 ].max
-    assert_equal_float(expected_f, actual_ld, delta, message)
-  end
-
-  #
-  # helper method for test_split_merge_words
-  #
-  def check_split_merge_words(x, l, wl)
-    w = LongMath.split_to_words(x, l)
-    y = LongMath.merge_from_words(w, l)
-    assert_equal(x, y, "#{x} splitted and merged should be equal but is #{y} l=#{l}")
-    assert_equal(wl, w.length, "#{x} splitted to l=#{l} should have length #{wl} but has #{w.length}")
-    w
-  end
+  @RCS_ID='-$Id: testlongdecimal.rb,v 1.32 2006/04/07 22:26:08 bk1 Exp $-'
 
   #
   # test split_to_words and merge_from_words
@@ -85,43 +54,6 @@ class TestLongDecimal_class < RUNIT::TestCase
     check_split_merge_words(x, 1000, 1)
   end
 
-  #
-  # helper method for test_exp
-  # tests if exp(x) with precision prec is calculated correctly
-  #
-  def check_exp_floated(x, prec)
-
-    # make sure x is LongDecimal
-    x0 = x
-    x = x.to_ld
-    # calculate y = exp(x)
-    y = LongMath.exp(x, prec)
-
-    # compare y against z = exp(x) calculated using regular floating point arithmetic
-    z = Math.exp(x.to_f)
-    yf = y.to_f
-    assert((yf - z).abs <= [ y.unit, z.abs / 1e9 ].max, "y=#{yf.to_s} and z=#{z.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
-      if (y < 1) then
-        l10 = (Math.log(y.to_f) / Math.log(10)).round
-        lprec += l10
-      end
-      z = LongMath.log(y, lprec)
-      assert((x - z).abs <= z.unit, "x=#{x.to_s} and z=#{z.to_s} should be almost equal (y=#{y.to_s} lprec=#{lprec} prec=#{prec})")
-    end
-
-    # check by doing calculation with different internal rounding modes.  They should not differ.
-    yd = LongMath.exp_internal(x, prec, nil, nil, nil, nil, LongDecimal::ROUND_DOWN)
-    yu = LongMath.exp_internal(x, prec, nil, nil, nil, nil, LongDecimal::ROUND_UP)
-    assert_equal(yd, yu, "the result yd/yu should not depend on the internal rounding mode x0=#{x0} x=#{x} 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 x0=#{x0} x=#{x} p=#{prec} d=#{(y -yu).to_f.to_s}")
-  end
-
   #
   # test the calculation of the exponential function
   #
@@ -152,32 +84,10 @@ class TestLongDecimal_class < RUNIT::TestCase
     check_exp_floated(-700, 100)
     check_exp_floated(xx, 100)
     check_exp_floated(-xx, 100)
-  end
-
-  #
-  # helper method for test_exp_int
-  # tests if exp(x) with precision prec is calculated correctly
-  #
-  def check_exp_int(x)
-
-    # make sure x is LongDecimal
-    x0 = x
-    x  = x.to_ld
-    y  = LongMath.exp(x, 0)
-    assert_equal(y.scale, 0, "scale must be 0")
-
-    # compare y against z = exp(x) calculated using regular floating point arithmetic
-    z  = Math.exp(x0.to_f)
-    yf = y.to_f
-    yi = yf.round
-    zi = z.round
-    assert((yi-zi).abs / [yf.abs, z.abs, Float::MIN].max < 1e-9, "yi=#{yi} and zi=#{zi} should be equal x=#{x} y=#{y} z=#{z}")
-
-    if (y > 1)
-      w = LongMath.log(y, 0)
-      assert((w-x).abs < 1, "log(y)=#{w} must be almost x=#{x0}")
-    end
 
+    # random tests that have failed previously
+    check_exp_floated(LongDecimal("0.0000000000000000000000000050000000000000000000000000000000000000000000000000000000000000017066"), 25)
+    check_exp_floated(LongDecimal("0.00000000000000000000000000000000000000000000000000000000000000570000000004000000000000050"), 86)
   end
 
   #
@@ -219,24 +129,6 @@ class TestLongDecimal_class < RUNIT::TestCase
 
   end
 
-  #
-  # helper method for test_lm_power_xint
-  # tests if exp(x) with precision prec is calculated correctly
-  #
-  def check_power_xint(x, y, prec)
-
-    xi = x.to_i
-    x  = x.to_ld()
-    y  = y.to_ld()
-    z  = LongMath.power(x, y, prec)
-    zz = LongMath.power_internal(x, y, prec)
-    assert((zz - z).abs <= z.unit, "power with and without optimizations z=#{z} zz=#{zz} x=#{x} y=#{y}")
-    # compare y against z = exp(x) calculated using regular floating point arithmetic
-    zz = (xi) ** (y.to_f)
-    zf = z.to_f
-    assert((zf - zz).abs < [z.unit.to_f, zz.abs / 1e9 ].max, "z=#{z} and zz=#{zz} should be almost equal x=#{x} y=#{y} (zf=#{zf})")
-  end
-
   #
   # test LongMath.power for bases that can be expressed as integer
   #
@@ -332,28 +224,6 @@ class TestLongDecimal_class < RUNIT::TestCase
 
   end
 
-  #
-  # helper method for test_lm_power_yint
-  # tests if exp(x) with precision prec is calculated correctly
-  #
-  def check_power_yint(x, y, prec)
-
-    yi = y.to_i
-    x  = x.to_ld
-    y  = y.to_ld
-
-    z  = LongMath.power(x, y, prec, LongMath::ROUND_HALF_UP)
-    zz = (x ** yi).round_to_scale(prec, LongMath::ROUND_HALF_UP)
-    assert_equal(z, zz, "power with ** or power-method x=#{x} y=#{y} z=#{z} zz=#{zz}")
-    zz = LongMath.power_internal(x, y, prec)
-    assert((zz - z).abs <= z.unit, "power with and without optimizations x=#{x} y=#{y} z=#{z} zz=#{zz}")
-
-    zz = (x.to_f) ** (y.to_f)
-    zf = z.to_f
-    # assert((zf - zz).abs / [zf.abs, zz.abs, Float::MIN].max < 1e-9, "z=#{zf.to_s} and zz=#{zz.to_s} should be almost equal x=#{x} y=#{y} z=#{z} zz=#{zz}")
-    assert((zf - zz).abs < [ z.unit.to_f, zf.abs / 1e9 ].max, "zf=#{zf.to_s} and zz=#{zz.to_s} should be almost equal x=#{x} y=#{y} z=#{z} zz=#{zz}")
-  end
-
   #
   # test LongMath.power for bases that can be expressed as integer
   #
@@ -510,58 +380,6 @@ class TestLongDecimal_class < RUNIT::TestCase
     assert((yr-wr).abs <= wr.unit, "wr-yr")
   end
 
-  #
-  # helper method for test_log
-  # tests if log(x) with precision prec is calculated correctly
-  #
-  def check_log_floated(x, prec, divisor=1e9, summand=0)
-
-    # make sure x is LongDecimal
-    x0 = x
-    x = x.to_ld
-    # calculate y = log(x)
-    y = LongMath.log(x, prec)
-
-    # compare y against z = exp(x) calculated using regular floating
-    # point arithmetic
-    if (x <= LongMath::MAX_FLOATABLE) then
-      xf = x.to_f
-      if (xf > 0) then
-        z = Math.log(x.to_f)
-        zl = z.to_ld(y.scale)
-        delta = [ y.unit, z.abs / divisor + summand ].max
-        assert((y - zl).abs <= delta, "y=#{y.to_s} (#{y.to_f}) and z=#{z.to_s} (#{zl.to_f}) should be almost equal (d=#{delta} x=#{x} y=#{y})")
-      end
-    end
-
-    # check by taking exp(log(y))
-    # 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 <= LongMath::MAX_EXP_ABLE) then
-      eprec = prec-1
-      if (y > 1) then
-        ly = 0
-        if (y > LongMath::MAX_FLOATABLE) then
-          puts("unusual y=#{y} y=#{y}\n")
-          ly = LongMath::MAX_EXP_ABLE
-        else
-          ly = Math.log(y.to_f)
-        end
-        l10 = (ly / Math.log(10)).ceil
-        eprec = [ eprec - l10, 0 ].max
-      end
-
-      z = LongMath.exp(y, eprec)
-      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
-
-    # 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)
-    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}")
-  end
-
   #
   # test the calculation of the logarithm function
   #
@@ -596,57 +414,12 @@ class TestLongDecimal_class < RUNIT::TestCase
     check_log_floated(1e-90, 100)
     check_log_floated(1e-300, 100)
     check_log_floated(LongDecimal(1, 2000), 100)
-  end
-
-  #
-  # helper method for test_lm_power
-  # tests if LongMath::power(x, y, prec) with precision prec is calculated correctly
-  #
-  def check_power_floated(x, y, prec)
-
-    # puts("start: check_power_floated: x=#{x} y=#{y} prec=#{prec}\n")
-    # make sure x and y are LongDecimal
-    x0 = x
-    x = x.to_ld
-    y0 = y
-    y = y.to_ld
-    # 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}")
-
-    # check by taking log(z) = y * log(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 (z > 0) then
-      lprec = prec
-      if (z < 1) then
-        l10 = (Math.log(z.to_f) / Math.log(10)).floor
-        lprec += l10
-      end
-      if (x < 1) then
-        l10 = (Math.log(x.to_f) / Math.log(10)).floor
-        lprec += l10
-      end
-      unit = (10**(-lprec)).to_ld
-      if (lprec < 0)
-        lprec = 0
-      end
-      l10y = 0
-      if (y > 1) then
-        l10y = (Math.log(y.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")
 
+    # random tests that have failed
+    check_log_floated(LongDecimal("666.000000000000000000000000000000000091600000000531000000000000000000000000000000000000000000831"), 1)
+    check_log_floated(LongDecimal("333.000000000000000000000000919000000000000000000000000000000000001240000000000198"), 91)
+    check_log_floated(LongDecimal("695.000000000000000000000000000000000000016169000000000000000572"), 10)
+    check_log_floated(LongDecimal("553.00000000526000000000000000000000000000000000000000000000000298000000000000000079"), 1)
   end
 
   #
@@ -681,69 +454,6 @@ class TestLongDecimal_class < RUNIT::TestCase
     check_power_floated(1.01, -1e-20, 21)
   end
 
-  #
-  # helper method for test_log10
-  # tests if log10(x) with precision prec is calculated correctly
-  #
-  def check_log10_floated(x, prec)
-
-    # make sure x is LongDecimal
-    x0 = x
-    x = x.to_ld
-    # calculate y = log10(x)
-    y = LongMath.log10(x, prec)
-
-    # compare y against z = log10(x) calculated using regular floating
-    # point arithmetic
-    if (x <= LongMath::MAX_FLOATABLE) then
-      xf = x.to_f
-      if (xf > 0) then
-        z = Math.log(x.to_f) / Math.log(10)
-        yf = y.to_f
-        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}")
-      end
-    end
-
-    # check by taking 10**(log10(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 <= LongMath::MAX_EXP_ABLE) then
-      eprec = prec
-      if (y > 1) then
-        lx = 0
-        if (x > LongMath::MAX_FLOATABLE) then
-          puts("unusual x=#{x} y=#{y}\n")
-          lx = LongMath::MAX_EXP_ABLE
-        else
-          lx = Math.log(x.to_f)
-        end
-        l10 = (lx / Math.log(10)).ceil
-        eprec = [ eprec - l10, 0 ].max
-      end
-
-      z = LongMath.power(10.to_ld, y, eprec)
-      # zz = LongMath.exp10(y, eprec)
-      # assert((zz - z).abs <= z.unit, "zz=#{zz.to_s} and z=#{z.to_s} should be almost equal (y=#{y.to_s} eprec=#{eprec} prec=#{prec})")
-      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
-
-  end
-
-  #
-  # helper method for test_log10
-  # tests if log10(x) with precision prec is calculated correctly
-  #
-  def check_log10_exact(x, log10x, prec)
-
-    # make sure x is LongDecimal
-    x0 = x
-    x = x.to_ld
-    log10x = log10x.to_ld(prec)
-    # calculate y = log10(x)
-    y = LongMath.log10(x, prec)
-    assert_equal(y, log10x, "log x should match exactly x=#{x} y=#{y} log10x=#{log10x}")
-  end
-
   #
   # test the calculation of the base-10-logarithm function
   #
@@ -763,69 +473,6 @@ class TestLongDecimal_class < RUNIT::TestCase
     check_log10_exact(10**10, 10, 30)
   end
 
-  #
-  # helper method for test_log2
-  # tests if log2(x) with precision prec is calculated correctly
-  #
-  def check_log2_floated(x, prec)
-
-    # make sure x is LongDecimal
-    x0 = x
-    x = x.to_ld
-    # calculate y = log2(x)
-    y = LongMath.log2(x, prec)
-
-    # compare y against z = log2(x) calculated using regular floating
-    # point arithmetic
-    if (x <= LongMath::MAX_FLOATABLE) then
-      xf = x.to_f
-      if (xf > 0) then
-        z = Math.log(x.to_f) / Math.log(2)
-        yf = y.to_f
-        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}")
-      end
-    end
-
-    # check by taking 2**(log2(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 <= LongMath::MAX_EXP_ABLE) then
-      eprec = prec
-      if (y > 1) then
-        lx = 0
-        if (x > LongMath::MAX_FLOATABLE) then
-          puts("unusual x=#{x} y=#{y}\n")
-          lx = LongMath::MAX_EXP_ABLE
-        else
-          lx = Math.log(x.to_f)
-        end
-        l10 = (lx / Math.log(10)).ceil
-        eprec = [ eprec - l10, 0 ].max
-      end
-
-      z = LongMath.power(2.to_ld, y, eprec)
-      # zz = LongMath.exp2(y, eprec)
-      # assert((zz - z).abs <= z.unit, "zz=#{zz.to_s} and z=#{z.to_s} should be almost equal (y=#{y.to_s} eprec=#{eprec} prec=#{prec})")
-      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
-
-  end
-
-  #
-  # helper method for test_log2
-  # tests if log2(x) with precision prec is calculated correctly
-  #
-  def check_log2_exact(x, log2x, prec)
-
-    # make sure x is LongDecimal
-    x0 = x
-    x = x.to_ld
-    log2x = log2x.to_ld(prec)
-    # calculate y = log2(x)
-    y = LongMath.log2(x, prec)
-    assert_equal(y, log2x, "log x should match exactly x=#{x} y=#{y} log2x=#{log2x} prec=#{prec}")
-  end
-
   #
   # test the calculation of the base-10-logarithm function
   #
@@ -904,18 +551,6 @@ class TestLongDecimal_class < RUNIT::TestCase
     assert_equal(l.round_to_scale(201, LongMath::ROUND_HALF_EVEN), pi, "201 digits")
   end
 
-  #
-  # helper method for test_int_sqrtb
-  #
-  def check_sqrtb(x, s)
-    y = LongMath.sqrtb(x)
-    z = y * y
-    zz = (y+1)*(y+1)
-    assert(0 <= y, "sqrt must be >= 0" + s)
-    assert(z <= x && x < zz, "y=#{y}=sqrt(#{x}) and x in [#{z}, #{zz})" + s)
-    y
-  end
-
   #
   # test method sqrtb for calculating sqrt of short integers
   #
@@ -954,18 +589,6 @@ class TestLongDecimal_class < RUNIT::TestCase
     end
   end
 
-  #
-  # helper method of test_int_sqrtw
-  #
-  def check_sqrtw(x, s)
-    y = LongMath.sqrtw(x)
-    z = y * y
-    zz = (y+1)*(y+1)
-    assert(0 <= y, "sqrt must be >= 0" + s)
-    assert(z <= x && x < zz, "y=#{y}=sqrt(#{x}) and x in [#{z}, #{zz})" + s)
-    y
-  end
-
   #
   # test method sqrtb for calculating sqrt of long integers
   #
@@ -1004,20 +627,6 @@ class TestLongDecimal_class < RUNIT::TestCase
     end
   end
 
-  #
-  # helper method for test_int_sqrtb_with_remainder
-  #
-  def check_sqrtb_with_remainder(x, s)
-    y, r = LongMath.sqrtb_with_remainder(x)
-    z0 = y * y
-    z1 = z0 + r
-    z2 = (y+1)*(y+1)
-    assert(0 <= y, "sqrt _with_remaindermust be >= 0" + s)
-    assert_equal(z1, x, "x=#{x} y=#{y} r=#{r} z0=#{z0} z1=#{z1} z2=#{z2}" + s)
-    assert(z0 <= x && x < z2, "y=#{y}=sqrt(_with_remainder#{x}) and x in [#{z0}, #{z2}) r=#{r} z0=#{z0} z1=#{z1} z2=#{z2}" + s)
-    y
-  end
-
   #
   # test method sqrtb_with_remainder for calculating sqrt _with_remainderof short integers
   #
@@ -1060,20 +669,6 @@ class TestLongDecimal_class < RUNIT::TestCase
     end
   end
 
-  #
-  # helper method for test_int_sqrtw_with_remainder
-  #
-  def check_sqrtw_with_remainder(x, s)
-    y, r = LongMath.sqrtw_with_remainder(x)
-    z0 = y * y
-    z1 = z0 + r
-    z2 = (y+1)*(y+1)
-    assert(0 <= y, "sqrt _with_remaindermust be >= 0" + s)
-    assert_equal(z1, x, "x=#{x} y=#{y} r=#{r} z0=#{z0} z1=#{z1} z2=#{z2}" + s)
-    assert(z0 <= x && x < z2, "y=#{y}=sqrt(_with_remainder#{x}) and x in [#{z0}, #{z2}) r=#{r} z0=#{z0} z1=#{z1} z2=#{z2}" + s)
-    y
-  end
-
   #
   # test method sqrtb_with_remainder for calculating sqrt _with_remainderof long integers
   #
@@ -1419,6 +1014,23 @@ class TestLongDecimal_class < RUNIT::TestCase
     assert_equal(4, LongMath.int_digits10(9999), "9999")
   end
 
+  #
+  # test round_trailing_zeros of LongDecimal
+  #
+  def test_round_trailing_zeros
+    x = LongDecimal.one!(100)
+    y = x.round_trailing_zeros
+    z = LongDecimal.one!(0)
+    assert_equal(y, z, "1 w/o trailing")
+    x = LongDecimal(22400, 5)
+    y = x.round_trailing_zeros
+    z = LongDecimal(224, 3)
+    assert_equal(y, z, "2.24 w/o trailing")
+    x = LongDecimal(123456, 3)
+    y = x.round_trailing_zeros
+    assert_equal(y, x, "1234.56 w/o trailing")
+  end
+
   #
   # test rounding of LongDecimal with ROUND_UP
   #
@@ -1785,6 +1397,27 @@ class TestLongDecimal_class < RUNIT::TestCase
     assert((l.to_f - 0.0224).abs < 0.0224 * 0.000001, "l=#{l.inspect}")
   end
 
+  #
+  # test to_ld of Numeric
+  #
+  def test_to_ld
+    x = LongDecimal(123, 100)
+    y = x.to_ld(20, LongMath::ROUND_UP)
+    z = LongDecimal(1, 20)
+    assert_kind_of(LongDecimal, y, "must be ld")
+    assert_equal(y, z, "x=#{x} y=#{y}")
+    y = x.to_ld(20, LongMath::ROUND_HALF_UP)
+    z = LongDecimal(0, 20)
+    assert_kind_of(LongDecimal, y, "must be ld")
+    assert_equal(y, z, "x=#{x} y=#{y}")
+
+    x = 224
+    y = x.to_ld(20)
+    z = LongDecimal(224*10**20, 20)
+    assert_kind_of(LongDecimal, y, "must be ld")
+    assert_equal(y, z, "x=#{x} y=#{y}")
+  end
+
   #
   # test conversion to BigDecimal
   #
@@ -2227,6 +1860,33 @@ class TestLongDecimal_class < RUNIT::TestCase
     assert((zz-z).abs < 1e-9, "z=#{z.inspect}")
   end
 
+  #
+  # test square of LongDecimal
+  #
+  def test_square
+    10.times do |i|
+      n = (i*i+i)/2
+      x = LongDecimal(n, i)
+      y = x.square
+      z = LongDecimal(n*n, 2*i)
+      assert_equal(y, z, "square i=#{i}")
+    end
+  end
+
+  #
+  # test reciprocal of LongDecimal
+  #
+  def test_reciprocal
+    10.times do |i|
+      k = 2*i+1
+      n = (k*k+k)/2
+      x = LongDecimal(n, i)
+      y = x.reciprocal
+      z = LongDecimalQuot(Rational(10**i, n), [i+2*(Math.log10(n)-i).floor, 0].max)
+      assert_equal(z, y, "reciprocal x=#{x} y=#{y} z=#{z} i=#{i} k=#{k} n=#{n}")
+    end
+  end
+
   #
   # test power (**) of LongDecimal
   #
@@ -2402,6 +2062,49 @@ class TestLongDecimal_class < RUNIT::TestCase
     end
   end
 
+  #
+  # test dec, dec!, inc and inc! of LongDecimal
+  #
+  def test_inc_dec
+
+    x0 = LongDecimal(224, 1)
+    x  = LongDecimal(224, 1)
+    y  = x.inc
+    z  = LongDecimal(234, 1)
+    assert_equal(x, x0, "x")
+    assert_equal(z, y, "y, z")
+    x.inc!
+    assert_equal(z, x, "z, x")
+
+    x0 = LongDecimal(224, 1)
+    x  = LongDecimal(224, 1)
+    y  = x.dec
+    z  = LongDecimal(214, 1)
+    assert_equal(x, x0, "x")
+    assert_equal(z, y, "y, z")
+    x.dec!
+    assert_equal(z, x, "z, x")
+  end
+
+  #
+  # test pred and succ of LongDecimal
+  #
+  def test_pred_succ
+    x0 = LongDecimal(2245, 2)
+    x  = LongDecimal(2245, 2)
+    ys = x.succ
+    assert_equal(x, x0, "x")
+    yp = x.pred
+    assert_equal(x, x0, "x")
+    zs = LongDecimal(2246, 2)
+    zp = LongDecimal(2244, 2)
+    assert_equal(zs, ys, "succ")
+    assert_equal(zp, yp, "pred")
+    y  = LongDecimal(2254, 2)
+    n  = (x..y).to_a.size
+    assert_equal(10, n, "size")
+  end
+
   #
   # test of &-operator of LongDecimal
   #
@@ -2704,18 +2407,6 @@ class TestLongDecimal_class < RUNIT::TestCase
     assert_equal(z, y, "2240")
   end
 
-  #
-  # helper method of test_sqrt
-  #
-  def check_sqrt(x, scale, mode, su0, su1, str)
-    y = x.sqrt(scale, mode)
-    z0 = (y+su0*y.unit).square
-    z1 = (y+su1*y.unit).square
-    assert(0 <= y.sign, "sqrt must be >= 0" + str)
-    assert(z0 <= x && x <= z1, "y=#{y}=sqrt(#{x}) and x in [#{z0}, #{z1})" + str)
-    y
-  end
-
   #
   # test sqrt of LongDecimal
   #
@@ -2798,19 +2489,6 @@ class TestLongDecimal_class < RUNIT::TestCase
     assert_equal(y1, y2, "y1 y2")
   end
 
-  #
-  # helper method of test_sqrt_with_remainder
-  #
-  def check_sqrt_with_remainder(x, scale, str)
-    y, r = x.sqrt_with_remainder(scale)
-    z0 = y.square
-    z1 = y.succ.square
-    assert(0 <= y.sign, "sqrt must be >= 0" + str)
-    assert(z0 <= x && x < z1, "y=#{y}=sqrt(#{x}) and x in [#{z0}, #{z1})" + str)
-    assert((x - z0 - r).zero?, "x=y*y+r")
-    r
-  end
-
   #
   # test sqrt_with_remainder of LongDecimal
   #
@@ -3007,6 +2685,73 @@ class TestLongDecimal_class < RUNIT::TestCase
     assert_equal(y, y, "y equals y")
   end
 
+  #
+  # test value-equality-comparison (===) of LongDecimal
+  #
+  def test_val_equal
+    x = LongDecimal(224, 2)
+    y = LongDecimal(2240, 3)
+    assert((x === y), "value equal")
+    assert(x != y, "but not equal")
+    assert(x === x, "x equals x")
+    assert(y === y, "y equals y")
+    x = 1.to_ld(100)
+    y = 1
+    assert((x === y), "value equal")
+    assert(x != y, "but not equal")
+    assert(x === x, "x equals x")
+    assert(y === y, "y equals y")
+    x = LongDecimal(123456, 3)
+    y = Rational(123456, 1000)
+    assert((x === y), "value equal")
+    assert(x != y, "but not equal")
+    assert(x === x, "x equals x")
+    assert(y === y, "y equals y")
+  end
+
+  #
+  # test .unit() of LongDecimal
+  #
+  def test_unit
+    10.times do |i|
+      x = LongDecimal.zero!(i)
+      u = x.unit
+      v = LongDecimal(1, i)
+      assert_equal(u, v, "unit i=#{i}")
+      x = i.to_ld(i*i)
+      u = x.unit
+      v = LongDecimal(1, i*i)
+      assert_equal(u, v, "unit i=#{i}")
+    end
+  end
+
+  #
+  # test denominator of LongDecimal
+  #
+  def test_denominator
+    x = LongDecimal("-2.20")
+    assert_equal(100, x.denominator, "-2.20")
+    x = LongDecimal("2.20")
+    assert_equal(100, x.denominator, "2.20")
+    x = LongDecimal("2.2400")
+    assert_equal(10000, x.denominator, "2.2400")
+    x = LongDecimal(-1, 2)
+    assert_equal(100, x.denominator, "-1 2")
+    x = LongDecimal(-221, 1)
+    assert_equal(10, x.denominator, "-221 1")
+    x = LongDecimal(-224, 0)
+    assert_equal(1, x.denominator, "-224 0")
+    x = LongDecimal(-3, 5)
+    assert_equal(100000, x.denominator, "-3 5")
+    x = LongDecimal(0, 20)
+    assert_equal(10**20, x.denominator, "0 20")
+    x = LongDecimal(30000000, 8)
+    assert_equal(10**8, x.denominator, "30000000 8")
+    x = LongDecimal(3330000000, 8)
+    assert_equal(10**8, x.denominator, "3330000000 8")
+
+  end
+
   #
   # test construction of LongDecimalQuot from LongDecimal
   #
@@ -3421,27 +3166,27 @@ class TestLongDecimal_class < RUNIT::TestCase
   def test_ldq_to_ld
     x = LongDecimalQuot(1, 100)
     y = x.to_ld
-    assert((y.kind_of? LongDecimal), "must be ld")
+    assert_kind_of(LongDecimal, y, "must be ld")
     assert_equal(100, y.scale, "scale is 100")
     assert(y.one?, "must be one")
     x = LongDecimalQuot(Rational(13, 9), 10)
     y = x.to_ld
-    assert((y.kind_of? LongDecimal), "must be ld")
+    assert_kind_of(LongDecimal, y, "must be ld")
     assert_equal(10, y.scale, "scale is 10")
     assert_equal(LongDecimal("1.4444444444"), y, "1.44...")
     x = LongDecimalQuot(Rational(14, 9), 10)
     y = x.to_ld
-    assert((y.kind_of? LongDecimal), "must be ld")
+    assert_kind_of(LongDecimal, y, "must be ld")
     assert_equal(10, y.scale, "scale is 10")
     assert_equal(LongDecimal("1.5555555556"), y, "1.55...")
     x = LongDecimalQuot(Rational(7, 20), 1)
     y = x.to_ld
-    assert((y.kind_of? LongDecimal), "must be ld")
+    assert_kind_of(LongDecimal, y, "must be ld")
     assert_equal(1, y.scale, "scale is 1")
     assert_equal(LongDecimal("0.4"), y, "0.4")
     x = LongDecimalQuot(Rational(7, 2), 1)
     y = x.to_ld
-    assert((y.kind_of? LongDecimal), "must be ld")
+    assert_kind_of(LongDecimal, y, "must be ld")
     assert_equal(1, y.scale, "scale is 1")
     assert_equal(LongDecimal("3.5"), y, "3.5")
   end
@@ -3865,6 +3610,30 @@ class TestLongDecimal_class < RUNIT::TestCase
     end
   end
 
+  #
+  # test dec, dec!, inc and inc! of LongDecimalQuot
+  #
+  def test_ldq_inc_dec
+
+    x0 = LongDecimalQuot(Rational(224, 225), 1)
+    x  = LongDecimalQuot(Rational(224, 225), 1)
+    y  = x.inc
+    z  = LongDecimalQuot(Rational(449, 225), 1)
+    assert_equal(x, x0, "x")
+    assert_equal(z, y, "y, z")
+    x.inc!
+    assert_equal(z, x, "z, x")
+
+    x0 = LongDecimalQuot(Rational(224, 225), 1)
+    x  = LongDecimalQuot(Rational(224, 225), 1)
+    y  = x.dec
+    z  = LongDecimalQuot(Rational(-1, 225), 1)
+    assert_equal(x, x0, "x")
+    assert_equal(z, y, "y, z")
+    x.dec!
+    assert_equal(z, x, "z, x")
+  end
+
   #
   # test absolute value of LongDecimalQuot
   #