long-decimal 1.00.02 → 1.00.03

data/lib/long-decimal/version.rb

@@ -1,3 +1,3 @@
 module LongDecimalSupport
-  VERSION = "1.00.02"
+  VERSION = "1.00.03"
 end

data/test/testlongdecimal.rb

@@ -2,8 +2,9 @@
 #
 # testlongdecimal.rb -- runit test for long-decimal.rb
 #
-# (C) Karl Brodowsky (IT Sky Consulting GmbH) 2006-2009
+# (C) Karl Brodowsky (IT Sky Consulting GmbH) 2006-2015
 #
+# TAG:       $TAG v1.00.03$
 # CVS-ID:    $Header: /var/cvs/long-decimal/long-decimal/test/testlongdecimal.rb,v 1.86 2011/01/16 22:16:59 bk1 Exp $
 # CVS-Label: $Name:  $
 # Author:    $Author: bk1 $ (Karl Brodowsky)
@@ -1147,6 +1148,7 @@ class TestLongDecimal_class < UnitTest # RUNIT::TestCase
             y = Complex(yr, yi)
             z = x/y
             msg = "x=#{x} y=#{y} z=#{z} xr=#{xr.inspect} (#{tw_c}) xi=#{xi.inspect} (#{fi_c}) yr=#{yr.inspect} (#{th_c}) yi=#{yi.inspect} (#{fo_c})"
+            # puts msg
             if (xr.kind_of? Integer) && (xi.kind_of? Integer) && (yr.kind_of? Integer) && (yi.kind_of? Integer) # && ! LongDecimal::RUNNING_19
               # ruby 1.9 creates rational result even from integers, ruby 1.8 uses integers as results.
               zc = (x.cdiv y)
@@ -2378,8 +2380,8 @@ class TestLongDecimal_class < UnitTest # RUNIT::TestCase
   #
   # test rounding with ROUND_HARMONIC_ODD
   #
-  def test_round_to_scale_harmonic_even
-    print "\ntest_round_to_scale_harmonic_even [#{Time.now}]: "
+  def test_round_to_scale_harmonic_odd
+    print "\ntest_round_to_scale_harmonic_odd [#{Time.now}]: "
     l = LongDecimal("2.39")
     r = l.round_to_scale(0, ROUND_HARMONIC_ODD)
     assert_equal("2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
@@ -2909,6 +2911,7 @@ class TestLongDecimal_class < UnitTest # RUNIT::TestCase
         end
 
         text0 = "m=#{modulus} x=#{x} s=#{remainders.inspect}"
+        # puts text0
         print "."
         $stdout.flush
         n = 3*modulus
@@ -3061,6 +3064,7 @@ class TestLongDecimal_class < UnitTest # RUNIT::TestCase
         end
 
         text = "m=#{modulus} x=#{x} s=#{remainders.inspect}"
+        # puts text
         print "."
         $stdout.flush
 
@@ -3527,6 +3531,11 @@ class TestLongDecimal_class < UnitTest # RUNIT::TestCase
   #
   def check_int_round_major_to_two_allowed_remainders(remainder_sets, boundary_exact_integral, major_mode, &block)
 
+    if RUBY_VERSION.match /^1\.8/
+      puts "Warning: this test is not supported for Ruby #{RUBY_VERSION}"
+      return
+    end
+
     mode_up = MODE_LOOKUP[[major_mode, MINOR_UP]]
     mode_down = MODE_LOOKUP[[major_mode, MINOR_DOWN]]
     mode_floor = MODE_LOOKUP[[major_mode, MINOR_FLOOR]]
@@ -3534,6 +3543,7 @@ class TestLongDecimal_class < UnitTest # RUNIT::TestCase
 
     20.upto 25 do |modulus|
       remainder_sets.each do |remainders|
+        # puts text
         print "."
         $stdout.flush
 
@@ -4026,6 +4036,7 @@ class TestLongDecimal_class < UnitTest # RUNIT::TestCase
       end
     end
     map.each do |x, x1|
+      # puts "x=#{x} x1=#{x1}"
       print ":"
       $stdout.flush
       map.each do |y, y1|
@@ -5489,15 +5500,20 @@ class TestLongDecimal_class < UnitTest # RUNIT::TestCase
   #
   def test_sqrt
     print "\ntest_sqrt [#{Time.now}]: "
+
+    # sqrt of 0 is always 0 without need to round
     x = LongDecimal.zero!(101)
     y = check_sqrt(x, 120, ROUND_UNNECESSARY, 0, 0, "zero")
     assert(y.zero?, "sqrt(0)")
 
+    # sqrt of 1 is always 1 without need to round
     x = LongDecimal.one!(101)
     y = check_sqrt(x, 120, ROUND_UNNECESSARY, 0, 0, "one")
     assert(y.one?, "sqrt(1)")
 
+    # sqrt of 2 always gets rounded somehow
     x = LongDecimal.two!(101)
+    x.freeze
     y0 = check_sqrt(x, 120, ROUND_DOWN, 0, 1, "two")
     assert(y0.square < x, "y0*y0")
     assert(y0.succ.square > x, "(y0.succ).square")
@@ -5548,6 +5564,7 @@ class TestLongDecimal_class < UnitTest # RUNIT::TestCase
     assert(y0 <= y1, "y0 y1")
     assert(y1 <= y2, "y1 y2")
 
+    # sqrt of 3 always gets rounded somehow
     x = 3.to_ld
     y0 = check_sqrt(x, 120, ROUND_DOWN, 0, 1, "three")
     assert(y0.square < x, "y0*y0")
@@ -5559,6 +5576,7 @@ class TestLongDecimal_class < UnitTest # RUNIT::TestCase
     assert(y0 <= y1, "y0 y1")
     assert(y1 <= y2, "y1 y2")
 
+    # sqrt of 4 always gets rounded somehow
     x  = 4.to_ld(101)
     y0 = check_sqrt(x, 120, ROUND_DOWN, 0, 0, "four")
     y1 = check_sqrt(x, 120, ROUND_HALF_EVEN, 0, 0, "four")
@@ -5600,6 +5618,81 @@ class TestLongDecimal_class < UnitTest # RUNIT::TestCase
     check_sqrt_with_remainder(x, 120, "five")
   end
 
+  # test sqare roots that come to lie exactly on the geometric mean of the two rounding candidates
+  def test_sqrt_on_geometric_boundary
+    print "\ntest_sqrt_on_geometric_boundary [#{Time.now}]: "
+    1.upto(100) do |int_val|
+      100.times do |scale|
+        y_lower = LongDecimal(int_val, scale)
+        y_upper = y_lower.succ
+        x = y_lower * y_upper
+        msg = "x=#{x} y_lower=#{y_lower} y_upper=#{y_upper} "
+        # puts msg
+        [ ROUND_GEOMETRIC_UP, ROUND_GEOMETRIC_CEILING ].each do |mode|
+          y = LongMath.sqrt(x, scale, mode)
+          assert_equal(y_upper, y, msg + "y=#{y} mode=#{mode}")
+        end
+        [ ROUND_GEOMETRIC_DOWN, ROUND_GEOMETRIC_FLOOR ].each do |mode|
+          y = LongMath.sqrt(x, scale, mode)
+          assert_equal(y_lower, y, msg + "y=#{y} mode=#{mode}")
+        end
+        y = LongMath.sqrt(x, scale, ROUND_GEOMETRIC_EVEN)
+        assert(y == y_lower || y == y_upper, msg + "y=#{y} mode=#{ROUND_GEOMETRIC_EVEN}")
+        assert(y[0] == 0, msg + "y=#{y} mode=#{ROUND_GEOMETRIC_EVEN}")
+        y = LongMath.sqrt(x, scale, ROUND_GEOMETRIC_ODD)
+        assert(y == y_lower || y == y_upper, msg + "y=#{y} mode=#{ROUND_GEOMETRIC_ODD}")
+        assert(y[0] == 1, msg + "y=#{y} mode=#{ROUND_GEOMETRIC_ODD}")
+      end
+    end
+  end
+
+  # test sqare roots that come to lie exactly on the geometric mean of the two rounding candidates
+  def test_sqrt_zero_on_geometric_boundary
+    print "\ntest_sqrt_on_geometric_boundary [#{Time.now}]: "
+    100.times do |scale|
+      y_lower = LongDecimal(0, scale)
+      y_upper = y_lower.succ
+      x = y_lower * y_upper
+      msg = "x=#{x} y_lower=#{y_lower} y_upper=#{y_upper} "
+      ALL_MINOR.each do |minor|
+        if (minor == MINOR_UNUSED)
+          next
+        end
+        mode = MODE_LOOKUP[[MAJOR_GEOMETRIC, minor]]
+        y = LongMath.sqrt(x, scale, mode)
+        assert_equal(0, y, msg + "y=#{y} mode=#{mode}")
+      end
+    end
+  end
+
+  # test sqare roots that come to lie exactly on the quadratic mean of the two rounding candidates
+  def test_sqrt_on_quadratic_boundary
+    print "\ntest_sqrt_on_quadratic_boundary [#{Time.now}]: "
+    100.times do |int_val|
+      100.times do |scale|
+        y_lower = LongDecimal(int_val, scale)
+        y_upper = y_lower.succ
+        x = LongMath.arithmetic_mean(2*scale + 2, ROUND_HALF_EVEN, y_lower * y_lower, y_upper * y_upper)
+        msg = "x=#{x} y_lower=#{y_lower} y_upper=#{y_upper} "
+        # puts msg
+        [ ROUND_QUADRATIC_UP, ROUND_QUADRATIC_CEILING ].each do |mode|
+          y = LongMath.sqrt(x, scale, mode)
+          assert_equal(y_upper, y, msg + "y=#{y} mode=#{mode}")
+        end
+        [ ROUND_QUADRATIC_DOWN, ROUND_QUADRATIC_FLOOR ].each do |mode|
+          y = LongMath.sqrt(x, scale, mode)
+          assert_equal(y, y_lower, msg + "y=#{y} mode=#{mode}")
+        end
+        y = LongMath.sqrt(x, scale, ROUND_QUADRATIC_EVEN)
+        assert(y == y_lower || y == y_upper, msg + "y=#{y} mode=#{ROUND_QUADRATIC_EVEN}")
+        assert(y[0] == 0, msg + "y=#{y} mode=#{ROUND_QUADRATIC_EVEN}")
+        y = LongMath.sqrt(x, scale, ROUND_QUADRATIC_ODD)
+        assert(y == y_lower || y == y_upper, msg + "y=#{y} mode=#{ROUND_QUADRATIC_ODD}")
+        assert(y[0] == 1, msg + "y=#{y} mode=#{ROUND_QUADRATIC_ODD}")
+      end
+    end
+  end
+
   #
   # test LongMath.sqrt with non-LongDecimal arguments
   #
@@ -5740,6 +5833,34 @@ class TestLongDecimal_class < UnitTest # RUNIT::TestCase
     check_cbrt_with_remainder(x, 120, "five")
   end
 
+  # test sqare roots that come to lie exactly on the cubic mean of the two rounding candidates
+  def test_cbrt_on_cubic_boundary
+    print "\ntest_cbrt_on_cubic_boundary [#{Time.now}]: "
+    100.times do |int_val|
+      100.times do |scale|
+        y_lower = LongDecimal(int_val, scale)
+        y_upper = y_lower.succ
+        x = LongMath.arithmetic_mean(3*scale + 2, ROUND_HALF_EVEN, y_lower.cube(), y_upper.cube())
+        msg = "x=#{x} y_lower=#{y_lower} y_upper=#{y_upper} "
+        # puts msg
+        [ ROUND_CUBIC_UP, ROUND_CUBIC_CEILING ].each do |mode|
+          y = LongMath.cbrt(x, scale, mode)
+          assert_equal(y_upper, y, msg + "y=#{y} mode=#{mode}")
+        end
+        [ ROUND_CUBIC_DOWN, ROUND_CUBIC_FLOOR ].each do |mode|
+          y = LongMath.cbrt(x, scale, mode)
+          assert_equal(y, y_lower, msg + "y=#{y} mode=#{mode}")
+        end
+        y = LongMath.cbrt(x, scale, ROUND_CUBIC_EVEN)
+        assert(y == y_lower || y == y_upper, msg + "y=#{y} mode=#{ROUND_CUBIC_EVEN}")
+        assert(y[0] == 0, msg + "y=#{y} mode=#{ROUND_CUBIC_EVEN}")
+        y = LongMath.cbrt(x, scale, ROUND_CUBIC_ODD)
+        assert(y == y_lower || y == y_upper, msg + "y=#{y} mode=#{ROUND_CUBIC_ODD}")
+        assert(y[0] == 1, msg + "y=#{y} mode=#{ROUND_CUBIC_ODD}")
+      end
+    end
+  end
+
   #
   # test LongMath.cbrt with non-LongDecimal arguments
   #
@@ -7354,6 +7475,46 @@ class TestLongDecimal_class < UnitTest # RUNIT::TestCase
     end
   end
 
+  def test_means_two_param_round_up
+    print "\ntest_means_two_param_round_up [#{Time.now}] (20 sec): "
+    arr = [ 0, 1, 2, 7, 0.0, 1.0, 2.0, Math::PI, Rational(40, 9), Rational(0, 1), Rational(1,1), Rational(2,3), LongDecimal(3333333333333333, 10), LongDecimal(33, 10), LongDecimal(0, 10), LongDecimal(10000000000, 10), LongMath.pi(100) ]
+    x = Math::PI
+    y = Math::PI
+    print "."
+    prec = 0
+    rm = ROUND_UP
+    xx = x.to_ld(prec, rm)
+    yy = y.to_ld(prec, rm)
+    mi = [xx, yy].min
+    am = LongMath.arithmetic_mean(prec, rm, x, y)
+    gm = LongMath.geometric_mean(prec, rm, x, y)
+    if (x.sgn == 0 || y.sgn == 0)
+      hm = gm
+    else
+      hm = LongMath.harmonic_mean(prec, rm, x, y)
+    end
+    qm = LongMath.quadratic_mean(prec, rm, x, y)
+    cm = LongMath.cubic_mean(prec, rm, x, y)
+    ma = [xx, yy].max
+
+    text = "mi=#{mi} hm=#{hm} gm=#{gm} am=#{am} qm=#{qm} cm=#{cm} ma=#{ma} prec=#{prec} rm=#{rm} x=#{x} y=#{y}"
+    assert(mi <= hm.succ, text)
+    assert(hm <= gm.succ, text)
+    assert(gm <= am.succ, text)
+    assert(am <= qm.succ, text)
+    assert(qm <= cm.succ, text)
+    assert(cm <= ma.succ, text)
+    if (x == y)
+      assert_equal(mi, hm, text)
+      assert_equal(hm, gm, text)
+      assert_equal(gm, am, text)
+      assert_equal(am, qm, text)
+      assert_equal(qm, cm, text)
+      assert_equal(cm, ma, text)
+    end
+  end
+
+  # test the right ordering of the means excluding agm/hgm
   def test_means_three_param
     print "\ntest_means_three_param [#{Time.now}] (4 min): "
     arr = [ 0, 1, 2, 0.0, 1.0, Math::PI, Rational(40, 9), Rational(0, 1), Rational(1,1), LongDecimal(3333333333333333, 10), LongDecimal(0, 10), LongDecimal(10000000000, 10), LongMath.pi(100) ]
@@ -7363,6 +7524,60 @@ class TestLongDecimal_class < UnitTest # RUNIT::TestCase
         arr.each do |z|
           print "."
           12.times do |prec|
+            ALL_ROUNDING_MODES.each do |rm|
+              if (rm == ROUND_UNNECESSARY)
+                next
+              end
+              xx = x.to_ld(prec, rm)
+              yy = y.to_ld(prec, rm)
+              zz = z.to_ld(prec, rm)
+              mi = [xx, yy, zz].min
+              am = LongMath.arithmetic_mean(prec, rm, x, y, z)
+              gm = LongMath.geometric_mean(prec, rm, x, y, z)
+              if (x.sgn == 0 || y.sgn == 0 || z.sgn == 0)
+                hm = gm
+              else
+                hm = LongMath.harmonic_mean(prec, rm, x, y, z)
+              end
+              qm = LongMath.quadratic_mean(prec, rm, x, y, z)
+              cm = LongMath.cubic_mean(prec, rm, x, y, z)
+              ma = [xx, yy, zz].max
+              text = "mi=#{mi} hm=#{hm} gm=#{gm} am=#{am} qm=#{qm} cm=#{cm} ma=#{ma} prec=#{prec} rm=#{rm} x=#{x} y=#{y} z=#{z}"
+              assert(mi <= hm.succ, text)
+              assert(hm <= gm.succ, text)
+              assert(gm <= am.succ, text)
+              assert(am <= qm.succ, text)
+              assert(qm <= cm.succ, text)
+              assert(cm <= ma.succ, text)
+              if (x == y && y == z)
+                assert_equal(mi, hm, text)
+                assert_equal(hm, gm, text)
+                assert_equal(gm, am, text)
+                assert_equal(am, qm, text)
+                assert_equal(qm, cm, text)
+                assert_equal(cm, ma, text)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+
+  # test the right ordering of the means (including agm/hgm)
+  def test_means_three_param_agm_hgm
+    print "\ntest_means_three_param_agm_hgm [#{Time.now}] (4 min): "
+    arr = [ 0, 1, 2, 0.0, 1.0, Math::PI, Rational(40, 9), Rational(0, 1), Rational(1,1), LongDecimal(3333333333333333, 10), LongDecimal(0, 10), LongDecimal(10000000000, 10), LongMath.pi(100) ]
+    arr.each do |x|
+      x.freeze
+      arr.each do |y|
+        y.freeze
+        print ":"
+        arr.each do |z|
+          z.freeze
+          print "."
+          prec = 0
+          3.times do |i|
             ALL_ROUNDING_MODES.each do |rm|
               if (rm == ROUND_UNNECESSARY)
                 next
@@ -7384,7 +7599,7 @@ class TestLongDecimal_class < UnitTest # RUNIT::TestCase
               qm = LongMath.quadratic_mean(prec, rm, x, y, z)
               cm = LongMath.cubic_mean(prec, rm, x, y, z)
               ma = [xx, yy, zz].max
-              text = "mi=#{mi} hm=#{hm} gm=#{gm} am=#{am} qm=#{qm} cm=#{cm} ma=#{ma} prec=#{prec} rm=#{rm} x=#{x} y=#{y} z=#{z}"
+              text = "mi=#{mi} hm=#{hm} gm=#{gm} am=#{am} qm=#{qm} cm=#{cm} ma=#{ma} prec=#{prec} rm=#{rm} x=#{x} y=#{y} z=#{z} i=#{i}"
               assert(mi <= hm.succ, text)
               assert(hm <= hgm.succ, text)
               assert(hgm <= gm.succ, text)
@@ -7398,12 +7613,13 @@ class TestLongDecimal_class < UnitTest # RUNIT::TestCase
                 assert_equal(hm, hgm, text)
                 assert_equal(hgm, gm, text)
                 assert_equal(gm, agm, text)
-                assert_equal(gm, agm, text)
+                assert_equal(agm, am, text)
                 assert_equal(am, qm, text)
                 assert_equal(qm, cm, text)
                 assert_equal(cm, ma, text)
               end
             end
+            prec = (prec << 3) + 11
           end
         end
       end
@@ -7493,6 +7709,7 @@ class TestLongDecimal_class < UnitTest # RUNIT::TestCase
         @powers_of_10[x] = zz
       end
       assert_equal(z, zz)
+      # puts("exp=" + x.to_s)
       $stdout.flush
     else
       @powers_of_10[x] ||= z
@@ -7512,10 +7729,12 @@ class TestLongDecimal_class < UnitTest # RUNIT::TestCase
 
     12.times do |i|
       check_npower10(3**i)
+      # puts(3**i)
     end
 
     12.times do |i|
       check_npower10(3**i)
+      # puts(3**i)
     end
 
     y = 1
@@ -7530,6 +7749,7 @@ class TestLongDecimal_class < UnitTest # RUNIT::TestCase
     x0 = 2046
     y0 = 10**x0
     60.times do |i|
+      # puts "i=" + i.to_s
       $stdout.flush
       y = y0
       x = x0

data/test/testlongdeclib.rb

@@ -2,8 +2,9 @@
 #
 # library for tests for long-decimal.rb and long-decimal-extra.rb
 #
-# (C) Karl Brodowsky (IT Sky Consulting GmbH) 2006-2009
+# (C) Karl Brodowsky (IT Sky Consulting GmbH) 2006-2015
 #
+# TAG:       $TAG v1.00.03$
 # CVS-ID:    $Header: /var/cvs/long-decimal/long-decimal/test/testlongdeclib.rb,v 1.42 2011/02/03 00:22:39 bk1 Exp $
 # CVS-Label: $Name:  $
 # Author:    $Author: bk1 $ (Karl Brodowsky)
@@ -26,6 +27,8 @@ end
 #
 module TestLongDecHelper
 
+  include LongDecimalRoundingMode
+
   @RCS_ID='-$Id: testlongdeclib.rb,v 1.42 2011/02/03 00:22:39 bk1 Exp $-'
 
   def assert_equal_float(lhs, rhs, delta=0, msg="")
@@ -106,8 +109,8 @@ module TestLongDecHelper
 #       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)
+#         #       ed   = expected.round_to_scale(prec, ROUND_HALF_FLOOR)
+#         #       eu   = expected.round_to_scale(prec, ROUND_HALF_CEILING)
 #         #       # puts("ed=#{ed} eu=#{eu} e=#{expected} a=#{actual}")
 #         #       ed <= actual && actual <= eu
 
@@ -178,7 +181,7 @@ module TestLongDecHelper
     # eprec = prec+1
     y  = LongMath.exp(x, prec)
     yy = LongMath.exp(x, prec+10)
-    #  assert_equal(yy.round_to_scale(y.scale, LongDecimal::ROUND_HALF_DOWN), y, "x=#{x} y=#{y} yy=#{yy}")
+    #  assert_equal(yy.round_to_scale(y.scale, 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
@@ -206,8 +209,8 @@ module TestLongDecHelper
     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)
+    yd = LongMath.exp_internal(x, prec, nil, nil, nil, nil, ROUND_DOWN)
+    yu = LongMath.exp_internal(x, prec, nil, nil, nil, nil, 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}")
     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}")
@@ -256,7 +259,7 @@ module TestLongDecHelper
     # 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(yy.round_to_scale(y.scale, 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
@@ -303,7 +306,7 @@ module TestLongDecHelper
     # 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(yy.round_to_scale(y.scale, 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
@@ -369,8 +372,8 @@ module TestLongDecHelper
     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)
+    z  = LongMath.power(x, y, prec, ROUND_HALF_UP)
+    zz = (x ** yi).round_to_scale(prec, 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}")
@@ -394,8 +397,8 @@ module TestLongDecHelper
     x = x.to_ld
     y = LongDecimal("0.5") * y2i
 
-    z  = LongMath.power(x, y, prec, LongMath::ROUND_HALF_UP)
-    zz = LongMath.sqrt(x ** y2i, prec, LongMath::ROUND_HALF_UP)
+    z  = LongMath.power(x, y, prec, ROUND_HALF_UP)
+    zz = LongMath.sqrt(x ** y2i, prec, 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}")
@@ -423,7 +426,7 @@ module TestLongDecHelper
     # calculate y = log(x)
     y  = LongMath.log(x, prec)
     yy = LongMath.log(x, prec+10)
-    # assert_equal(yy.round_to_scale(y.scale, LongDecimal::ROUND_HALF_DOWN), y, "x=#{x} y=#{y} yy=#{yy}")
+    # assert_equal(yy.round_to_scale(y.scale, 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 = log(x) calculated using regular floating
@@ -474,10 +477,10 @@ 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_FLOOR)
-    yu = LongMath.log_internal(x, prec, nil, nil, LongDecimal::ROUND_CEILING)
+    # yd = LongMath.log_internal(x, prec, nil, nil, ROUND_DOWN)
+    # yu = LongMath.log_internal(x, prec, nil, nil, ROUND_UP)
+    yd = LongMath.log_internal(x, prec, nil, nil, ROUND_FLOOR)
+    yu = LongMath.log_internal(x, prec, nil, nil, 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}")
@@ -503,7 +506,7 @@ module TestLongDecHelper
     prec_dp = 2*prec+1
     z_dp = LongMath.power(x, y, prec_dp)
     msg = "x=#{x}\ny=#{y}\nz=#{z}\nz_dp=#{z_dp}\nprec=#{prec}"
-    puts msg
+    # puts msg
     assert((z - z_dp).abs <= 2*z.unit, msg)
 
     corr2 = (x - 1).abs*1000000000 # 10**9
@@ -515,23 +518,27 @@ module TestLongDecHelper
       zf = z.to_f
       qf = 1e9
       delta = [ z.unit.to_f, zf.abs / qf ].max
+      # puts "delta=#{delta} z=#{z} zu=#{z.unit} zuf=#{z.unit.to_f} zf=#{zf} |zf/qf|=#{zf.abs/qf}"
       if (yf.abs > 1)
         l = Math.log(yf.abs)
         if (l > 1)
           delta *= l
         end
+        # puts "delta=#{delta} l=#{l}"
       end
       corr = corr2 * 0.5
       if corr > 1
         corr_f = [ corr.to_f, 5.0 ].min
         delta *= corr_f
       end
+      # puts "delta=#{delta} corr_f=#{corr_f} corr=#{corr}"
 
       diff  = (zf - wf).abs
       msg = "z=#{z}=#{zf} and wf=#{wf.to_s} should be almost equal\nx=#{x}=#{xf}\ny=#{y}=#{yf}\ndelta=#{delta}\nl=#{l}\ndiff=#{diff}\nprec=#{prec}\ncorr=#{corr}=#{corr.to_f}\ncorr2=#{corr2}=#{corr2.to_f}\ncorr_f=#{corr_f}"
-      puts msg
+      # puts msg
       assert_equal_float(zf, wf, delta, msg)
-      puts "OK"
+      # puts "OK"
+      print "."
     end
 
     # check by taking log(z) = y * log(x)
@@ -560,8 +567,8 @@ module TestLongDecHelper
       u_dp = LongMath.log(z_dp, lprec_dp)
       v = LongMath.log(x, lprec+l10y)
       v_dp = LongMath.log(x, lprec_dp + l10y)
-      yv = (y*v).round_to_scale(lprec, LongDecimal::ROUND_HALF_DOWN)
-      yv_dp = (y * v_dp).round_to_scale(lprec_dp, LongDecimal::ROUND_HALF_DOWN)
+      yv = (y*v).round_to_scale(lprec, ROUND_HALF_DOWN)
+      yv_dp = (y * v_dp).round_to_scale(lprec_dp, ROUND_HALF_DOWN)
       assert((u_dp - yv_dp).abs <= unit, "u=log(z,#{lprec})=#{u_dp}=#{u} and yv=y*v=y*log(x,#{lprec+l10y})=#{yv_dp}=#{yv} should be almost equal (unit=#{unit} x=#{x.to_s} y=#{y.to_s} z=#{z_dp}=#{z.to_s} u=#{u_dp}=#{u.to_s} v=#{v_dp}=#{v.to_s} lprec=#{lprec} prec=#{prec} lprec_dp=#{lprec_dp} prec_dp=#{prec_dp})")
       assert((u - yv).abs <= unit, "u=log(z,#{lprec})=#{u} and yv=y*v=y*log(x,#{lprec+l10y})=#{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
@@ -661,7 +668,7 @@ module TestLongDecHelper
     # calculate y = log2(x)
     y  = LongMath.log2(x, prec)
     yy = LongMath.log2(x, prec+10)
-    # assert_equal(yy.round_to_scale(y.scale, LongDecimal::ROUND_HALF_DOWN), y, "x=#{x} y=#{y} yy=#{yy}")
+    # assert_equal(yy.round_to_scale(y.scale, 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 = log2(x) calculated using regular floating
@@ -778,13 +785,26 @@ module TestLongDecHelper
 
   #
   # helper method of test_sqrt
+  # su0 and su1 describe how close the sqrt should be to the ideal result in units of the result
+  # usually su0=0 or -1 and su1=0 or 1
   #
   def check_sqrt(x, scale, mode, su0, su1, str)
     y  = x.sqrt(scale, mode)
-    if (mode == LongMath::ROUND_HALF_UP || mode == LongMath::ROUND_HALF_DOWN || mode == LongMath::ROUND_HALF_EVEN)
+    if (mode == ROUND_UNNECESSARY)
+      ALL_ROUNDING_MODES.each do |any_mode|
+        if (any_mode == ROUND_UNNECESSARY)
+          next
+        end
+        yy = x.sqrt(scale, any_mode)
+        assert_equal(y, yy, "any_mode=#{any_mode}")
+      end
+    end
+
+    if (mode == ROUND_HALF_UP || mode == ROUND_HALF_DOWN || mode == ROUND_HALF_EVEN)
       yy = x.sqrt(scale+10, mode)
       assert_equal(yy.round_to_scale(y.scale, mode), y, "x=#{x} y=#{y} yy=#{yy}")
     end
+
     z0 = (y+su0*y.unit).square
     z1 = (y+su1*y.unit).square
     assert(0 <= y.sign, "sqrt must be >= 0" + str)
@@ -823,6 +843,7 @@ module TestLongDecHelper
   def check_cbrtb_with_remainder(x, s)
     y, r = LongMath.cbrtb_with_remainder(x)
     z0 = y.cube
+    # puts "x=#{x} y=#{y} z0=#{z0} r=#{r}"
     z1 = z0 + r
     z2 = (y+1).cube
     assert(0 <= y, "cbrt _with_remainder must be >= 0" + s)
@@ -836,7 +857,7 @@ module TestLongDecHelper
   #
   def check_cbrt(x, scale, mode, su0, su1, str)
     y  = x.cbrt(scale, mode)
-    if (mode == LongMath::ROUND_HALF_UP || mode == LongMath::ROUND_HALF_DOWN || mode == LongMath::ROUND_HALF_EVEN)
+    if (mode == ROUND_HALF_UP || mode == ROUND_HALF_DOWN || mode == ROUND_HALF_EVEN)
       yy = x.cbrt(scale+10, mode)
       assert_equal(yy.round_to_scale(y.scale, mode), y, "x=#{x} y=#{y} yy=#{yy}")
     end