long-decimal 1.00.02 → 1.00.03

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a9b2ae9e4c8f0f4af956ca3603f351f2c45ecef1
-  data.tar.gz: b0d237ee8813f6e5f2ac6d458b0f22a5afc3b9c4
+  metadata.gz: f4d758878cf5a3d2d5f20a4738e94a261114da04
+  data.tar.gz: 3db2e6b11a3f8aae44a7cccfc81ea902165ec4bb
 SHA512:
-  metadata.gz: 40718a7b4ac4011aee592fd16516fe79ea39e1aaa585113b0220463057064ef14f7f934071e45313014427121862297fde386726bad73d6525ee530353b1ddd6
-  data.tar.gz: 4ce22512fcba5dc1b57bd9dc389a269b52046f1d6e20ca134a5cc57aed34303ee9d5248249d84ce36d8e529549cad86b318f0d7eb6f2c3096ab0fc7ace9b58a9
+  metadata.gz: 8aa62b76ff524e76b9c2d38dbb5cd660c38dfd1fdae8f575312da56ecf7438875860fdd1fae605ba2dc04409fc252a67fcdb596117d04b2784e724657d20e425
+  data.tar.gz: 4dde6badc8da94abaef63c8151a13452dda84658a41bb83bd5efc219d36e3a03cb32b6999ec20ef28f91392d11b2dbba5dc7ddcb0ef32f06b5531e75cb346519

data/README

@@ -1,11 +1,20 @@
 Version
 -------
 
-This version (1.00.02) is fixing bugs from version 1.00.01.
-It also can be considered as a release candidate from the upcoming
-version 1.01.00, adding new features.
+This version (1.00.03) is fixing bugs from version 1.00.02.
+It can be considered as a release candidate from the upcoming
+version 1.01.00.
 
-Improvements over the previous version:
+Change Log
+----------
+
+Improvements in 1.00.03
+- tests improved
+- bug fixes in mean calculation functionality for non-LongDecimal paramters
+- calculation of sqrt on arguments that result in the exact square root being the boundary for geometric or quadratic rounding recognized and fixed
+- calculation of cbrt on arguments that result in the exact cube root being the boundary for cubic rounding recognized and fixed
+
+Improvements over the previous version in 1.00.02
 
 - migration from CVS (rubyforge) to GIT (github)
 - bug fixed with frozen string attempted to be changed when parsing a string for a long-decimal number.
@@ -17,19 +26,29 @@ Improvements over the previous version:
 - moved power, log10, log2 etc. from long-decimal-extra.rb to long-decimal.rb
 - added more unit tests
 
+Road Map
+--------
+
 Work to do for 1.01.00:
 - go through functions that are working with rounding modes as parameter (like transcendental functions, sqrt, cbrt etc.) to ensure that they work properly with all new rounding modes
 - improve algorithm for rounding with sum constraint
 - go through unit tests to see they are covering all rounding modes
 - add unit tests for rounding with sum constraint
+- caching of frequently used calculation results needs to be done independent of rounding mode
+- add tests comparing results of transcendental functions for different rounding modes
 - rubydoc-documentation
 - external documentation
 
 Work to do for 1.02.00 (or 2.00.00):
 - add the following transcendental functions: sin, cos, tan, cot, sec, csc, sinh, cosh, tanh, coth, sech, csch, asin, acos, atan, atan2, acot, asec, acsc, asinh, acosh, atanh, acoth, asech, acsch
+- support Complex of LongDecimal wherever it makes sense
 - documentation
 - external documentation
-- interoperability with flt
+- interoperability with gmp, mpfr, mpfi, flt and other libraries
+- interoparability with rails
+
+Status
+------
 
 The existing functionality did not show any bugs during intensive
 testing, so it could be assumed that the whole library is good for
@@ -84,6 +103,11 @@ require 'long-decimal'
 Test
 ----
 
+Tests have been run with Ruby 1.8.7, 1.9.3, 2.0.0 and 2.1.1
+Some tests do not work with 1.8.7 because of missing language features.
+They are skipped.  No major effort for adapting tests to this version
+will be allocated.
+
 Some runit tests have been included.  They give some indication of the
 correctness of this library and allow changes to be checked in order
 to make sure that what was running before would still work afterwards.
@@ -99,27 +123,24 @@ ruby test/testlongdecimal.rb
 
 This is the result of the test:
 
-Finished in 5174.187655 seconds.
-134 tests, 9461909 assertions, 0 failures, 0 errors
+Finished in 2952.440454s, 0.0660 runs/s, 7759.3877 assertions/s.
+
+195 runs, 22909130 assertions, 0 failures, 0 errors, 0 skips
 
 In addition random tests for exp, exp2, exp10, sqrt, log, log2 and
 log10 can be run for a long time, using
 
 ruby test/testrandom.rb.
 
-The functionality in lib/long-decimal-extra.rb, which contains some
-more advanced and less tested methods, has its tests in
+The power function did fail in some tests, which have been collected in
 
 ruby test/testlongdecimal-extra.rb
 
-and its random tests in
+some additional tests are in
 
 ruby test/testrandom-extra.rb
 
-This is the result of the test:
-
-Finished in 4115.851979 seconds.
-12 tests, 976 assertions, 0 failures, 0 errors
+They should be integrated into testrandom.rb
 
 Likewise tests for powers x to the yth with random x and y (which also
 resided in long-decimal-extra.rb) can be tested for a long time using
@@ -137,11 +158,10 @@ long-decimal-extra and find an error with it, please report it.
 Install
 -------
 
-
 1. Using ruby-gems (preferred)
 - open a shell window
 - become root, unless the current user has the right to install gems
-  (which is usually the case on windows)
+  (which is usually the case on windows or when using rvm)
 
   su
 
@@ -162,25 +182,21 @@ Install
   where $RUBY_DIR is the directory containing your ruby-installation,
                   usually /usr/lib/ruby or /usr/local/lib/ruby on
                   Linux/Unix-systems.
-        $RUBY_VERSION is the major version of your Ruby, like 1.8
+        $RUBY_VERSION is the major version of your Ruby, like 2.1
         $LONG_DECIMAL_VERSION is the version of long-decimal that you
-                              have installed, like 0.00.20
-  on my machine that would be
-  /usr/local/lib/ruby/gems/1.8/doc/long-decimal-0.02.01/rdoc/index.html
+                              have installed, like 1.00.03
 
 2. Installing from the sources (it is preferred to use the
    gem-installation, but since long-decimal is open-source-software you
    are off course granted the right to download the source and change
    it and install your own version.)
 
-- download the newest source-tar.gz-file from long-decimal project at rubyforge
+- download the newest source-tar.gz-file from long-decimal project at github
   which can be found by
-  http://rubyforge.org/projects/long-decimal/ -> Files
-  ( http://rubyforge.org/frs/?group_id=1334 )
 - open a shell window
   cd to the directory where you have downloaded the .tar.gz-file
   unpack the file using tar
-  tar xfzvv long-decimal-beta-1_00.tar.gz
+  tar xfzvv long-decimal-*.tar.gz
   cd long-decimal
 - now you can use rake for several operations
   - rake test
@@ -238,7 +254,7 @@ License
 
 Ruby's license or LGPL
 Find copies of these licenses on http://www.gnu.org/ or http://www.ruby-lang.org/
-� Karl Brodowsky (IT Sky Consulting GmbH) 2006-2014
+� Karl Brodowsky (IT Sky Consulting GmbH) 2006-2015
 http://www.it-sky-consulting.com/
 
 Warranty

data/Rakefile

@@ -3,8 +3,9 @@
 #
 # Rakefile for long-decimal project
 #
-# (C) Karl Brodowsky (IT Sky Consulting GmbH) 2006-2009
+# (C) Karl Brodowsky (IT Sky Consulting GmbH) 2006-2015
 #
+# TAG:       $TAG v1.00.03$
 # CVS-ID:    $Header: /var/cvs/long-decimal/long-decimal/Rakefile,v 1.4 2009/04/15 19:29:37 bk1 Exp $
 # CVS-Label: $Name:  $
 # Author:    $Author: bk1 $ (Karl Brodowsky)

data/lib/long-decimal-extra.rb

@@ -1,8 +1,13 @@
 #
 # long-decimal-extra.rb -- Arbitrary precision decimals with fixed decimal point
 #
-# (C) Karl Brodowsky (IT Sky Consulting GmbH) 2006-2009
+# additional features: all functionality in this file is experimental
+# and can be removed without notice in future versions. Or moved to
+# long-decimal.rb, if useful.
 #
+# (C) Karl Brodowsky (IT Sky Consulting GmbH) 2006-2015
+#
+# TAG:       $TAG v1.00.03$
 # CVS-ID:    $Header: /var/cvs/long-decimal/long-decimal/lib/long-decimal-extra.rb,v 1.29 2011/02/04 23:17:21 bk1 Exp $
 # CVS-Label: $Name:  $
 # Author:    $Author: bk1 $ (Karl Brodowsky)
@@ -320,12 +325,14 @@ class LongDecimal
     elsif dividend < divisor
       # self is between 0 and 1 and dividend > LongMath::MAX_FLOATABLE
       # return LongDecimal(dividend.div(LongMath.npower10(digits)), scale -digits).to_f
+      # puts "via s (1): #{self.inspect}"
       return self.to_s.to_f
     else
       q = dividend.abs / divisor
       if (q.abs > 1000000000000000000000)
         return q.to_f
       else
+        # puts "via s (2): #{self.inspect}"
         return self.to_s.to_f
       end
     end
@@ -456,4 +463,33 @@ class Bignum
 
 end
 
+def LongMath.continued_fraction(x, steps)
+  if (x == 0)
+    x
+  end
+  arr = []
+  steps.times do
+    xi = x.to_ld(0, LongMath::ROUND_FLOOR)
+    xd = x-xi
+    if xd.zero?
+      return arr
+    end
+    x = 1/xd
+    arr.push(xi.to_i)
+  end
+  arr
+end
+
+def LongMath.continued_fraction_to_r(arr)
+  result = nil
+  arr.reverse.each do |x|
+    if (result.nil?)
+      result = Rational(x)
+    else
+      result = Rational(x) + 1/result
+    end
+  end
+  result
+end
+
 # end of file long-decimal-extra.rb

data/lib/long-decimal.rb

@@ -1,12 +1,13 @@
 #
 # long-decimal.rb -- Arbitrary precision decimals with fixed decimal point
 #
-# (C) Karl Brodowsky (IT Sky Consulting GmbH) 2006-2009
+# (C) Karl Brodowsky (IT Sky Consulting GmbH) 2006-2015
 #
 # This class contains the basic functionality for working with LongDecimal
 # additional functionality, mostly transcendental functions,
 # may be found in long-decimal-extra.rb
 #
+# TAG:       $TAG v1.00.03$
 # CVS-ID:    $Header: /var/cvs/long-decimal/long-decimal/lib/long-decimal.rb,v 1.87 2011/01/30 20:01:40 bk1 Exp $
 # CVS-Label: $Name:  $
 # Author:    $Author: bk1 $ (Karl Brodowsky)
@@ -50,6 +51,8 @@ module LongDecimalRoundingMode
   private
 
   ALL_MINOR = [ MINOR_UP, MINOR_DOWN, MINOR_CEILING, MINOR_FLOOR, MINOR_EVEN, MINOR_ODD ]
+  # puts(ALL_MINOR)
+  # puts
 
   NO_MINOR = [ MINOR_UNUSED ]
 
@@ -105,6 +108,9 @@ module LongDecimalRoundingMode
 
   ALL_MAJOR_MODES = [  MAJOR_UP, MAJOR_DOWN, MAJOR_CEILING, MAJOR_FLOOR, MAJOR_UNNECESSARY, MAJOR_HALF, MAJOR_GEOMETRIC, MAJOR_HARMONIC, MAJOR_QUADRATIC, MAJOR_CUBIC ]
 
+  # puts("ALL_MAJOR_MODES:")
+  # puts(ALL_MAJOR_MODES)
+  # puts
 
   MUL_INVERSE_MAJOR_MODE = {
     MAJOR_UP           =>   MAJOR_DOWN,
@@ -298,9 +304,9 @@ module LongDecimalRoundingMode
           on_boundary = true
         end
       elsif (major == MAJOR_CUBIC)
-        cube = unrounded * unrounded * unrounded
+        cube = unrounded ** 3
         lhs = 2 * cube
-        rhs = lower * lower * lower + upper * upper * upper
+        rhs = lower ** 3 + upper ** 3
         d = lhs <=> rhs
         if (d < 0)
           # unrounded < x_cubic(lower, upper)
@@ -382,7 +388,9 @@ module LongDecimalRoundingMode
   end
 
   ALL_ROUNDING_MODES.freeze
+  # puts(ALL_ROUNDING_MODES)
   MODE_LOOKUP.freeze
+  # puts(MODE_LOOKUP)
 
   ALL_ROUNDING_MODES.each do |rm|
     majm = rm.major
@@ -391,6 +399,7 @@ module LongDecimalRoundingMode
     MUL_INVERSE_MODE[rm] = mul_inv
     add_inv = MODE_LOOKUP[[ ADD_INVERSE_MAJOR_MODE[majm], ADD_INVERSE_MINOR_MODE[minm]]]
     ADD_INVERSE_MODE[rm] = add_inv
+    # puts("rm=#{rm} mul_inv=#{mul_inv} add_inv=#{add_inv}")
   end
 
   MUL_INVERSE_MODE.freeze
@@ -614,6 +623,7 @@ class Integer
     end
     lower = self - (r_self - r_lower)
     upper = self + (r_upper - r_self)
+    # puts "round_to_allowed_remainders(remainders_param=#{remainders_param} modulus=#{modulus} rounding_mode=#{rounding_mode} zero_rounding_mode=#{zero_rounding_mode}) remainders=#{remainders} lower=#{lower} upper=#{upper} r_lower=#{r_lower} r_upper=#{r_upper} r_self=#{r_self}"
 
     unless (lower < self && self < upper)
       raise ArgumentError, "self=#{self} not in (#{lower}, #{upper}) with r_self=#{r_self} r_lower=#{r_lower} r_upper=#{r_upper}"
@@ -1440,6 +1450,7 @@ class LongDecimal < LongDecimalBase
     # result 0.0 if int_val == 0
     if (int_val == 0)
       # t1
+      # puts "t1 #{self.to_s}=#{self.inspect} -> 0.0"
       return 0.0
     end
 
@@ -1447,12 +1458,15 @@ class LongDecimal < LongDecimalBase
       if (int_val.abs <= LongMath::MAX_FLOATABLE)
         y = int_val.to_f
         # t2
+        # puts "t2 #{self.to_s}=#{self.inspect} -> #{y}"
         return y
       elsif int_val < 0
         # t13
+        # puts "t13 #{self.to_s}=#{self.inspect} -> -Infinity"
         return -1.0/0.0
       elsif int_val > 0
         # t14
+        # puts "t13 #{self.to_s}=#{self.inspect} -> Infinity"
         return 1.0/0.0
       end
     end
@@ -1461,6 +1475,7 @@ class LongDecimal < LongDecimalBase
     if (self < 0) then
       y = -(-self).to_f
       # t3
+      # puts "t3 #{self.to_s}=#{self.inspect} -> #{y}"
       return y
     end
 
@@ -1468,6 +1483,7 @@ class LongDecimal < LongDecimalBase
     if (int_val <= LongMath::MAX_FLOATABLE && scale <= Float::MAX_10_EXP)
       y = to_f_simple(int_val, scale)
       # t4
+      # puts "t4 #{self.to_s}=#{self.inspect} -> #{y}"
       return y
     end
 
@@ -1477,6 +1493,7 @@ class LongDecimal < LongDecimalBase
     # handle overflow: raise exception
     if (int_val > divisor * LongMath::MAX_FLOATABLE) then
       # t5
+      # puts "t5 #{self.to_s}=#{self.inspect} -> Infinity"
       return 1/0.0 # Infinity
     end
 
@@ -1484,6 +1501,7 @@ class LongDecimal < LongDecimalBase
     # handle underflow: return 0.0
     if (int_val * LongMath::INV_MIN_FLOATABLE * 20 < divisor) then
       # t6
+      # puts "t6 #{self.to_s}=#{self.inspect} -> 0.0"
       p = int_val * LongMath::INV_MIN_FLOATABLE * 20
       d = divisor
       n = int_val
@@ -1503,11 +1521,13 @@ class LongDecimal < LongDecimalBase
         y *= q
         if (y == 0.0)
           # t7
+          # puts "t7 #{self.to_s}=#{self.inspect} -> #{y}"
           return y
         end
         s -= qe
       end
       # t8
+      # puts "t8 #{self.to_s}=#{self.inspect} -> #{y}"
       return y
     end
 
@@ -1520,6 +1540,7 @@ class LongDecimal < LongDecimalBase
       # scale = 0, 0 < int_val <= MAX_FLOATABLE
       y = to_f_simple(rounded_ld.int_val, rounded_ld.scale)
       # t9
+      # puts "t9 #{self.to_s}=#{self.inspect} #{rounded_ld.to_s}=#{rounded_ld.inspect} -> #{y}"
       return y
     end
 
@@ -1530,6 +1551,7 @@ class LongDecimal < LongDecimalBase
 
     if (cmp == 0)
       # t10
+      # puts "t10 #{self.to_s}=#{self.inspect} -> 1.0"
       return 1.0
     elsif (cmp > 0)
       # self > 1, retain MAX_SIGNIFICANT_FLOATABLE_DIGITS
@@ -1537,6 +1559,7 @@ class LongDecimal < LongDecimalBase
       # self >= LongMath::FLOATABLE_WITHOUT_FRACTION > self > 1, scale = 16,
       y = to_f_simple(rounded_ld.int_val, rounded_ld.scale)
       # t11
+      # puts "t11 #{self.to_s}=#{self.inspect} #{rounded_ld.to_s}=#{rounded_ld.inspect} -> #{y}"
       return y
     else
       # self < 1
@@ -1552,6 +1575,7 @@ class LongDecimal < LongDecimalBase
       rounded_ld = round_to_scale(new_scale, ROUND_HALF_UP)
       y = to_f_simple(rounded_ld.int_val, rounded_ld.scale)
       # t12
+      # puts "t12 #{self.to_s}=#{self.inspect} #{rounded_ld.to_s}=#{rounded_ld.inspect} sd=#{sd} #{self <=> 1} -> #{y}"
       return y
     end
   end
@@ -1668,11 +1692,21 @@ class LongDecimal < LongDecimalBase
   #
   def sint_digits10
     if (@digits10.nil?)
-      @digits10 = LongMath.int_digits10(int_val) - scale
+      result = LongMath.int_digits10(int_val) - scale
+      if frozen?
+        return result
+      end
+      @digits10 = result
     end
     @digits10
   end
 
+  # freeze but calcuate sint_digits10 before
+  def freeze_ld
+    sint_digits10
+    freeze
+  end
+
   #
   # number of decimal digits before the decimal point, not counting a
   # single 0.
@@ -2191,9 +2225,11 @@ class LongDecimal < LongDecimalBase
       # s, o = other.coerce(self.to_f)
       if (RUNNING_19)
         s, o = other.coerce(self)
+        # puts "complex coerce 19: #{self}, #{other} -> #{s}, #{o}"
         return o, s
       else
         s, o = other.coerce(Complex(self, 0))
+        # puts "complex coerce 18/J: #{self}, #{other} -> #{s}, #{o}"
         return o, s
       end
       # s, o = other.coerce(Complex(self.to_f, 0))
@@ -2529,6 +2565,7 @@ class LongDecimalQuot < LongDecimalBase
     if (s.kind_of? LongDecimalQuot) then
       LongDecimalQuot(s.rat - o.rat, [s.scale, o.scale].max)
     else
+      # puts "ldq-coerce: s=#{s} o=#{o} self=#{self} other=#{other}"
       s - o
     end
   end
@@ -2803,6 +2840,9 @@ class Numeric
   # optional second argument gives the rouding mode
   #
   def to_ld(prec = nil, mode = LongMath.standard_mode)
+    if (kind_of? Complex)
+      return Complex(real.to_ld(prec, mode), imaginary.to_ld(prec, mode))
+    end
     l = LongDecimal(self)
     if (prec.nil?)
       return l
@@ -2937,7 +2977,9 @@ class Rational
     def to_f
       num = numerator
       den = denominator
+      # puts("num=#{num} den=#{den}")
       sign = num <=> 0
+      # puts("num=#{num} den=#{den} sign=#{sign}")
       if (sign.zero?)
         return 0.0
       elsif sign < 0
@@ -3022,7 +3064,9 @@ module LongMath
     if (power.nil?)
       power = powers_big_base ** n1
       @@powers_of_big_base[n1] = power
+      # puts "npower_of_big_base(n1=#{n1}) c->#{power.size}"
     else
+      # puts "npower_of_big_base(n1=#{n1}) c<-#{power.size}"
    end
     power
   end
@@ -3173,6 +3217,21 @@ module LongMath
           return
         end
       end
+      key.freeze
+      if (val.kind_of? LongDecimal)
+        val.freeze_ld
+      elsif (val.kind_of? Array)
+        val.each do |entry|
+          if (entry.kind_of? LongDecimal)
+            entry.freeze_ld
+          else
+            entry.freeze
+          end
+        end
+        val.freeze
+      else
+        val.freeze
+      end
       @@cache[key] = val
     end
   end
@@ -3244,8 +3303,11 @@ module LongMath
     n1 = n >> POWERS_MED_EXP_PARAM
     p  = npower10_cached(n0)
     if (n1 > 0) then
+      # puts "n0=#{n0} n1=#{n1}"
       p1 = npower_of_big_base(n1)
+      # puts "n0=#{n0} n1=#{n1} p1"
       p *= p1
+      # puts "n0=#{n0} n1=#{n1} p"
     end
     return p
   end
@@ -4031,7 +4093,7 @@ module LongMath
     end
     cache_key = nil
     y_arr = nil
-    unless (with_rem)
+    unless (with_rem || mode.major == MAJOR_GEOMETRIC || mode.major == MAJOR_QUADRATIC)
       cache_key = get_cache_key("sqrt", x, mode, [2, 3, 5, 6, 7, 8, 10])
       y_arr = get_cached(cache_key, x, prec)
     end
@@ -4046,8 +4108,43 @@ module LongMath
       return y_arr
     else
       y, r = y_arr
-      if ((mode == ROUND_HALF_EVEN || mode == ROUND_HALF_ODD || mode == ROUND_HALF_DOWN) && r > 0) then
-        mode = ROUND_HALF_UP
+      if (mode.major == MAJOR_GEOMETRIC || mode.major == MAJOR_QUADRATIC)
+        # we need to deal with the case that the square root is on the exact border
+        y_lower = y.round_to_scale(prec, ROUND_DOWN)
+        y_upper = y.round_to_scale(prec, ROUND_UP)
+        # puts "mode=#{mode} x=#{x} y=#{y} r=#{r} y_lower=#{y_lower} y_upper=#{y_upper} prec=#{prec} prec1=#{prec1}"
+        if (r == 0)
+          if (y == y_lower)
+            # puts "r=0 y=y_lower=#{y_lower} (x=#{x} y_upper=#{y_upper} mode=#{mode})"
+            return y_lower
+          elsif (y == y_upper)
+            # puts "r=0 y=y_upper=#{y_upper} (x=#{x} y_lower=#{y_lower} mode=#{mode})"
+            return y_upper
+          end
+        end
+        # puts "mode=#{mode} x=#{x} gm2=#{y_lower * y_upper} qm2=#{arithmetic_mean(prec*2+1, ROUND_HALF_UP, y_lower*y_lower, y_upper*y_upper)}"
+        if (mode.major == MAJOR_GEOMETRIC && x == y_lower * y_upper \
+            || mode.major == MAJOR_QUADRATIC && x == arithmetic_mean(prec1*2+1, ROUND_HALF_UP, y_lower*y_lower, y_upper*y_upper))
+          if (mode.minor == MINOR_UP || mode.minor == MINOR_CEILING)
+            # puts "r=0 y=#{y} on boundary: y_upper=#{y_upper} (x=#{x} y_lower=#{y_lower} mode=#{mode})"
+            return y_upper;
+          elsif (mode.minor == MINOR_DOWN || mode.minor == MINOR_FLOOR)
+            # puts "r=0 y=#{y} on boundary: y_lower=#{y_lower} (x=#{x} y_upper=#{y_upper} mode=#{mode})"
+            return y_lower;
+          elsif (mode.minor == MINOR_EVEN && y_upper[0] == 0 || mode.minor == MINOR_ODD && y_upper[0] == 1)
+            # puts "r=0 y=#{y} on boundary odd/even: y_upper=#{y_upper} (x=#{x} y_lower=#{y_lower} y_upper=#{y_upper} mode=#{mode})"
+            return y_upper;
+          elsif (mode.minor == MINOR_EVEN && y_lower[0] == 0 || mode.minor == MINOR_ODD && y_lower[0] == 1)
+            # puts "r=0 y=#{y} on boundary odd/even: y_lower=#{y_lower} (x=#{x} y_lower=#{y_lower} y_upper=#{y_upper} mode=#{mode})"
+            return y_lower;
+          else
+            raise ArgumentError, "unsupported combination: x=#{x} prec=#{prec} prec1=#{prec1} mode=#{mode} y=#{y} r=#{r} y_lower=#{y_lower} y_upper=#{y_upper}"
+          end
+        end
+      end
+
+      if ((mode.minor == MINOR_EVEN || mode.minor == MINOR_ODD || mode.minor == MINOR_DOWN || mode.minor == MINOR_FLOOR) && r > 0) then
+        mode = MODE_LOOKUP[[mode.major, MINOR_UP]];
       end
       y = y.round_to_scale(prec, mode)
       return y
@@ -4099,7 +4196,7 @@ module LongMath
     end
     cache_key = nil
     y_arr = nil
-    unless (with_rem)
+    unless (with_rem || mode.major == MAJOR_CUBIC)
       cache_key = get_cache_key("cbrt", x, mode, [2, 3, 5, 6, 7, 8, 10])
       y_arr = get_cached(cache_key, x, prec)
     end
@@ -4114,8 +4211,42 @@ module LongMath
       return y_arr
     else
       y, r = y_arr
-      if ((mode == ROUND_HALF_EVEN || mode == ROUND_HALF_ODD || mode == ROUND_HALF_DOWN) && r > 0) then
-        mode = ROUND_HALF_UP
+      if (mode.major == MAJOR_CUBIC)
+        # we need to deal with the case that the square root is on the exact border
+        y_lower = y.round_to_scale(prec, ROUND_DOWN)
+        y_upper = y.round_to_scale(prec, ROUND_UP)
+        # puts "mode=#{mode} x=#{x} y=#{y} r=#{r} y_lower=#{y_lower} y_upper=#{y_upper} prec=#{prec} prec1=#{prec1}"
+        if (r == 0)
+          if (y == y_lower)
+            # puts "r=0 y=y_lower=#{y_lower} (x=#{x} y_upper=#{y_upper} mode=#{mode})"
+            return y_lower
+          elsif (y == y_upper)
+            # puts "r=0 y=y_upper=#{y_upper} (x=#{x} y_lower=#{y_lower} mode=#{mode})"
+            return y_upper
+          end
+        end
+        # puts "mode=#{mode} x=#{x} gm2=#{y_lower * y_upper} qm2=#{arithmetic_mean(prec*2+1, ROUND_HALF_UP, y_lower*y_lower, y_upper*y_upper)}"
+        if (mode.major == MAJOR_CUBIC && x == arithmetic_mean(prec1*3+1, ROUND_HALF_UP, y_lower.cube(), y_upper.cube()))
+          if (mode.minor == MINOR_UP || mode.minor == MINOR_CEILING)
+            # puts "r=0 y=#{y} on boundary: y_upper=#{y_upper} (x=#{x} y_lower=#{y_lower} mode=#{mode})"
+            return y_upper;
+          elsif (mode.minor == MINOR_DOWN || mode.minor == MINOR_FLOOR)
+            # puts "r=0 y=#{y} on boundary: y_lower=#{y_lower} (x=#{x} y_upper=#{y_upper} mode=#{mode})"
+            return y_lower;
+          elsif (mode.minor == MINOR_EVEN && y_upper[0] == 0 || mode.minor == MINOR_ODD && y_upper[0] == 1)
+            # puts "r=0 y=#{y} on boundary odd/even: y_upper=#{y_upper} (x=#{x} y_lower=#{y_lower} y_upper=#{y_upper} mode=#{mode})"
+            return y_upper;
+          elsif (mode.minor == MINOR_EVEN && y_lower[0] == 0 || mode.minor == MINOR_ODD && y_lower[0] == 1)
+            # puts "r=0 y=#{y} on boundary odd/even: y_lower=#{y_lower} (x=#{x} y_lower=#{y_lower} y_upper=#{y_upper} mode=#{mode})"
+            return y_lower;
+          else
+            raise ArgumentError, "unsupported combination: x=#{x} prec=#{prec} prec1=#{prec1} mode=#{mode} y=#{y} r=#{r} y_lower=#{y_lower} y_upper=#{y_upper}"
+          end
+        end
+      end
+
+      if ((mode.minor == MINOR_EVEN || mode.minor == MINOR_ODD || mode.minor == MINOR_DOWN || mode.minor == MINOR_FLOOR) && r > 0) then
+        mode = MODE_LOOKUP[[mode.major, MINOR_UP]];
       end
       y = y.round_to_scale(prec, mode)
       return y
@@ -4661,6 +4792,7 @@ module LongMath
     raise TypeError, "x=#{x.inspect} must not negative" unless x >= 0
     prec = check_is_prec(prec, "prec")
     check_is_mode(mode, "mode")
+    # puts "LongMath.power(x=#{x} y=#{y} prec=#{prec} mode=#{mode})"
 
     # handle the special cases where base or exponent are 0 or 1 explicitely
     if y.zero? then
@@ -4677,8 +4809,10 @@ module LongMath
     # x ** y <= 10**-s/2  <=> y * log(x) <= -s log(10) - log(2)
 
     iprec, iprec_x, iprec_y, logx_y_f = calc_iprec_for_power(x, y, prec)
+    # puts "x=#{x} y=#{y} prec=#{prec} iprec=#{iprec} iprec_x=#{iprec_x} iprec_y=#{iprec_y} logx_y_f=#{logx_y_f}: checking x < 1 && y > 0 || x > 1 && y < 0=#{x < 1 && y > 0 || x > 1 && y < 0}"
     $stdout.flush
     if (x < 1 && y > 0 || x > 1 && y < 0) then
+      # puts "checking if zero logx_y_f=#{logx_y_f} <= #{- prec * LOG10 - LOG2}"
       if (logx_y_f <= - prec * LOG10 - LOG2) then
         return LongDecimal.zero!(prec)
       end
@@ -4728,8 +4862,10 @@ module LongMath
       y = -y
       x = (1/x).round_to_scale(iprec_x*2, mode)
       iprec, iprec_x, iprec_y, logx_y_f = calc_iprec_for_power(x, y, prec)
+      # puts "x=#{x} y=#{y} prec=#{prec} iprec=#{iprec} iprec_x=#{iprec_x} iprec_y=#{iprec_y} logx_y_f=#{logx_y_f}: checking x < 1 && y > 0 || x > 1 && y < 0=#{x < 1 && y > 0 || x > 1 && y < 0}"
       $stdout.flush
       if (x < 1 && y > 0 || x > 1 && y < 0) then
+        # puts "checking if zero logx_y_f=#{logx_y_f} <= #{- prec * LOG10 - LOG2}"
         if (logx_y_f <= - prec * LOG10 - LOG2) then
           return LongDecimal.zero!(prec)
         end
@@ -4741,12 +4877,14 @@ module LongMath
     y0 = y.round_to_scale(0, LongMath.standard_imode).to_i
     x0 = x
     point_shift = 0
+    # puts "x0=#{x0} y0=#{y0}"
     while x0 > LongMath::MAX_FLOATABLE
       x0 = x0.move_point_left(100)
       point_shift += 100
     end
     iprec2 = 2 * (iprec + point_shift)
     iprec3 = [ iprec2, LongMath.prec_limit() - 24 ].min
+    # puts "x0=#{x0} y0=#{y0} point_shift=#{point_shift} iprec=#{iprec} iprec2=#{iprec2} iprec3=#{iprec3}"
     z0 = LongMath.ipower(x0, y0, iprec3, mode)
     if (point_shift > 0)
       unless z0.kind_of? LongDecimal
@@ -4762,6 +4900,7 @@ module LongMath
     # z1 = LongMath.power_internal(x, y1, prec+prec_extra , mode)
     z1 = LongMath.power_internal(x, y1, prec+prec_extra + 4, mode)
     z  = z0 * z1
+    # puts("x=#{x} y=#{y} z=#{z} y not int")
     return z.to_ld(prec, mode)
   end
 
@@ -4780,10 +4919,12 @@ module LongMath
     raise TypeError, "exponent y=#{y.inspect} must not be greater MAX_FLOATABLE=#{MAX_FLOATABLE}" unless y.abs <= MAX_FLOATABLE
     prec = check_is_prec(prec, "prec")
     check_is_mode(mode, "mode")
+    # puts "LongMath.ipower(x=#{x} y=#{y} prec=#{prec} mode=#{mode})"
 
     if (y.zero?)
       return 1
     elsif ! (x.kind_of? LongDecimalBase) || x.scale * y.abs <= prec
+      # puts "x=#{x} y=#{y} using **"
       return x ** y
     elsif (y < 0)
       l = Math.log10(x.abs.to_f)
@@ -4792,10 +4933,12 @@ module LongMath
       end
       # return (1/LongMath.ipower(x, -y, prec + 2, mode)).round_to_scale(prec, mode)
       xi = 1/x
+      # puts "x=#{x} y=#{y} prec=#{prec} using (1/x)**y xi=#{xi}"
       xr = xi.round_to_scale(prec + 6, mode)
       return LongMath.ipower(xr, -y, prec, mode)
     else
       # y > 0
+      # puts "x=#{x} y=#{y} regular"
       cnt = 0
       z  = x
       y0 = y
@@ -4816,6 +4959,7 @@ module LongMath
             x = x.round_to_scale(prec+4, mode)
           end
           if (cnt > 1000)
+            # puts("ipower x=#{x} y=#{y} cnt=#{cnt} z=#{z} t=#{Time.now - t0}")
             cnt = 0
           end
 
@@ -4828,7 +4972,9 @@ module LongMath
           end
         end
       end
+      # puts "z=#{z} rounding prec=#{prec}"
       z = z.round_to_scale(prec, mode)
+      # puts "rounded -> z=#{z}"
       return z
     end
   end
@@ -4934,7 +5080,7 @@ module LongMath
     if (args.empty?)
       raise ArgumentError, "cannot calculate average of empty array"
     end
-    sum = args.inject(0) do |psum,x|
+    sum = args.inject(LongDecimal.zero!((1.5*new_scale + 25).to_i)) do |psum,x|
       psum + x
     end
     raw_result = if (sum.kind_of? Integer)
@@ -4943,6 +5089,21 @@ module LongMath
         sum / args.size
     end
     result = raw_result.to_ld(new_scale, rounding_mode)
+    # puts "sum=#{sum} args.size=#{args.size} raw_result=#{raw_result} result=#{result} new_scale=#{new_scale} rounding_mode=#{rounding_mode}"
+    return result
+  end
+
+  # arithmetic mean with LongDecimalQuot as result (experimental)
+  # parameters arguments for which arithmetic mean is calculated
+  # result is exact if parameters are Integer, LongDecimal, LongDecimalQuot or Rational
+  def LongMath.arithmetic_mean_ldq(*args)
+    if (args.empty?)
+      raise ArgumentError, "cannot calculate average of empty array"
+    end
+    sum = args.inject(LongDecimalQuot(0, 0)) do |psum,x|
+      psum + x
+    end
+    result = sum / args.size
     return result
   end
 
@@ -4959,7 +5120,7 @@ module LongMath
     if (has_zero)
       return LongDecimal.zero!(new_scale)
     end
-    prod = args.inject(1) do |pprod,x|
+    prod = args.inject(LongDecimal.one!(new_scale + 20)) do |pprod, x|
       pprod * x.abs
     end
     result = nil
@@ -4988,11 +5149,11 @@ module LongMath
     if (has_zero)
       raise ArgumentError, "cannot calculate harmonic mean of argument list containing zero #{args.inspect}"
     end
-    sum = args.inject(0) do |psum, x|
+    sum = args.inject(LongDecimal.zero!) do |psum, x|
       psum + if (x.kind_of? Integer)
                Rational(1, x)
              else
-               1/x
+               LongDecimal.one!(new_scale+1)/x
              end
     end
     raw_result = args.size / sum
@@ -5000,6 +5161,28 @@ module LongMath
     return result
   end
 
+  # harmonic mean with LongDecimalQuot as result (experimental)
+  # parameters arguments for which arithmetic mean is calculated
+  # result is exact if parameters are Integer, LongDecimal, LongDecimalQuot or Rational
+  def LongMath.harmonic_mean_ldq(*args)
+    result_sign, all_same, has_neg, has_zero, has_pos = sign_check_for_mean(true, *args)
+    if (all_same)
+      return LongDecimalQuot(args)
+    end
+    if (has_zero)
+      raise ArgumentError, "cannot calculate harmonic mean of argument list containing zero #{args.inspect}"
+    end
+    sum = args.inject(LongDecimalQuot(0, 0)) do |psum, x|
+      psum + if (x.kind_of? Integer)
+               Rational(1, x)
+             else
+               1 / x
+             end
+    end
+    result = args.size / sum
+    return result
+  end
+
   # arithmetic-geometric mean (AGM)
   def LongMath.arithmetic_geometric_mean(new_scale, rounding_mode, *args)
     result_sign, all_same, has_neg, has_zero, has_pos = sign_check_for_mean(true, *args)
@@ -5044,7 +5227,10 @@ module LongMath
     if (all_same)
       return args[0].to_ld(new_scale, rounding_mode)
     end
-    sum = args.inject(0) do |psum, x|
+    sum = args.inject(LongDecimal.zero!) do |psum, x|
+      if (! (x.kind_of? LongDecimalBase) && ! (x.kind_of? Rational))
+        x = x.to_ld(2*new_scale + 20)
+      end
       psum + x*x
     end
     quot = if (sum.kind_of? Integer)
@@ -5065,11 +5251,14 @@ module LongMath
     if (all_same)
       return args[0].to_ld(new_scale, rounding_mode)
     end
-    sum = args.inject(0) do |psum, x|
+    sum = args.inject(LongDecimal.zero!) do |psum, x|
       if (x.kind_of? Complex)
         raise ArgumentError, "cubic mean not supported for complex numbers args=#{args.inspect}"
       end
-      psum + x*x*x
+      if (! (x.kind_of? LongDecimalBase) && ! (x.kind_of? Rational))
+        x = x.to_ld(2*new_scale + 20)
+      end
+      psum + x ** 3
     end
     quot = if (sum.kind_of? Integer)
              Rational(sum, args.size)
@@ -5107,6 +5296,7 @@ module LongMath
 
   # round elements in such a way that round(new_scale, rounding_mode_sum, sum(elements)) = sum(elements_rounded)
   # HAARE_NIEMEYER
+  #  (experimental)
   def LongMath.round_sum_hm(new_scale, rounding_mode_sum, *elements)
     if (elements.empty?)
       return elements
@@ -5136,6 +5326,7 @@ module LongMath
 
   # round elements in such a way that round(new_scale, rounding_mode, sum(elements)) = sum(elements_rounded)
   # where rounding_mode_set is
+  #  (experimental)
   def LongMath.round_sum_divisor(new_scale, rounding_mode_sum, rounding_mode_set, *elements)
     if (elements.empty?)
       return elements