long-decimal 1.00.01 → 1.00.02

data/lib/long-decimal/version.rb

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

data/long-decimal.gemspec

@@ -0,0 +1,22 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'long-decimal/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "long-decimal"
+  spec.version       = LongDecimalSupport::VERSION
+  spec.authors       = ["Karl Brodowsky"]
+  spec.email         = ["karl_brodowsky@yahoo.com"]
+  spec.summary       = %q{Fixed Point Decimal Numbers}
+  spec.description   = %q{Decimal arbitrary precision fixed point numbers in pure Ruby.}
+  spec.homepage      = "https://github.com/bk1/ruby-long-decimal"
+  spec.license       = "LGPL or Ruby"
+  spec.files         = "./Gemfile", "./LICENSE", "./README", "./Rakefile", "./lib/long-decimal-extra.rb", "./lib/long-decimal.rb", "./test/testlongdecimal.rb", "./test/testlongdeclib.rb", "./test/testrandlib.rb", "./test/testrandom.rb", "./test/testrandpower.rb", "./tex/long-decimal.pdf", "./tex/long-decimal.tex", "./long-decimal.gemspec", "./lib/long-decimal/version.rb"
+  spec.executables   = 
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+end

data/test/testlongdecimal.rb

@@ -5,11 +5,20 @@
 # (C) Karl Brodowsky (IT Sky Consulting GmbH) 2006-2009
 #
 # 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: RELEASE_1_00_00 $
+# CVS-Label: $Name:  $
 # Author:    $Author: bk1 $ (Karl Brodowsky)
 #
 
-require 'test/unit'
+$test_type = nil
+if ((RUBY_VERSION.match /^1\./) || (RUBY_VERSION.match /^2\.0/)) then
+  require 'test/unit'
+  $test_type = :v20
+else
+  require 'minitest/autorun'
+  require 'test/unit/assertions'
+  include Test::Unit::Assertions
+  $test_type = :v21
+end
 
 # require "runit/testcase"
 # require "runit/cui/testrunner"
@@ -20,11 +29,20 @@ load "test/testlongdeclib.rb"
 
 LongMath.prec_overflow_handling = :warn_use_max
 
+if ($test_type == :v20)
+  class UnitTest < Test::Unit::TestCase
+  end
+else
+  class UnitTest < MiniTest::Test
+  end
+end
+
 #
 # test class for LongDecimal and LongDecimalQuot
 #
-class TestLongDecimal_class < Test::Unit::TestCase # RUNIT::TestCase
+class TestLongDecimal_class < UnitTest # RUNIT::TestCase
   include TestLongDecHelper
+  include LongDecimalRoundingMode
 
   @RCS_ID='-$Id: testlongdecimal.rb,v 1.86 2011/01/16 22:16:59 bk1 Exp $-'
 
@@ -186,6 +204,82 @@ class TestLongDecimal_class < Test::Unit::TestCase # RUNIT::TestCase
     assert((zr-xr).abs <= zr.unit, "zr-xr")
   end
 
+  #
+  # test exp2 of LongMath
+  #
+  def test_exp2
+    print "\ntest_exp2 [#{Time.now}]: "
+    10.times do |i|
+      n = (i*i+i)/2
+      x = LongDecimal(n, 3*i)+LongMath.pi(20)
+      check_exp2_floated(x, n)
+
+      y  = LongMath.exp2(x, n)
+      yy = LongMath.exp2(x, n + 5)
+      assert_equal(yy.round_to_scale(y.scale, LongDecimal::ROUND_HALF_DOWN), y, "x=#{x} y=#{y} yy=#{yy}")
+      z  = LongMath.power(2, x, n)
+      assert_equal(z, y, "exp2 x=#{x} y=#{y} z=#{z} i=#{i} n=#{n}")
+    end
+
+    # random tests that have failed previously
+    check_exp2_floated(LongDecimal("-0.00147492625237084606064197462823289474038138852346725504592707365251736299180323394082648207114993022483949313246714392730651107673327728615912046468517225938833913598854936005"), 20)
+
+  end
+
+  #
+  # test the calculation of the exponential function where result is
+  # near zero
+  #
+  def test_exp2_near_zero
+    print "\ntest_exp2_near_zero [#{Time.now}]: "
+
+    x = LongDecimal(1, 100)
+    y = LongMath.log2(x, 100)
+    z = check_exp2_floated(y, 100)
+    assert_equal(x, z, "must be equal")
+    z = check_exp2_floated(y, 99)
+    assert(z.zero?, "must be zero")
+    z = check_exp2_floated(y * 100, 99)
+    assert(z.zero?, "must be zero")
+
+  end
+
+  #
+  # test exp10 of LongMath
+  #
+  def test_exp10
+    print "\ntest_exp10 [#{Time.now}]: "
+    10.times do |i|
+      n  = (i*i+i)/2
+      x  = LongDecimal(n, 3*i)+LongMath.pi(20)
+      check_exp10_floated(x, n)
+
+      y  = LongMath.exp10(x, n)
+      yy = LongMath.exp10(x, n + 5)
+      assert_equal(yy.round_to_scale(y.scale, LongDecimal::ROUND_HALF_DOWN), y, "x=#{x} y=#{y} yy=#{yy}")
+      z  = LongMath.power(10, x, n)
+      assert_equal(z, y, "exp10 x=#{x} y=#{y} z=#{z} i=#{i} n=#{n}")
+    end
+  end
+
+  #
+  # test the calculation of the exponential function where result is
+  # near zero
+  #
+  def test_exp10_near_zero
+    print "\ntest_exp10_near_zero [#{Time.now}]: "
+
+    x = LongDecimal(1, 100)
+    y = LongMath.log10(x, 100)
+    z = check_exp10_floated(y, 100)
+    assert_equal(x, z, "must be equal")
+    z = check_exp10_floated(y, 99)
+    assert(z.zero?, "must be zero")
+    z = check_exp10_floated(y * 100, 99)
+    assert(z.zero?, "must be zero")
+
+  end
+
   #
   # test LongMath.log with non-LongDecimal arguments
   #
@@ -282,6 +376,410 @@ class TestLongDecimal_class < Test::Unit::TestCase # RUNIT::TestCase
   end
 
 
+  #
+  # test LongMath.power for bases that can be expressed as integer
+  #
+  def test_lm_power_xint
+    print "\ntest_lm_power_xint [#{Time.now}]: "
+
+    xx = LongMath.log(3, 40)
+    pi = LongMath.pi(40)
+    sq = LongMath.sqrt(5, 40)
+
+    check_power_xint(2, 700.01, 10)
+    check_power_xint(2, 100.001, 10)
+    check_power_xint(2, 1.000000001, 10)
+    check_power_xint(2, 0.01, 10)
+    check_power_xint(2, 1e-10, 10)
+    check_power_xint(2, 1e-90, 10)
+    check_power_xint(2, 0, 10)
+    check_power_xint(2, -1.000000001, 10)
+    check_power_xint(2, -100.001, 10)
+    check_power_xint(2, -700.01, 10)
+    check_power_xint(2, xx, 10)
+    check_power_xint(2, pi, 10)
+    check_power_xint(2, sq, 10)
+
+    check_power_xint(10, 308.01, 10)
+    check_power_xint(10, 100.001, 10)
+    check_power_xint(10, 1.000000001, 10)
+    check_power_xint(10, 0.01, 10)
+    check_power_xint(10, 1e-10, 10)
+    check_power_xint(10, 1e-90, 10)
+    check_power_xint(10, 0, 10)
+    check_power_xint(10, -1.000000001, 10)
+    check_power_xint(10, -100.001, 10)
+    check_power_xint(10, -308.01, 10)
+    check_power_xint(10, xx, 10)
+    check_power_xint(10, pi, 10)
+    check_power_xint(10, sq, 10)
+
+    check_power_xint(2, 700.01, 100)
+    check_power_xint(2, 100.001, 100)
+    check_power_xint(2, 1.000000001, 100)
+    check_power_xint(2, 0.01, 100)
+    check_power_xint(2, 1e-10, 100)
+    check_power_xint(2, 1e-90, 100)
+    check_power_xint(2, 0, 100)
+    check_power_xint(2, -1.000000001, 100)
+    check_power_xint(2, -100.001, 100)
+    check_power_xint(2, -700.01, 100)
+    check_power_xint(2, xx, 100)
+    check_power_xint(2, pi, 100)
+    check_power_xint(2, sq, 100)
+
+    check_power_xint(10, 308.01, 100)
+    check_power_xint(10, 100.001, 100)
+    check_power_xint(10, 1.000000001, 100)
+    check_power_xint(10, 0.01, 100)
+    check_power_xint(10, 1e-10, 100)
+    check_power_xint(10, 1e-90, 100)
+    check_power_xint(10, 0, 100)
+    check_power_xint(10, -1.000000001, 100)
+    check_power_xint(10, -100.001, 100)
+    check_power_xint(10, -308.01, 100)
+    check_power_xint(10, xx, 100)
+    check_power_xint(10, pi, 100)
+    check_power_xint(10, sq, 100)
+
+    check_power_xint(2, 700.01, 40)
+    check_power_xint(2, 100.001, 40)
+    check_power_xint(2, 1.000000001, 40)
+    check_power_xint(2, 0.01, 40)
+    check_power_xint(2, 1e-10, 40)
+    check_power_xint(2, 1e-90, 40)
+    check_power_xint(2, 0, 40)
+    check_power_xint(2, -1.000000001, 40)
+    check_power_xint(2, -100.001, 40)
+    check_power_xint(2, -700.01, 40)
+    check_power_xint(2, xx, 40)
+    check_power_xint(2, pi, 40)
+    check_power_xint(2, sq, 40)
+
+    check_power_xint(10, 308.01, 40)
+    check_power_xint(10, 100.001, 40)
+    check_power_xint(10, 1.000000001, 40)
+    check_power_xint(10, 0.01, 40)
+    check_power_xint(10, 1e-10, 40)
+    check_power_xint(10, 1e-90, 40)
+    check_power_xint(10, 0, 40)
+    check_power_xint(10, -1.000000001, 40)
+    check_power_xint(10, -100.001, 40)
+    check_power_xint(10, -308.01, 40)
+    check_power_xint(10, xx, 40)
+    check_power_xint(10, pi, 40)
+    check_power_xint(10, sq, 40)
+
+  end
+
+  #
+  # test LongMath.power for bases that can be expressed as integer
+  #
+  def test_lm_power_yint
+    print "\ntest_lm_power_yint [#{Time.now}] (2 min): "
+
+    xx = LongMath.log(3, 40)
+    pi = LongMath.pi(40)
+    sq = LongMath.sqrt(5, 40)
+
+    check_power_yint(xx, 400, 10)
+    check_power_yint(xx, 100, 10)
+    check_power_yint(xx, 1, 10)
+    check_power_yint(xx, 0, 10)
+    check_power_yint(xx, -1, 10)
+    check_power_yint(xx, -100, 10)
+    check_power_yint(xx, -400, 10)
+
+    check_power_yint(pi, 400, 10)
+    check_power_yint(pi, 100, 10)
+    check_power_yint(pi, 1, 10)
+    check_power_yint(pi, 0, 10)
+    check_power_yint(pi, -1, 10)
+    check_power_yint(pi, -100, 10)
+    check_power_yint(pi, -400, 10)
+
+    check_power_yint(sq, 400, 10)
+    check_power_yint(sq, 100, 10)
+    check_power_yint(sq, 1, 10)
+    check_power_yint(sq, 0, 10)
+    check_power_yint(sq, -1, 10)
+    check_power_yint(sq, -100, 10)
+    check_power_yint(sq, -400, 10)
+
+    check_power_yint(xx, 400, 100)
+    check_power_yint(xx, 100, 100)
+    check_power_yint(xx, 1, 100)
+    check_power_yint(xx, 0, 100)
+    check_power_yint(xx, -1, 100)
+    check_power_yint(xx, -100, 100)
+    check_power_yint(xx, -400, 100)
+
+    check_power_yint(pi, 400, 100)
+    check_power_yint(pi, 100, 100)
+    check_power_yint(pi, 1, 100)
+    check_power_yint(pi, 0, 100)
+    check_power_yint(pi, -1, 100)
+    check_power_yint(pi, -100, 100)
+    check_power_yint(pi, -400, 100)
+
+    check_power_yint(sq, 400, 100)
+    check_power_yint(sq, 100, 100)
+    check_power_yint(sq, 1, 100)
+    check_power_yint(sq, 0, 100)
+    check_power_yint(sq, -1, 100)
+    check_power_yint(sq, -100, 100)
+    check_power_yint(sq, -400, 100)
+
+    check_power_yint(xx, 400, 40)
+    check_power_yint(xx, 100, 40)
+    check_power_yint(xx, 1, 40)
+    check_power_yint(xx, 0, 40)
+    check_power_yint(xx, -1, 40)
+    check_power_yint(xx, -100, 40)
+    check_power_yint(xx, -400, 40)
+
+    check_power_yint(pi, 400, 40)
+    check_power_yint(pi, 100, 40)
+    check_power_yint(pi, 1, 40)
+    check_power_yint(pi, 0, 40)
+    check_power_yint(pi, -1, 40)
+    check_power_yint(pi, -100, 40)
+    check_power_yint(pi, -400, 40)
+
+    check_power_yint(sq, 400, 40)
+    check_power_yint(sq, 100, 40)
+    check_power_yint(sq, 1, 40)
+    check_power_yint(sq, 0, 40)
+    check_power_yint(sq, -1, 40)
+    check_power_yint(sq, -100, 40)
+    check_power_yint(sq, -400, 40)
+
+  end
+
+  #
+  # test LongMath.power for bases that can be expressed as integer
+  #
+  def test_lm_power_yhalfint
+    print "\ntest_lm_power_yhalfint [#{Time.now}] (10 min): "
+
+    xx = LongMath.log(3, 40)
+    pi = LongMath.pi(40)
+    sq = LongMath.sqrt(5, 40)
+
+    check_power_yhalfint(xx, 801, 10)
+    check_power_yhalfint(xx, 799, 10)
+    check_power_yhalfint(xx, 201, 10)
+    check_power_yhalfint(xx, 3, 10)
+    check_power_yhalfint(xx, 1, 10)
+    check_power_yhalfint(xx, -1, 10)
+    check_power_yhalfint(xx, -201, 10)
+    check_power_yhalfint(xx, -799, 10)
+    check_power_yhalfint(xx, -801, 10)
+
+    check_power_yhalfint(pi, 801, 10)
+    check_power_yhalfint(pi, 799, 10)
+    check_power_yhalfint(pi, 201, 10)
+    check_power_yhalfint(pi, 3, 10)
+    check_power_yhalfint(pi, 1, 10)
+    check_power_yhalfint(pi, -1, 10)
+    check_power_yhalfint(pi, -201, 10)
+    check_power_yhalfint(pi, -799, 10)
+    check_power_yhalfint(pi, -801, 10)
+
+    check_power_yhalfint(sq, 801, 10)
+    check_power_yhalfint(sq, 799, 10)
+    check_power_yhalfint(sq, 201, 10)
+    check_power_yhalfint(sq, 3, 10)
+    check_power_yhalfint(sq, 1, 10)
+    check_power_yhalfint(sq, -1, 10)
+    check_power_yhalfint(sq, -201, 10)
+    check_power_yhalfint(sq, -799, 10)
+    check_power_yhalfint(sq, -801, 10)
+
+    check_power_yhalfint(xx, 801, 40)
+    check_power_yhalfint(xx, 799, 40)
+    check_power_yhalfint(xx, 201, 40)
+    check_power_yhalfint(xx, 3, 40)
+    check_power_yhalfint(xx, 1, 40)
+    check_power_yhalfint(xx, -1, 40)
+    check_power_yhalfint(xx, -201, 40)
+    check_power_yhalfint(xx, -799, 40)
+    check_power_yhalfint(xx, -801, 40)
+
+    check_power_yhalfint(pi, 801, 40)
+    check_power_yhalfint(pi, 799, 40)
+    check_power_yhalfint(pi, 201, 40)
+    check_power_yhalfint(pi, 3, 40)
+    check_power_yhalfint(pi, 1, 40)
+    check_power_yhalfint(pi, -1, 40)
+    check_power_yhalfint(pi, -201, 40)
+    check_power_yhalfint(pi, -799, 40)
+    check_power_yhalfint(pi, -801, 40)
+
+    check_power_yhalfint(sq, 801, 40)
+    check_power_yhalfint(sq, 799, 40)
+    check_power_yhalfint(sq, 201, 40)
+    check_power_yhalfint(sq, 3, 40)
+    check_power_yhalfint(sq, 1, 40)
+    check_power_yhalfint(sq, -1, 40)
+    check_power_yhalfint(sq, -201, 40)
+    check_power_yhalfint(sq, -799, 40)
+    check_power_yhalfint(sq, -801, 40)
+
+  end
+
+  #
+  # test the calculation of the base-10-logarithm function
+  #
+  def test_log10
+    print "\ntest_log10 [#{Time.now}]: "
+    check_log10_floated(10**2000, 30)
+    check_log10_floated(100, 30)
+    check_log10_floated(1, 30)
+    check_log10_floated(0.01, 30)
+    check_log10_floated(1e-10, 30)
+    check_log10_floated(1e-90, 30)
+    check_log10_floated(1e-300, 30)
+    check_log10_floated(LongDecimal(1, 2000), 30)
+
+    check_log10_exact(10**2000, 2000, 30)
+    check_log10_exact(10**0, 0, 30)
+    check_log10_exact(10**1, 1, 30)
+    check_log10_exact(10**10, 10, 30)
+
+    # random tests that have failed
+    check_log10_floated(LongDecimal("587.00000000000000000095700000000000000000000000000000000000000000000000000000000000000000000001206"), 21)
+    check_log10_floated(LongDecimal("543.0000002480000900000000000000000000000000000000000000000000000000000000000000000000847"), 2)
+    check_log10_floated(LongDecimal("180.0000000000000000003570000000000000000000000000000000000000000000000577000000000000000000000000000637"), 2)
+    check_log10_floated(LongDecimal("0.0000000000000000000000000000000000000000180000000063000000000000000000000000000000000025"), 74)
+    check_log10_floated(LongDecimal("0.0000000000000000000000000006200000000000000000000000000000000000000000000000007940000015"), 74)
+    check_log10_floated(LongDecimal("0.00000000000000000000000000000000000000000032900000000000000000000233000000000000000000000000000000254"), 10)
+    check_log10_floated(LongDecimal("0.00000000000000000000000233000000094800000000000000000000000000000000000000000000000000000000000000682"), 100)
+    check_log10_floated(LongDecimal("0.000000000000000000000000000000000000097000000041500000000000000000784"), 97)
+    check_log10_floated(LongDecimal("185.000025300000000000000006320000000000000000000000000000737"), 27)
+    check_log10_floated(LongDecimal("0.00000000000000000000000000000302000000000000000000000000000000000000000000000000000000060673"), 100)
+    check_log10_floated(LongDecimal("442.000000000000045300000000000000000000000000000000000000000000000000000000000000000000000721000000000752"), 97)
+    check_log10_floated(LongDecimal("0.001030927835051546391752577284408545010096715910298651428936221023301883588097777204212461151695109779555577162172"), 62)
+
+  end
+
+  #
+  # test the calculation of the base-10-logarithm function
+  #
+  def test_log2
+    print "\ntest_log2 [#{Time.now}]: "
+    check_log2_floated(10**2000, 30)
+    check_log2_floated(2**2000, 30)
+    check_log2_floated(100, 30)
+    check_log2_floated(1, 30)
+    check_log2_floated(0.01, 30)
+    check_log2_floated(1e-10, 30)
+    check_log2_floated(1e-90, 30)
+    check_log2_floated(1e-300, 30)
+    check_log2_floated(LongDecimal(1, 2000), 30)
+
+    check_log2_exact(2**2000, 2000, 30)
+    check_log2_exact(2**0, 0, 30)
+    check_log2_exact(2**1, 1, 30)
+    check_log2_exact(2**10, 10, 30)
+
+    # random tests that have failed
+    check_log2_floated(LongDecimal("341.00000739000000000000000000000000000000000000000000000000000000000000171"), 3)
+    check_log2_floated(LongDecimal("504.00000000000000000000000000000000000000000000000000000000000000000000000000000000000327400000000000828"), 1)
+    check_log2_floated(LongDecimal("0.0033222591362126245847176079734219269102990032888157967351353737817463383406363175903135730345286354858609181999523961456225622835123748782987926188031081"), 48)
+    check_log2_floated(LongDecimal("0.000802000000000000000000197000000000000000000000302"), 84)
+    check_log2_floated(LongDecimal("0.00000000000000000000000000000000000000000000000000000000000000000000000452000000000069480"), 3)
+    check_log2_floated(LongDecimal("0.0000000000000000000000000000000000000000000000000000930000000000000000000000000983000000000000300"), 61)
+    check_log2_floated(LongDecimal("0.000000000000000000000000000000000000000000000000000000000086000133000000000000000000000000947"), 106)
+    check_log2_floated(LongDecimal("0.00000000000000000000000000000276000000000000000000000000000000000008560000000000000000000000000000161"), 81)
+
+  end
+
+  #
+  # test the calculation of the base-x-logarithm of sqrt(x)
+  #
+  def test_log_2_10_of_sqrt
+    print "\ntest_log_2_10_of_sqrt [#{Time.now}]: "
+    # n = 125
+    n = 30
+    m = 5
+    x2  = LongMath.sqrt(2, n)
+    x10 = LongMath.sqrt(10, n)
+
+    (2*m).times do |i|
+      check_log2_floated(x2, n+m-i)
+      check_log10_floated(x10, n+m-i)
+    end
+
+    y2  = check_log2_floated(x2, n)
+    assert((y2*2).one?, "xe=#{x2} ye=#{y2}")
+    y10 = check_log10_floated(x10, n)
+    assert((y10*2).one?, "xe=#{x10} ye=#{y10}")
+
+  end
+
+  #
+  # test LongMath.power with non-LongDecimal arguments
+  #
+  def test_non_ld_power
+    print "\ntest_non_ld_power [#{Time.now}]: "
+    xi = 77
+    yi = 88
+    zi = LongMath.power(xi, yi, 35)
+    wi = (LongMath.log(zi, 40) / LongMath.log(xi, 40)).round_to_scale(30, LongMath::ROUND_HALF_EVEN)
+    assert(wi.is_int?, "wi=#{wi} not int (zi=#{zi})")
+    assert_equal(yi, wi.to_i, "zi=#{zi} wi=#{wi}")
+    zj = LongMath.power_internal(xi, yi, 35)
+    assert_equal(zi, zj, "internal power should yield the same result zi=#{zi} zj=#{zj}")
+
+    xf = 77.0
+    yf = 88.0
+    zf = LongMath.power(xf, yf, 35)
+    wf = (LongMath.log(zf, 40) / LongMath.log(xf, 40)).round_to_scale(30, LongMath::ROUND_HALF_EVEN)
+    assert(wf.is_int?, "wf=#{wf} not int (zf=#{zf} wi=#{wi} zi=#{zi}")
+    assert_equal(yf, wf.to_i, "yf=#{yf} wf=#{yf}")
+
+    xr = Rational(224, 225)
+    yr = Rational(168, 169)
+    zr = LongMath.power(xr, yr, 35)
+    wr = (LongMath.log(zr, 40) / LongMath.log(xr, 40)).round_to_scale(30, LongMath::ROUND_HALF_EVEN)
+    assert((yr-wr).abs <= wr.unit, "wr-yr")
+  end
+
+  #
+  # test the calculation of the power-function of LongMath
+  #
+  def test_lm_power
+    print "\ntest_lm_power [#{Time.now}]: "
+    check_power_floated(1.001, 1.001, 10)
+    check_power_floated(1.001, 2.001, 10)
+    check_power_floated(2.001, 1.001, 10)
+    check_power_floated(2.001, 2.001, 10)
+    check_power_floated(100.001, 10.001, 10)
+    check_power_floated(10.001, 100.001, 10)
+    check_power_floated(10.001, 100.001, 100)
+    check_power_floated(1e-20, 1.01, 19)
+    check_power_floated(1.01, 1e-20, 19)
+    check_power_floated(1e-20, 1.01, 20)
+    check_power_floated(1.01, 1e-20, 20)
+    check_power_floated(1e-20, 1.01, 21)
+    check_power_floated(1.01, 1e-20, 21)
+
+    check_power_floated(1.001, -1.001, 10)
+    check_power_floated(1.001, -2.001, 10)
+    check_power_floated(2.001, -1.001, 10)
+    check_power_floated(2.001, -2.001, 10)
+    check_power_floated(100.001, -10.001, 10)
+    check_power_floated(10.001, -100.001, 10)
+    check_power_floated(1e-20, -1.01, 19)
+    check_power_floated(1.01, -1e-20, 19)
+    check_power_floated(1e-20, -1.01, 20)
+    check_power_floated(1.01, -1e-20, 20)
+    check_power_floated(1e-20, -1.01, 21)
+    check_power_floated(1.01, -1e-20, 21)
+
+  end
+
 
   #
   # test calculation of pi
@@ -331,15 +829,15 @@ class TestLongDecimal_class < Test::Unit::TestCase # RUNIT::TestCase
 
     l = LongDecimal(s)
     pi = LongMath.pi 200
-    assert_equal(l.round_to_scale(200, LongMath::ROUND_HALF_EVEN), pi, "200 digits")
+    assert_equal(l.round_to_scale(200, ROUND_HALF_EVEN), pi, "200 digits")
     pi = LongMath.pi 201
-    assert_equal(l.round_to_scale(201, LongMath::ROUND_HALF_EVEN), pi, "201 digits")
+    assert_equal(l.round_to_scale(201, ROUND_HALF_EVEN), pi, "201 digits")
     pi = LongMath.pi 199
-    assert_equal(l.round_to_scale(199, LongMath::ROUND_HALF_EVEN), pi, "199 digits")
+    assert_equal(l.round_to_scale(199, ROUND_HALF_EVEN), pi, "199 digits")
     pi = LongMath.pi 201
-    assert_equal(l.round_to_scale(201, LongMath::ROUND_HALF_EVEN), pi, "201 digits")
+    assert_equal(l.round_to_scale(201, ROUND_HALF_EVEN), pi, "201 digits")
     pi = LongMath.pi 1000
-    assert_equal(l.round_to_scale(1000, LongMath::ROUND_HALF_EVEN), pi, "1000 digits")
+    assert_equal(l.round_to_scale(1000, ROUND_HALF_EVEN), pi, "1000 digits")
   end
 
   #
@@ -649,7 +1147,6 @@ class TestLongDecimal_class < Test::Unit::TestCase # 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)
@@ -733,7 +1230,12 @@ class TestLongDecimal_class < Test::Unit::TestCase # RUNIT::TestCase
     zb = Complex(BigDecimal("2.4"),BigDecimal("-3.2"))
     zf = Complex(2.4,-3.2)
     zl = Complex(LongDecimal("2.4"),LongDecimal("-3.2"))
-    zi = Complex(2, -4)
+    zi = nil
+    if ($test_type == :v20)
+      zi = Complex(2, -4)
+    else
+      zi = zr
+    end
     twenties.each do |x|
       threes.each do |yr|
         fours.each do |yi|
@@ -930,7 +1432,7 @@ class TestLongDecimal_class < Test::Unit::TestCase # RUNIT::TestCase
     f = 224.225
     l = LongDecimal(f, 4)
     assert_equal("0.0224225", l.to_s, "l=#{l.inspect} f=#{f.inspect}")
-    assert_equal(l, (f/10000).to_ld(7), "to_ld")
+    assert_equal(l, (f/10000).to_ld(7), "to_ld l=#{l} f=#{f}")
   end
 
   #
@@ -1118,23 +1620,23 @@ class TestLongDecimal_class < Test::Unit::TestCase # RUNIT::TestCase
   def test_round_to_scale_up
     print "\ntest_round_to_scale_up [#{Time.now}]: "
     l = LongDecimal("2.21")
-    r = l.round_to_scale(1, LongDecimal::ROUND_UP)
+    r = l.round_to_scale(1, ROUND_UP)
     assert_equal("2.3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("2.21", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("-2.21")
-    r = l.round_to_scale(1, LongDecimal::ROUND_UP)
+    r = l.round_to_scale(1, ROUND_UP)
     assert_equal("-2.3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("-2.21", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("2.20")
-    r = l.round_to_scale(1, LongDecimal::ROUND_UP)
+    r = l.round_to_scale(1, ROUND_UP)
     assert_equal("2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("2.20", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("-2.20")
-    r = l.round_to_scale(1, LongDecimal::ROUND_UP)
+    r = l.round_to_scale(1, ROUND_UP)
     assert_equal("-2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("-2.20", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("2.24")
-    r = l.round_to_scale(4, LongDecimal::ROUND_UP)
+    r = l.round_to_scale(4, ROUND_UP)
     assert_equal("2.2400", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
   end
 
@@ -1144,23 +1646,23 @@ class TestLongDecimal_class < Test::Unit::TestCase # RUNIT::TestCase
   def test_round_to_scale_down
     print "\ntest_round_to_scale_down [#{Time.now}]: "
     l = LongDecimal("2.29")
-    r = l.round_to_scale(1, LongDecimal::ROUND_DOWN)
+    r = l.round_to_scale(1, ROUND_DOWN)
     assert_equal("2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("2.29", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("-2.29")
-    r = l.round_to_scale(1, LongDecimal::ROUND_DOWN)
+    r = l.round_to_scale(1, ROUND_DOWN)
     assert_equal("-2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("-2.29", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("2.20")
-    r = l.round_to_scale(1, LongDecimal::ROUND_DOWN)
+    r = l.round_to_scale(1, ROUND_DOWN)
     assert_equal("2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("2.20", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("-2.20")
-    r = l.round_to_scale(1, LongDecimal::ROUND_DOWN)
+    r = l.round_to_scale(1, ROUND_DOWN)
     assert_equal("-2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("-2.20", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("2.24")
-    r = l.round_to_scale(4, LongDecimal::ROUND_DOWN)
+    r = l.round_to_scale(4, ROUND_DOWN)
     assert_equal("2.2400", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
   end
 
@@ -1170,23 +1672,23 @@ class TestLongDecimal_class < Test::Unit::TestCase # RUNIT::TestCase
   def test_round_to_scale_ceiling
     print "\ntest_round_to_scale_ceiling [#{Time.now}]: "
     l = LongDecimal("2.21")
-    r = l.round_to_scale(1, LongDecimal::ROUND_CEILING)
+    r = l.round_to_scale(1, ROUND_CEILING)
     assert_equal("2.3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("2.21", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("-2.29")
-    r = l.round_to_scale(1, LongDecimal::ROUND_CEILING)
+    r = l.round_to_scale(1, ROUND_CEILING)
     assert_equal("-2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("-2.29", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("2.20")
-    r = l.round_to_scale(1, LongDecimal::ROUND_CEILING)
+    r = l.round_to_scale(1, ROUND_CEILING)
     assert_equal("2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("2.20", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("-2.20")
-    r = l.round_to_scale(1, LongDecimal::ROUND_CEILING)
+    r = l.round_to_scale(1, ROUND_CEILING)
     assert_equal("-2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("-2.20", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("2.24")
-    r = l.round_to_scale(4, LongDecimal::ROUND_CEILING)
+    r = l.round_to_scale(4, ROUND_CEILING)
     assert_equal("2.2400", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
   end
 
@@ -1196,23 +1698,23 @@ class TestLongDecimal_class < Test::Unit::TestCase # RUNIT::TestCase
   def test_round_to_scale_floor
     print "\ntest_round_to_scale_floor [#{Time.now}]: "
     l = LongDecimal("2.29")
-    r = l.round_to_scale(1, LongDecimal::ROUND_FLOOR)
+    r = l.round_to_scale(1, ROUND_FLOOR)
     assert_equal("2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("2.29", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("-2.21")
-    r = l.round_to_scale(1, LongDecimal::ROUND_FLOOR)
+    r = l.round_to_scale(1, ROUND_FLOOR)
     assert_equal("-2.3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("-2.21", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("2.20")
-    r = l.round_to_scale(1, LongDecimal::ROUND_FLOOR)
+    r = l.round_to_scale(1, ROUND_FLOOR)
     assert_equal("2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("2.20", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("-2.20")
-    r = l.round_to_scale(1, LongDecimal::ROUND_FLOOR)
+    r = l.round_to_scale(1, ROUND_FLOOR)
     assert_equal("-2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("-2.20", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("2.24")
-    r = l.round_to_scale(4, LongDecimal::ROUND_FLOOR)
+    r = l.round_to_scale(4, ROUND_FLOOR)
     assert_equal("2.2400", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
   end
 
@@ -1222,39 +1724,39 @@ class TestLongDecimal_class < Test::Unit::TestCase # RUNIT::TestCase
   def test_round_to_scale_half_up
     print "\ntest_round_to_scale_half_up [#{Time.now}]: "
     l = LongDecimal("2.20")
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_UP)
+    r = l.round_to_scale(1, ROUND_HALF_UP)
     assert_equal("2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("2.20", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("2.21")
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_UP)
+    r = l.round_to_scale(1, ROUND_HALF_UP)
     assert_equal("2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("2.21", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("2.25")
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_UP)
+    r = l.round_to_scale(1, ROUND_HALF_UP)
     assert_equal("2.3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("2.25", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("2.29")
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_UP)
+    r = l.round_to_scale(1, ROUND_HALF_UP)
     assert_equal("2.3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("2.29", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("-2.20")
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_UP)
+    r = l.round_to_scale(1, ROUND_HALF_UP)
     assert_equal("-2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("-2.20", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("-2.21")
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_UP)
+    r = l.round_to_scale(1, ROUND_HALF_UP)
     assert_equal("-2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("-2.21", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("-2.25")
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_UP)
+    r = l.round_to_scale(1, ROUND_HALF_UP)
     assert_equal("-2.3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("-2.25", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("-2.29")
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_UP)
+    r = l.round_to_scale(1, ROUND_HALF_UP)
     assert_equal("-2.3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("-2.29", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("2.24")
-    r = l.round_to_scale(4, LongDecimal::ROUND_HALF_UP)
+    r = l.round_to_scale(4, ROUND_HALF_UP)
     assert_equal("2.2400", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
   end
 
@@ -1264,123 +1766,123 @@ class TestLongDecimal_class < Test::Unit::TestCase # RUNIT::TestCase
   def test_round_to_scale_half_down
     print "\ntest_round_to_scale_half_down [#{Time.now}]: "
     l = LongDecimal("2.20")
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_DOWN)
+    r = l.round_to_scale(1, ROUND_HALF_DOWN)
     assert_equal("2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("2.20", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("2.21")
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_DOWN)
+    r = l.round_to_scale(1, ROUND_HALF_DOWN)
     assert_equal("2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("2.21", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("2.25")
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_DOWN)
+    r = l.round_to_scale(1, ROUND_HALF_DOWN)
     assert_equal("2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("2.25", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("2.29")
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_DOWN)
+    r = l.round_to_scale(1, ROUND_HALF_DOWN)
     assert_equal("2.3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("2.29", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("-2.20")
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_DOWN)
+    r = l.round_to_scale(1, ROUND_HALF_DOWN)
     assert_equal("-2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("-2.20", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("-2.21")
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_DOWN)
+    r = l.round_to_scale(1, ROUND_HALF_DOWN)
     assert_equal("-2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("-2.21", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("-2.25")
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_DOWN)
+    r = l.round_to_scale(1, ROUND_HALF_DOWN)
     assert_equal("-2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("-2.25", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("-2.29")
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_DOWN)
+    r = l.round_to_scale(1, ROUND_HALF_DOWN)
     assert_equal("-2.3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("-2.29", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("2.24")
-    r = l.round_to_scale(4, LongDecimal::ROUND_HALF_DOWN)
+    r = l.round_to_scale(4, ROUND_HALF_DOWN)
     assert_equal("2.2400", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
   end
 
   #
   # test rounding with ROUND_HALF_CEILING
   #
-  def test_round_to_scale_half_up
-    print "\ntest_round_to_scale_half_up [#{Time.now}]: "
+  def test_round_to_scale_half_ceiling
+    print "\ntest_round_to_scale_half_ceiling [#{Time.now}]: "
     l = LongDecimal("2.20")
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_CEILING)
+    r = l.round_to_scale(1, ROUND_HALF_CEILING)
     assert_equal("2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("2.20", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("2.21")
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_CEILING)
+    r = l.round_to_scale(1, ROUND_HALF_CEILING)
     assert_equal("2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("2.21", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("2.25")
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_CEILING)
+    r = l.round_to_scale(1, ROUND_HALF_CEILING)
     assert_equal("2.3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("2.25", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("2.29")
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_CEILING)
+    r = l.round_to_scale(1, ROUND_HALF_CEILING)
     assert_equal("2.3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("2.29", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("-2.20")
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_CEILING)
+    r = l.round_to_scale(1, ROUND_HALF_CEILING)
     assert_equal("-2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("-2.20", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("-2.21")
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_CEILING)
+    r = l.round_to_scale(1, ROUND_HALF_CEILING)
     assert_equal("-2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("-2.21", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("-2.25")
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_CEILING)
+    r = l.round_to_scale(1, ROUND_HALF_CEILING)
     assert_equal("-2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("-2.25", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("-2.29")
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_CEILING)
+    r = l.round_to_scale(1, ROUND_HALF_CEILING)
     assert_equal("-2.3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("-2.29", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("2.24")
-    r = l.round_to_scale(4, LongDecimal::ROUND_HALF_CEILING)
+    r = l.round_to_scale(4, ROUND_HALF_CEILING)
     assert_equal("2.2400", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
   end
 
   #
   # test rounding with ROUND_HALF_FLOOR
   #
-  def test_round_to_scale_half_down
-    print "\ntest_round_to_scale_half_down [#{Time.now}]: "
+  def test_round_to_scale_half_floor
+    print "\ntest_round_to_scale_half_floor [#{Time.now}]: "
     l = LongDecimal("2.20")
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_FLOOR)
+    r = l.round_to_scale(1, ROUND_HALF_FLOOR)
     assert_equal("2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("2.20", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("2.21")
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_FLOOR)
+    r = l.round_to_scale(1, ROUND_HALF_FLOOR)
     assert_equal("2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("2.21", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("2.25")
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_FLOOR)
+    r = l.round_to_scale(1, ROUND_HALF_FLOOR)
     assert_equal("2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("2.25", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("2.29")
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_FLOOR)
+    r = l.round_to_scale(1, ROUND_HALF_FLOOR)
     assert_equal("2.3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("2.29", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("-2.20")
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_FLOOR)
+    r = l.round_to_scale(1, ROUND_HALF_FLOOR)
     assert_equal("-2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("-2.20", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("-2.21")
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_FLOOR)
+    r = l.round_to_scale(1, ROUND_HALF_FLOOR)
     assert_equal("-2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("-2.21", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("-2.25")
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_FLOOR)
+    r = l.round_to_scale(1, ROUND_HALF_FLOOR)
     assert_equal("-2.3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("-2.25", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("-2.29")
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_FLOOR)
+    r = l.round_to_scale(1, ROUND_HALF_FLOOR)
     assert_equal("-2.3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("-2.29", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("2.24")
-    r = l.round_to_scale(4, LongDecimal::ROUND_HALF_FLOOR)
+    r = l.round_to_scale(4, ROUND_HALF_FLOOR)
     assert_equal("2.2400", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
   end
 
@@ -1390,64 +1892,755 @@ class TestLongDecimal_class < Test::Unit::TestCase # RUNIT::TestCase
   def test_round_to_scale_half_even
     print "\ntest_round_to_scale_half_even [#{Time.now}]: "
     l = LongDecimal("2.20")
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_EVEN)
+    r = l.round_to_scale(1, ROUND_HALF_EVEN)
     assert_equal("2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("2.20", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("2.21")
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_EVEN)
+    r = l.round_to_scale(1, ROUND_HALF_EVEN)
     assert_equal("2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("2.21", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("2.25")
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_EVEN)
+    r = l.round_to_scale(1, ROUND_HALF_EVEN)
     assert_equal("2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("2.25", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("2.35")
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_EVEN)
+    r = l.round_to_scale(1, ROUND_HALF_EVEN)
     assert_equal("2.4", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("2.35", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("2.29")
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_EVEN)
+    r = l.round_to_scale(1, ROUND_HALF_EVEN)
     assert_equal("2.3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("2.29", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("-2.20")
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_EVEN)
+    r = l.round_to_scale(1, ROUND_HALF_EVEN)
     assert_equal("-2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("-2.20", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("-2.21")
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_EVEN)
+    r = l.round_to_scale(1, ROUND_HALF_EVEN)
     assert_equal("-2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("-2.21", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("-2.25")
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_EVEN)
+    r = l.round_to_scale(1, ROUND_HALF_EVEN)
     assert_equal("-2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("-2.25", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("-2.35")
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_EVEN)
+    r = l.round_to_scale(1, ROUND_HALF_EVEN)
     assert_equal("-2.4", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("-2.35", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("-2.29")
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_EVEN)
+    r = l.round_to_scale(1, ROUND_HALF_EVEN)
     assert_equal("-2.3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_equal("-2.29", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("2.24")
-    r = l.round_to_scale(4, LongDecimal::ROUND_HALF_EVEN)
+    r = l.round_to_scale(4, ROUND_HALF_EVEN)
     assert_equal("2.2400", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
   end
 
+  #
+  # test rounding with ROUND_HALF_ODD
+  #
+  def test_round_to_scale_half_odd
+    print "\ntest_round_to_scale_half_odd [#{Time.now}]: "
+    l = LongDecimal("2.20")
+    r = l.round_to_scale(1, ROUND_HALF_ODD)
+    assert_equal("2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("2.20", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimal("2.21")
+    r = l.round_to_scale(1, ROUND_HALF_ODD)
+    assert_equal("2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("2.21", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimal("2.25")
+    r = l.round_to_scale(1, ROUND_HALF_ODD)
+    assert_equal("2.3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("2.25", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimal("2.35")
+    r = l.round_to_scale(1, ROUND_HALF_ODD)
+    assert_equal("2.3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("2.35", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimal("2.29")
+    r = l.round_to_scale(1, ROUND_HALF_ODD)
+    assert_equal("2.3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("2.29", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimal("-2.20")
+    r = l.round_to_scale(1, ROUND_HALF_ODD)
+    assert_equal("-2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("-2.20", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimal("-2.21")
+    r = l.round_to_scale(1, ROUND_HALF_ODD)
+    assert_equal("-2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("-2.21", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimal("-2.25")
+    r = l.round_to_scale(1, ROUND_HALF_ODD)
+    assert_equal("-2.3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("-2.25", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimal("-2.35")
+    r = l.round_to_scale(1, ROUND_HALF_ODD)
+    assert_equal("-2.3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("-2.35", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimal("-2.29")
+    r = l.round_to_scale(1, ROUND_HALF_ODD)
+    assert_equal("-2.3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("-2.29", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimal("2.24")
+    r = l.round_to_scale(4, ROUND_HALF_ODD)
+    assert_equal("2.2400", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+  end
+
+  #
+  # test rounding with ROUND_GEOMETRIC_*
+  #
+  def test_round_to_scale_geometric_common
+    print "\ntest_round_to_scale_geometric_common [#{Time.now}]: "
+    ALL_ROUNDING_MODES.each do |rounding_mode|
+      if (rounding_mode.major == MAJOR_GEOMETRIC)
+        l = LongDecimal("0.00")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("0.0", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("0.00", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("0.01")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("0.1", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("0.01", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("0.000001")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("0.1", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("0.000001", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        r = l.round_to_scale(0, rounding_mode)
+        assert_equal("1", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("0.000001", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("0.099999")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("0.1", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("0.099999", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("-0.01")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("-0.1", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("-0.01", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("-0.000001")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("-0.1", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("-0.000001", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        r = l.round_to_scale(0, rounding_mode)
+        assert_equal("-1", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("-0.099999")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("-0.1", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("-0.099999", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("1.414213562373095048801688724209698078569671875376948073176679737990732478462107038850387534327641")
+        r = l.round_to_scale(0, rounding_mode)
+        assert_equal("1", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("1.414213562373095048801688724209698078569671875376948073176679737990732478462107038850387534327641", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("1.414213562373095048801688724209698078569671875376948073176679737990732478462107038850387534327642")
+        r = l.round_to_scale(0, rounding_mode)
+        assert_equal("2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("1.414213562373095048801688724209698078569671875376948073176679737990732478462107038850387534327642", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("-1.414213562373095048801688724209698078569671875376948073176679737990732478462107038850387534327641")
+        r = l.round_to_scale(0, rounding_mode)
+        assert_equal("-1", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("-1.414213562373095048801688724209698078569671875376948073176679737990732478462107038850387534327641", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("-1.414213562373095048801688724209698078569671875376948073176679737990732478462107038850387534327642")
+        r = l.round_to_scale(0, rounding_mode)
+        assert_equal("-2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("-1.414213562373095048801688724209698078569671875376948073176679737990732478462107038850387534327642", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+
+        l = LongDecimal("2.20")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("2.20", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("2.21")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("2.21", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("2.25")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("2.3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("2.25", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("2.29")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("2.3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("2.29", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("-2.20")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("-2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("-2.20", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("-2.21")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("-2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("-2.21", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("-2.25")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("-2.3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("-2.25", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("-2.29")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("-2.3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("-2.29", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("2.24")
+        r = l.round_to_scale(4, rounding_mode)
+        assert_equal("2.2400", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+      end
+    end
+  end
+
+  #
+  # test rounding with ROUND_HARMONIC_*
+  #
+  def test_round_to_scale_harmonic_common
+    print "\ntest_round_to_scale_harmonic_common [#{Time.now}]: "
+    ALL_ROUNDING_MODES.each do |rounding_mode|
+      if (rounding_mode.major == MAJOR_HARMONIC)
+        l = LongDecimal("0.00")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("0.0", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("0.00", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("0.01")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("0.1", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("0.01", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("0.000001")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("0.1", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("0.000001", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        r = l.round_to_scale(0, rounding_mode)
+        assert_equal("1", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("0.000001", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("0.099999")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("0.1", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("0.099999", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("-0.01")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("-0.1", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("-0.01", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("-0.000001")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("-0.1", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("-0.000001", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        r = l.round_to_scale(0, rounding_mode)
+        assert_equal("-1", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("-0.099999")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("-0.1", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("-0.099999", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+
+        # harmonic mean of 1 and 2 is 4/3
+        l = LongDecimal("1.33333333333333333333333333333333333333333333")
+        r = l.round_to_scale(0, rounding_mode)
+        assert_equal("1", r.to_s, "l=#{l.inspect} r=#{r.inspect} rounding_mode=#{rounding_mode}")
+        assert_equal("1.33333333333333333333333333333333333333333333", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("1.33333333333333333333333333333333333333333334")
+        r = l.round_to_scale(0, rounding_mode)
+        assert_equal("2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("1.33333333333333333333333333333333333333333334", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("-1.33333333333333333333333333333333333333333333")
+        r = l.round_to_scale(0, rounding_mode)
+        assert_equal("-1", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("-1.33333333333333333333333333333333333333333333", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("-1.33333333333333333333333333333333333333333334")
+        r = l.round_to_scale(0, rounding_mode)
+        assert_equal("-2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("-1.33333333333333333333333333333333333333333334", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+
+        l = LongDecimal("2.20")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("2.20", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("2.21")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("2.21", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("2.25")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("2.3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("2.25", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("2.29")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("2.3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("2.29", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("-2.20")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("-2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("-2.20", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("-2.21")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("-2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("-2.21", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("-2.25")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("-2.3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("-2.25", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("-2.29")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("-2.3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("-2.29", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("2.24")
+        r = l.round_to_scale(4, rounding_mode)
+        assert_equal("2.2400", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+      end
+    end
+  end
+
+  #
+  # test rounding with ROUND_HARMONIC_UP
+  #
+  def test_round_to_scale_harmonic_up
+    print "\ntest_round_to_scale_harmonic_up [#{Time.now}]: "
+    l = LongDecimal("2.39")
+    r = l.round_to_scale(0, ROUND_HARMONIC_UP)
+    assert_equal("2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("2.39", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimal("2.40")
+    r = l.round_to_scale(0, ROUND_HARMONIC_UP)
+    assert_equal("3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("2.40", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimal("2.41")
+    r = l.round_to_scale(0, ROUND_HARMONIC_UP)
+    assert_equal("3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("2.41", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimal("-2.39")
+    r = l.round_to_scale(0, ROUND_HARMONIC_UP)
+    assert_equal("-2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("-2.39", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimal("-2.40")
+    r = l.round_to_scale(0, ROUND_HARMONIC_UP)
+    assert_equal("-3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("-2.40", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimal("12.47999")
+    r = l.round_to_scale(0, ROUND_HARMONIC_UP)
+    assert_equal("12", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("12.47999", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimal("12.48")
+    r = l.round_to_scale(0, ROUND_HARMONIC_UP)
+    assert_equal("13", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("12.48", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimal("12.48001")
+    r = l.round_to_scale(0, ROUND_HARMONIC_UP)
+    assert_equal("13", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("12.48001", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+  end
+
+  #
+  # test rounding with ROUND_HARMONIC_DOWN
+  #
+  def test_round_to_scale_harmonic_down
+    print "\ntest_round_to_scale_harmonic_down [#{Time.now}]: "
+    l = LongDecimal("2.39")
+    r = l.round_to_scale(0, ROUND_HARMONIC_DOWN)
+    assert_equal("2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("2.39", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimal("2.40")
+    r = l.round_to_scale(0, ROUND_HARMONIC_DOWN)
+    assert_equal("2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("2.40", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimal("2.41")
+    r = l.round_to_scale(0, ROUND_HARMONIC_DOWN)
+    assert_equal("3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("2.41", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimal("-2.39")
+    r = l.round_to_scale(0, ROUND_HARMONIC_DOWN)
+    assert_equal("-2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("-2.39", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimal("-2.40")
+    r = l.round_to_scale(0, ROUND_HARMONIC_DOWN)
+    assert_equal("-2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("-2.40", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimal("12.47999")
+    r = l.round_to_scale(0, ROUND_HARMONIC_DOWN)
+    assert_equal("12", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("12.47999", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimal("12.48")
+    r = l.round_to_scale(0, ROUND_HARMONIC_DOWN)
+    assert_equal("12", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("12.48", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimal("12.48001")
+    r = l.round_to_scale(0, ROUND_HARMONIC_DOWN)
+    assert_equal("13", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("12.48001", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+  end
+
+  #
+  # test rounding with ROUND_HARMONIC_CEILING
+  #
+  def test_round_to_scale_harmonic_ceiling
+    print "\ntest_round_to_scale_harmonic_ceiling [#{Time.now}]: "
+    l = LongDecimal("2.39")
+    r = l.round_to_scale(0, ROUND_HARMONIC_CEILING)
+    assert_equal("2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("2.39", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimal("2.40")
+    r = l.round_to_scale(0, ROUND_HARMONIC_CEILING)
+    assert_equal("3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("2.40", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimal("2.41")
+    r = l.round_to_scale(0, ROUND_HARMONIC_CEILING)
+    assert_equal("3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("2.41", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimal("-2.39")
+    r = l.round_to_scale(0, ROUND_HARMONIC_CEILING)
+    assert_equal("-2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("-2.39", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimal("-2.40")
+    r = l.round_to_scale(0, ROUND_HARMONIC_CEILING)
+    assert_equal("-2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("-2.40", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimal("12.47999")
+    r = l.round_to_scale(0, ROUND_HARMONIC_CEILING)
+    assert_equal("12", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("12.47999", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimal("12.48")
+    r = l.round_to_scale(0, ROUND_HARMONIC_CEILING)
+    assert_equal("13", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("12.48", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimal("12.48001")
+    r = l.round_to_scale(0, ROUND_HARMONIC_CEILING)
+    assert_equal("13", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("12.48001", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+  end
+
+  #
+  # test rounding with ROUND_HARMONIC_FLOOR
+  #
+  def test_round_to_scale_harmonic_floor
+    print "\ntest_round_to_scale_harmonic_floor [#{Time.now}]: "
+    l = LongDecimal("2.39")
+    r = l.round_to_scale(0, ROUND_HARMONIC_FLOOR)
+    assert_equal("2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("2.39", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimal("2.40")
+    r = l.round_to_scale(0, ROUND_HARMONIC_FLOOR)
+    assert_equal("2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("2.40", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimal("2.41")
+    r = l.round_to_scale(0, ROUND_HARMONIC_FLOOR)
+    assert_equal("3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("2.41", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimal("-2.39")
+    r = l.round_to_scale(0, ROUND_HARMONIC_FLOOR)
+    assert_equal("-2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("-2.39", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimal("-2.40")
+    r = l.round_to_scale(0, ROUND_HARMONIC_FLOOR)
+    assert_equal("-3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("-2.40", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimal("12.47999")
+    r = l.round_to_scale(0, ROUND_HARMONIC_FLOOR)
+    assert_equal("12", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("12.47999", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimal("12.48")
+    r = l.round_to_scale(0, ROUND_HARMONIC_FLOOR)
+    assert_equal("12", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("12.48", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimal("12.48001")
+    r = l.round_to_scale(0, ROUND_HARMONIC_FLOOR)
+    assert_equal("13", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("12.48001", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+  end
+
+  #
+  # test rounding with ROUND_HARMONIC_EVEN
+  #
+  def test_round_to_scale_harmonic_even
+    print "\ntest_round_to_scale_harmonic_even [#{Time.now}]: "
+    l = LongDecimal("2.39")
+    r = l.round_to_scale(0, ROUND_HARMONIC_EVEN)
+    assert_equal("2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("2.39", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimal("2.40")
+    r = l.round_to_scale(0, ROUND_HARMONIC_EVEN)
+    assert_equal("2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("2.40", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimal("2.41")
+    r = l.round_to_scale(0, ROUND_HARMONIC_EVEN)
+    assert_equal("3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("2.41", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimal("-2.39")
+    r = l.round_to_scale(0, ROUND_HARMONIC_EVEN)
+    assert_equal("-2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("-2.39", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimal("-2.40")
+    r = l.round_to_scale(0, ROUND_HARMONIC_EVEN)
+    assert_equal("-2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("-2.40", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimal("12.47999")
+    r = l.round_to_scale(0, ROUND_HARMONIC_EVEN)
+    assert_equal("12", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("12.47999", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimal("12.48")
+    r = l.round_to_scale(0, ROUND_HARMONIC_EVEN)
+    assert_equal("12", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("12.48", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimal("12.48001")
+    r = l.round_to_scale(0, ROUND_HARMONIC_EVEN)
+    assert_equal("13", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("12.48001", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+  end
+
+  #
+  # test rounding with ROUND_HARMONIC_ODD
+  #
+  def test_round_to_scale_harmonic_even
+    print "\ntest_round_to_scale_harmonic_even [#{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}")
+    assert_equal("2.39", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimal("2.40")
+    r = l.round_to_scale(0, ROUND_HARMONIC_ODD)
+    assert_equal("3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("2.40", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimal("2.41")
+    r = l.round_to_scale(0, ROUND_HARMONIC_ODD)
+    assert_equal("3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("2.41", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    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}")
+    assert_equal("-2.39", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimal("-2.40")
+    r = l.round_to_scale(0, ROUND_HARMONIC_ODD)
+    assert_equal("-3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("-2.40", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimal("12.47999")
+    r = l.round_to_scale(0, ROUND_HARMONIC_ODD)
+    assert_equal("12", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("12.47999", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimal("12.48")
+    r = l.round_to_scale(0, ROUND_HARMONIC_ODD)
+    assert_equal("13", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("12.48", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimal("12.48001")
+    r = l.round_to_scale(0, ROUND_HARMONIC_ODD)
+    assert_equal("13", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_equal("12.48001", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+  end
+
+  #
+  # test rounding with ROUND_QUADRATIC_*
+  #
+  def test_round_to_scale_quadratic_common
+    print "\ntest_round_to_scale_quadratic_common [#{Time.now}]: "
+    ALL_ROUNDING_MODES.each do |rounding_mode|
+      if (rounding_mode.major == MAJOR_QUADRATIC)
+        l = LongDecimal("0.00")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("0.0", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("0.00", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("0.01")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("0.0", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("0.01", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("0.000001")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("0.0", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("0.000001", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        r = l.round_to_scale(0, rounding_mode)
+        assert_equal("0", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("0.000001", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("0.099999")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("0.1", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("0.099999", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("-0.01")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("0.0", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("-0.01", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("-0.000001")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("0.0", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("-0.000001", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        r = l.round_to_scale(0, rounding_mode)
+        assert_equal("0", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("-0.099999")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("-0.1", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("-0.099999", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+
+        # sqrt(2) is the quadratic mean of 0 and 2: 0.7071067811865475244008443621048490392848359376884740365883398689953662392310535194251937671638207864
+        l = LongDecimal("0.7071067811")
+        r = l.round_to_scale(0, rounding_mode)
+        assert_equal("0", r.to_s, "l=#{l.inspect} r=#{r.inspect} rounding_mode=#{rounding_mode}")
+        assert_equal("0.7071067811", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("0.7071067812")
+        r = l.round_to_scale(0, rounding_mode)
+        assert_equal("1", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("0.7071067812", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("-0.7071067811")
+        r = l.round_to_scale(0, rounding_mode)
+        assert_equal("0", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("-0.7071067811", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("-0.7071067812")
+        r = l.round_to_scale(0, rounding_mode)
+        assert_equal("-1", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("-0.7071067812", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+
+        l = LongDecimal("1.5811388300")
+        r = l.round_to_scale(0, rounding_mode)
+        assert_equal("1", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("1.5811388300", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("1.5811388301")
+        r = l.round_to_scale(0, rounding_mode)
+        assert_equal("2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("1.5811388301", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+
+        l = LongDecimal("2.20")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("2.20", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("2.21")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("2.21", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("2.25")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("2.25", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("2.29")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("2.3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("2.29", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("-2.20")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("-2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("-2.20", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("-2.21")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("-2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("-2.21", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("-2.25")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("-2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("-2.25", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("-2.29")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("-2.3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("-2.29", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("2.24")
+        r = l.round_to_scale(4, rounding_mode)
+        assert_equal("2.2400", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+      end
+    end
+  end
+
+  #
+  # test rounding with ROUND_CUBIC_*
+  #
+  def test_round_to_scale_cubic_common
+    print "\ntest_round_to_scale_cubic_common [#{Time.now}]: "
+    ALL_ROUNDING_MODES.each do |rounding_mode|
+      if (rounding_mode.major == MAJOR_CUBIC)
+        l = LongDecimal("0.00")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("0.0", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("0.00", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("0.01")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("0.0", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("0.01", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("0.000001")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("0.0", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("0.000001", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        r = l.round_to_scale(0, rounding_mode)
+        assert_equal("0", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("0.000001", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("0.099999")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("0.1", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("0.099999", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("-0.01")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("0.0", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("-0.01", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("-0.000001")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("0.0", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("-0.000001", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        r = l.round_to_scale(0, rounding_mode)
+        assert_equal("0", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("-0.099999")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("-0.1", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("-0.099999", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+
+        l = LongDecimal("0.7937005259")
+        r = l.round_to_scale(0, rounding_mode)
+        assert_equal("0", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("0.7937005259", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("0.7937005260")
+        r = l.round_to_scale(0, rounding_mode)
+        assert_equal("1", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("0.7937005260", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("-0.7937005259")
+        r = l.round_to_scale(0, rounding_mode)
+        assert_equal("0", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("-0.7937005259", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("-0.7937005260")
+        r = l.round_to_scale(0, rounding_mode)
+        assert_equal("-1", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("-0.7937005260", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+
+        l = LongDecimal("1.6509636244")
+        r = l.round_to_scale(0, rounding_mode)
+        assert_equal("1", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("1.6509636244", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("1.6509636245")
+        r = l.round_to_scale(0, rounding_mode)
+        assert_equal("2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("1.6509636245", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+
+        l = LongDecimal("2.20")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("2.20", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("2.21")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("2.21", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("2.25")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("2.25", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("2.29")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("2.3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("2.29", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("-2.20")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("-2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("-2.20", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("-2.21")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("-2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("-2.21", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("-2.25")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("-2.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("-2.25", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("-2.29")
+        r = l.round_to_scale(1, rounding_mode)
+        assert_equal("-2.3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        assert_equal("-2.29", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+        l = LongDecimal("2.24")
+        r = l.round_to_scale(4, rounding_mode)
+        assert_equal("2.2400", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+      end
+    end
+  end
+
   #
   # test rounding with ROUND_UNNECESSARY
   #
   def test_round_to_scale_unnecessary
     print "\ntest_round_to_scale_unnecessary [#{Time.now}]: "
     l = LongDecimal("2.24")
-    r = l.round_to_scale(4, LongDecimal::ROUND_UNNECESSARY)
+    r = l.round_to_scale(4, ROUND_UNNECESSARY)
     assert_equal("2.2400", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimal("2.2400")
-    r = l.round_to_scale(2, LongDecimal::ROUND_UNNECESSARY)
+    r = l.round_to_scale(2, ROUND_UNNECESSARY)
     assert_equal("2.24", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     begin
       l = LongDecimal("2.24")
-      r = l.round_to_scale(1, LongDecimal::ROUND_UNNECESSARY)
+      r = l.round_to_scale(1, ROUND_UNNECESSARY)
       assert_fail("should not have succeeded l=#{l.inspect} r=#{r.inspect}")
     rescue ArgumentError
       # ignored
@@ -1458,23 +2651,23 @@ class TestLongDecimal_class < Test::Unit::TestCase # RUNIT::TestCase
   # test rounding of int to remainder set
   #
   def test_int_round_to_one_allowed_remainder
-    print "\ntest_int_round_to_one_allowed_remainder [#{Time.now}] (20min): "
+    print "\ntest_int_round_to_one_allowed_remainder [#{Time.now}] (20sec): "
     $stdout.flush
     2.upto 20 do |modulus|
       0.upto modulus-1 do |r|
+        print "."
         n = 3*modulus
         (-n).upto n do |i|
           text = "i=#{i} n=#{n} m=#{modulus} r=#{r}"
-          print ":"
           $stdout.flush
 
-          i_rounded = check_round_to_one_remainder(i, r, modulus, LongDecimalRoundingMode::ROUND_UP, LongDecimalRoundingMode::ZERO_ROUND_TO_PLUS)
+          i_rounded = check_round_to_one_remainder(i, r, modulus, ROUND_UP, ZERO_ROUND_TO_PLUS)
           assert(i_rounded.abs >= i.abs, "i_r=#{i_rounded} " + text)
           if (i == 0) then
             assert(i_rounded >= 0, "i_r=#{i_rounded} " + text)
           end
 
-          i_rounded = check_round_to_one_remainder(i, r, modulus, LongDecimalRoundingMode::ROUND_DOWN, LongDecimalRoundingMode::ZERO_ROUND_TO_PLUS)
+          i_rounded = check_round_to_one_remainder(i, r, modulus, ROUND_DOWN, ZERO_ROUND_TO_PLUS)
           if (i > 0)
             assert(i_rounded <= i, "i_r=#{i_rounded} " + text)
           elsif (i < 0)
@@ -1485,39 +2678,75 @@ class TestLongDecimal_class < Test::Unit::TestCase # RUNIT::TestCase
             raise("i=#{i} i_r=#{i_rounded}")
           end
 
-          i_rounded = check_round_to_one_remainder(i, r, modulus, LongDecimalRoundingMode::ROUND_CEILING, LongDecimalRoundingMode::ZERO_ROUND_TO_PLUS)
+          i_rounded = check_round_to_one_remainder(i, r, modulus, ROUND_CEILING, ZERO_ROUND_TO_PLUS)
           assert(i_rounded >= i, "i_r=#{i_rounded} " + text)
 
-          i_rounded = check_round_to_one_remainder(i, r, modulus, LongDecimalRoundingMode::ROUND_FLOOR, LongDecimalRoundingMode::ZERO_ROUND_TO_PLUS)
+          i_rounded = check_round_to_one_remainder(i, r, modulus, ROUND_FLOOR, ZERO_ROUND_TO_PLUS)
           assert(i_rounded <= i, "i_r=#{i_rounded} " + text)
 
-          i_rounded = check_round_to_one_remainder(i, r, modulus, LongDecimalRoundingMode::ROUND_HALF_UP, LongDecimalRoundingMode::ZERO_ROUND_TO_PLUS)
+          i_rounded = check_round_to_one_remainder(i, r, modulus, ROUND_HALF_UP, ZERO_ROUND_TO_PLUS)
           dd = 2*(i_rounded - i).abs
           assert(dd <= modulus, "i_r=#{i_rounded} " + text)
           if (i_rounded.abs < i.abs || i_rounded.sgn == - i.sgn)
             assert(dd < modulus, "i_r=#{i_rounded} " + text)
           end
 
-          i_rounded = check_round_to_one_remainder(i, r, modulus, LongDecimalRoundingMode::ROUND_HALF_DOWN, LongDecimalRoundingMode::ZERO_ROUND_TO_PLUS)
+          i_rounded = check_round_to_one_remainder(i, r, modulus, ROUND_HALF_DOWN, ZERO_ROUND_TO_PLUS)
           dd = 2*(i_rounded - i).abs
           assert(dd <= modulus, "i_r=#{i_rounded} " + text)
           if (i_rounded.abs > i.abs && i_rounded.sgn == i.sgn)
             assert(dd < modulus, "i_r=#{i_rounded} " + text)
           end
 
-          i_rounded = check_round_to_one_remainder(i, r, modulus, LongDecimalRoundingMode::ROUND_HALF_CEILING, LongDecimalRoundingMode::ZERO_ROUND_TO_PLUS)
+          i_rounded = check_round_to_one_remainder(i, r, modulus, ROUND_HALF_CEILING, ZERO_ROUND_TO_PLUS)
           dd = 2*(i_rounded - i).abs
           assert(dd <= modulus, "i_r=#{i_rounded} " + text)
           if (i_rounded < i)
             assert(dd < modulus, "i_r=#{i_rounded} " + text)
           end
 
-          i_rounded = check_round_to_one_remainder(i, r, modulus, LongDecimalRoundingMode::ROUND_HALF_FLOOR, LongDecimalRoundingMode::ZERO_ROUND_TO_PLUS)
+          i_rounded = check_round_to_one_remainder(i, r, modulus, ROUND_HALF_FLOOR, ZERO_ROUND_TO_PLUS)
           dd = 2*(i_rounded - i).abs
           assert(dd <= modulus, "i_r=#{i_rounded} " + text)
           if (i_rounded > i && i != 0)
             assert(dd < modulus, "i_r=#{i_rounded} " + text)
           end
+
+          ALL_ROUNDING_MODES.each do |rounding_mode|
+            unless (rounding_mode.major == MAJOR_GEOMETRIC \
+                    || rounding_mode.major == MAJOR_HARMONIC \
+                    || rounding_mode.major == MAJOR_QUADRATIC \
+                    || rounding_mode.major == MAJOR_CUBIC)
+              next;
+            end
+            if (rounding_mode.minor == MINOR_EVEN || rounding_mode.minor == MINOR_ODD)
+              next
+            end
+            i_rounded = check_round_to_one_remainder(i, r, modulus, rounding_mode, ZERO_ROUND_TO_PLUS)
+          end
+        end
+      end
+    end
+  end
+
+  #
+  # test rounding of int to remainder set
+  #
+  def test_zero_round_to_zero_as_allowed_remainder
+    print "\ntest_zero_round_to_zero_as_allowed_remainder [#{Time.now}]: "
+
+    2.upto 20 do |modulus|
+      text = "m=#{modulus}"
+      ALL_ROUNDING_MODES.each do |rounding_mode|
+        if (rounding_mode.minor == MINOR_EVEN || rounding_mode.minor == MINOR_ODD)
+          next
+        end
+        if (rounding_mode.major == MAJOR_UNNECESSARY)
+          next
+        end
+        ALL_ZERO_MODES.each do |zero_mode|
+          zero_rounded = 0.round_to_allowed_remainders([0], modulus, rounding_mode, zero_mode)
+          assert_equal(0, zero_rounded)
         end
       end
     end
@@ -1532,104 +2761,91 @@ class TestLongDecimal_class < Test::Unit::TestCase # RUNIT::TestCase
       0.upto modulus-1 do |r|
         text = "m=#{modulus} r=#{r}"
 
-        zero_r = check_round_to_one_remainder(0, r, modulus, LongDecimalRoundingMode::ROUND_UP, LongDecimalRoundingMode::ZERO_ROUND_TO_PLUS)
+        zero_r = check_round_to_one_remainder(0, r, modulus, ROUND_UP, ZERO_ROUND_TO_PLUS)
         assert(zero_r >= 0, "0_r=#{zero_r} " + text)
-        zero_r = check_round_to_one_remainder(0, r, modulus, LongDecimalRoundingMode::ROUND_UP, LongDecimalRoundingMode::ZERO_ROUND_TO_MINUS)
+        zero_r = check_round_to_one_remainder(0, r, modulus, ROUND_UP, ZERO_ROUND_TO_MINUS)
         assert(zero_r <= 0, "0_r=#{zero_r} " + text)
-        zero_r = check_round_to_one_remainder(0, r, modulus, LongDecimalRoundingMode::ROUND_UP, LongDecimalRoundingMode::ZERO_ROUND_TO_CLOSEST_PREFER_PLUS)
+        zero_r = check_round_to_one_remainder(0, r, modulus, ROUND_UP, ZERO_ROUND_TO_CLOSEST_PREFER_PLUS)
         dd = 2*zero_r.abs
         assert(dd <= modulus, "0_r=#{zero_r} " + text)
         if (zero_r < 0)
           assert(dd < modulus, "0_r=#{zero_r} " + text)
         end
-        zero_r = check_round_to_one_remainder(0, r, modulus, LongDecimalRoundingMode::ROUND_UP, LongDecimalRoundingMode::ZERO_ROUND_TO_CLOSEST_PREFER_MINUS)
+        zero_r = check_round_to_one_remainder(0, r, modulus, ROUND_UP, ZERO_ROUND_TO_CLOSEST_PREFER_MINUS)
         dd = 2*zero_r.abs
         assert(dd <= modulus, "0_r=#{zero_r} " + text)
         if (zero_r > 0)
           assert(dd < modulus, "0_r=#{zero_r} " + text)
         end
 
-        zero_r = check_round_to_one_remainder(0, r, modulus, LongDecimalRoundingMode::ROUND_DOWN, LongDecimalRoundingMode::ZERO_ROUND_TO_PLUS)
+        zero_r = check_round_to_one_remainder(0, r, modulus, ROUND_DOWN, ZERO_ROUND_TO_PLUS)
         assert(zero_r >= 0, "0_r=#{zero_r} " + text)
-        zero_r = check_round_to_one_remainder(0, r, modulus, LongDecimalRoundingMode::ROUND_DOWN, LongDecimalRoundingMode::ZERO_ROUND_TO_MINUS)
+        zero_r = check_round_to_one_remainder(0, r, modulus, ROUND_DOWN, ZERO_ROUND_TO_MINUS)
         assert(zero_r <= 0, "0_r=#{zero_r} " + text)
-        zero_r = check_round_to_one_remainder(0, r, modulus, LongDecimalRoundingMode::ROUND_DOWN, LongDecimalRoundingMode::ZERO_ROUND_TO_CLOSEST_PREFER_PLUS)
+        zero_r = check_round_to_one_remainder(0, r, modulus, ROUND_DOWN, ZERO_ROUND_TO_CLOSEST_PREFER_PLUS)
         dd = 2*zero_r.abs
         assert(dd <= modulus, "0_r=#{zero_r} " + text)
         if (zero_r < 0)
           assert(dd < modulus, "0_r=#{zero_r} " + text)
         end
-        zero_r = check_round_to_one_remainder(0, r, modulus, LongDecimalRoundingMode::ROUND_DOWN, LongDecimalRoundingMode::ZERO_ROUND_TO_CLOSEST_PREFER_MINUS)
+        zero_r = check_round_to_one_remainder(0, r, modulus, ROUND_DOWN, ZERO_ROUND_TO_CLOSEST_PREFER_MINUS)
         dd = 2*zero_r.abs
         assert(dd <= modulus, "0_r=#{zero_r} " + text)
         if (zero_r > 0)
           assert(dd < modulus, "0_r=#{zero_r} " + text)
         end
 
-        zero_r = check_round_to_one_remainder(0, r, modulus, LongDecimalRoundingMode::ROUND_CEILING, LongDecimalRoundingMode::ZERO_ROUND_UNNECESSARY)
+        # ceiling always rounds toward positive infinity, so 0 does not need any special handling and zero_rounding_mode is ignored
+        zero_r = check_round_to_one_remainder(0, r, modulus, ROUND_CEILING, ZERO_ROUND_UNNECESSARY)
         assert(zero_r >= 0, "0_r=#{zero_r} " + text)
 
-        zero_r = check_round_to_one_remainder(0, r, modulus, LongDecimalRoundingMode::ROUND_FLOOR, LongDecimalRoundingMode::ZERO_ROUND_UNNECESSARY)
+        # ceiling always rounds toward negative infinity, so 0 does not need any special handling and zero_rounding_mode is ignored
+        zero_r = check_round_to_one_remainder(0, r, modulus, ROUND_FLOOR, ZERO_ROUND_UNNECESSARY)
         assert(zero_r <= 0, "0_r=#{zero_r} " + text)
 
-        zero_r = check_round_to_one_remainder(0, r, modulus, LongDecimalRoundingMode::ROUND_HALF_UP, LongDecimalRoundingMode::ZERO_ROUND_TO_PLUS)
-        dd = 2*zero_r.abs
-        assert(dd <= modulus, "0_r=#{zero_r} " + text)
-        if (zero_r < 0)
-          assert(dd < modulus, "0_r=#{zero_r} " + text)
-        end
-        zero_r = check_round_to_one_remainder(0, r, modulus, LongDecimalRoundingMode::ROUND_HALF_UP, LongDecimalRoundingMode::ZERO_ROUND_TO_CLOSEST_PREFER_PLUS)
-        dd = 2*zero_r.abs
-        assert(dd <= modulus, "0_r=#{zero_r} " + text)
-        if (zero_r < 0)
-          assert(dd < modulus, "0_r=#{zero_r} " + text)
-        end
-        zero_r = check_round_to_one_remainder(0, r, modulus, LongDecimalRoundingMode::ROUND_HALF_UP, LongDecimalRoundingMode::ZERO_ROUND_TO_MINUS)
-        dd = 2*zero_r.abs
-        assert(dd <= modulus, "0_r=#{zero_r} " + text)
-        if (zero_r > 0)
-          assert(dd < modulus, "0_r=#{zero_r} " + text)
-        end
-        zero_r = check_round_to_one_remainder(0, r, modulus, LongDecimalRoundingMode::ROUND_HALF_UP, LongDecimalRoundingMode::ZERO_ROUND_TO_CLOSEST_PREFER_MINUS)
-        dd = 2*zero_r.abs
-        assert(dd <= modulus, "0_r=#{zero_r} " + text)
-        if (zero_r > 0)
-          assert(dd < modulus, "0_r=#{zero_r} " + text)
-        end
-
-        zero_r = check_round_to_one_remainder(0, r, modulus, LongDecimalRoundingMode::ROUND_HALF_DOWN, LongDecimalRoundingMode::ZERO_ROUND_TO_PLUS)
-        dd = 2*zero_r.abs
-        assert(dd <= modulus, "0_r=#{zero_r} " + text)
-        if (zero_r < 0)
-          assert(dd < modulus, "0_r=#{zero_r} " + text)
-        end
-        zero_r = check_round_to_one_remainder(0, r, modulus, LongDecimalRoundingMode::ROUND_HALF_DOWN, LongDecimalRoundingMode::ZERO_ROUND_TO_CLOSEST_PREFER_PLUS)
-        dd = 2*zero_r.abs
-        assert(dd <= modulus, "0_r=#{zero_r} " + text)
-        if (zero_r < 0)
-          assert(dd < modulus, "0_r=#{zero_r} " + text)
-        end
-        zero_r = check_round_to_one_remainder(0, r, modulus, LongDecimalRoundingMode::ROUND_HALF_DOWN, LongDecimalRoundingMode::ZERO_ROUND_TO_MINUS)
-        dd = 2*zero_r.abs
-        assert(dd <= modulus, "0_r=#{zero_r} " + text)
-        if (zero_r > 0)
-          assert(dd < modulus, "0_r=#{zero_r} " + text)
-        end
-        zero_r = check_round_to_one_remainder(0, r, modulus, LongDecimalRoundingMode::ROUND_HALF_DOWN, LongDecimalRoundingMode::ZERO_ROUND_TO_CLOSEST_PREFER_MINUS)
-        dd = 2*zero_r.abs
-        assert(dd <= modulus, "0_r=#{zero_r} " + text)
-        if (zero_r > 0)
-          assert(dd < modulus, "0_r=#{zero_r} " + text)
+        ALL_ROUNDING_MODES.each do |rounding_mode|
+          unless (rounding_mode.minor == MINOR_UP || rounding_mode.minor == MINOR_DOWN)
+            next
+          end
+          unless (rounding_mode.major == MAJOR_HALF \
+                  || rounding_mode.major == MAJOR_HARMONIC \
+                  || rounding_mode.major == MAJOR_GEOMETRIC \
+                  || rounding_mode.major == MAJOR_QUADRATIC \
+                  || rounding_mode.major == MAJOR_CUBIC)
+            next
+          end
+          [ZERO_ROUND_TO_PLUS,ZERO_ROUND_TO_CLOSEST_PREFER_PLUS].each do |zero_rounding_mode|
+            zero_r = check_round_to_one_remainder(0, r, modulus, rounding_mode, zero_rounding_mode)
+            if (rounding_mode.major == MAJOR_HALF)
+              dd = 2*zero_r.abs
+              text2 = text + " dd=#{dd} rm=#{rounding_mode} zm=#{zero_rounding_mode}"
+              assert(dd <= modulus, "0_r=#{zero_r} " + text2)
+              if (zero_r < 0)
+                assert(dd < modulus, "0_r=#{zero_r} " + text2)
+              end
+            end
+          end
+          [ZERO_ROUND_TO_MINUS,ZERO_ROUND_TO_CLOSEST_PREFER_MINUS].each do |zero_rounding_mode|
+            zero_r = check_round_to_one_remainder(0, r, modulus, rounding_mode, ZERO_ROUND_TO_MINUS)
+            if (rounding_mode.major == MAJOR_HALF)
+              dd = 2*zero_r.abs
+              text2 = text + " dd=#{dd} rm=#{rounding_mode}"
+              assert(dd <= modulus, "0_r=#{zero_r} " + text2)
+              if (zero_r > 0)
+                assert(dd < modulus, "0_r=#{zero_r} " + text2)
+              end
+            end
+          end
         end
 
-        zero_r = check_round_to_one_remainder(0, r, modulus, LongDecimalRoundingMode::ROUND_HALF_CEILING, LongDecimalRoundingMode::ZERO_ROUND_UNNECESSARY)
+        zero_r = check_round_to_one_remainder(0, r, modulus, ROUND_HALF_CEILING, ZERO_ROUND_UNNECESSARY)
         dd = 2*zero_r.abs
         assert(dd <= modulus, "0_r=#{zero_r} " + text)
         if (zero_r < 0)
           assert(dd < modulus, "0_r=#{zero_r} " + text)
         end
 
-        zero_r = check_round_to_one_remainder(0, r, modulus, LongDecimalRoundingMode::ROUND_HALF_FLOOR, LongDecimalRoundingMode::ZERO_ROUND_UNNECESSARY)
+        zero_r = check_round_to_one_remainder(0, r, modulus, ROUND_HALF_FLOOR, ZERO_ROUND_UNNECESSARY)
         dd = 2*zero_r.abs
         assert(dd <= modulus, "0_r=#{zero_r} " + text)
         if (zero_r > 0)
@@ -1641,19 +2857,20 @@ class TestLongDecimal_class < Test::Unit::TestCase # RUNIT::TestCase
 
   def check_round_to_one_remainder(i, r, modulus, rounding_mode, zero_rounding_mode)
 
-    zero_modes = [ LongDecimalRoundingMode::ZERO_ROUND_TO_PLUS,\
-      LongDecimalRoundingMode::ZERO_ROUND_TO_MINUS,\
-      LongDecimalRoundingMode::ZERO_ROUND_TO_CLOSEST_PREFER_PLUS,\
-      LongDecimalRoundingMode::ZERO_ROUND_TO_CLOSEST_PREFER_MINUS,\
-      LongDecimalRoundingMode::ZERO_ROUND_UNNECESSARY ];
     remainders = [ r ]
     i_rounded = i.round_to_allowed_remainders(remainders, modulus, rounding_mode, zero_rounding_mode)
-    if (i != 0 || zero_rounding_mode == LongDecimalRoundingMode::ZERO_ROUND_UNNECESSARY)
-      zero_modes.each do |zm|
+    text = "i_r=#{i_rounded} i=#{i} m=#{modulus} r=#{r} mode=#{rounding_mode} zm=#{zero_rounding_mode}"
+
+    # if i is not zero or zero_rounding_mode is ZERO_ROUND_UNNECESSARY, using another zero_rounding_mode should not influence the result:
+    if (i != 0 || zero_rounding_mode == ZERO_ROUND_UNNECESSARY)
+      ALL_ZERO_MODES.each do |zm|
         assert_equal(i_rounded, i.round_to_allowed_remainders(remainders, modulus, rounding_mode, zm), "i=#{i} i_r=#{i_rounded} m=#{modulus} zm=#{zm} r=#{r}")
       end
     end
-    assert_equal(0, (i_rounded - r) % modulus)
+
+    # make sure that the result is congruent r modulo the modulus and within less than modulus away from i:
+    assert(! (i_rounded.nil?), text)
+    assert_equal(0, (i_rounded - r) % modulus, text)
     assert(i - modulus < i_rounded)
     assert(i_rounded < i + modulus)
     i_rounded
@@ -1663,94 +2880,148 @@ class TestLongDecimal_class < Test::Unit::TestCase # RUNIT::TestCase
   # test rounding of int to remainder set
   #
   def test_int_round_to_allowed_remainders
-    print "\ntest_int_round_to_allowed_remainders [#{Time.now}] (45 min): "
+    print "\ntest_int_round_to_allowed_remainders [#{Time.now}] (15 sec): "
     $stdout.flush
     # 2.upto 8 do |modulus|
     2.upto 7 do |modulus|
       xx = (1<< modulus) - 1
       xx.times do |x|
         remainders = make_set(x + 1, modulus)
+        min_remainder = remainders.min
+        max_remainder = remainders.max
+        max_neg_remainder = max_remainder - modulus
+        closest_remainder_prefer_plus = nil
+        closest_remainder_prefer_minus = nil
+        minus_remainder = if (min_remainder == 0)
+                            min_remainder
+                          else
+                            max_neg_remainder
+                          end
+        if (-max_neg_remainder > min_remainder)
+          closest_remainder_prefer_minus = min_remainder
+          closest_remainder_prefer_plus = min_remainder
+        elsif (-max_neg_remainder < min_remainder)
+          closest_remainder_prefer_minus = max_neg_remainder
+          closest_remainder_prefer_plus = max_neg_remainder
+        else
+          closest_remainder_prefer_minus = max_neg_remainder
+          closest_remainder_prefer_plus = min_remainder
+        end
+
         text0 = "m=#{modulus} x=#{x} s=#{remainders.inspect}"
-        # puts text0
-        print ":"
+        print "."
         $stdout.flush
         n = 3*modulus
         (-n).upto n do |i|
           text = "i=#{i} n=#{n} " + text0
-          i_rounded, set, above, below = check_round_to_remainders(i, remainders, modulus, LongDecimalRoundingMode::ROUND_UP, LongDecimalRoundingMode::ZERO_ROUND_TO_PLUS)
+          i_rounded, set, above, below = check_round_to_remainders(i, remainders, modulus, ROUND_UP, ZERO_ROUND_TO_PLUS)
+          assert(above.empty?)
+          assert(below.empty?)
           assert(i_rounded.abs >= i.abs, "i_r=#{i_rounded} " + text)
           if (i == 0) then
             assert(i_rounded >= 0, "i_r=#{i_rounded} " + text)
-            assert_equal(above.length, 0, "i_r=#{i_rounded} " + text)
+            assert_equal(min_remainder, i_rounded)
+            # assert_equal(above.length, 0, "i_r=#{i_rounded} " + text)
           elsif (i > 0) then
             # rounded away from 0, so for positive i to value >= i
-            assert_equal(above.length, 0, text)
+            # assert_equal(above.length, 0, text)
             assert(i_rounded >= i, "i_r=#{i_rounded} " + text)
+            assert(i_rounded >= min_remainder)
           else
             # i < 0
-            # rounded away from 0, so for positive i to value <= i
+            # rounded away from 0, so for negative i to value <= i
             assert_equal(below.length, 0, text)
             assert(i_rounded <= i, "i_r=#{i_rounded} " + text)
+            assert(i_rounded <= max_neg_remainder)
           end
 
-          i_rounded, set, above, below = check_round_to_remainders(i, remainders, modulus, LongDecimalRoundingMode::ROUND_DOWN, LongDecimalRoundingMode::ZERO_ROUND_TO_PLUS)
+          i_rounded, set, above, below = check_round_to_remainders(i, remainders, modulus, ROUND_DOWN, ZERO_ROUND_TO_PLUS)
+          assert(above.empty?)
+          assert(below.empty?)
           if (i > 0)
             assert(i_rounded <= i, "i_r=#{i_rounded} " + text)
-            assert_equal(below.length, 0, "i_r=#{i_rounded} " + text)
+            assert(i_rounded >= max_neg_remainder, "i_r=#{i_rounded} " + text)
+            # assert_equal(below.length, 0, "i_r=#{i_rounded} " + text)
           elsif (i < 0)
             assert(i_rounded >= i, "i_r=#{i_rounded} " + text)
-            assert_equal(above.length, 0, "i_r=#{i_rounded} " + text)
+            assert(i_rounded <= min_remainder, "i_r=#{i_rounded} " + text)
+            # assert_equal(above.length, 0, "i_r=#{i_rounded} " + text)
           elsif (i == 0) then
             assert(i_rounded >= 0, "i_r=#{i_rounded} " + text)
-            assert_equal(above.length, 0, "i_r=#{i_rounded} " + text)
+            assert_equal(min_remainder, i_rounded, "i_r=#{i_rounded} " + text)
+            # assert_equal(above.length, 0, "i_r=#{i_rounded} " + text)
           else
             raise("i=#{i} i_r=#{i_rounded}")
           end
 
-          i_rounded, set, above, below = check_round_to_remainders(i, remainders, modulus, LongDecimalRoundingMode::ROUND_CEILING, LongDecimalRoundingMode::ZERO_ROUND_TO_PLUS)
+          i_rounded, set, above, below = check_round_to_remainders(i, remainders, modulus, ROUND_CEILING, ZERO_ROUND_TO_PLUS)
+          assert(above.empty?)
+          assert(below.empty?)
           assert(i_rounded >= i, "i_r=#{i_rounded} " + text)
-          assert_equal(above.length, 0, "i_r=#{i_rounded} " + text)
+          # assert_equal(above.length, 0, "i_r=#{i_rounded} " + text)
 
-          i_rounded, set, above, below = check_round_to_remainders(i, remainders, modulus, LongDecimalRoundingMode::ROUND_FLOOR, LongDecimalRoundingMode::ZERO_ROUND_TO_PLUS)
+          i_rounded, set, above, below = check_round_to_remainders(i, remainders, modulus, ROUND_FLOOR, ZERO_ROUND_TO_PLUS)
+          assert(above.empty?)
+          assert(below.empty?)
           assert(i_rounded <= i, "i_r=#{i_rounded} " + text)
-          assert_equal(below.length, 0, "i_r=#{i_rounded} " + text)
+          # assert_equal(below.length, 0, "i_r=#{i_rounded} " + text)
 
-          i_rounded, set, above, below = check_round_to_remainders(i, remainders, modulus, LongDecimalRoundingMode::ROUND_HALF_UP, LongDecimalRoundingMode::ZERO_ROUND_TO_PLUS)
+          i_rounded, set, above, below = check_round_to_remainders(i, remainders, modulus, ROUND_HALF_UP, ZERO_ROUND_TO_PLUS)
+          assert(above.empty?)
+          assert(below.empty?)
           dd = 2*(i_rounded - i).abs
           assert(dd <= modulus, "i_r=#{i_rounded} " + text)
           if (i_rounded.abs < i.abs || i_rounded.sgn == - i.sgn)
             assert(dd < modulus, "i_r=#{i_rounded} " + text)
           end
-          assert_equal(below.length, 0, "i_r=#{i_rounded} " + text)
-          assert_equal(above.length, 0, "i_r=#{i_rounded} " + text)
 
-          i_rounded, set, above, below = check_round_to_remainders(i, remainders, modulus, LongDecimalRoundingMode::ROUND_HALF_DOWN, LongDecimalRoundingMode::ZERO_ROUND_TO_PLUS)
+          i_rounded, set, above, below = check_round_to_remainders(i, remainders, modulus, ROUND_HALF_DOWN, ZERO_ROUND_TO_PLUS)
+          assert(above.empty?)
+          assert(below.empty?)
           dd = 2*(i_rounded - i).abs
           assert(dd <= modulus, "i_r=#{i_rounded} " + text)
           if (i_rounded.abs > i.abs && i_rounded.sgn == i.sgn)
             assert(dd < modulus, "i_r=#{i_rounded} " + text)
           end
-          assert_equal(below.length, 0, "i_r=#{i_rounded} " + text)
-          assert_equal(above.length, 0, "i_r=#{i_rounded} " + text)
 
-          i_rounded, set, above, below = check_round_to_remainders(i, remainders, modulus, LongDecimalRoundingMode::ROUND_HALF_CEILING, LongDecimalRoundingMode::ZERO_ROUND_TO_PLUS)
+          i_rounded, set, above, below = check_round_to_remainders(i, remainders, modulus, ROUND_HALF_CEILING, ZERO_ROUND_TO_PLUS)
+          assert(above.empty?)
+          assert(below.empty?)
           dd = 2*(i_rounded - i).abs
           assert(dd <= modulus, "i_r=#{i_rounded} " + text)
           if (i_rounded < i)
             assert(dd < modulus, "i_r=#{i_rounded} " + text)
           end
-          assert_equal(below.length, 0, "i_r=#{i_rounded} " + text)
-          assert_equal(above.length, 0, "i_r=#{i_rounded} " + text)
 
-          i_rounded, set, above, below = check_round_to_remainders(i, remainders, modulus, LongDecimalRoundingMode::ROUND_HALF_FLOOR, LongDecimalRoundingMode::ZERO_ROUND_TO_PLUS)
+          i_rounded, set, above, below = check_round_to_remainders(i, remainders, modulus, ROUND_HALF_FLOOR, ZERO_ROUND_TO_PLUS)
+          assert(above.empty?)
+          assert(below.empty?)
           dd = 2*(i_rounded - i).abs
           assert(dd <= modulus, "i_r=#{i_rounded} " + text)
           if (i_rounded > i && i != 0)
             assert(dd < modulus, "i_r=#{i_rounded} " + text)
           end
-          assert_equal(below.length, 0, "i_r=#{i_rounded} " + text)
-          assert_equal(above.length, 0, "i_r=#{i_rounded} " + text)
 
+          ALL_ROUNDING_MODES.each do |rounding_mode|
+            unless (rounding_mode.major == MAJOR_GEOMETRIC \
+                    || rounding_mode.major == MAJOR_HARMONIC \
+                    || rounding_mode.major == MAJOR_QUADRATIC \
+                    || rounding_mode.major == MAJOR_CUBIC)
+              next;
+            end
+            if (rounding_mode.minor == MINOR_EVEN || rounding_mode.minor == MINOR_ODD)
+              next
+            end
+            i_rounded, set, above, below = check_round_to_remainders(i, remainders, modulus, rounding_mode, ZERO_ROUND_TO_PLUS)
+            if (rounding_mode.major != MAJOR_CUBIC)
+              if (i < 0)
+                assert(i_rounded <= 0, "i_r=#{i_rounded} " + text)
+              end
+              if (i > 0)
+                assert(i_rounded >= 0, "i_r=#{i_rounded} " + text)
+              end
+            end
+          end
         end
       end
     end
@@ -1760,134 +3031,271 @@ class TestLongDecimal_class < Test::Unit::TestCase # RUNIT::TestCase
   # test rounding of 0 to remainder set
   #
   def test_zero_round_to_allowed_remainders
-    print "\ntest_zero_round_to_allowed_remainders [#{Time.now}] (long): "
+    print "\ntest_zero_round_to_allowed_remainders [#{Time.now}]: "
     $stdout.flush
 
     2.upto 7 do |modulus|
       xx = (1<< modulus) - 1
       xx.times do |x|
         remainders = make_set(x + 1, modulus)
+
+        min_remainder = remainders.min
+        max_remainder = remainders.max
+        max_neg_remainder = max_remainder - modulus
+        closest_remainder_prefer_plus = nil
+        closest_remainder_prefer_minus = nil
+        minus_remainder = if (min_remainder == 0)
+                            min_remainder
+                          else
+                            max_neg_remainder
+                          end
+        if (-max_neg_remainder > min_remainder)
+          closest_remainder_prefer_minus = min_remainder
+          closest_remainder_prefer_plus = min_remainder
+        elsif (-max_neg_remainder < min_remainder)
+          closest_remainder_prefer_minus = max_neg_remainder
+          closest_remainder_prefer_plus = max_neg_remainder
+        else
+          closest_remainder_prefer_minus = max_neg_remainder
+          closest_remainder_prefer_plus = min_remainder
+        end
+
         text = "m=#{modulus} x=#{x} s=#{remainders.inspect}"
-        # puts text
         print "."
         $stdout.flush
 
         # ROUND_UP and ROUND_DOWN have the same effect for 0
-        zero_r1, set1, above1, below1 = check_round_to_remainders(0, remainders, modulus, LongDecimalRoundingMode::ROUND_UP, LongDecimalRoundingMode::ZERO_ROUND_TO_PLUS)
-        zero_r2, set2, above2, below2 = check_round_to_remainders(0, remainders, modulus, LongDecimalRoundingMode::ROUND_DOWN, LongDecimalRoundingMode::ZERO_ROUND_TO_PLUS)
+        zero_r1, set1, above1, below1 = check_round_to_remainders(0, remainders, modulus, ROUND_UP, ZERO_ROUND_TO_PLUS)
+        zero_r2, set2, above2, below2 = check_round_to_remainders(0, remainders, modulus, ROUND_DOWN, ZERO_ROUND_TO_PLUS)
+        assert(above1.empty?)
+        assert(below1.empty?)
+        assert(above2.empty?)
+        assert(below2.empty?)
         assert_equal(zero_r1, zero_r2, text)
-        assert_equal(above1, above2, text)
-        assert_equal(below1, below2, text)
         assert(zero_r1 >= 0, "0_r=#{zero_r1} " + text)
-        assert_equal(above1.length, 0, text)
-
-        zero_r1, set1, above1, below1 = check_round_to_remainders(0, remainders, modulus, LongDecimalRoundingMode::ROUND_UP, LongDecimalRoundingMode::ZERO_ROUND_TO_MINUS)
-        zero_r2, set2, above2, below2 = check_round_to_remainders(0, remainders, modulus, LongDecimalRoundingMode::ROUND_DOWN, LongDecimalRoundingMode::ZERO_ROUND_TO_MINUS)
+        assert_equal(min_remainder, zero_r1, "0_r=#{zero_r1} " + text)
+
+        zero_r1, set1, above1, below1 = check_round_to_remainders(0, remainders, modulus, ROUND_UP, ZERO_ROUND_TO_MINUS)
+        zero_r2, set2, above2, below2 = check_round_to_remainders(0, remainders, modulus, ROUND_DOWN, ZERO_ROUND_TO_MINUS)
+        assert(above1.empty?)
+        assert(below1.empty?)
+        assert(above2.empty?)
+        assert(below2.empty?)
         assert_equal(zero_r1, zero_r2, text)
-        assert_equal(above1, above2, text)
-        assert_equal(below1, below2, text)
         assert(zero_r1 <= 0, "0_r=#{zero_r1} " + text)
-        assert_equal(below1.length, 0, text)
-
-        zero_r1, set1, above1, below1 = check_round_to_remainders(0, remainders, modulus, LongDecimalRoundingMode::ROUND_UP, LongDecimalRoundingMode::ZERO_ROUND_TO_CLOSEST_PREFER_PLUS)
-        zero_r2, set2, above2, below2 = check_round_to_remainders(0, remainders, modulus, LongDecimalRoundingMode::ROUND_DOWN, LongDecimalRoundingMode::ZERO_ROUND_TO_CLOSEST_PREFER_PLUS)
+        assert_equal(minus_remainder, zero_r1, "0_r=#{zero_r1} " + text)
+
+        zero_r1, set1, above1, below1 = check_round_to_remainders(0, remainders, modulus, ROUND_UP, ZERO_ROUND_TO_CLOSEST_PREFER_PLUS)
+        zero_r2, set2, above2, below2 = check_round_to_remainders(0, remainders, modulus, ROUND_DOWN, ZERO_ROUND_TO_CLOSEST_PREFER_PLUS)
+        assert(above1.empty?)
+        assert(below1.empty?)
+        assert(above2.empty?)
+        assert(below2.empty?)
         assert_equal(zero_r1, zero_r2, text)
-        assert_equal(above1, above2, text)
-        assert_equal(below1, below2, text)
+        assert_equal(closest_remainder_prefer_plus, zero_r1, text)
         dd = 2*zero_r1.abs
         assert(dd <= modulus, "0_r=#{zero_r1} dd=#{dd} " + text)
         if (zero_r1 < 0)
           assert(dd < modulus, "0_r=#{zero_r1} dd=#{dd} " + text)
         end
-        if (below1.length > 0)
-          assert(below1.max.abs >= zero_r1.abs, text)
-        end
-        if (above1.length > 0)
-          assert(above1.min.abs >= zero_r1.abs, text)
-        end
-
-        zero_r1, set1, above1, below1 = check_round_to_remainders(0, remainders, modulus, LongDecimalRoundingMode::ROUND_UP, LongDecimalRoundingMode::ZERO_ROUND_TO_CLOSEST_PREFER_MINUS)
-        zero_r2, set2, above2, below2 = check_round_to_remainders(0, remainders, modulus, LongDecimalRoundingMode::ROUND_DOWN, LongDecimalRoundingMode::ZERO_ROUND_TO_CLOSEST_PREFER_MINUS)
+        #if (below1.length > 0)
+        #  assert(below1.max.abs >= zero_r1.abs, text)
+        #end
+        #if (above1.length > 0)
+        #  assert(above1.min.abs >= zero_r1.abs, text)
+        #end
+
+        zero_r1, set1, above1, below1 = check_round_to_remainders(0, remainders, modulus, ROUND_UP, ZERO_ROUND_TO_CLOSEST_PREFER_MINUS)
+        zero_r2, set2, above2, below2 = check_round_to_remainders(0, remainders, modulus, ROUND_DOWN, ZERO_ROUND_TO_CLOSEST_PREFER_MINUS)
+        assert(above1.empty?)
+        assert(below1.empty?)
+        assert(above2.empty?)
+        assert(below2.empty?)
         assert_equal(zero_r1, zero_r2, text)
-        assert_equal(above1, above2, text)
-        assert_equal(below1, below2, text)
+        assert_equal(closest_remainder_prefer_minus, zero_r1, text)
+        # assert_equal(above1, above2, text)
+        # assert_equal(below1, below2, text)
         dd = 2*zero_r1.abs
         assert(dd <= modulus, "0_r=#{zero_r1} dd=#{dd} " + text)
         if (zero_r1 > 0)
           assert(dd < modulus, "0_r=#{zero_r1} dd=#{dd} " + text)
         end
-        if (below1.length > 0)
-          assert(below1.max.abs >= zero_r1.abs, text)
-        end
-        assert_equal(above1.length, 0, text)
-
-        zero_r0, set0, above0, below0 = check_round_to_remainders(0, remainders, modulus, LongDecimalRoundingMode::ROUND_CEILING, LongDecimalRoundingMode::ZERO_ROUND_UNNECESSARY)
-        assert(zero_r0 >= 0, "0_r=#{zero_r0} " + text)
-        assert_equal(above0.length, 0, text)
-
-        zero_r0, set0, above0, below0 = check_round_to_remainders(0, remainders, modulus, LongDecimalRoundingMode::ROUND_FLOOR, LongDecimalRoundingMode::ZERO_ROUND_UNNECESSARY)
-        assert(zero_r0 <= 0, "0_r=#{zero_r0} " + text)
-        assert_equal(below0.length, 0, text)
-
-        zero_r1, set1, above1, below1 = check_round_to_remainders(0, remainders, modulus, LongDecimalRoundingMode::ROUND_HALF_UP, LongDecimalRoundingMode::ZERO_ROUND_TO_PLUS)
-        zero_r2, set2, above2, below2 = check_round_to_remainders(0, remainders, modulus, LongDecimalRoundingMode::ROUND_HALF_DOWN, LongDecimalRoundingMode::ZERO_ROUND_TO_PLUS)
+        #if (below1.length > 0)
+        #  assert(below1.max.abs >= zero_r1.abs, text)
+        #end
+        #assert_equal(above1.length, 0, text)
+
+        zero_rounded, set0, above0, below0 = check_round_to_remainders(0, remainders, modulus, ROUND_CEILING, ZERO_ROUND_UNNECESSARY)
+        assert(above0.empty?)
+        assert(below0.empty?)
+        assert(zero_rounded >= 0, "0_r=#{zero_rounded} " + text)
+        assert_equal(min_remainder, zero_rounded, text)
+        # assert_equal(above0.length, 0, text)
+
+        zero_rounded, set0, above0, below0 = check_round_to_remainders(0, remainders, modulus, ROUND_FLOOR, ZERO_ROUND_UNNECESSARY)
+        assert(above0.empty?)
+        assert(below0.empty?)
+        assert(zero_rounded <= 0, "0_r=#{zero_rounded} " + text)
+        assert_equal(minus_remainder, zero_rounded, text)
+        # assert_equal(below0.length, 0, text)
+
+        zero_r1, set1, above1, below1 = check_round_to_remainders(0, remainders, modulus, ROUND_HALF_UP, ZERO_ROUND_TO_PLUS)
+        zero_r2, set2, above2, below2 = check_round_to_remainders(0, remainders, modulus, ROUND_HALF_DOWN, ZERO_ROUND_TO_PLUS)
+        assert(above1.empty?)
+        assert(below1.empty?)
+        assert(above2.empty?)
+        assert(below2.empty?)
         assert_equal(zero_r1, zero_r2, text)
-        assert_equal(above1, above2, text)
-        assert_equal(below1, below2, text)
-        zero_r2, set2, above2, below2 = check_round_to_remainders(0, remainders, modulus, LongDecimalRoundingMode::ROUND_HALF_UP, LongDecimalRoundingMode::ZERO_ROUND_TO_CLOSEST_PREFER_PLUS)
+        if (zero_r1 < 0)
+          assert_equal(max_neg_remainder, zero_r1)
+        else
+          assert_equal(min_remainder, zero_r1)
+        end
+        # assert_equal(above1, above2, text)
+        # assert_equal(below1, below2, text)
+        zero_r2, set2, above2, below2 = check_round_to_remainders(0, remainders, modulus, ROUND_HALF_UP, ZERO_ROUND_TO_CLOSEST_PREFER_PLUS)
+        assert(above1.empty?)
+        assert(below1.empty?)
+        assert(above2.empty?)
+        assert(below2.empty?)
         assert_equal(zero_r1, zero_r2, text)
-        assert_equal(above1, above2, text)
-        assert_equal(below1, below2, text)
-        zero_r2, set2, above2, below2 = check_round_to_remainders(0, remainders, modulus, LongDecimalRoundingMode::ROUND_HALF_DOWN, LongDecimalRoundingMode::ZERO_ROUND_TO_CLOSEST_PREFER_PLUS)
+        if (zero_r1 < 0)
+          assert_equal(max_neg_remainder, zero_r1)
+        else
+          assert_equal(min_remainder, zero_r1)
+        end
+        #assert_equal(above1, above2, text)
+        #assert_equal(below1, below2, text)
+        zero_r2, set2, above2, below2 = check_round_to_remainders(0, remainders, modulus, ROUND_HALF_DOWN, ZERO_ROUND_TO_CLOSEST_PREFER_PLUS)
+        assert(above1.empty?)
+        assert(below1.empty?)
+        assert(above2.empty?)
+        assert(below2.empty?)
         assert_equal(zero_r1, zero_r2, text)
-        assert_equal(above1, above2, text)
-        assert_equal(below1, below2, text)
+        # assert_equal(above1, above2, text)
+        # assert_equal(below1, below2, text)
         dd = 2*zero_r1.abs
         assert(dd <= modulus, "0_r=#{zero_r1} dd=#{dd} " + text)
         if (zero_r1 < 0)
           assert(dd < modulus, "0_r=#{zero_r1} dd=#{dd} " + text)
+          assert_equal(max_neg_remainder, zero_r1)
+        else
+          assert_equal(min_remainder, zero_r1)
         end
-        assert_equal(below1.length, 0, text)
-        assert_equal(above1.length, 0, text)
-
-        zero_r1, set1, above1, below1 = check_round_to_remainders(0, remainders, modulus, LongDecimalRoundingMode::ROUND_HALF_UP, LongDecimalRoundingMode::ZERO_ROUND_TO_MINUS)
-        zero_r2, set2, above2, below2 = check_round_to_remainders(0, remainders, modulus, LongDecimalRoundingMode::ROUND_HALF_DOWN, LongDecimalRoundingMode::ZERO_ROUND_TO_MINUS)
+        # assert_equal(below1.length, 0, text)
+        # assert_equal(above1.length, 0, text)
+
+        zero_r1, set1, above1, below1 = check_round_to_remainders(0, remainders, modulus, ROUND_HALF_UP, ZERO_ROUND_TO_MINUS)
+        zero_r2, set2, above2, below2 = check_round_to_remainders(0, remainders, modulus, ROUND_HALF_DOWN, ZERO_ROUND_TO_MINUS)
+        assert(above1.empty?)
+        assert(below1.empty?)
+        assert(above2.empty?)
+        assert(below2.empty?)
         assert_equal(zero_r1, zero_r2, text)
-        assert_equal(above1, above2, text)
-        assert_equal(below1, below2, text)
-        zero_r2, set2, above2, below2 = check_round_to_remainders(0, remainders, modulus, LongDecimalRoundingMode::ROUND_HALF_UP, LongDecimalRoundingMode::ZERO_ROUND_TO_CLOSEST_PREFER_MINUS)
+        if (zero_r1 < 0)
+          assert_equal(max_neg_remainder, zero_r1)
+        else
+          assert_equal(min_remainder, zero_r1)
+        end
+        # assert_equal(above1, above2, text)
+        # assert_equal(below1, below2, text)
+        zero_r2, set2, above2, below2 = check_round_to_remainders(0, remainders, modulus, ROUND_HALF_UP, ZERO_ROUND_TO_CLOSEST_PREFER_MINUS)
+        assert(above1.empty?)
+        assert(below1.empty?)
+        assert(above2.empty?)
+        assert(below2.empty?)
         assert_equal(zero_r1, zero_r2, text)
-        assert_equal(above1, above2, text)
-        assert_equal(below1, below2, text)
-        zero_r2, set2, above2, below2 = check_round_to_remainders(0, remainders, modulus, LongDecimalRoundingMode::ROUND_HALF_DOWN, LongDecimalRoundingMode::ZERO_ROUND_TO_CLOSEST_PREFER_MINUS)
+        # assert_equal(above1, above2, text)
+        # assert_equal(below1, below2, text)
+        zero_r2, set2, above2, below2 = check_round_to_remainders(0, remainders, modulus, ROUND_HALF_DOWN, ZERO_ROUND_TO_CLOSEST_PREFER_MINUS)
+        assert(above1.empty?)
+        assert(below1.empty?)
+        assert(above2.empty?)
+        assert(below2.empty?)
         assert_equal(zero_r1, zero_r2, text)
-        assert_equal(above1, above2, text)
-        assert_equal(below1, below2, text)
+        # assert_equal(above1, above2, text)
+        # assert_equal(below1, below2, text)
         dd = 2*zero_r1.abs
         assert(dd <= modulus, "0_r=#{zero_r1} dd=#{dd} " + text)
         if (zero_r1 > 0)
           assert(dd < modulus, "0_r=#{zero_r1} dd=#{dd} " + text)
+          assert_equal(min_remainder, zero_r1)
+        else
+          assert_equal(minus_remainder, zero_r1)
         end
-        assert_equal(below1.length, 0, text)
-        assert_equal(above1.length, 0, text)
-
-        zero_r0, set0, above0, below0 = check_round_to_remainders(0, remainders, modulus, LongDecimalRoundingMode::ROUND_HALF_CEILING, LongDecimalRoundingMode::ZERO_ROUND_UNNECESSARY)
-        dd = 2*zero_r0.abs
-        assert(dd <= modulus, "0_r=#{zero_r0} dd=#{dd} " + text)
-        if (zero_r0 < 0)
-          assert(dd < modulus, "0_r=#{zero_r0} dd=#{dd} " + text)
+        # assert_equal(below1.length, 0, text)
+        # assert_equal(above1.length, 0, text)
+
+        zero_rounded, set0, above0, below0 = check_round_to_remainders(0, remainders, modulus, ROUND_HALF_CEILING, ZERO_ROUND_UNNECESSARY)
+        assert(above0.empty?)
+        assert(below0.empty?)
+        dd = 2*zero_rounded.abs
+        assert(dd <= modulus, "0_r=#{zero_rounded} dd=#{dd} " + text)
+        if (zero_rounded < 0)
+          assert_equal(max_neg_remainder, zero_rounded)
+          assert(dd < modulus, "0_r=#{zero_rounded} dd=#{dd} " + text)
+        else
+          assert_equal(min_remainder, zero_rounded)
         end
-        assert_equal(below0.length, 0, text)
-        assert_equal(above0.length, 0, text)
-
-        zero_r0, set0, above0, below0 = check_round_to_remainders(0, remainders, modulus, LongDecimalRoundingMode::ROUND_HALF_FLOOR, LongDecimalRoundingMode::ZERO_ROUND_UNNECESSARY)
-        dd = 2*zero_r0.abs
-        assert(dd <= modulus, "0_r=#{zero_r0} " + text)
-        if (zero_r0 > 0)
-          assert(dd < modulus, "0_r=#{zero_r0} " + text)
+        # assert_equal(below0.length, 0, text)
+        # assert_equal(above0.length, 0, text)
+
+        zero_rounded, set0, above0, below0 = check_round_to_remainders(0, remainders, modulus, ROUND_HALF_FLOOR, ZERO_ROUND_UNNECESSARY)
+        assert(above0.empty?)
+        assert(below0.empty?)
+        dd = 2*zero_rounded.abs
+        assert(dd <= modulus, "0_r=#{zero_rounded} " + text)
+        if (zero_rounded > 0)
+          assert_equal(min_remainder, zero_r1)
+          assert(dd < modulus, "0_r=#{zero_rounded} " + text)
+        else
+          assert_equal(minus_remainder, zero_r1)
+        end
+        # assert_equal(below0.length, 0, text)
+        # assert_equal(above0.length, 0, text)
+
+        ALL_ROUNDING_MODES.each do |rounding_mode|
+          unless (rounding_mode.major == MAJOR_GEOMETRIC \
+                  || rounding_mode.major == MAJOR_HARMONIC \
+                  || rounding_mode.major == MAJOR_QUADRATIC \
+                  || rounding_mode.major == MAJOR_CUBIC)
+            next;
+          end
+          if (rounding_mode.minor == MINOR_EVEN || rounding_mode.minor == MINOR_ODD)
+            next
+          end
+
+          if (rounding_mode == ROUND_CUBIC_CEILING)
+            i_rounded, set, above, below = check_round_to_remainders(0, remainders, modulus, rounding_mode, ZERO_ROUND_UNNECESSARY)
+            if (min_remainder+max_neg_remainder > 0)
+              assert_equal(minus_remainder, i_rounded, text+" i_rounded=#{i_rounded} rounding_mode=#{rounding_mode}")
+            else
+              assert_equal(min_remainder, i_rounded, text+" i_rounded=#{i_rounded} rounding_mode=#{rounding_mode}")
+            end
+          elsif (rounding_mode == ROUND_CUBIC_FLOOR)
+            i_rounded, set, above, below = check_round_to_remainders(0, remainders, modulus, rounding_mode, ZERO_ROUND_UNNECESSARY)
+            if (min_remainder+max_neg_remainder < 0)
+              assert_equal(min_remainder, i_rounded, text+" i_rounded=#{i_rounded} rounding_mode=#{rounding_mode}")
+            else
+              assert_equal(minus_remainder, i_rounded, text+" i_rounded=#{i_rounded} rounding_mode=#{rounding_mode}")
+            end
+          elsif ((rounding_mode == ROUND_CUBIC_DOWN || rounding_mode == ROUND_CUBIC_UP) && min_remainder+max_neg_remainder != 0)
+            assert_equal(closest_remainder_prefer_minus, closest_remainder_prefer_plus)
+            i_rounded = 0.round_to_allowed_remainders(remainders, modulus, rounding_mode, ZERO_ROUND_UNNECESSARY)
+            assert_equal(closest_remainder_prefer_plus, i_rounded, text+" i_rounded=#{i_rounded} rounding_mode=#{rounding_mode}")
+            i_rounded, set, above, below = check_round_to_remainders(0, remainders, modulus, rounding_mode, ZERO_ROUND_UNNECESSARY)
+            assert_equal(closest_remainder_prefer_plus, i_rounded, text+" i_rounded=#{i_rounded} rounding_mode=#{rounding_mode}")
+          else
+            i_rounded, set, above, below = check_round_to_remainders(0, remainders, modulus, rounding_mode, ZERO_ROUND_TO_PLUS)
+            assert_equal(min_remainder, i_rounded, text+" i_rounded=#{i_rounded} rounding_mode=#{rounding_mode}")
+            i_rounded, set, above, below = check_round_to_remainders(0, remainders, modulus, rounding_mode, ZERO_ROUND_TO_MINUS)
+            assert_equal(minus_remainder, i_rounded, text+" i_rounded=#{i_rounded} rounding_mode=#{rounding_mode}")
+            i_rounded, set, above, below = check_round_to_remainders(0, remainders, modulus, rounding_mode, ZERO_ROUND_TO_CLOSEST_PREFER_PLUS)
+            assert_equal(closest_remainder_prefer_plus, i_rounded, text+" i_rounded=#{i_rounded} rounding_mode=#{rounding_mode}")
+            i_rounded, set, above, below = check_round_to_remainders(0, remainders, modulus, rounding_mode, ZERO_ROUND_TO_CLOSEST_PREFER_MINUS)
+            assert_equal(closest_remainder_prefer_minus, i_rounded, text+" i_rounded=#{i_rounded} rounding_mode=#{rounding_mode}")
+          end
         end
-        assert_equal(below0.length, 0, text)
-        assert_equal(above0.length, 0, text)
 
       end
     end
@@ -1907,27 +3315,36 @@ class TestLongDecimal_class < Test::Unit::TestCase # RUNIT::TestCase
 
   def check_round_to_remainders(i, remainders, modulus, rounding_mode, zero_rounding_mode)
 
-    zero_modes = [ LongDecimalRoundingMode::ZERO_ROUND_TO_PLUS,\
-      LongDecimalRoundingMode::ZERO_ROUND_TO_MINUS,\
-      LongDecimalRoundingMode::ZERO_ROUND_TO_CLOSEST_PREFER_PLUS,\
-      LongDecimalRoundingMode::ZERO_ROUND_TO_CLOSEST_PREFER_MINUS,\
-      LongDecimalRoundingMode::ZERO_ROUND_UNNECESSARY ];
+    # do the rounding
+    i_rounded = i.round_to_allowed_remainders(remainders.clone, modulus, rounding_mode, zero_rounding_mode)
 
-    i_rounded = i.round_to_allowed_remainders(remainders, modulus, rounding_mode, zero_rounding_mode)
-    if (i != 0 || zero_rounding_mode == LongDecimalRoundingMode::ZERO_ROUND_UNNECESSARY)
-      zero_modes.each do |zm|
-        assert_equal(i_rounded, i.round_to_allowed_remainders(remainders, modulus, rounding_mode, zm), "i=#{i} i_r=#{i_rounded} m=#{modulus} zm=#{zm}")
+    # make sure that the zero_rounding_mode does not matter if i is not zero or if ZERO_ROUND_UNNECESSARY is provided
+    if (i != 0 || zero_rounding_mode == ZERO_ROUND_UNNECESSARY)
+      ALL_ZERO_MODES.each do |zm|
+        assert_equal(i_rounded, i.round_to_allowed_remainders(remainders.clone, modulus, rounding_mode, zm), "i=#{i} i_r=#{i_rounded} m=#{modulus} zm=#{zm}")
       end
     end
+
+    # make sure there is exactly one remainder matching
     one_remainder = remainders.select do |r|
       (i_rounded - r) % modulus == 0
     end
-    assert_equal(1, one_remainder.length, "i_r=#{i_rounded} i=#{i} m=#{modulus} r=#{remainders} or=#{one_remainder.to_s}")
+    assert_equal(1, one_remainder.length, "i_r=#{i_rounded} i=#{i} m=#{modulus} r=#{remainders} or=#{one_remainder.to_s} rm=#{rounding_mode} zm=#{zero_rounding_mode}")
+
+    # make sure that i_rounded is less than modulus away from i
     assert(i - modulus < i_rounded)
     assert(i_rounded < i + modulus)
+
+    # run the test with each single remainder:
     set = remainders.map do |r|
-      check_round_to_one_remainder(i, r, modulus, rounding_mode, zero_rounding_mode)
+      if (zero_rounding_mode == ZERO_ROUND_UNNECESSARY)
+        check_round_to_one_remainder(i, r, modulus, rounding_mode, ZERO_ROUND_TO_CLOSEST_PREFER_PLUS)
+      else
+        check_round_to_one_remainder(i, r, modulus, rounding_mode, zero_rounding_mode)
+      end
     end
+
+    # find members which are closer than i_rounded above and below from the results of rounding to a single remainder
     closer_above = []
     closer_below = []
     found = false
@@ -1941,16 +3358,20 @@ class TestLongDecimal_class < Test::Unit::TestCase # RUNIT::TestCase
           assert(i_rounded < i_r)
           if closer
             closer_above.push(i_r)
+            # raise ArgumentError, "i=#{i} ir=#{i_r} i_rounded=#{i_rounded} remainders=#{remainders.inspect} m=#{modulus} rm=#{rounding_mode} zm=#{zero_rounding_mode} closer_above"
           end
         else
           # i_r < i
           assert(i_r < i_rounded)
           if closer
             closer_below.push(i_r)
+            # raise ArgumentError, "i=#{i} ir=#{i_r} i_rounded=#{i_rounded} remainders=#{remainders.inspect} m=#{modulus} rm=#{rounding_mode} zm=#{zero_rounding_mode} closer_below"
           end
         end
       end
     end
+    # assert(closer_below.empty?)
+    # assert(closer_above.empty?)
     return i_rounded, set, closer_above, closer_below
 
   end # check_round_to_remainders
@@ -1959,6 +3380,228 @@ class TestLongDecimal_class < Test::Unit::TestCase # RUNIT::TestCase
   #
   # ROUND_UNNECESSARY/ROUND_HALF_EVEN
 
+  def test_minor_major_rounding_modes
+    print "\ntest_minor_major_rounding_modes [#{Time.now}]: "
+    $stdout.flush
+    [[  ROUND_CEILING, MAJOR_CEILING, MINOR_UNUSED ],
+     [  ROUND_UNNECESSARY, MAJOR_UNNECESSARY, MINOR_UNUSED ],
+     [  ROUND_UP, MAJOR_UP, MINOR_UNUSED ],
+     [  ROUND_DOWN, MAJOR_DOWN, MINOR_UNUSED ],
+     [  ROUND_FLOOR, MAJOR_FLOOR, MINOR_UNUSED ],
+     [  ROUND_CUBIC_CEILING, MAJOR_CUBIC, MINOR_CEILING ],
+     [  ROUND_CUBIC_DOWN, MAJOR_CUBIC, MINOR_DOWN ],
+     [  ROUND_CUBIC_EVEN, MAJOR_CUBIC, MINOR_EVEN ],
+     [  ROUND_CUBIC_ODD, MAJOR_CUBIC, MINOR_ODD ],
+     [  ROUND_CUBIC_FLOOR, MAJOR_CUBIC, MINOR_FLOOR ],
+     [  ROUND_CUBIC_UP, MAJOR_CUBIC, MINOR_UP ],
+     [  ROUND_GEOMETRIC_CEILING, MAJOR_GEOMETRIC, MINOR_CEILING ],
+     [  ROUND_GEOMETRIC_DOWN, MAJOR_GEOMETRIC, MINOR_DOWN ],
+     [  ROUND_GEOMETRIC_EVEN, MAJOR_GEOMETRIC, MINOR_EVEN ],
+     [  ROUND_GEOMETRIC_ODD, MAJOR_GEOMETRIC, MINOR_ODD ],
+     [  ROUND_GEOMETRIC_FLOOR, MAJOR_GEOMETRIC, MINOR_FLOOR ],
+     [  ROUND_GEOMETRIC_UP, MAJOR_GEOMETRIC, MINOR_UP ],
+     [  ROUND_HALF_CEILING, MAJOR_HALF, MINOR_CEILING ],
+     [  ROUND_HALF_DOWN, MAJOR_HALF, MINOR_DOWN ],
+     [  ROUND_HALF_EVEN, MAJOR_HALF, MINOR_EVEN ],
+     [  ROUND_HALF_ODD, MAJOR_HALF, MINOR_ODD ],
+     [  ROUND_HALF_FLOOR, MAJOR_HALF, MINOR_FLOOR ],
+     [  ROUND_HALF_UP, MAJOR_HALF, MINOR_UP ],
+     [  ROUND_HARMONIC_CEILING, MAJOR_HARMONIC, MINOR_CEILING ],
+     [  ROUND_HARMONIC_DOWN, MAJOR_HARMONIC, MINOR_DOWN ],
+     [  ROUND_HARMONIC_EVEN, MAJOR_HARMONIC, MINOR_EVEN ],
+     [  ROUND_HARMONIC_ODD, MAJOR_HARMONIC, MINOR_ODD ],
+     [  ROUND_HARMONIC_FLOOR, MAJOR_HARMONIC, MINOR_FLOOR ],
+     [  ROUND_HARMONIC_UP, MAJOR_HARMONIC, MINOR_UP ],
+     [  ROUND_QUADRATIC_CEILING, MAJOR_QUADRATIC, MINOR_CEILING ],
+     [  ROUND_QUADRATIC_DOWN, MAJOR_QUADRATIC, MINOR_DOWN ],
+     [  ROUND_QUADRATIC_EVEN, MAJOR_QUADRATIC, MINOR_EVEN ],
+     [  ROUND_QUADRATIC_ODD, MAJOR_QUADRATIC, MINOR_ODD ],
+     [  ROUND_QUADRATIC_FLOOR, MAJOR_QUADRATIC, MINOR_FLOOR ],
+     [  ROUND_QUADRATIC_UP, MAJOR_QUADRATIC, MINOR_UP ]].each do |triple|
+      mode = triple[0]
+      major = triple[1]
+      minor = triple[2]
+      found = MODE_LOOKUP[[major, minor]]
+      assert_equal(mode, found)
+      assert_same(mode, found)
+      assert_equal(major, mode.major)
+      assert_equal(major, found.major)
+      assert_equal(minor, mode.minor)
+      assert_equal(minor, found.minor)
+    end
+  end
+
+  # test remainder rounding half with exact boundary
+  #
+  def test_int_round_half_int_param_to_two_allowed_remainders
+    print "\ntest_int_round_half_to_two_allowed_remainders [#{Time.now}]: "
+    $stdout.flush
+    check_int_round_major_to_two_allowed_remainders([[1, 3], [1, 5], [2, 4], [2, 6], [3, 5], [3, 7]], true, MAJOR_HALF) do |x, y|
+      LongMath.arithmetic_mean(0, ROUND_FLOOR, x, y).to_i
+    end
+  end
+
+  # test remainder rounding half with exact boundary
+  #
+  def test_int_round_half_non_int_param_to_two_allowed_remainders
+    print "\ntest_int_round_half_to_two_allowed_remainders [#{Time.now}] (long): "
+    $stdout.flush
+    check_int_round_major_to_two_allowed_remainders([[1, 2], [1, 4], [1, 6], [2, 3], [2, 5], [2, 7], [3, 4], [3, 6], [3, 8], [4, 5], [4, 7]], false, MAJOR_HALF) do |x, y|
+      LongMath.arithmetic_mean(0, ROUND_FLOOR, x, y).to_i
+    end
+  end
+
+  # test remainder rounding geometric with exact boundary
+  #
+  def test_int_round_geometric_int_param_to_two_allowed_remainders
+    print "\ntest_int_round_geometric_to_two_allowed_remainders [#{Time.now}]: "
+    $stdout.flush
+    check_int_round_major_to_two_allowed_remainders([[1, 4], [1, 9], [2, 8]], true, MAJOR_GEOMETRIC) do |x, y|
+      LongMath.geometric_mean(0, ROUND_FLOOR, x, y).to_i
+    end
+  end
+
+  # test remainder rounding geometric with exact boundary
+  #
+  def test_int_round_geometric_non_int_param_to_two_allowed_remainders
+    print "\ntest_int_round_geometric_to_two_allowed_remainders [#{Time.now}] (long): "
+    $stdout.flush
+    check_int_round_major_to_two_allowed_remainders([[1, 2], [1, 3], [1, 5], [1, 6], [1, 7], [1, 8], [2, 3], [2, 4], [2, 5], [2, 6], [2, 7]], false, MAJOR_GEOMETRIC) do |x, y|
+      LongMath.geometric_mean(0, ROUND_FLOOR, x, y).to_i
+    end
+  end
+
+  # test remainder rounding harmonic with exact boundary
+  #
+  def test_int_round_harmonic_int_param_to_two_allowed_remainders
+    print "\ntest_int_round_harmonic_to_two_allowed_remainders [#{Time.now}]: "
+    $stdout.flush
+    check_int_round_major_to_two_allowed_remainders([[2, 6], [3, 6]], true, MAJOR_HARMONIC) do |x, y|
+      LongMath.harmonic_mean(0, ROUND_FLOOR, x, y).to_i
+    end
+  end
+
+  # test remainder rounding harmonic with exact boundary
+  #
+  def test_int_round_harmonic_non_int_param_to_two_allowed_remainders
+    print "\ntest_int_round_harmonic_to_two_allowed_remainders [#{Time.now}] (long): "
+    $stdout.flush
+    check_int_round_major_to_two_allowed_remainders([[1, 2], [1, 3], [1, 4], [1, 5], [1, 6], [1, 7], [1, 8], [2, 3], [2, 4], [2, 5], [2, 7]], false, MAJOR_HARMONIC) do |x, y|
+      LongMath.harmonic_mean(0, ROUND_FLOOR, x, y).to_i
+    end
+  end
+
+  # test remainder rounding quadratic with exact boundary
+  #
+  def test_int_round_quadratic_int_param_to_two_allowed_remainders
+    print "\ntest_int_round_quadratic_to_two_allowed_remainders [#{Time.now}]: "
+    $stdout.flush
+    check_int_round_major_to_two_allowed_remainders([[1, 7]], true, MAJOR_QUADRATIC) do |x, y|
+      LongMath.quadratic_mean(0, ROUND_FLOOR, x, y).to_i
+    end
+  end
+
+  # test remainder rounding quadratic with exact boundary
+  #
+  def test_int_round_quadratic_non_int_param_to_two_allowed_remainders
+    print "\ntest_int_round_quadratic_to_two_allowed_remainders [#{Time.now}] (long): "
+    $stdout.flush
+    check_int_round_major_to_two_allowed_remainders([[1, 2], [1, 3], [1, 4], [1, 5], [1, 6], [1, 8], [2, 3], [2, 4], [2, 5], [2, 6], [2, 7], [3, 4], [3, 5], [3, 6], [3, 7]], false, MAJOR_QUADRATIC) do |x, y|
+      LongMath.quadratic_mean(0, ROUND_FLOOR, x, y).to_i
+    end
+  end
+
+  # test remainder rounding cubic with exact boundary
+  #
+  def test_int_round_cubic_non_int_param_to_two_allowed_remainders
+    print "\ntest_int_round_cubic_non_int_param_to_two_allowed_remainders [#{Time.now}]: "
+    $stdout.flush
+    check_int_round_major_to_two_allowed_remainders([[1, 2], [1, 3], [1, 4], [1, 5], [1, 6], [1, 7], [1, 8], [2, 3], [2, 4], [2, 5], [2, 7]], false, MAJOR_CUBIC) do |x, y|
+      LongMath.cubic_mean(0, ROUND_FLOOR, x, y).to_i
+    end
+  end
+
+  # TODO: round to zero, away from zero to negative, away from zero to positive, across zero to negative, across zero to positive
+
+  # test remainder rounding geometric
+  #
+  def check_int_round_major_to_two_allowed_remainders(remainder_sets, boundary_exact_integral, major_mode, &block)
+
+    mode_up = MODE_LOOKUP[[major_mode, MINOR_UP]]
+    mode_down = MODE_LOOKUP[[major_mode, MINOR_DOWN]]
+    mode_floor = MODE_LOOKUP[[major_mode, MINOR_FLOOR]]
+    mode_ceiling = MODE_LOOKUP[[major_mode, MINOR_CEILING]]
+
+    20.upto 25 do |modulus|
+      remainder_sets.each do |remainders|
+        print "."
+        $stdout.flush
+
+        lower_remainder = remainders[0]
+        upper_remainder = remainders[1]
+
+        text = "m=#{modulus} x=#{0} s=#{remainders.inspect}"
+
+        zero_rounded = 0.round_to_allowed_remainders(remainders, modulus, mode_up, ZERO_ROUND_TO_PLUS)
+        assert_equal(lower_remainder, zero_rounded, text + " zero_rounded=#{zero_rounded}")
+        zero_rounded = 0.round_to_allowed_remainders(remainders, modulus, mode_down, ZERO_ROUND_TO_PLUS)
+        assert_equal(lower_remainder, zero_rounded, text + " zero_rounded=#{zero_rounded}")
+        zero_rounded = 0.round_to_allowed_remainders(remainders, modulus, mode_up, ZERO_ROUND_TO_CLOSEST_PREFER_PLUS)
+        assert_equal(lower_remainder, zero_rounded, text + " zero_rounded=#{zero_rounded}")
+        zero_rounded = 0.round_to_allowed_remainders(remainders, modulus, mode_down, ZERO_ROUND_TO_CLOSEST_PREFER_PLUS)
+        assert_equal(lower_remainder, zero_rounded, text + " zero_rounded=#{zero_rounded}")
+        zero_rounded = 0.round_to_allowed_remainders(remainders, modulus, mode_ceiling, ZERO_ROUND_TO_PLUS)
+        assert_equal(lower_remainder, zero_rounded, text)
+
+        # zero_r1 = 0.round_to_allowed_remainders(remainders, modulus, mode_up, ZERO_ROUND_TO_MINUS)
+        # zero_r2 = 0.round_to_allowed_remainders(remainders, modulus, mode_down, ZERO_ROUND_TO_MINUS)
+        # assert_equal(zero_r1, zero_r2, text + " zero_r1=#{zero_r1} zero_r2=#{zero_r2}")
+        # assert_equal(upper_remainder - modulus, zero_r1, text + " zero_r1=#{zero_r1} zero_r2=#{zero_r2}")
+
+        # zero_r0 = 0.round_to_allowed_remainders(remainders, modulus, mode_floor, ZERO_ROUND_TO_MINUS)
+        # assert_equal(upper_remainder - modulus, zero_r0, "zero_r0=#{zero_r0} < 0 " + text)
+
+        param = block.yield(lower_remainder, upper_remainder)
+        boundary_lower = nil
+        boundary_upper = nil
+        if (boundary_exact_integral)
+          boundary_lower = param - 1
+        else
+          boundary_lower = param
+        end
+        boundary_upper = param +1
+
+        1.upto boundary_lower do |x|
+          ALL_ROUNDING_MODES.each do |rm|
+            if (rm.major == major_mode && rm.minor != MINOR_EVEN && rm.minor != MINOR_ODD)
+              text = "m=#{modulus} x=#{x} rm=#{rm} s=#{remainders.inspect} param=#{param}"
+              one_r0 = x.round_to_allowed_remainders(remainders, modulus, rm, ZERO_ROUND_UNNECESSARY)
+              assert_equal(lower_remainder, one_r0, text)
+            end
+          end
+        end
+        if (boundary_exact_integral)
+          ALL_ROUNDING_MODES.each do |rm|
+            if (rm.major == major_mode && rm.minor != MINOR_EVEN && rm.minor != MINOR_ODD)
+              text = "m=#{modulus} x=#{param} rm=#{rm} s=#{remainders.inspect}"
+              x_r0 = param.round_to_allowed_remainders(remainders, modulus, rm, ZERO_ROUND_UNNECESSARY)
+              assert(remainders.member?(x_r0), "x_r0=#{x_r0} " + text)
+            end
+          end
+        end
+        boundary_upper.upto upper_remainder do |x|
+          ALL_ROUNDING_MODES.each do |rm|
+            if (rm.major == major_mode && rm.minor != MINOR_EVEN && rm.minor != MINOR_ODD)
+              text = "m=#{modulus} x=#{x} rm=#{rm} s=#{remainders.inspect}"
+              other_r0 = x.round_to_allowed_remainders(remainders, modulus, rm, ZERO_ROUND_UNNECESSARY)
+              assert_equal(upper_remainder, other_r0, text)
+            end
+          end
+        end
+      end
+    end
+  end
+
   #
   # test conversion to String
   #
@@ -1995,53 +3638,53 @@ class TestLongDecimal_class < Test::Unit::TestCase # RUNIT::TestCase
     l = LongDecimal(224, 0)
     s = l.to_s(5)
     assert_equal("224.00000", s, "l=#{l.inspect} 5")
-    s = l.to_s(5, LongDecimal::ROUND_UNNECESSARY, 16)
+    s = l.to_s(5, ROUND_UNNECESSARY, 16)
     assert_equal("e0.00000", s, "l=#{l.inspect} 5 ROUND_UNNECESSARY 16")
 
     l = LongDecimal(224, 1)
-    s = l.to_s(0, LongDecimal::ROUND_HALF_UP)
+    s = l.to_s(0, ROUND_HALF_UP)
     assert_equal("22", s, "l=#{l.inspect} 0 ROUND_HALF_UP")
-    s = l.to_s(5, LongDecimal::ROUND_HALF_UP)
+    s = l.to_s(5, ROUND_HALF_UP)
     assert_equal("22.40000", s, "l=#{l.inspect} 5 ROUND_HALF_UP")
-    s = l.to_s(5, LongDecimal::ROUND_HALF_UP, 16)
+    s = l.to_s(5, ROUND_HALF_UP, 16)
     assert_equal("16.66666", s, "l=#{l.inspect} 5 ROUND_HALF_UP")
-    s = l.to_s(5, LongDecimal::ROUND_HALF_DOWN, 16)
+    s = l.to_s(5, ROUND_HALF_DOWN, 16)
     assert_equal("16.66666", s, "l=#{l.inspect} 5 ROUND_HALF_DOWN")
 
     l = LongDecimal(224, 2)
-    s = l.to_s(0, LongDecimal::ROUND_HALF_UP)
+    s = l.to_s(0, ROUND_HALF_UP)
     assert_equal("2", s, "l=#{l.inspect} 0 ROUND_HALF_UP")
-    s = l.to_s(5, LongDecimal::ROUND_HALF_UP)
+    s = l.to_s(5, ROUND_HALF_UP)
     assert_equal("2.24000", s, "l=#{l.inspect} 5 ROUND_HALF_UP")
-    s = l.to_s(5, LongDecimal::ROUND_HALF_UP, 16)
+    s = l.to_s(5, ROUND_HALF_UP, 16)
     assert_equal("2.3d70a", s, "l=#{l.inspect} 5 ROUND_HALF_UP")
-    s = l.to_s(5, LongDecimal::ROUND_HALF_DOWN, 16)
+    s = l.to_s(5, ROUND_HALF_DOWN, 16)
     assert_equal("2.3d70a", s, "l=#{l.inspect} 5 ROUND_HALF_DOWN")
 
     l = LongDecimal(-224, 0)
     s = l.to_s(5)
     assert_equal("-224.00000", s, "l=#{l.inspect} 5")
-    s = l.to_s(5, LongDecimal::ROUND_UNNECESSARY, 16)
+    s = l.to_s(5, ROUND_UNNECESSARY, 16)
     assert_equal("-e0.00000", s, "l=#{l.inspect} 5 ROUND_UNNECESSARY 16")
 
     l = LongDecimal(-224, 1)
-    s = l.to_s(0, LongDecimal::ROUND_HALF_UP)
+    s = l.to_s(0, ROUND_HALF_UP)
     assert_equal("-22", s, "l=#{l.inspect} 0 ROUND_HALF_UP")
-    s = l.to_s(5, LongDecimal::ROUND_HALF_UP)
+    s = l.to_s(5, ROUND_HALF_UP)
     assert_equal("-22.40000", s, "l=#{l.inspect} 5 ROUND_HALF_UP")
-    s = l.to_s(5, LongDecimal::ROUND_HALF_UP, 16)
+    s = l.to_s(5, ROUND_HALF_UP, 16)
     assert_equal("-16.66666", s, "l=#{l.inspect} 5 ROUND_HALF_UP")
-    s = l.to_s(5, LongDecimal::ROUND_HALF_DOWN, 16)
+    s = l.to_s(5, ROUND_HALF_DOWN, 16)
     assert_equal("-16.66666", s, "l=#{l.inspect} 5 ROUND_HALF_DOWN")
 
     l = LongDecimal(-224, 2)
-    s = l.to_s(0, LongDecimal::ROUND_HALF_UP)
+    s = l.to_s(0, ROUND_HALF_UP)
     assert_equal("-2", s, "l=#{l.inspect} 0 ROUND_HALF_UP")
-    s = l.to_s(5, LongDecimal::ROUND_HALF_UP)
+    s = l.to_s(5, ROUND_HALF_UP)
     assert_equal("-2.24000", s, "l=#{l.inspect} 5 ROUND_HALF_UP")
-    s = l.to_s(5, LongDecimal::ROUND_HALF_UP, 16)
+    s = l.to_s(5, ROUND_HALF_UP, 16)
     assert_equal("-2.3d70a", s, "l=#{l.inspect} 5 ROUND_HALF_UP")
-    s = l.to_s(5, LongDecimal::ROUND_HALF_DOWN, 16)
+    s = l.to_s(5, ROUND_HALF_DOWN, 16)
     assert_equal("-2.3d70a", s, "l=#{l.inspect} 5 ROUND_HALF_DOWN")
   end
 
@@ -2070,11 +3713,11 @@ class TestLongDecimal_class < Test::Unit::TestCase # RUNIT::TestCase
   def test_to_ld
     print "\ntest_to_ld [#{Time.now}]: "
     x = LongDecimal(123, 100)
-    y = x.to_ld(20, LongMath::ROUND_UP)
+    y = x.to_ld(20, 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)
+    y = x.to_ld(20, ROUND_HALF_UP)
     z = LongDecimal(0, 20)
     assert_kind_of(LongDecimal, y, "must be ld")
     assert_equal(y, z, "x=#{x} y=#{y}")
@@ -2340,11 +3983,11 @@ class TestLongDecimal_class < Test::Unit::TestCase # RUNIT::TestCase
     print "\ntest_int_mul [#{Time.now}] (90 sec): "
     $stdout.flush
     65.times do |i|
-      x0 = (1<<i)-1
+      x0 = (1 << i)-1
       3.times do |k|
         x = x0+k
         65.times do |j|
-          y0 = (1<<j)-1
+          y0 = (1 << j)-1
           3.times do |l|
             y = y0+l
             z = x*y
@@ -2366,7 +4009,7 @@ class TestLongDecimal_class < Test::Unit::TestCase # RUNIT::TestCase
   # test multiplication which uses internally multiplication of fixnum, which is buggy in JRuby and has been fixed here.
   #
   def test_mul2
-    print "\ntest_mul2 [#{Time.now}] (25 min): "
+    print "\ntest_mul2 [#{Time.now}]: "
     $stdout.flush
 
     map = {}
@@ -2383,7 +4026,6 @@ class TestLongDecimal_class < Test::Unit::TestCase # RUNIT::TestCase
       end
     end
     map.each do |x, x1|
-      # puts "x=#{x} x1=#{x1}"
       print ":"
       $stdout.flush
       map.each do |y, y1|
@@ -2765,248 +4407,248 @@ class TestLongDecimal_class < Test::Unit::TestCase # RUNIT::TestCase
 
     y = LongDecimal(3, 1)   # 0.3  dy=0 sy=1
     # 2dy+sy+sx-max(dx+sx,dy+sy)-3 = -3 -> use 0
-    z = x.divide(y, LongMath::ROUND_DOWN)
-    zz = Rational(224, 30).to_ld(0, LongMath::ROUND_DOWN)
+    z = x.divide(y, ROUND_DOWN)
+    zz = Rational(224, 30).to_ld(0, ROUND_DOWN)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = x.divide(y, LongMath::ROUND_UP)
-    zz = Rational(224, 30).to_ld(0, LongMath::ROUND_UP)
+    z = x.divide(y, ROUND_UP)
+    zz = Rational(224, 30).to_ld(0, ROUND_UP)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
     # 2dx+sx+sy-max(dx+sx,dy+sy)-3 = -1 -> use 0
-    z = y.divide(x, LongMath::ROUND_DOWN)
-    zz = Rational(30, 224).to_ld(0, LongMath::ROUND_DOWN)
+    z = y.divide(x, ROUND_DOWN)
+    zz = Rational(30, 224).to_ld(0, ROUND_DOWN)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = y.divide(x, LongMath::ROUND_UP)
-    zz = Rational(30, 224).to_ld(0, LongMath::ROUND_UP)
+    z = y.divide(x, ROUND_UP)
+    zz = Rational(30, 224).to_ld(0, ROUND_UP)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
 
                                    # x= 2.24     dx=1 sx=2
     y = LongDecimal(30000000, 8)   # 0.30000000  dy=0 sy=8
     # 2dy+sy+sx-max(dx+sx,dy+sy)-3 = -1 -> use 0
-    z = x.divide(y, LongMath::ROUND_DOWN)
-    zz = Rational(224, 30).to_ld(0, LongMath::ROUND_DOWN)
+    z = x.divide(y, ROUND_DOWN)
+    zz = Rational(224, 30).to_ld(0, ROUND_DOWN)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = x.divide(y, LongMath::ROUND_UP)
-    zz = Rational(224, 30).to_ld(0, LongMath::ROUND_UP)
+    z = x.divide(y, ROUND_UP)
+    zz = Rational(224, 30).to_ld(0, ROUND_UP)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
     # 2dx+sx+sy-max(dx+sx,dy+sy)-3 = 1
-    z = y.divide(x, LongMath::ROUND_DOWN)
-    zz = Rational(30, 224).to_ld(1, LongMath::ROUND_DOWN)
+    z = y.divide(x, ROUND_DOWN)
+    zz = Rational(30, 224).to_ld(1, ROUND_DOWN)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = y.divide(x, LongMath::ROUND_UP)
-    zz = Rational(30, 224).to_ld(1, LongMath::ROUND_UP)
+    z = y.divide(x, ROUND_UP)
+    zz = Rational(30, 224).to_ld(1, ROUND_UP)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
 
                             # x= 2.24 dx=1  sx=2
     y = LongDecimal(3, 4)   # 0.0003  dy=-4 sy=4
     # 2dy+sy+sx-max(dx+sx,dy+sy)-3 = -8 -> use 0
-    z = x.divide(y, LongMath::ROUND_DOWN)
-    zz = Rational(22400, 3).to_ld(0, LongMath::ROUND_DOWN)
+    z = x.divide(y, ROUND_DOWN)
+    zz = Rational(22400, 3).to_ld(0, ROUND_DOWN)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = x.divide(y, LongMath::ROUND_UP)
-    zz = Rational(22400, 3).to_ld(0, LongMath::ROUND_UP)
+    z = x.divide(y, ROUND_UP)
+    zz = Rational(22400, 3).to_ld(0, ROUND_UP)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
     # 2dx+sx+sy-max(dx+sx,dy+sy)-3 = 2
-    z = y.divide(x, LongMath::ROUND_DOWN)
-    zz = Rational(3, 22400).to_ld(2, LongMath::ROUND_DOWN)
+    z = y.divide(x, ROUND_DOWN)
+    zz = Rational(3, 22400).to_ld(2, ROUND_DOWN)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = y.divide(x, LongMath::ROUND_UP)
-    zz = Rational(3, 22400).to_ld(2, LongMath::ROUND_UP)
+    z = y.divide(x, ROUND_UP)
+    zz = Rational(3, 22400).to_ld(2, ROUND_UP)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
 
                              # x= 2.24 dx=1 sx=2
     y = LongDecimal(3333, 2) # 33.33   dy=2 sy=2
     # 2dy+sy+sx-max(dx+sx,dy+sy)-3 = 1
-    z = x.divide(y, LongMath::ROUND_DOWN)
-    zz = Rational(224, 3333).to_ld(1, LongMath::ROUND_DOWN)
+    z = x.divide(y, ROUND_DOWN)
+    zz = Rational(224, 3333).to_ld(1, ROUND_DOWN)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = x.divide(y, LongMath::ROUND_UP)
-    zz = Rational(224, 3333).to_ld(1, LongMath::ROUND_UP)
+    z = x.divide(y, ROUND_UP)
+    zz = Rational(224, 3333).to_ld(1, ROUND_UP)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
     # 2dx+sx+sy-max(dx+sx,dy+sy)-3 = -1 -> use 0
-    z = y.divide(x, LongMath::ROUND_DOWN)
-    zz = Rational(3333, 224).to_ld(0, LongMath::ROUND_DOWN)
+    z = y.divide(x, ROUND_DOWN)
+    zz = Rational(3333, 224).to_ld(0, ROUND_DOWN)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = y.divide(x, LongMath::ROUND_UP)
-    zz = Rational(3333, 224).to_ld(0, LongMath::ROUND_UP)
+    z = y.divide(x, ROUND_UP)
+    zz = Rational(3333, 224).to_ld(0, ROUND_UP)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
 
                               # x= 2.24 dx=1 sx=2
     y = LongDecimal(33333, 2) # 333.33  dy=3 sy=2
     # 2dy+sy+sx-max(dx+sx,dy+sy)-3 = 2
-    z = x.divide(y, LongMath::ROUND_DOWN)
-    zz = Rational(224, 33333).to_ld(2, LongMath::ROUND_DOWN)
+    z = x.divide(y, ROUND_DOWN)
+    zz = Rational(224, 33333).to_ld(2, ROUND_DOWN)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = x.divide(y, LongMath::ROUND_UP)
-    zz = Rational(224, 33333).to_ld(2, LongMath::ROUND_UP)
+    z = x.divide(y, ROUND_UP)
+    zz = Rational(224, 33333).to_ld(2, ROUND_UP)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
     # 2dx+sx+sy-max(dx+sx,dy+sy)-3 = -2 -> use 0
-    z = y.divide(x, LongMath::ROUND_DOWN)
-    zz = Rational(33333, 224).to_ld(0, LongMath::ROUND_DOWN)
+    z = y.divide(x, ROUND_DOWN)
+    zz = Rational(33333, 224).to_ld(0, ROUND_DOWN)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = y.divide(x, LongMath::ROUND_UP)
-    zz = Rational(33333, 224).to_ld(0, LongMath::ROUND_UP)
+    z = y.divide(x, ROUND_UP)
+    zz = Rational(33333, 224).to_ld(0, ROUND_UP)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
 
                               # x= 2.24 dx=1 sx=2
     y = LongDecimal(33333, 3) # 33.333  dy=2 sy=3
     # 2dy+sy+sx-max(dx+sx,dy+sy)-3 = 1
-    z = x.divide(y, LongMath::ROUND_DOWN)
-    zz = Rational(2240, 33333).to_ld(1, LongMath::ROUND_DOWN)
+    z = x.divide(y, ROUND_DOWN)
+    zz = Rational(2240, 33333).to_ld(1, ROUND_DOWN)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = x.divide(y, LongMath::ROUND_UP)
-    zz = Rational(2240, 33333).to_ld(1, LongMath::ROUND_UP)
+    z = x.divide(y, ROUND_UP)
+    zz = Rational(2240, 33333).to_ld(1, ROUND_UP)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
     # 2dx+sx+sy-max(dx+sx,dy+sy)-3 = -1 -> use 0
-    z = y.divide(x, LongMath::ROUND_DOWN)
-    zz = Rational(33333, 2240).to_ld(0, LongMath::ROUND_DOWN)
+    z = y.divide(x, ROUND_DOWN)
+    zz = Rational(33333, 2240).to_ld(0, ROUND_DOWN)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = y.divide(x, LongMath::ROUND_UP)
-    zz = Rational(33333, 2240).to_ld(0, LongMath::ROUND_UP)
+    z = y.divide(x, ROUND_UP)
+    zz = Rational(33333, 2240).to_ld(0, ROUND_UP)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
 
                              # x= 2.24 dx=1 sx=2
     y = LongDecimal(3333, 3) # 3.333   dy=1 sy=3
     # 2dy+sy+sx-max(dx+sx,dy+sy)-3 = 0
-    z = x.divide(y, LongMath::ROUND_DOWN)
-    zz = Rational(2240, 3333).to_ld(0, LongMath::ROUND_DOWN)
+    z = x.divide(y, ROUND_DOWN)
+    zz = Rational(2240, 3333).to_ld(0, ROUND_DOWN)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = x.divide(y, LongMath::ROUND_UP)
-    zz = Rational(2240, 3333).to_ld(0, LongMath::ROUND_UP)
+    z = x.divide(y, ROUND_UP)
+    zz = Rational(2240, 3333).to_ld(0, ROUND_UP)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
     # 2dx+sx+sy-max(dx+sx,dy+sy)-3 = 0
-    z = y.divide(x, LongMath::ROUND_DOWN)
-    zz = Rational(3333, 2240).to_ld(0, LongMath::ROUND_DOWN)
+    z = y.divide(x, ROUND_DOWN)
+    zz = Rational(3333, 2240).to_ld(0, ROUND_DOWN)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = y.divide(x, LongMath::ROUND_UP)
-    zz = Rational(3333, 2240).to_ld(0, LongMath::ROUND_UP)
+    z = y.divide(x, ROUND_UP)
+    zz = Rational(3333, 2240).to_ld(0, ROUND_UP)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
 
                                   # x= 2.24    dx=1 sx=2
     y = LongDecimal(123456789, 3) # 123456.789 dy=6 sy=3
     # 2dy+sy+sx-max(dx+sx,dy+sy)-3 = 5
-    z = x.divide(y, LongMath::ROUND_DOWN)
-    zz = Rational(2240, 123456789).to_ld(5, LongMath::ROUND_DOWN)
+    z = x.divide(y, ROUND_DOWN)
+    zz = Rational(2240, 123456789).to_ld(5, ROUND_DOWN)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = x.divide(y, LongMath::ROUND_UP)
-    zz = Rational(2240, 123456789).to_ld(5, LongMath::ROUND_UP)
+    z = x.divide(y, ROUND_UP)
+    zz = Rational(2240, 123456789).to_ld(5, ROUND_UP)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
     # 2dx+sx+sy-max(dx+sx,dy+sy)-3 = -5 -> use 0
-    z = y.divide(x, LongMath::ROUND_DOWN)
-    zz = Rational(123456789, 2240).to_ld(0, LongMath::ROUND_DOWN)
+    z = y.divide(x, ROUND_DOWN)
+    zz = Rational(123456789, 2240).to_ld(0, ROUND_DOWN)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = y.divide(x, LongMath::ROUND_UP)
-    zz = Rational(123456789, 2240).to_ld(0, LongMath::ROUND_UP)
+    z = y.divide(x, ROUND_UP)
+    zz = Rational(123456789, 2240).to_ld(0, ROUND_UP)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
 
                  # x= 2.24 dx=1 sx=2
     y = 5.to_ld  #    5    dy=1 sy=0
     # 2dy+sy+sx-max(dx+sx,dy+sy)-3 = -2 -> use 0
-    z = x.divide(y, LongMath::ROUND_DOWN)
-    zz = Rational(224, 500).to_ld(0, LongMath::ROUND_DOWN)
+    z = x.divide(y, ROUND_DOWN)
+    zz = Rational(224, 500).to_ld(0, ROUND_DOWN)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = x.divide(y, LongMath::ROUND_UP)
-    zz = Rational(224, 500).to_ld(0, LongMath::ROUND_UP)
+    z = x.divide(y, ROUND_UP)
+    zz = Rational(224, 500).to_ld(0, ROUND_UP)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
     # 2dx+sx+sy-max(dx+sx,dy+sy)-3 = -2 -> use 0
-    z = y.divide(x, LongMath::ROUND_DOWN)
-    zz = Rational(500, 224).to_ld(0, LongMath::ROUND_DOWN)
+    z = y.divide(x, ROUND_DOWN)
+    zz = Rational(500, 224).to_ld(0, ROUND_DOWN)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = y.divide(x, LongMath::ROUND_UP)
-    zz = Rational(500, 224).to_ld(0, LongMath::ROUND_UP)
+    z = y.divide(x, ROUND_UP)
+    zz = Rational(500, 224).to_ld(0, ROUND_UP)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
 
                     # x= 2.24 dx=1 sx=2
     y = 5.001.to_ld #         dy=1 sy=3
     # 2dy+sy+sx-max(dx+sx,dy+sy)-3 = 0
-    z = x.divide(y, LongMath::ROUND_DOWN)
-    zz = Rational(224, 500).to_ld(0, LongMath::ROUND_DOWN)
+    z = x.divide(y, ROUND_DOWN)
+    zz = Rational(224, 500).to_ld(0, ROUND_DOWN)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = x.divide(y, LongMath::ROUND_UP)
-    zz = Rational(224, 500).to_ld(0, LongMath::ROUND_UP)
+    z = x.divide(y, ROUND_UP)
+    zz = Rational(224, 500).to_ld(0, ROUND_UP)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
     # 2dx+sx+sy-max(dx+sx,dy+sy)-3 = 0
-    z = y.divide(x, LongMath::ROUND_DOWN)
-    zz = Rational(500, 224).to_ld(0, LongMath::ROUND_DOWN)
+    z = y.divide(x, ROUND_DOWN)
+    zz = Rational(500, 224).to_ld(0, ROUND_DOWN)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = y.divide(x, LongMath::ROUND_UP)
-    zz = Rational(500, 224).to_ld(0, LongMath::ROUND_UP)
+    z = y.divide(x, ROUND_UP)
+    zz = Rational(500, 224).to_ld(0, ROUND_UP)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
 
     y = Rational(5, 3).to_ld
     # y is has no scale, use scale of x
-    z = x.divide(y, LongMath::ROUND_DOWN)
-    zz = Rational(224*3, 500).to_ld(0, LongMath::ROUND_DOWN)
+    z = x.divide(y, ROUND_DOWN)
+    zz = Rational(224*3, 500).to_ld(0, ROUND_DOWN)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = x.divide(y, LongMath::ROUND_UP)
-    zz = Rational(224*3, 500).to_ld(0, LongMath::ROUND_UP)
+    z = x.divide(y, ROUND_UP)
+    zz = Rational(224*3, 500).to_ld(0, ROUND_UP)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
     # y is has no scale, use scale of x
-    z = y.divide(x, LongMath::ROUND_DOWN)
-    zz = Rational(500, 224*3).to_ld(0, LongMath::ROUND_DOWN)
+    z = y.divide(x, ROUND_DOWN)
+    zz = Rational(500, 224*3).to_ld(0, ROUND_DOWN)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = y.divide(x, LongMath::ROUND_UP)
-    zz = Rational(500, 224*3).to_ld(0, LongMath::ROUND_UP)
+    z = y.divide(x, ROUND_UP)
+    zz = Rational(500, 224*3).to_ld(0, ROUND_UP)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
 
     y = LongDecimalQuot(Rational(5, 3), 3).to_ld
-    z = x.divide(y, LongMath::ROUND_DOWN)
-    zz = Rational(224*3, 500).to_ld(0, LongMath::ROUND_DOWN)
+    z = x.divide(y, ROUND_DOWN)
+    zz = Rational(224*3, 500).to_ld(0, ROUND_DOWN)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = x.divide(y, LongMath::ROUND_UP)
-    zz = Rational(224*3, 500).to_ld(0, LongMath::ROUND_UP)
+    z = x.divide(y, ROUND_UP)
+    zz = Rational(224*3, 500).to_ld(0, ROUND_UP)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = y.divide(x, LongMath::ROUND_DOWN)
-    zz = Rational(500, 224*3).to_ld(0, LongMath::ROUND_DOWN)
+    z = y.divide(x, ROUND_DOWN)
+    zz = Rational(500, 224*3).to_ld(0, ROUND_DOWN)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = y.divide(x, LongMath::ROUND_UP)
-    zz = Rational(500, 224*3).to_ld(0, LongMath::ROUND_UP)
+    z = y.divide(x, ROUND_UP)
+    zz = Rational(500, 224*3).to_ld(0, ROUND_UP)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
   end
@@ -3020,7 +4662,7 @@ class TestLongDecimal_class < Test::Unit::TestCase # RUNIT::TestCase
 
     y = Complex(5, 3)
     puts("x=#{x.inspect} y=#{y.inspect}")
-    z = x.divide(y, LongMath::ROUND_DOWN)
+    z = x.divide(y, ROUND_DOWN)
     zz = 2.24 / Complex(5, 3)
     assert_kind_of(Complex, z, "z=#{z.inspect}")
     assert((zz-z).abs < 1e-9, "z=#{z.inspect}")
@@ -3035,219 +4677,219 @@ class TestLongDecimal_class < Test::Unit::TestCase # RUNIT::TestCase
     x = LongDecimal(224, 2) # 2.24
 
     y = LongDecimal(3, 1)   # 0.3
-    z = x.divide_s(y, 1, LongMath::ROUND_DOWN)
-    zz = Rational(224, 30).to_ld(1, LongMath::ROUND_DOWN)
+    z = x.divide_s(y, 1, ROUND_DOWN)
+    zz = Rational(224, 30).to_ld(1, ROUND_DOWN)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = x.divide_s(y, 1, LongMath::ROUND_UP)
-    zz = Rational(224, 30).to_ld(1, LongMath::ROUND_UP)
+    z = x.divide_s(y, 1, ROUND_UP)
+    zz = Rational(224, 30).to_ld(1, ROUND_UP)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = y.divide_s(x, 1, LongMath::ROUND_DOWN)
-    zz = Rational(30, 224).to_ld(1, LongMath::ROUND_DOWN)
+    z = y.divide_s(x, 1, ROUND_DOWN)
+    zz = Rational(30, 224).to_ld(1, ROUND_DOWN)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = y.divide_s(x, 1, LongMath::ROUND_UP)
-    zz = Rational(30, 224).to_ld(1, LongMath::ROUND_UP)
+    z = y.divide_s(x, 1, ROUND_UP)
+    zz = Rational(30, 224).to_ld(1, ROUND_UP)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
 
     y = LongDecimal(30000000, 8)   # 0.30000000
-    z = x.divide_s(y, 1, LongMath::ROUND_DOWN)
-    zz = Rational(224, 30).to_ld(1, LongMath::ROUND_DOWN)
+    z = x.divide_s(y, 1, ROUND_DOWN)
+    zz = Rational(224, 30).to_ld(1, ROUND_DOWN)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = x.divide_s(y, 1, LongMath::ROUND_UP)
-    zz = Rational(224, 30).to_ld(1, LongMath::ROUND_UP)
+    z = x.divide_s(y, 1, ROUND_UP)
+    zz = Rational(224, 30).to_ld(1, ROUND_UP)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = y.divide_s(x, 2, LongMath::ROUND_DOWN)
-    zz = Rational(30, 224).to_ld(2, LongMath::ROUND_DOWN)
+    z = y.divide_s(x, 2, ROUND_DOWN)
+    zz = Rational(30, 224).to_ld(2, ROUND_DOWN)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = y.divide_s(x, 20, LongMath::ROUND_UP)
-    zz = Rational(30, 224).to_ld(20, LongMath::ROUND_UP)
+    z = y.divide_s(x, 20, ROUND_UP)
+    zz = Rational(30, 224).to_ld(20, ROUND_UP)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
 
     y = LongDecimal(3, 4)   # 0.0003
-    z = x.divide_s(y, 2, LongMath::ROUND_DOWN)
-    zz = Rational(22400, 3).to_ld(2, LongMath::ROUND_DOWN)
+    z = x.divide_s(y, 2, ROUND_DOWN)
+    zz = Rational(22400, 3).to_ld(2, ROUND_DOWN)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = x.divide_s(y, 2, LongMath::ROUND_UP)
-    zz = Rational(22400, 3).to_ld(2, LongMath::ROUND_UP)
+    z = x.divide_s(y, 2, ROUND_UP)
+    zz = Rational(22400, 3).to_ld(2, ROUND_UP)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = y.divide_s(x, 3, LongMath::ROUND_DOWN)
-    zz = Rational(3, 22400).to_ld(3, LongMath::ROUND_DOWN)
+    z = y.divide_s(x, 3, ROUND_DOWN)
+    zz = Rational(3, 22400).to_ld(3, ROUND_DOWN)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = y.divide_s(x, 2, LongMath::ROUND_UP)
-    zz = Rational(3, 22400).to_ld(2, LongMath::ROUND_UP)
+    z = y.divide_s(x, 2, ROUND_UP)
+    zz = Rational(3, 22400).to_ld(2, ROUND_UP)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
 
     y = LongDecimal(3333, 2) # 33.33
-    z = x.divide_s(y, 4, LongMath::ROUND_DOWN)
-    zz = Rational(224, 3333).to_ld(4, LongMath::ROUND_DOWN)
+    z = x.divide_s(y, 4, ROUND_DOWN)
+    zz = Rational(224, 3333).to_ld(4, ROUND_DOWN)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = x.divide_s(y, 30, LongMath::ROUND_UP)
-    zz = Rational(224, 3333).to_ld(30, LongMath::ROUND_UP)
+    z = x.divide_s(y, 30, ROUND_UP)
+    zz = Rational(224, 3333).to_ld(30, ROUND_UP)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = y.divide_s(x, 4, LongMath::ROUND_DOWN)
-    zz = Rational(3333, 224).to_ld(4, LongMath::ROUND_DOWN)
+    z = y.divide_s(x, 4, ROUND_DOWN)
+    zz = Rational(3333, 224).to_ld(4, ROUND_DOWN)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = y.divide_s(x, 1, LongMath::ROUND_UP)
-    zz = Rational(3333, 224).to_ld(1, LongMath::ROUND_UP)
+    z = y.divide_s(x, 1, ROUND_UP)
+    zz = Rational(3333, 224).to_ld(1, ROUND_UP)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
 
     y = LongDecimal(33333, 2) # 333.33
-    z = x.divide_s(y, 3, LongMath::ROUND_DOWN)
-    zz = Rational(224, 33333).to_ld(3, LongMath::ROUND_DOWN)
+    z = x.divide_s(y, 3, ROUND_DOWN)
+    zz = Rational(224, 33333).to_ld(3, ROUND_DOWN)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = x.divide_s(y, 3, LongMath::ROUND_UP)
-    zz = Rational(224, 33333).to_ld(3, LongMath::ROUND_UP)
+    z = x.divide_s(y, 3, ROUND_UP)
+    zz = Rational(224, 33333).to_ld(3, ROUND_UP)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = y.divide_s(x, 33, LongMath::ROUND_DOWN)
-    zz = Rational(33333, 224).to_ld(33, LongMath::ROUND_DOWN)
+    z = y.divide_s(x, 33, ROUND_DOWN)
+    zz = Rational(33333, 224).to_ld(33, ROUND_DOWN)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = y.divide_s(x, 4, LongMath::ROUND_UP)
-    zz = Rational(33333, 224).to_ld(4, LongMath::ROUND_UP)
+    z = y.divide_s(x, 4, ROUND_UP)
+    zz = Rational(33333, 224).to_ld(4, ROUND_UP)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
 
     y = LongDecimal(33333, 3) # 33.333
-    z = x.divide_s(y, 2, LongMath::ROUND_DOWN)
-    zz = Rational(2240, 33333).to_ld(2, LongMath::ROUND_DOWN)
+    z = x.divide_s(y, 2, ROUND_DOWN)
+    zz = Rational(2240, 33333).to_ld(2, ROUND_DOWN)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = x.divide_s(y, 2, LongMath::ROUND_UP)
-    zz = Rational(2240, 33333).to_ld(2, LongMath::ROUND_UP)
+    z = x.divide_s(y, 2, ROUND_UP)
+    zz = Rational(2240, 33333).to_ld(2, ROUND_UP)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = y.divide_s(x, 2, LongMath::ROUND_DOWN)
-    zz = Rational(33333, 2240).to_ld(2, LongMath::ROUND_DOWN)
+    z = y.divide_s(x, 2, ROUND_DOWN)
+    zz = Rational(33333, 2240).to_ld(2, ROUND_DOWN)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = y.divide_s(x, 1, LongMath::ROUND_UP)
-    zz = Rational(33333, 2240).to_ld(1, LongMath::ROUND_UP)
+    z = y.divide_s(x, 1, ROUND_UP)
+    zz = Rational(33333, 2240).to_ld(1, ROUND_UP)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
 
     y = LongDecimal(3333, 3) # 3.333
-    z = x.divide_s(y, 1, LongMath::ROUND_DOWN)
-    zz = Rational(2240, 3333).to_ld(1, LongMath::ROUND_DOWN)
+    z = x.divide_s(y, 1, ROUND_DOWN)
+    zz = Rational(2240, 3333).to_ld(1, ROUND_DOWN)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = x.divide_s(y, 1, LongMath::ROUND_UP)
-    zz = Rational(2240, 3333).to_ld(1, LongMath::ROUND_UP)
+    z = x.divide_s(y, 1, ROUND_UP)
+    zz = Rational(2240, 3333).to_ld(1, ROUND_UP)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = y.divide_s(x, 1, LongMath::ROUND_DOWN)
-    zz = Rational(3333, 2240).to_ld(1, LongMath::ROUND_DOWN)
+    z = y.divide_s(x, 1, ROUND_DOWN)
+    zz = Rational(3333, 2240).to_ld(1, ROUND_DOWN)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = y.divide_s(x, 1, LongMath::ROUND_UP)
-    zz = Rational(3333, 2240).to_ld(1, LongMath::ROUND_UP)
+    z = y.divide_s(x, 1, ROUND_UP)
+    zz = Rational(3333, 2240).to_ld(1, ROUND_UP)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
 
     y = LongDecimal(123456789, 3) # 123456.789
-    z = x.divide_s(y, 3, LongMath::ROUND_DOWN)
-    zz = Rational(2240, 123456789).to_ld(3, LongMath::ROUND_DOWN)
+    z = x.divide_s(y, 3, ROUND_DOWN)
+    zz = Rational(2240, 123456789).to_ld(3, ROUND_DOWN)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = x.divide_s(y, 7, LongMath::ROUND_UP)
-    zz = Rational(2240, 123456789).to_ld(7, LongMath::ROUND_UP)
+    z = x.divide_s(y, 7, ROUND_UP)
+    zz = Rational(2240, 123456789).to_ld(7, ROUND_UP)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = y.divide_s(x, 0, LongMath::ROUND_DOWN)
-    zz = Rational(123456789, 2240).to_ld(0, LongMath::ROUND_DOWN)
+    z = y.divide_s(x, 0, ROUND_DOWN)
+    zz = Rational(123456789, 2240).to_ld(0, ROUND_DOWN)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = y.divide_s(x, 9, LongMath::ROUND_UP)
-    zz = Rational(123456789, 2240).to_ld(9, LongMath::ROUND_UP)
+    z = y.divide_s(x, 9, ROUND_UP)
+    zz = Rational(123456789, 2240).to_ld(9, ROUND_UP)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
 
     y = 5.to_ld  #    5
-    z = x.divide_s(y, 1, LongMath::ROUND_DOWN)
-    zz = Rational(224, 500).to_ld(1, LongMath::ROUND_DOWN)
+    z = x.divide_s(y, 1, ROUND_DOWN)
+    zz = Rational(224, 500).to_ld(1, ROUND_DOWN)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = x.divide_s(y, 1, LongMath::ROUND_UP)
-    zz = Rational(224, 500).to_ld(1, LongMath::ROUND_UP)
+    z = x.divide_s(y, 1, ROUND_UP)
+    zz = Rational(224, 500).to_ld(1, ROUND_UP)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = y.divide_s(x, 1, LongMath::ROUND_DOWN)
-    zz = Rational(500, 224).to_ld(1, LongMath::ROUND_DOWN)
+    z = y.divide_s(x, 1, ROUND_DOWN)
+    zz = Rational(500, 224).to_ld(1, ROUND_DOWN)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = y.divide_s(x, 1, LongMath::ROUND_UP)
-    zz = Rational(500, 224).to_ld(1, LongMath::ROUND_UP)
+    z = y.divide_s(x, 1, ROUND_UP)
+    zz = Rational(500, 224).to_ld(1, ROUND_UP)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
 
     y = 5.001.to_ld  # 5.001
-    z = x.divide_s(y, 1, LongMath::ROUND_DOWN)
-    zz = Rational(224, 500).to_ld(1, LongMath::ROUND_DOWN)
+    z = x.divide_s(y, 1, ROUND_DOWN)
+    zz = Rational(224, 500).to_ld(1, ROUND_DOWN)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = x.divide_s(y, 1, LongMath::ROUND_UP)
-    zz = Rational(224, 500).to_ld(1, LongMath::ROUND_UP)
+    z = x.divide_s(y, 1, ROUND_UP)
+    zz = Rational(224, 500).to_ld(1, ROUND_UP)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = y.divide_s(x, 1, LongMath::ROUND_DOWN)
-    zz = Rational(500, 224).to_ld(1, LongMath::ROUND_DOWN)
+    z = y.divide_s(x, 1, ROUND_DOWN)
+    zz = Rational(500, 224).to_ld(1, ROUND_DOWN)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = y.divide_s(x, 1, LongMath::ROUND_UP)
-    zz = Rational(500, 224).to_ld(1, LongMath::ROUND_UP)
+    z = y.divide_s(x, 1, ROUND_UP)
+    zz = Rational(500, 224).to_ld(1, ROUND_UP)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
 
     y = Rational(5, 3).to_ld(3) # 1.667
-    z = x.divide_s(y, 4, LongMath::ROUND_DOWN)
-    zz = Rational(2240, 1667).to_ld(4, LongMath::ROUND_DOWN)
+    z = x.divide_s(y, 4, ROUND_DOWN)
+    zz = Rational(2240, 1667).to_ld(4, ROUND_DOWN)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "x=#{x} y=#{y} z=#{z} z=#{z.inspect}")
-    z = x.divide_s(y, 1, LongMath::ROUND_UP)
-    zz = Rational(2240, 1667).to_ld(1, LongMath::ROUND_UP)
+    z = x.divide_s(y, 1, ROUND_UP)
+    zz = Rational(2240, 1667).to_ld(1, ROUND_UP)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
     # y is has no scale, use scale of x
-    z = y.divide_s(x, 1, LongMath::ROUND_DOWN)
-    zz = Rational(1667, 2240).to_ld(1, LongMath::ROUND_DOWN)
+    z = y.divide_s(x, 1, ROUND_DOWN)
+    zz = Rational(1667, 2240).to_ld(1, ROUND_DOWN)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = y.divide_s(x, 1, LongMath::ROUND_UP)
-    zz = Rational(1667, 2240).to_ld(1, LongMath::ROUND_UP)
+    z = y.divide_s(x, 1, ROUND_UP)
+    zz = Rational(1667, 2240).to_ld(1, ROUND_UP)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
 
     y = LongDecimalQuot(Rational(5, 3), 3).to_ld
-    z = x.divide_s(y, 1, LongMath::ROUND_DOWN)
-    zz = Rational(2240, 1667).to_ld(1, LongMath::ROUND_DOWN)
+    z = x.divide_s(y, 1, ROUND_DOWN)
+    zz = Rational(2240, 1667).to_ld(1, ROUND_DOWN)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = x.divide_s(y, 1, LongMath::ROUND_UP)
-    zz = Rational(2240, 1667).to_ld(1, LongMath::ROUND_UP)
+    z = x.divide_s(y, 1, ROUND_UP)
+    zz = Rational(2240, 1667).to_ld(1, ROUND_UP)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = y.divide_s(x, 2, LongMath::ROUND_DOWN)
-    zz = Rational(1667, 2240).to_ld(2, LongMath::ROUND_DOWN)
+    z = y.divide_s(x, 2, ROUND_DOWN)
+    zz = Rational(1667, 2240).to_ld(2, ROUND_DOWN)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
-    z = y.divide_s(x, 224, LongMath::ROUND_UP)
-    zz = Rational(1667, 2240).to_ld(224, LongMath::ROUND_UP)
+    z = y.divide_s(x, 224, ROUND_UP)
+    zz = Rational(1667, 2240).to_ld(224, ROUND_UP)
     assert_kind_of(LongDecimal, z, "z=#{z.inspect}")
     assert_equal(zz, z, "z=#{z.inspect}")
   end
@@ -3260,7 +4902,7 @@ class TestLongDecimal_class < Test::Unit::TestCase # RUNIT::TestCase
     x = LongDecimal(224, 2) # 2.24
 
     y = Complex(5, 3)
-    z = x.divide_s(y, 2, LongMath::ROUND_DOWN)
+    z = x.divide_s(y, 2, ROUND_DOWN)
     zz = 2.24 / Complex(5, 3)
     assert_kind_of(Complex, z, "z=#{z.inspect}")
     assert((zz-z).abs < 1e-9, "z=#{z.inspect}")
@@ -3848,79 +5490,79 @@ class TestLongDecimal_class < Test::Unit::TestCase # RUNIT::TestCase
   def test_sqrt
     print "\ntest_sqrt [#{Time.now}]: "
     x = LongDecimal.zero!(101)
-    y = check_sqrt(x, 120, LongDecimal::ROUND_UNNECESSARY, 0, 0, "zero")
+    y = check_sqrt(x, 120, ROUND_UNNECESSARY, 0, 0, "zero")
     assert(y.zero?, "sqrt(0)")
 
     x = LongDecimal.one!(101)
-    y = check_sqrt(x, 120, LongDecimal::ROUND_UNNECESSARY, 0, 0, "one")
+    y = check_sqrt(x, 120, ROUND_UNNECESSARY, 0, 0, "one")
     assert(y.one?, "sqrt(1)")
 
     x = LongDecimal.two!(101)
-    y0 = check_sqrt(x, 120, LongDecimal::ROUND_DOWN, 0, 1, "two")
+    y0 = check_sqrt(x, 120, ROUND_DOWN, 0, 1, "two")
     assert(y0.square < x, "y0*y0")
     assert(y0.succ.square > x, "(y0.succ).square")
-    y1 = check_sqrt(x, 120, LongDecimal::ROUND_HALF_EVEN, -1, 1, "two")
-    y2 = check_sqrt(x, 120, LongDecimal::ROUND_UP, -1, 0, "two")
+    y1 = check_sqrt(x, 120, ROUND_HALF_EVEN, -1, 1, "two")
+    y2 = check_sqrt(x, 120, ROUND_UP, -1, 0, "two")
     assert(y2.pred.square < x, "y2.pred.square")
     assert(y2.square > x, "y2*y2")
     assert(y0 <= y1, "y0 y1")
     assert(y1 <= y2, "y1 y2")
 
-    y0 = check_sqrt(x, 140, LongDecimal::ROUND_DOWN, 0, 1, "two")
+    y0 = check_sqrt(x, 140, ROUND_DOWN, 0, 1, "two")
     assert(y0.square < x, "y0*y0")
     assert(y0.succ.square > x, "(y0.succ).square")
-    y1 = check_sqrt(x, 140, LongDecimal::ROUND_HALF_EVEN, -1, 1, "two")
-    y2 = check_sqrt(x, 140, LongDecimal::ROUND_UP, -1, 0, "two")
+    y1 = check_sqrt(x, 140, ROUND_HALF_EVEN, -1, 1, "two")
+    y2 = check_sqrt(x, 140, ROUND_UP, -1, 0, "two")
     assert(y2.pred.square < x, "y2.pred.square")
     assert(y2.square > x, "y2*y2")
     assert(y0 <= y1, "y0 y1")
     assert(y1 <= y2, "y1 y2")
 
-    y0 = check_sqrt(x, 160, LongDecimal::ROUND_DOWN, 0, 1, "two")
+    y0 = check_sqrt(x, 160, ROUND_DOWN, 0, 1, "two")
     assert(y0.square < x, "y0*y0")
     assert(y0.succ.square > x, "(y0.succ).square")
-    y1 = check_sqrt(x, 160, LongDecimal::ROUND_HALF_EVEN, -1, 1, "two")
-    y2 = check_sqrt(x, 160, LongDecimal::ROUND_UP, -1, 0, "two")
+    y1 = check_sqrt(x, 160, ROUND_HALF_EVEN, -1, 1, "two")
+    y2 = check_sqrt(x, 160, ROUND_UP, -1, 0, "two")
     assert(y2.pred.square < x, "y2.pred.square")
     assert(y2.square > x, "y2*y2")
     assert(y0 <= y1, "y0 y1")
     assert(y1 <= y2, "y1 y2")
 
-    y0 = check_sqrt(x, 120, LongDecimal::ROUND_DOWN, 0, 1, "two")
+    y0 = check_sqrt(x, 120, ROUND_DOWN, 0, 1, "two")
     assert(y0.square < x, "y0*y0")
     assert(y0.succ.square > x, "(y0.succ).square")
-    y1 = check_sqrt(x, 120, LongDecimal::ROUND_HALF_EVEN, -1, 1, "two")
-    y2 = check_sqrt(x, 120, LongDecimal::ROUND_UP, -1, 0, "two")
+    y1 = check_sqrt(x, 120, ROUND_HALF_EVEN, -1, 1, "two")
+    y2 = check_sqrt(x, 120, ROUND_UP, -1, 0, "two")
     assert(y2.pred.square < x, "y2.pred.square")
     assert(y2.square > x, "y2*y2")
     assert(y0 <= y1, "y0 y1")
     assert(y1 <= y2, "y1 y2")
 
-    y0 = check_sqrt(x, 100, LongDecimal::ROUND_DOWN, 0, 1, "two")
+    y0 = check_sqrt(x, 100, ROUND_DOWN, 0, 1, "two")
     assert(y0.square < x, "y0*y0")
     assert(y0.succ.square > x, "(y0.succ).square")
-    y1 = check_sqrt(x, 100, LongDecimal::ROUND_HALF_EVEN, -1, 1, "two")
-    y2 = check_sqrt(x, 100, LongDecimal::ROUND_UP, -1, 0, "two")
+    y1 = check_sqrt(x, 100, ROUND_HALF_EVEN, -1, 1, "two")
+    y2 = check_sqrt(x, 100, ROUND_UP, -1, 0, "two")
     assert(y2.pred.square < x, "y2.pred.square")
     assert(y2.square > x, "y2*y2")
     assert(y0 <= y1, "y0 y1")
     assert(y1 <= y2, "y1 y2")
 
     x = 3.to_ld
-    y0 = check_sqrt(x, 120, LongDecimal::ROUND_DOWN, 0, 1, "three")
+    y0 = check_sqrt(x, 120, ROUND_DOWN, 0, 1, "three")
     assert(y0.square < x, "y0*y0")
     assert(y0.succ.square > x, "(y0.succ).square")
-    y1 = check_sqrt(x, 120, LongDecimal::ROUND_HALF_EVEN, -1, 1, "three")
-    y2 = check_sqrt(x, 120, LongDecimal::ROUND_UP, -1, 0, "three")
+    y1 = check_sqrt(x, 120, ROUND_HALF_EVEN, -1, 1, "three")
+    y2 = check_sqrt(x, 120, ROUND_UP, -1, 0, "three")
     assert(y2.pred.square < x, "y2.pred.square")
     assert(y2.square > x, "y2*y2")
     assert(y0 <= y1, "y0 y1")
     assert(y1 <= y2, "y1 y2")
 
     x  = 4.to_ld(101)
-    y0 = check_sqrt(x, 120, LongDecimal::ROUND_DOWN, 0, 0, "four")
-    y1 = check_sqrt(x, 120, LongDecimal::ROUND_HALF_EVEN, 0, 0, "four")
-    y2 = check_sqrt(x, 120, LongDecimal::ROUND_UP, 0, 0, "four")
+    y0 = check_sqrt(x, 120, ROUND_DOWN, 0, 0, "four")
+    y1 = check_sqrt(x, 120, ROUND_HALF_EVEN, 0, 0, "four")
+    y2 = check_sqrt(x, 120, ROUND_UP, 0, 0, "four")
     assert_equal(y0, y1, "y0 y1")
     assert_equal(y1, y2, "y1 y2")
   end
@@ -3964,21 +5606,21 @@ class TestLongDecimal_class < Test::Unit::TestCase # RUNIT::TestCase
   def test_non_ld_sqrt
     print "\ntest_non_ld_sqrt [#{Time.now}]: "
     xi = 77
-    yi = LongMath.sqrt(xi, 31, LongMath::ROUND_HALF_EVEN)
-    zi = yi.square.round_to_scale(30, LongMath::ROUND_HALF_EVEN)
+    yi = LongMath.sqrt(xi, 31, ROUND_HALF_EVEN)
+    zi = yi.square.round_to_scale(30, ROUND_HALF_EVEN)
     assert(zi.is_int?, "zi=#{zi.to_s}")
     assert_equal(xi, zi.to_i, "zi")
 
     xf = 77.0
-    yf = LongMath.sqrt(xf, 31, LongMath::ROUND_HALF_EVEN)
-    zf = yf.square.round_to_scale(30, LongMath::ROUND_HALF_EVEN)
+    yf = LongMath.sqrt(xf, 31, ROUND_HALF_EVEN)
+    zf = yf.square.round_to_scale(30, ROUND_HALF_EVEN)
     assert(zf.is_int?, "zf")
     assert_equal(xf, zf.to_f, "zf")
     assert_equal(yi, yf, "i-f")
 
     xr = Rational(224, 227)
-    yr = LongMath.sqrt(xr, 31, LongMath::ROUND_HALF_EVEN)
-    zr = yr.square.round_to_scale(30, LongMath::ROUND_HALF_EVEN)
+    yr = LongMath.sqrt(xr, 31, ROUND_HALF_EVEN)
+    zr = yr.square.round_to_scale(30, ROUND_HALF_EVEN)
     assert((zr-xr).abs <= zr.unit, "zr-xr")
   end
 
@@ -3988,79 +5630,79 @@ class TestLongDecimal_class < Test::Unit::TestCase # RUNIT::TestCase
   def test_cbrt
     print "\ntest_cbrt [#{Time.now}]: "
     x = LongDecimal.zero!(101)
-    y = check_cbrt(x, 120, LongDecimal::ROUND_UNNECESSARY, 0, 0, "zero")
+    y = check_cbrt(x, 120, ROUND_UNNECESSARY, 0, 0, "zero")
     assert(y.zero?, "cbrt(0)")
 
     x = LongDecimal.one!(101)
-    y = check_cbrt(x, 120, LongDecimal::ROUND_UNNECESSARY, 0, 0, "one")
+    y = check_cbrt(x, 120, ROUND_UNNECESSARY, 0, 0, "one")
     assert(y.one?, "cbrt(1)")
 
     x = LongDecimal.two!(101)
-    y0 = check_cbrt(x, 120, LongDecimal::ROUND_DOWN, 0, 1, "two")
+    y0 = check_cbrt(x, 120, ROUND_DOWN, 0, 1, "two")
     assert(y0.cube < x, "y0**3")
     assert(y0.succ.cube > x, "(y0.succ).cube")
-    y1 = check_cbrt(x, 120, LongDecimal::ROUND_HALF_EVEN, -1, 1, "two")
-    y2 = check_cbrt(x, 120, LongDecimal::ROUND_UP, -1, 0, "two")
+    y1 = check_cbrt(x, 120, ROUND_HALF_EVEN, -1, 1, "two")
+    y2 = check_cbrt(x, 120, ROUND_UP, -1, 0, "two")
     assert(y2.pred.cube < x, "y2.pred.cube")
     assert(y2.cube > x, "y2**3")
     assert(y0 <= y1, "y0 y1")
     assert(y1 <= y2, "y1 y2")
 
-    y0 = check_cbrt(x, 140, LongDecimal::ROUND_DOWN, 0, 1, "two")
+    y0 = check_cbrt(x, 140, ROUND_DOWN, 0, 1, "two")
     assert(y0.cube < x, "y0**3")
     assert(y0.succ.cube > x, "(y0.succ).cube")
-    y1 = check_cbrt(x, 140, LongDecimal::ROUND_HALF_EVEN, -1, 1, "two")
-    y2 = check_cbrt(x, 140, LongDecimal::ROUND_UP, -1, 0, "two")
+    y1 = check_cbrt(x, 140, ROUND_HALF_EVEN, -1, 1, "two")
+    y2 = check_cbrt(x, 140, ROUND_UP, -1, 0, "two")
     assert(y2.pred.cube < x, "y2.pred.cube")
     assert(y2.cube > x, "y2**3")
     assert(y0 <= y1, "y0 y1")
     assert(y1 <= y2, "y1 y2")
 
-    y0 = check_cbrt(x, 160, LongDecimal::ROUND_DOWN, 0, 1, "two")
+    y0 = check_cbrt(x, 160, ROUND_DOWN, 0, 1, "two")
     assert(y0.cube < x, "y0**3")
     assert(y0.succ.cube > x, "(y0.succ).cube")
-    y1 = check_cbrt(x, 160, LongDecimal::ROUND_HALF_EVEN, -1, 1, "two")
-    y2 = check_cbrt(x, 160, LongDecimal::ROUND_UP, -1, 0, "two")
+    y1 = check_cbrt(x, 160, ROUND_HALF_EVEN, -1, 1, "two")
+    y2 = check_cbrt(x, 160, ROUND_UP, -1, 0, "two")
     assert(y2.pred.cube < x, "y2.pred.cube")
     assert(y2.cube > x, "y2**3")
     assert(y0 <= y1, "y0 y1")
     assert(y1 <= y2, "y1 y2")
 
-    y0 = check_cbrt(x, 120, LongDecimal::ROUND_DOWN, 0, 1, "two")
+    y0 = check_cbrt(x, 120, ROUND_DOWN, 0, 1, "two")
     assert(y0.cube < x, "y0**3")
     assert(y0.succ.cube > x, "(y0.succ).cube")
-    y1 = check_cbrt(x, 120, LongDecimal::ROUND_HALF_EVEN, -1, 1, "two")
-    y2 = check_cbrt(x, 120, LongDecimal::ROUND_UP, -1, 0, "two")
+    y1 = check_cbrt(x, 120, ROUND_HALF_EVEN, -1, 1, "two")
+    y2 = check_cbrt(x, 120, ROUND_UP, -1, 0, "two")
     assert(y2.pred.cube < x, "y2.pred.cube")
     assert(y2.cube > x, "y2**3")
     assert(y0 <= y1, "y0 y1")
     assert(y1 <= y2, "y1 y2")
 
-    y0 = check_cbrt(x, 100, LongDecimal::ROUND_DOWN, 0, 1, "two")
+    y0 = check_cbrt(x, 100, ROUND_DOWN, 0, 1, "two")
     assert(y0.cube < x, "y0**3")
     assert(y0.succ.cube > x, "(y0.succ).cube")
-    y1 = check_cbrt(x, 100, LongDecimal::ROUND_HALF_EVEN, -1, 1, "two")
-    y2 = check_cbrt(x, 100, LongDecimal::ROUND_UP, -1, 0, "two")
+    y1 = check_cbrt(x, 100, ROUND_HALF_EVEN, -1, 1, "two")
+    y2 = check_cbrt(x, 100, ROUND_UP, -1, 0, "two")
     assert(y2.pred.cube < x, "y2.pred.cube")
     assert(y2.cube > x, "y2**3")
     assert(y0 <= y1, "y0 y1")
     assert(y1 <= y2, "y1 y2")
 
     x = 3.to_ld
-    y0 = check_cbrt(x, 120, LongDecimal::ROUND_DOWN, 0, 1, "three")
+    y0 = check_cbrt(x, 120, ROUND_DOWN, 0, 1, "three")
     assert(y0.cube < x, "y0**3")
     assert(y0.succ.cube > x, "(y0.succ).cube")
-    y1 = check_cbrt(x, 120, LongDecimal::ROUND_HALF_EVEN, -1, 1, "three")
-    y2 = check_cbrt(x, 120, LongDecimal::ROUND_UP, -1, 0, "three")
+    y1 = check_cbrt(x, 120, ROUND_HALF_EVEN, -1, 1, "three")
+    y2 = check_cbrt(x, 120, ROUND_UP, -1, 0, "three")
     assert(y2.pred.cube < x, "y2.pred.cube")
     assert(y2.cube > x, "y2**3")
     assert(y0 <= y1, "y0 y1")
     assert(y1 <= y2, "y1 y2")
 
     x  = 8.to_ld(101)
-    y0 = check_cbrt(x, 120, LongDecimal::ROUND_DOWN, 0, 0, "eight")
-    y1 = check_cbrt(x, 120, LongDecimal::ROUND_HALF_EVEN, 0, 0, "eight")
-    y2 = check_cbrt(x, 120, LongDecimal::ROUND_UP, 0, 0, "eight")
+    y0 = check_cbrt(x, 120, ROUND_DOWN, 0, 0, "eight")
+    y1 = check_cbrt(x, 120, ROUND_HALF_EVEN, 0, 0, "eight")
+    y2 = check_cbrt(x, 120, ROUND_UP, 0, 0, "eight")
     assert_equal(y0, y1, "y0 y1")
     assert_equal(y1, y2, "y1 y2")
   end
@@ -4104,21 +5746,21 @@ class TestLongDecimal_class < Test::Unit::TestCase # RUNIT::TestCase
   def test_non_ld_cbrt
     print "\ntest_non_ld_cbrt [#{Time.now}]: "
     xi = 77
-    yi = LongMath.cbrt(xi, 32, LongMath::ROUND_HALF_EVEN)
-    zi = yi.cube.round_to_scale(30, LongMath::ROUND_HALF_EVEN)
+    yi = LongMath.cbrt(xi, 32, ROUND_HALF_EVEN)
+    zi = yi.cube.round_to_scale(30, ROUND_HALF_EVEN)
     assert(zi.is_int?, "zi=#{zi.to_s}")
     assert_equal(xi, zi.to_i, "zi")
 
     xf = 77.0
-    yf = LongMath.cbrt(xf, 32, LongMath::ROUND_HALF_EVEN)
-    zf = yf.cube.round_to_scale(30, LongMath::ROUND_HALF_EVEN)
+    yf = LongMath.cbrt(xf, 32, ROUND_HALF_EVEN)
+    zf = yf.cube.round_to_scale(30, ROUND_HALF_EVEN)
     assert(zf.is_int?, "zf")
     assert_equal(xf, zf.to_f, "zf")
     assert_equal(yi, yf, "i-f")
 
     xr = Rational(224, 227)
-    yr = LongMath.cbrt(xr, 32, LongMath::ROUND_HALF_EVEN)
-    zr = yr.cube.round_to_scale(30, LongMath::ROUND_HALF_EVEN)
+    yr = LongMath.cbrt(xr, 32, ROUND_HALF_EVEN)
+    zr = yr.cube.round_to_scale(30, ROUND_HALF_EVEN)
     assert((zr-xr).abs <= zr.unit, "zr-xr")
   end
 
@@ -4461,31 +6103,31 @@ class TestLongDecimal_class < Test::Unit::TestCase # RUNIT::TestCase
     # 0.99555555555555...
     l = LongDecimalQuot(Rational(224, 225), 0)
     # 1.0
-    r = l.round_to_scale(1, LongDecimal::ROUND_UP)
+    r = l.round_to_scale(1, ROUND_UP)
     assert_equal("1.0", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_kind_of(LongDecimal, r, "must be LongDecimal")
     assert_equal("224/225[0]", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimalQuot(-Rational(224, 225), 0)
-    r = l.round_to_scale(1, LongDecimal::ROUND_UP)
+    r = l.round_to_scale(1, ROUND_UP)
     assert_equal("-1.0", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_kind_of(LongDecimal, r, "must be LongDecimal")
     assert_equal("-224/225[0]", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     # 0.00444444444444444
     l = LongDecimalQuot(Rational(1, 225), 0)
-    r = l.round_to_scale(1, LongDecimal::ROUND_UP)
+    r = l.round_to_scale(1, ROUND_UP)
     assert_equal("0.1", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_kind_of(LongDecimal, r, "must be LongDecimal")
     assert_equal("1/225[0]", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimalQuot(Rational(-1, 225), 0)
-    r = l.round_to_scale(1, LongDecimal::ROUND_UP)
+    r = l.round_to_scale(1, ROUND_UP)
     assert_equal("-0.1", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_kind_of(LongDecimal, r, "must be LongDecimal")
     assert_equal("-1/225[0]", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimalQuot(Rational(1, 1), 1000)
-    r = l.round_to_scale(4, LongDecimal::ROUND_UP)
+    r = l.round_to_scale(4, ROUND_UP)
     assert_equal("1.0000", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimalQuot(Rational(1, 1), 1)
-    r = l.round_to_scale(4, LongDecimal::ROUND_UP)
+    r = l.round_to_scale(4, ROUND_UP)
     assert_equal("1.0000", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
   end
 
@@ -4498,31 +6140,31 @@ class TestLongDecimal_class < Test::Unit::TestCase # RUNIT::TestCase
     # 0.99555555555555...
     l = LongDecimalQuot(Rational(224, 225), 0)
     # 0.9
-    r = l.round_to_scale(1, LongDecimal::ROUND_DOWN)
+    r = l.round_to_scale(1, ROUND_DOWN)
     assert_equal("0.9", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_kind_of(LongDecimal, r, "must be LongDecimal")
     assert_equal("224/225[0]", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimalQuot(-Rational(224, 225), 0)
-    r = l.round_to_scale(1, LongDecimal::ROUND_DOWN)
+    r = l.round_to_scale(1, ROUND_DOWN)
     assert_equal("-0.9", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_kind_of(LongDecimal, r, "must be LongDecimal")
     assert_equal("-224/225[0]", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     # 0.00444444444444444
     l = LongDecimalQuot(Rational(1, 225), 0)
-    r = l.round_to_scale(1, LongDecimal::ROUND_DOWN)
+    r = l.round_to_scale(1, ROUND_DOWN)
     assert_equal("0.0", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_kind_of(LongDecimal, r, "must be LongDecimal")
     assert_equal("1/225[0]", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimalQuot(Rational(-1, 225), 0)
-    r = l.round_to_scale(1, LongDecimal::ROUND_DOWN)
+    r = l.round_to_scale(1, ROUND_DOWN)
     assert_equal("0.0", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_kind_of(LongDecimal, r, "must be LongDecimal")
     assert_equal("-1/225[0]", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimalQuot(Rational(1, 1), 1000)
-    r = l.round_to_scale(4, LongDecimal::ROUND_DOWN)
+    r = l.round_to_scale(4, ROUND_DOWN)
     assert_equal("1.0000", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimalQuot(Rational(1, 1), 1)
-    r = l.round_to_scale(4, LongDecimal::ROUND_DOWN)
+    r = l.round_to_scale(4, ROUND_DOWN)
     assert_equal("1.0000", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
   end
 
@@ -4534,31 +6176,31 @@ class TestLongDecimal_class < Test::Unit::TestCase # RUNIT::TestCase
 
     # 0.99555555555555...
     l = LongDecimalQuot(Rational(224, 225), 0)
-    r = l.round_to_scale(1, LongDecimal::ROUND_CEILING)
+    r = l.round_to_scale(1, ROUND_CEILING)
     assert_equal("1.0", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_kind_of(LongDecimal, r, "must be LongDecimal")
     assert_equal("224/225[0]", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimalQuot(-Rational(224, 225), 0)
-    r = l.round_to_scale(1, LongDecimal::ROUND_CEILING)
+    r = l.round_to_scale(1, ROUND_CEILING)
     assert_equal("-0.9", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_kind_of(LongDecimal, r, "must be LongDecimal")
     assert_equal("-224/225[0]", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     # 0.00444444444444444
     l = LongDecimalQuot(Rational(1, 225), 0)
-    r = l.round_to_scale(1, LongDecimal::ROUND_CEILING)
+    r = l.round_to_scale(1, ROUND_CEILING)
     assert_equal("0.1", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_kind_of(LongDecimal, r, "must be LongDecimal")
     assert_equal("1/225[0]", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimalQuot(Rational(-1, 225), 0)
-    r = l.round_to_scale(1, LongDecimal::ROUND_CEILING)
+    r = l.round_to_scale(1, ROUND_CEILING)
     assert_equal("0.0", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_kind_of(LongDecimal, r, "must be LongDecimal")
     assert_equal("-1/225[0]", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimalQuot(Rational(1, 1), 1000)
-    r = l.round_to_scale(4, LongDecimal::ROUND_CEILING)
+    r = l.round_to_scale(4, ROUND_CEILING)
     assert_equal("1.0000", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimalQuot(Rational(1, 1), 1)
-    r = l.round_to_scale(4, LongDecimal::ROUND_CEILING)
+    r = l.round_to_scale(4, ROUND_CEILING)
     assert_equal("1.0000", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
   end
 
@@ -4570,31 +6212,31 @@ class TestLongDecimal_class < Test::Unit::TestCase # RUNIT::TestCase
 
     # 0.99555555555555...
     l = LongDecimalQuot(Rational(224, 225), 0)
-    r = l.round_to_scale(1, LongDecimal::ROUND_FLOOR)
+    r = l.round_to_scale(1, ROUND_FLOOR)
     assert_equal("0.9", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_kind_of(LongDecimal, r, "must be LongDecimal")
     assert_equal("224/225[0]", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimalQuot(-Rational(224, 225), 0)
-    r = l.round_to_scale(1, LongDecimal::ROUND_FLOOR)
+    r = l.round_to_scale(1, ROUND_FLOOR)
     assert_equal("-1.0", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_kind_of(LongDecimal, r, "must be LongDecimal")
     assert_equal("-224/225[0]", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     # 0.00444444444444444
     l = LongDecimalQuot(Rational(1, 225), 0)
-    r = l.round_to_scale(1, LongDecimal::ROUND_FLOOR)
+    r = l.round_to_scale(1, ROUND_FLOOR)
     assert_equal("0.0", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_kind_of(LongDecimal, r, "must be LongDecimal")
     assert_equal("1/225[0]", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimalQuot(Rational(-1, 225), 0)
-    r = l.round_to_scale(1, LongDecimal::ROUND_FLOOR)
+    r = l.round_to_scale(1, ROUND_FLOOR)
     assert_equal("-0.1", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_kind_of(LongDecimal, r, "must be LongDecimal")
     assert_equal("-1/225[0]", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimalQuot(Rational(1, 1), 1000)
-    r = l.round_to_scale(4, LongDecimal::ROUND_FLOOR)
+    r = l.round_to_scale(4, ROUND_FLOOR)
     assert_equal("1.0000", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimalQuot(Rational(1, 1), 1)
-    r = l.round_to_scale(4, LongDecimal::ROUND_FLOOR)
+    r = l.round_to_scale(4, ROUND_FLOOR)
     assert_equal("1.0000", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
   end
 
@@ -4606,40 +6248,40 @@ class TestLongDecimal_class < Test::Unit::TestCase # RUNIT::TestCase
 
     # 0.99555555555555...
     l = LongDecimalQuot(Rational(224, 225), 0)
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_UP)
+    r = l.round_to_scale(1, ROUND_HALF_UP)
     assert_equal("1.0", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_kind_of(LongDecimal, r, "must be LongDecimal")
     assert_equal("224/225[0]", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimalQuot(-Rational(224, 225), 0)
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_UP)
+    r = l.round_to_scale(1, ROUND_HALF_UP)
     assert_equal("-1.0", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_kind_of(LongDecimal, r, "must be LongDecimal")
     assert_equal("-224/225[0]", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     # 0.00444444444444444
     l = LongDecimalQuot(Rational(1, 225), 0)
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_UP)
+    r = l.round_to_scale(1, ROUND_HALF_UP)
     assert_equal("0.0", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_kind_of(LongDecimal, r, "must be LongDecimal")
     assert_equal("1/225[0]", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimalQuot(Rational(-1, 225), 0)
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_UP)
+    r = l.round_to_scale(1, ROUND_HALF_UP)
     assert_equal("0.0", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_kind_of(LongDecimal, r, "must be LongDecimal")
     assert_equal("-1/225[0]", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimalQuot(Rational(1, 1), 1000)
-    r = l.round_to_scale(4, LongDecimal::ROUND_HALF_UP)
+    r = l.round_to_scale(4, ROUND_HALF_UP)
     assert_equal("1.0000", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimalQuot(Rational(1, 1), 1)
-    r = l.round_to_scale(4, LongDecimal::ROUND_HALF_UP)
+    r = l.round_to_scale(4, ROUND_HALF_UP)
     assert_equal("1.0000", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     # 56.25
     l = LongDecimalQuot(Rational(225, 4), 0)
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_UP)
+    r = l.round_to_scale(1, ROUND_HALF_UP)
     assert_equal("56.3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_kind_of(LongDecimal, r, "must be LongDecimal")
     assert_equal("225/4[0]", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimalQuot(Rational(-225, 4), 0)
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_UP)
+    r = l.round_to_scale(1, ROUND_HALF_UP)
     assert_equal("-56.3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_kind_of(LongDecimal, r, "must be LongDecimal")
     assert_equal("-225/4[0]", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
@@ -4653,40 +6295,40 @@ class TestLongDecimal_class < Test::Unit::TestCase # RUNIT::TestCase
 
     # 0.99555555555555...
     l = LongDecimalQuot(Rational(224, 225), 0)
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_DOWN)
+    r = l.round_to_scale(1, ROUND_HALF_DOWN)
     assert_equal("1.0", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_kind_of(LongDecimal, r, "must be LongDecimal")
     assert_equal("224/225[0]", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimalQuot(-Rational(224, 225), 0)
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_DOWN)
+    r = l.round_to_scale(1, ROUND_HALF_DOWN)
     assert_equal("-1.0", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_kind_of(LongDecimal, r, "must be LongDecimal")
     assert_equal("-224/225[0]", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     # 0.00444444444444444
     l = LongDecimalQuot(Rational(1, 225), 0)
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_DOWN)
+    r = l.round_to_scale(1, ROUND_HALF_DOWN)
     assert_equal("0.0", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_kind_of(LongDecimal, r, "must be LongDecimal")
     assert_equal("1/225[0]", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimalQuot(Rational(-1, 225), 0)
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_DOWN)
+    r = l.round_to_scale(1, ROUND_HALF_DOWN)
     assert_equal("0.0", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_kind_of(LongDecimal, r, "must be LongDecimal")
     assert_equal("-1/225[0]", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimalQuot(Rational(1, 1), 1000)
-    r = l.round_to_scale(4, LongDecimal::ROUND_HALF_DOWN)
+    r = l.round_to_scale(4, ROUND_HALF_DOWN)
     assert_equal("1.0000", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimalQuot(Rational(1, 1), 1)
-    r = l.round_to_scale(4, LongDecimal::ROUND_HALF_DOWN)
+    r = l.round_to_scale(4, ROUND_HALF_DOWN)
     assert_equal("1.0000", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     # 56.25
     l = LongDecimalQuot(Rational(225, 4), 0)
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_DOWN)
+    r = l.round_to_scale(1, ROUND_HALF_DOWN)
     assert_equal("56.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_kind_of(LongDecimal, r, "must be LongDecimal")
     assert_equal("225/4[0]", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimalQuot(Rational(-225, 4), 0)
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_DOWN)
+    r = l.round_to_scale(1, ROUND_HALF_DOWN)
     assert_equal("-56.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_kind_of(LongDecimal, r, "must be LongDecimal")
     assert_equal("-225/4[0]", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
@@ -4700,40 +6342,40 @@ class TestLongDecimal_class < Test::Unit::TestCase # RUNIT::TestCase
 
     # 0.99555555555555...
     l = LongDecimalQuot(Rational(224, 225), 0)
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_CEILING)
+    r = l.round_to_scale(1, ROUND_HALF_CEILING)
     assert_equal("1.0", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_kind_of(LongDecimal, r, "must be LongDecimal")
     assert_equal("224/225[0]", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimalQuot(-Rational(224, 225), 0)
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_CEILING)
+    r = l.round_to_scale(1, ROUND_HALF_CEILING)
     assert_equal("-1.0", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_kind_of(LongDecimal, r, "must be LongDecimal")
     assert_equal("-224/225[0]", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     # 0.00444444444444444
     l = LongDecimalQuot(Rational(1, 225), 0)
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_CEILING)
+    r = l.round_to_scale(1, ROUND_HALF_CEILING)
     assert_equal("0.0", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_kind_of(LongDecimal, r, "must be LongDecimal")
     assert_equal("1/225[0]", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimalQuot(Rational(-1, 225), 0)
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_CEILING)
+    r = l.round_to_scale(1, ROUND_HALF_CEILING)
     assert_equal("0.0", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_kind_of(LongDecimal, r, "must be LongDecimal")
     assert_equal("-1/225[0]", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimalQuot(Rational(1, 1), 1000)
-    r = l.round_to_scale(4, LongDecimal::ROUND_HALF_CEILING)
+    r = l.round_to_scale(4, ROUND_HALF_CEILING)
     assert_equal("1.0000", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimalQuot(Rational(1, 1), 1)
-    r = l.round_to_scale(4, LongDecimal::ROUND_HALF_CEILING)
+    r = l.round_to_scale(4, ROUND_HALF_CEILING)
     assert_equal("1.0000", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     # 56.25
     l = LongDecimalQuot(Rational(225, 4), 0)
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_CEILING)
+    r = l.round_to_scale(1, ROUND_HALF_CEILING)
     assert_equal("56.3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_kind_of(LongDecimal, r, "must be LongDecimal")
     assert_equal("225/4[0]", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimalQuot(Rational(-225, 4), 0)
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_CEILING)
+    r = l.round_to_scale(1, ROUND_HALF_CEILING)
     assert_equal("-56.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_kind_of(LongDecimal, r, "must be LongDecimal")
     assert_equal("-225/4[0]", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
@@ -4747,40 +6389,40 @@ class TestLongDecimal_class < Test::Unit::TestCase # RUNIT::TestCase
 
     # 0.99555555555555...
     l = LongDecimalQuot(Rational(224, 225), 0)
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_FLOOR)
+    r = l.round_to_scale(1, ROUND_HALF_FLOOR)
     assert_equal("1.0", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_kind_of(LongDecimal, r, "must be LongDecimal")
     assert_equal("224/225[0]", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimalQuot(-Rational(224, 225), 0)
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_FLOOR)
+    r = l.round_to_scale(1, ROUND_HALF_FLOOR)
     assert_equal("-1.0", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_kind_of(LongDecimal, r, "must be LongDecimal")
     assert_equal("-224/225[0]", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     # 0.00444444444444444
     l = LongDecimalQuot(Rational(1, 225), 0)
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_FLOOR)
+    r = l.round_to_scale(1, ROUND_HALF_FLOOR)
     assert_equal("0.0", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_kind_of(LongDecimal, r, "must be LongDecimal")
     assert_equal("1/225[0]", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimalQuot(Rational(-1, 225), 0)
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_FLOOR)
+    r = l.round_to_scale(1, ROUND_HALF_FLOOR)
     assert_equal("0.0", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_kind_of(LongDecimal, r, "must be LongDecimal")
     assert_equal("-1/225[0]", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimalQuot(Rational(1, 1), 1000)
-    r = l.round_to_scale(4, LongDecimal::ROUND_HALF_FLOOR)
+    r = l.round_to_scale(4, ROUND_HALF_FLOOR)
     assert_equal("1.0000", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimalQuot(Rational(1, 1), 1)
-    r = l.round_to_scale(4, LongDecimal::ROUND_HALF_FLOOR)
+    r = l.round_to_scale(4, ROUND_HALF_FLOOR)
     assert_equal("1.0000", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     # 56.25
     l = LongDecimalQuot(Rational(225, 4), 0)
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_FLOOR)
+    r = l.round_to_scale(1, ROUND_HALF_FLOOR)
     assert_equal("56.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_kind_of(LongDecimal, r, "must be LongDecimal")
     assert_equal("225/4[0]", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimalQuot(Rational(-225, 4), 0)
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_FLOOR)
+    r = l.round_to_scale(1, ROUND_HALF_FLOOR)
     assert_equal("-56.3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_kind_of(LongDecimal, r, "must be LongDecimal")
     assert_equal("-225/4[0]", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
@@ -4794,56 +6436,112 @@ class TestLongDecimal_class < Test::Unit::TestCase # RUNIT::TestCase
 
     # 0.99555555555555...
     l = LongDecimalQuot(Rational(224, 225), 0)
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_EVEN)
+    r = l.round_to_scale(1, ROUND_HALF_EVEN)
     assert_equal("1.0", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_kind_of(LongDecimal, r, "must be LongDecimal")
     assert_equal("224/225[0]", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimalQuot(-Rational(224, 225), 0)
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_EVEN)
+    r = l.round_to_scale(1, ROUND_HALF_EVEN)
     assert_equal("-1.0", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_kind_of(LongDecimal, r, "must be LongDecimal")
     assert_equal("-224/225[0]", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     # 0.00444444444444444
     l = LongDecimalQuot(Rational(1, 225), 0)
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_EVEN)
+    r = l.round_to_scale(1, ROUND_HALF_EVEN)
     assert_equal("0.0", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_kind_of(LongDecimal, r, "must be LongDecimal")
     assert_equal("1/225[0]", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimalQuot(Rational(-1, 225), 0)
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_EVEN)
+    r = l.round_to_scale(1, ROUND_HALF_EVEN)
     assert_equal("0.0", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_kind_of(LongDecimal, r, "must be LongDecimal")
     assert_equal("-1/225[0]", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimalQuot(Rational(1, 1), 1000)
-    r = l.round_to_scale(4, LongDecimal::ROUND_HALF_EVEN)
+    r = l.round_to_scale(4, ROUND_HALF_EVEN)
     assert_equal("1.0000", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     l = LongDecimalQuot(Rational(1, 1), 1)
-    r = l.round_to_scale(4, LongDecimal::ROUND_HALF_EVEN)
+    r = l.round_to_scale(4, ROUND_HALF_EVEN)
     assert_equal("1.0000", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     # 56.25
     l = LongDecimalQuot(Rational(225, 4), 0)
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_EVEN)
+    r = l.round_to_scale(1, ROUND_HALF_EVEN)
     assert_equal("56.2", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_kind_of(LongDecimal, r, "must be LongDecimal")
     assert_equal("225/4[0]", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
     # 56.75
     l = LongDecimalQuot(Rational(227, 4), 0)
-    r = l.round_to_scale(1, LongDecimal::ROUND_HALF_EVEN)
+    r = l.round_to_scale(1, ROUND_HALF_EVEN)
     assert_equal("56.8", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     assert_kind_of(LongDecimal, r, "must be LongDecimal")
     assert_equal("227/4[0]", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
   end
 
+  #
+  # test rounding of LongDecimalQuot with ROUND_HALF_ODD
+  #
+  def test_ldq_round_to_scale_half_odd
+    print "\ntest_ldq_round_to_scale_half_odd [#{Time.now}]: "
+
+    # 0.99555555555555...
+    l = LongDecimalQuot(Rational(224, 225), 0)
+    r = l.round_to_scale(1, ROUND_HALF_ODD)
+    assert_equal("1.0", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_kind_of(LongDecimal, r, "must be LongDecimal")
+    assert_equal("224/225[0]", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimalQuot(-Rational(224, 225), 0)
+    r = l.round_to_scale(1, ROUND_HALF_ODD)
+    assert_equal("-1.0", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_kind_of(LongDecimal, r, "must be LongDecimal")
+    assert_equal("-224/225[0]", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    # 0.00444444444444444
+    l = LongDecimalQuot(Rational(1, 225), 0)
+    r = l.round_to_scale(1, ROUND_HALF_ODD)
+    assert_equal("0.0", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_kind_of(LongDecimal, r, "must be LongDecimal")
+    assert_equal("1/225[0]", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimalQuot(Rational(-1, 225), 0)
+    r = l.round_to_scale(1, ROUND_HALF_ODD)
+    assert_equal("0.0", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_kind_of(LongDecimal, r, "must be LongDecimal")
+    assert_equal("-1/225[0]", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimalQuot(Rational(1, 1), 1000)
+    r = l.round_to_scale(4, ROUND_HALF_ODD)
+    assert_equal("1.0000", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    l = LongDecimalQuot(Rational(1, 1), 1)
+    r = l.round_to_scale(4, ROUND_HALF_ODD)
+    assert_equal("1.0000", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    # 56.25
+    l = LongDecimalQuot(Rational(225, 4), 0)
+    r = l.round_to_scale(1, ROUND_HALF_ODD)
+    assert_equal("56.3", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_kind_of(LongDecimal, r, "must be LongDecimal")
+    assert_equal("225/4[0]", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    # 56.75
+    l = LongDecimalQuot(Rational(227, 4), 0)
+    r = l.round_to_scale(1, ROUND_HALF_ODD)
+    assert_equal("56.7", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
+    assert_kind_of(LongDecimal, r, "must be LongDecimal")
+    assert_equal("227/4[0]", l.to_s, "l=#{l.inspect} r=#{r.inspect}")
+  end
+
+  # TODO: do tests with rational numbers that approach square and cube roots with continuos fractions
+  # TODO: do tests for harmonic that are exact matches
+  # def test_ldq_round_to_scale_geometric_common
+  # def test_ldq_round_to_scale_harmonic_common
+  # def test_ldq_round_to_scale_harmonic_*
+  # def test_ldq_round_to_scale_quadratic_common
+  # def test_ldq_round_to_scale_cubic_common
+
   #
   # test rounding of LongDecimalQuot with ROUND_UNNECESSARY
   #
   def test_ldq_round_to_scale_unnecessary
     print "\ntest_ldq_round_to_scale_unnecessary [#{Time.now}]: "
     l = LongDecimalQuot(Rational(225, 4), 5)
-    r = l.round_to_scale(2, LongDecimal::ROUND_UNNECESSARY)
+    r = l.round_to_scale(2, ROUND_UNNECESSARY)
     assert_equal("56.25", r.to_s, "l=#{l.inspect} r=#{r.inspect}")
     begin
-      r = l.round_to_scale(1, LongDecimal::ROUND_UNNECESSARY)
+      r = l.round_to_scale(1, ROUND_UNNECESSARY)
       assert_fail("should not have succeeded l=#{l.inspect} r=#{r.inspect}")
     rescue ArgumentError
       # ignored
@@ -4979,7 +6677,7 @@ class TestLongDecimal_class < Test::Unit::TestCase # RUNIT::TestCase
     y = x.to_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...")
+    assert_equal(LongDecimal("1.5555555556"), y, "1.55... y=#{y} x=#{x}")
     x = LongDecimalQuot(Rational(7, 20), 1)
     y = x.to_ld
     assert_kind_of(LongDecimal, y, "must be ld")
@@ -5588,21 +7286,173 @@ class TestLongDecimal_class < Test::Unit::TestCase # RUNIT::TestCase
     assert(! (y.eql? x), "! #{y.inspect} eql? #{x.inspect}")
   end
 
+  def test_means_one_param
+    print "\ntest_means_one_param [#{Time.now}]: "
+    [ -1, 0, 1, 7, -1.0, 0.0, 1.0, Math::PI, Rational(-1, 1), Rational(0, 1), Rational(1,1), Rational(2,3), LongDecimal(-10000000000, 10), LongDecimal(-1, 10), LongDecimal(0, 10), LongDecimal(10000000000, 10), LongMath.pi(100) ].each do |x|
+      # , Complex(-1, -2), Complex(0,0), Complex(Rational(3, 2), LongDecimal(4, 3))
+      12.times do |prec|
+        ALL_ROUNDING_MODES.each do |rm|
+          if (rm == ROUND_UNNECESSARY)
+            next
+          end
+          xx = x.to_ld(prec, rm)
+          text = "x=#{x} xx=#{xx} rm=#{rm} prec=#{prec}"
+          assert_equal(xx, LongMath.arithmetic_mean(prec, rm, x), text)
+          assert_equal(xx, LongMath.geometric_mean(prec, rm, x), text)
+          if (x.sgn != 0)
+            assert_equal(xx, LongMath.harmonic_mean(prec, rm, x), text)
+          end
+          assert_equal(xx, LongMath.quadratic_mean(prec, rm, x), text)
+          assert_equal(xx, LongMath.cubic_mean(prec, rm, x), text)
+        end
+      end
+    end
+  end
+
+  def test_means_two_param
+    print "\ntest_means_two_param [#{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) ]
+    arr.each do |x|
+      arr.each do |y|
+        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)
+            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
+        end
+      end
+    end
+  end
+
+  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) ]
+    arr.each do |x|
+      arr.each do |y|
+        print ":"
+        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)
+              agm = LongMath.arithmetic_geometric_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
+                hgm = gm
+              else
+                hm = LongMath.harmonic_mean(prec, rm, x, y, z)
+                hgm = LongMath.harmonic_geometric_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 <= hgm.succ, text)
+              assert(hgm <= gm.succ, text)
+              assert(gm <= agm.succ, text)
+              assert(agm <= 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, hgm, text)
+                assert_equal(hgm, gm, text)
+                assert_equal(gm, agm, text)
+                assert_equal(gm, agm, text)
+                assert_equal(am, qm, text)
+                assert_equal(qm, cm, text)
+                assert_equal(cm, ma, text)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+
+  def test_arithmetic_means_two_param_known_result
+    assert_equal(1, LongMath.arithmetic_mean(0, ROUND_UNNECESSARY, 0, 2))
+    assert_equal(0, LongMath.arithmetic_mean(0, ROUND_UNNECESSARY, -1, 1))
+    assert_equal(3, LongMath.arithmetic_mean(0, ROUND_UNNECESSARY, 1, 5))
+  end
+
+  def test_geometric_means_two_param_known_result
+    assert_equal(2, LongMath.geometric_mean(0, ROUND_UNNECESSARY, 1, 4))
+    assert_equal(10, LongMath.geometric_mean(0, ROUND_UNNECESSARY, 4, 25))
+    assert_equal(-3, LongMath.geometric_mean(0, ROUND_UNNECESSARY, -1, -9))
+  end
+
+  def test_harmonic_means_two_param_known_result
+    assert_equal(3, LongMath.harmonic_mean(0, ROUND_UNNECESSARY, 2, 6))
+    assert_equal(4, LongMath.harmonic_mean(0, ROUND_UNNECESSARY, 3, 6))
+    assert_equal(-3, LongMath.harmonic_mean(0, ROUND_UNNECESSARY, -2, -6))
+  end
+
+  def test_quadratic_means_two_param_known_result
+    assert_equal(5, LongMath.quadratic_mean(0, ROUND_UNNECESSARY, 1, 7))
+    assert_equal(10, LongMath.quadratic_mean(0, ROUND_UNNECESSARY, 2, 14))
+    assert_equal(15, LongMath.quadratic_mean(0, ROUND_UNNECESSARY, 3, 21))
+    assert_equal(13, LongMath.quadratic_mean(0, ROUND_UNNECESSARY, 7, 17))
+    assert_equal(-5, LongMath.quadratic_mean(0, ROUND_UNNECESSARY, -1, -7))
+  end
+
+
   #
   # test mul minverse of RoundingMode
   #
   def test_rm_minverse
     print "\ntest_rm_minverse [#{Time.now}]: "
-    assert_equal(LongMath::ROUND_UP,           LongMath::ROUND_DOWN.minverse)
-    assert_equal(LongMath::ROUND_DOWN,         LongMath::ROUND_UP.minverse)
-    assert_equal(LongMath::ROUND_CEILING,      LongMath::ROUND_FLOOR.minverse)
-    assert_equal(LongMath::ROUND_FLOOR,        LongMath::ROUND_CEILING.minverse)
-    assert_equal(LongMath::ROUND_HALF_UP,      LongMath::ROUND_HALF_DOWN.minverse)
-    assert_equal(LongMath::ROUND_HALF_DOWN,    LongMath::ROUND_HALF_UP.minverse)
-    assert_equal(LongMath::ROUND_HALF_CEILING, LongMath::ROUND_HALF_FLOOR.minverse)
-    assert_equal(LongMath::ROUND_HALF_FLOOR,   LongMath::ROUND_HALF_CEILING.minverse)
-    assert_equal(LongMath::ROUND_HALF_EVEN,    LongMath::ROUND_HALF_EVEN.minverse)
-    assert_equal(LongMath::ROUND_UNNECESSARY,  LongMath::ROUND_UNNECESSARY.minverse)
+    assert_equal(ROUND_UP,           ROUND_DOWN.minverse)
+    assert_equal(ROUND_DOWN,         ROUND_UP.minverse)
+    assert_equal(ROUND_CEILING,      ROUND_FLOOR.minverse)
+    assert_equal(ROUND_FLOOR,        ROUND_CEILING.minverse)
+    assert_equal(ROUND_HALF_UP,      ROUND_HALF_DOWN.minverse)
+    assert_equal(ROUND_HALF_DOWN,    ROUND_HALF_UP.minverse)
+    assert_equal(ROUND_HALF_CEILING, ROUND_HALF_FLOOR.minverse)
+    assert_equal(ROUND_HALF_FLOOR,   ROUND_HALF_CEILING.minverse)
+    assert_equal(ROUND_HALF_EVEN,    ROUND_HALF_EVEN.minverse)
+    assert_equal(ROUND_HALF_ODD,     ROUND_HALF_ODD.minverse)
+    assert_equal(ROUND_UNNECESSARY,  ROUND_UNNECESSARY.minverse)
   end
 
   #
@@ -5610,16 +7460,17 @@ class TestLongDecimal_class < Test::Unit::TestCase # RUNIT::TestCase
   #
   def test_rm_ainverse
     print "\ntest_rm_ainverse [#{Time.now}]: "
-    assert_equal(LongMath::ROUND_UP,           LongMath::ROUND_UP.ainverse)
-    assert_equal(LongMath::ROUND_DOWN,         LongMath::ROUND_DOWN.ainverse)
-    assert_equal(LongMath::ROUND_CEILING,      LongMath::ROUND_FLOOR.ainverse)
-    assert_equal(LongMath::ROUND_FLOOR,        LongMath::ROUND_CEILING.ainverse)
-    assert_equal(LongMath::ROUND_HALF_UP,      LongMath::ROUND_HALF_UP.ainverse)
-    assert_equal(LongMath::ROUND_HALF_DOWN,    LongMath::ROUND_HALF_DOWN.ainverse)
-    assert_equal(LongMath::ROUND_HALF_CEILING, LongMath::ROUND_HALF_FLOOR.ainverse)
-    assert_equal(LongMath::ROUND_HALF_FLOOR,   LongMath::ROUND_HALF_CEILING.ainverse)
-    assert_equal(LongMath::ROUND_HALF_EVEN,    LongMath::ROUND_HALF_EVEN.ainverse)
-    assert_equal(LongMath::ROUND_UNNECESSARY,  LongMath::ROUND_UNNECESSARY.ainverse)
+    assert_equal(ROUND_UP,           ROUND_UP.ainverse)
+    assert_equal(ROUND_DOWN,         ROUND_DOWN.ainverse)
+    assert_equal(ROUND_CEILING,      ROUND_FLOOR.ainverse)
+    assert_equal(ROUND_FLOOR,        ROUND_CEILING.ainverse)
+    assert_equal(ROUND_HALF_UP,      ROUND_HALF_UP.ainverse)
+    assert_equal(ROUND_HALF_DOWN,    ROUND_HALF_DOWN.ainverse)
+    assert_equal(ROUND_HALF_CEILING, ROUND_HALF_FLOOR.ainverse)
+    assert_equal(ROUND_HALF_FLOOR,   ROUND_HALF_CEILING.ainverse)
+    assert_equal(ROUND_HALF_EVEN,    ROUND_HALF_EVEN.ainverse)
+    assert_equal(ROUND_HALF_ODD,     ROUND_HALF_ODD.ainverse)
+    assert_equal(ROUND_UNNECESSARY,  ROUND_UNNECESSARY.ainverse)
   end
 
 
@@ -5642,7 +7493,6 @@ class TestLongDecimal_class < Test::Unit::TestCase # 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
@@ -5662,12 +7512,10 @@ class TestLongDecimal_class < Test::Unit::TestCase # 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
@@ -5682,7 +7530,6 @@ class TestLongDecimal_class < Test::Unit::TestCase # RUNIT::TestCase
     x0 = 2046
     y0 = 10**x0
     60.times do |i|
-      puts "i=" + i.to_s
       $stdout.flush
       y = y0
       x = x0