long-decimal 1.00.01 → 1.00.02

data/lib/long-decimal.rb

@@ -7,8 +7,8 @@
 # additional functionality, mostly transcendental functions,
 # may be found in long-decimal-extra.rb
 #
-# CVS-ID:    $Header: /var/cvs/long-decimal/long-decimal/lib/long-decimal.rb,v 1.86 2011/01/23 20:55:32 bk1 Exp $
-# CVS-Label: $Name: RELEASE_1_00_01 $
+# 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)
 #
 
@@ -26,7 +26,106 @@ BYTE_SIZE_OF_ONE = 1.size
 #
 module LongDecimalRoundingMode
 
-  RoundingModeClass = Struct.new(:name, :num)
+  private
+
+  RoundingMinorMode = Struct.new(:name, :part)
+
+  # exactly on the boundary round away from zero
+  MINOR_UP = RoundingMinorMode.new(:MINOR_UP, :_UP)
+  # exactly on the boundary round towards zero
+  MINOR_DOWN = RoundingMinorMode.new(:MINOR_DOWN, :_DOWN)
+  # exactly on the boundary round towards positive infinitiy (to the higher of the two possible values)
+  MINOR_CEILING = RoundingMinorMode.new(:MINOR_CEILING, :_CEILING)
+  # exactly on the boundary round towards negative infinitiy (to the lower of the two possible values)
+  MINOR_FLOOR = RoundingMinorMode.new(:MINOR_FLOOR, :_FLOOR)
+  # exactly on the boundary pick the one with even end digit
+  MINOR_EVEN = RoundingMinorMode.new(:MINOR_EVEN, :_EVEN)
+  # exactly on the boundary pick the one with even end digit
+  MINOR_ODD = RoundingMinorMode.new(:MINOR_ODD, :_ODD)
+  # (away from zero if last digit after rounding towards zero would have been 0 or 5; otherwise towards zero)
+  # MINOR_05UP = RoundingMinorMode.new(:MINOR_05UP, :_05UP)
+  # for major modes that are completely defined by themselves and do not need to rely on minor modes for the boundary stuff
+  MINOR_UNUSED = RoundingMinorMode.new(:MINOR_UNUSED, "")
+
+  private
+
+  ALL_MINOR = [ MINOR_UP, MINOR_DOWN, MINOR_CEILING, MINOR_FLOOR, MINOR_EVEN, MINOR_ODD ]
+
+  NO_MINOR = [ MINOR_UNUSED ]
+
+  # which mode is to be used instead when we do an multiplicative inversion?
+  MUL_INVERSE_MINOR_MODE = {
+    MINOR_UNUSED  =>   MINOR_UNUSED,
+    MINOR_UP      =>   MINOR_DOWN,
+    MINOR_DOWN    =>   MINOR_UP,
+    MINOR_CEILING =>   MINOR_FLOOR,
+    MINOR_FLOOR   =>   MINOR_CEILING,
+    MINOR_EVEN    =>   MINOR_EVEN,
+    MINOR_ODD     =>   MINOR_ODD,
+  }
+
+  # which mode is to be used instead when we do an additive inversion?
+  ADD_INVERSE_MINOR_MODE = {
+    MINOR_UNUSED  =>   MINOR_UNUSED,
+    MINOR_UP      =>   MINOR_UP,
+    MINOR_DOWN    =>   MINOR_DOWN,
+    MINOR_CEILING =>   MINOR_FLOOR,
+    MINOR_FLOOR   =>   MINOR_CEILING,
+    MINOR_EVEN    =>   MINOR_EVEN,
+    MINOR_ODD     =>   MINOR_ODD,
+  }
+
+  RoundingMajorMode = Struct.new(:name, :part, :minor)
+
+  # round away from zero
+  MAJOR_UP = RoundingMajorMode.new(:MAJOR_UP, :UP, NO_MINOR)
+  # round towards zero
+  MAJOR_DOWN = RoundingMajorMode.new(:MAJOR_DOWN, :DOWN, NO_MINOR)
+  # pick the higher of the two possible values
+  MAJOR_CEILING = RoundingMajorMode.new(:MAJOR_CEILING, :CEILING, NO_MINOR)
+  # pick the lower of the two possible values
+  MAJOR_FLOOR = RoundingMajorMode.new(:MAJOR_FLOOR, :FLOOR, NO_MINOR)
+  # use the original value, if it is not already rounded, raise an error
+  MAJOR_UNNECESSARY = RoundingMajorMode.new(:MAJOR_UNNECESSARY, :UNNECESSARY, NO_MINOR)
+  # (away from zero if last digit after rounding towards zero would have been 0 or 5; otherwise towards zero)
+  # MAJOR_05UP = RoundingMinorMode.new(:MAJOR_05UP, :_05UP, NO_MINOR)
+
+  # the arithmetic mean of two adjacent rounded values is the boundary
+  MAJOR_HALF = RoundingMajorMode.new(:MAJOR_HALF, :HALF, ALL_MINOR)
+  # the arithmetic mean of two adjacent rounded values is the boundary
+  MAJOR_GEOMETRIC = RoundingMajorMode.new(:MAJOR_GEOMETRIC, :GEOMETRIC, ALL_MINOR)
+  # the harmonic mean of two adjacent rounded values is the boundary
+  MAJOR_HARMONIC = RoundingMajorMode.new(:MAJOR_HARMONIC, :HARMONIC, ALL_MINOR)
+  # the quadratic mean of two adjacent rounded values is the boundary
+  MAJOR_QUADRATIC = RoundingMajorMode.new(:MAJOR_QUADRATIC, :QUADRATIC, ALL_MINOR)
+  # the cubic mean of two adjacent rounded values is the boundary
+  MAJOR_CUBIC = RoundingMajorMode.new(:MAJOR_CUBIC, :CUBIC, ALL_MINOR)
+
+  private
+
+  ALL_MAJOR_MODES = [  MAJOR_UP, MAJOR_DOWN, MAJOR_CEILING, MAJOR_FLOOR, MAJOR_UNNECESSARY, MAJOR_HALF, MAJOR_GEOMETRIC, MAJOR_HARMONIC, MAJOR_QUADRATIC, MAJOR_CUBIC ]
+
+
+  MUL_INVERSE_MAJOR_MODE = {
+    MAJOR_UP           =>   MAJOR_DOWN,
+    MAJOR_DOWN         =>   MAJOR_UP,
+    MAJOR_CEILING      =>   MAJOR_FLOOR,
+    MAJOR_FLOOR        =>   MAJOR_CEILING,
+    MAJOR_HALF         =>   MAJOR_HALF,
+    MAJOR_UNNECESSARY  =>   MAJOR_UNNECESSARY
+  }
+
+  # which mode is to be used instead when we do an additive inversion?
+  ADD_INVERSE_MAJOR_MODE = {
+    MAJOR_UP           =>   MAJOR_UP,
+    MAJOR_DOWN         =>   MAJOR_DOWN,
+    MAJOR_CEILING      =>   MAJOR_FLOOR,
+    MAJOR_FLOOR        =>   MAJOR_CEILING,
+    MAJOR_HALF         =>   MAJOR_HALF,
+    MAJOR_UNNECESSARY  =>   MAJOR_UNNECESSARY
+  }
+
+  RoundingModeClass = Struct.new(:name, :major, :minor, :num)
 
   #
   # enumeration class to express the possible rounding modes that are
@@ -63,53 +162,281 @@ module LongDecimalRoundingMode
       LongDecimalRoundingMode::ADD_INVERSE_MODE[self]
     end
 
+    # internal use
+    # no special checks included
+    # we assume: lower <= unrounded <= upper
+    # we assume: sign = sgn(unrounded)
+    def pick_value(unrounded, sign, lower, upper, even)
+      if (sign == 0 || major == MAJOR_UNNECESSARY)
+        if (lower == unrounded)
+          return lower
+        elsif (upper == unrounded)
+          return upper
+        end
+      end
+      if (major == MAJOR_UP && sign > 0)
+        return upper
+      elsif (major == MAJOR_UP && sign < 0)
+        return lower
+      elsif (major == MAJOR_DOWN && sign > 0)
+        return lower
+      elsif (major == MAJOR_DOWN && sign < 0)
+        return upper
+      elsif (major == MAJOR_CEILING)
+        return upper
+      elsif (major == MAJOR_FLOOR)
+        return lower
+      elsif (major == MAJOR_UNNECESSARY)
+        raise ArgumentError, "rounding #{name} of unrounded=#{unrounded} (sign=#{sign}) is not applicable for lower=#{lower} and upper=#{upper}"
+      end
+      on_boundary = false
+      if (major == MAJOR_HALF)
+        d = unrounded - lower <=> upper - unrounded
+        if (d < 0)
+          # unrounded is below half
+          return lower
+        elsif (d > 0)
+          # unrounded is below half
+          return upper
+        else
+          on_boundary = true
+        end
+      elsif (major == MAJOR_GEOMETRIC)
+        prod = lower * upper
+        if (prod < 0)
+          raise ArgumentError, "geometric rounding #{name} of unrounded=#{unrounded} (sign=#{sign}) is not applicable for lower=#{lower} and upper=#{upper} with different signs"
+        elsif (prod == 0)
+          # lower or upper is 0
+          # we only round 0 to 0
+          if (sign == 0)
+            raise ArgumentError, "geometric rounding #{name} of unrounded=#{unrounded} (sign=#{sign}) is not applicable for lower=#{lower} and upper=#{upper} with 0 cannot be decided"
+          elsif (sign < 0)
+            return lower
+          else
+            return upper
+          end
+        end
+        # now prod > 0
+        square = unrounded * unrounded
+        d = square <=> prod
+        if (d < 0)
+          # |unrounded| < sqrt(lower*upper)
+          if (sign < 0)
+            # lower < unrounded < upper < 0
+            return upper
+          else
+            # (sign > 0)
+            return lower
+          end
+        elsif (d > 0)
+          # |unrounded| > sqrt(lower*upper)
+          if (sign < 0)
+            # lower < unrounded < upper < 0
+            return lower
+          else
+            # (sign > 0)
+            return upper
+          end
+        else
+          # (d == 0)
+          on_boundary = true
+        end
+      elsif (major == MAJOR_HARMONIC)
+        prod = lower * upper
+        if (prod < 0)
+          raise ArgumentError, "harmonic rounding #{name} of unrounded=#{unrounded} is not applicable for lower=#{lower} and upper=#{upper} with different signs"
+        elsif (prod == 0)
+          # lower or upper is 0
+          # we only round 0 to 0
+          if (sign == 0)
+            raise ArgumentError, "harmonic rounding #{name} of unrounded=#{unrounded} is not applicable for lower=#{lower} and upper=#{upper} with 0 cannot be decided"
+          elsif (sign < 0)
+            return lower
+          else
+            return upper
+          end
+        end
+        # now prod > 0
+        # so either lower < unrounded < upper < 0
+        # or 0 < lower < unrounded < upper
+        sum = lower + upper
+        lhs = unrounded * sum
+        rhs = 2*prod
+        d = lhs <=> rhs
+        if (sign < 0)
+          # lower + upper < 0
+          d = -d
+        end
+        if (d < 0)
+          # unrounded < 2*upper*lower/(upper+lower)
+          return lower
+        elsif (d > 0)
+          # unrounded > 2*upper*lower/(upper+lower)
+          return upper
+        else
+          # (d == 0)
+          on_boundary = true
+        end
+      elsif (major == MAJOR_QUADRATIC)
+        square = unrounded * unrounded
+        lhs = 2 * square
+        rhs = lower * lower + upper * upper
+        d = lhs <=> rhs
+        if (sign < 0)
+          # lower <= unrounded <= upper <= 0
+          # lower^2 >= unrounded >= upper^2 >= 0
+          d = -d
+        end
+        if (d < 0)
+          # unrounded < sqrt(...)
+          return lower
+        elsif (d > 0)
+          # unrounded > sqrt(...)
+          return upper
+        else
+          # (d == 0)
+          on_boundary = true
+        end
+      elsif (major == MAJOR_CUBIC)
+        cube = unrounded * unrounded * unrounded
+        lhs = 2 * cube
+        rhs = lower * lower * lower + upper * upper * upper
+        d = lhs <=> rhs
+        if (d < 0)
+          # unrounded < x_cubic(lower, upper)
+          return lower
+        elsif (d > 0)
+          # unrounded > x_cubic(lower, upper)
+          return upper
+        else
+          # (d == 0)
+          on_boundary = true
+        end
+      else
+        raise ArgumentError, "unsupported rounding mode (#{name}: major=#{major})"
+      end
+      if (! on_boundary)
+        raise ArgumentError, "rounding #{name} of unrounded=#{unrounded} failed for lower=#{lower} and upper=#{upper}: not on boundary"
+      end
+      if (minor == MINOR_UP)
+        return ROUND_UP.pick_value(unrounded, sign, lower, upper, even)
+      elsif (minor == MINOR_DOWN)
+        return ROUND_DOWN.pick_value(unrounded, sign, lower, upper, even)
+      elsif (minor == MINOR_CEILING)
+        return ROUND_CEILING.pick_value(unrounded, sign, lower, upper, even)
+      elsif (minor == MINOR_FLOOR)
+        return ROUND_FLOOR.pick_value(unrounded, sign, lower, upper, even)
+      elsif (minor == MINOR_UNUSED)
+        raise ArgumentError, "rounding #{name} of unrounded=#{unrounded} failed for lower=#{lower} and upper=#{upper}: on boundary but no applicable minor mode"
+      elsif (minor == MINOR_EVEN)
+        return even
+      elsif (minor == MINOR_ODD)
+        if (lower == even)
+          return upper
+        else
+          return lower
+        end
+      else
+        raise ArgumentError, "rounding #{name} of unrounded=#{unrounded} failed for lower=#{lower} and upper=#{upper}: on boundary but no applicable minor mode"
+      end
+    end
+
     def hash
       num
     end
 
+    def to_long_s
+      "RM(#{name} major=#{major.name} minor=#{minor.name} num=#{num})"
+    end
+
+    def to_s
+      "#{name}"
+    end
+
   end
 
+  MODE_LOOKUP = {}
+
+  rounding_mode_counter = 0
+
+  public
+
+  ALL_ROUNDING_MODES = []
+
+  MUL_INVERSE_MODE = {}
+
+  ADD_INVERSE_MODE = {}
+
+
+  ALL_MAJOR_MODES.each do |majm|
+    majm_str = majm.part.to_s
+    majm.minor.each do |minm|
+      minm_str = minm.part.to_s
+      const_str = "ROUND_" + majm_str + minm_str
+      class_eval("#{const_str} = RoundingModeClass.new(:#{const_str}, #{majm.name}, #{minm.name}, rounding_mode_counter)")
+      class_eval("#{const_str}.freeze")
+      rounding_mode_counter += 1
+      class_eval("ALL_ROUNDING_MODES.push(#{const_str})")
+      class_eval("MODE_LOOKUP[[#{majm.name}, #{minm.name}]] = #{const_str}")
+    end
+  end
+
+  ALL_ROUNDING_MODES.freeze
+  MODE_LOOKUP.freeze
+
+  ALL_ROUNDING_MODES.each do |rm|
+    majm = rm.major
+    minm = rm.minor
+    mul_inv = MODE_LOOKUP[[ MUL_INVERSE_MAJOR_MODE[majm], MUL_INVERSE_MINOR_MODE[minm]]]
+    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
+  end
+
+  MUL_INVERSE_MODE.freeze
+  ADD_INVERSE_MODE.freeze
+
   #
   # rounding modes as constants
   #
-  ROUND_UP           = RoundingModeClass.new(:ROUND_UP, 0)
-  ROUND_DOWN         = RoundingModeClass.new(:ROUND_DOWN, 1)
-  ROUND_CEILING      = RoundingModeClass.new(:ROUND_CEILING, 2)
-  ROUND_FLOOR        = RoundingModeClass.new(:ROUND_FLOOR, 3)
-  ROUND_HALF_UP      = RoundingModeClass.new(:ROUND_HALF_UP, 4)
-  ROUND_HALF_DOWN    = RoundingModeClass.new(:ROUND_HALF_DOWN, 5)
-  ROUND_HALF_CEILING = RoundingModeClass.new(:ROUND_HALF_CEILING, 6)
-  ROUND_HALF_FLOOR   = RoundingModeClass.new(:ROUND_HALF_FLOOR, 7)
-  ROUND_HALF_EVEN    = RoundingModeClass.new(:ROUND_HALF_EVEN, 8)
-  ROUND_UNNECESSARY  = RoundingModeClass.new(:ROUND_UNNECESSARY, 9)
-
-  # which mode is to be used instead when we do an multiplicative inversion?
-  MUL_INVERSE_MODE = {
-    ROUND_UP           =>   ROUND_DOWN,
-    ROUND_DOWN         =>   ROUND_UP,
-    ROUND_CEILING      =>   ROUND_FLOOR,
-    ROUND_FLOOR        =>   ROUND_CEILING,
-    ROUND_HALF_UP      =>   ROUND_HALF_DOWN,
-    ROUND_HALF_DOWN    =>   ROUND_HALF_UP,
-    ROUND_HALF_CEILING =>   ROUND_HALF_FLOOR,
-    ROUND_HALF_FLOOR   =>   ROUND_HALF_CEILING,
-    ROUND_HALF_EVEN    =>   ROUND_HALF_EVEN,
-    ROUND_UNNECESSARY  =>   ROUND_UNNECESSARY
-  }
-
-  # which mode is to be used instead when we do an additive inversion?
-  ADD_INVERSE_MODE = {
-    ROUND_UP           =>   ROUND_UP,
-    ROUND_DOWN         =>   ROUND_DOWN,
-    ROUND_CEILING      =>   ROUND_FLOOR,
-    ROUND_FLOOR        =>   ROUND_CEILING,
-    ROUND_HALF_UP      =>   ROUND_HALF_UP,
-    ROUND_HALF_DOWN    =>   ROUND_HALF_DOWN,
-    ROUND_HALF_CEILING =>   ROUND_HALF_FLOOR,
-    ROUND_HALF_FLOOR   =>   ROUND_HALF_CEILING,
-    ROUND_HALF_EVEN    =>   ROUND_HALF_EVEN,
-    ROUND_UNNECESSARY  =>   ROUND_UNNECESSARY
-  }
+  # ROUND_UP           = RoundingModeClass.new(:ROUND_UP, 0)
+  # ROUND_DOWN         = RoundingModeClass.new(:ROUND_DOWN, 1)
+  # ROUND_CEILING      = RoundingModeClass.new(:ROUND_CEILING, 2)
+  # ROUND_FLOOR        = RoundingModeClass.new(:ROUND_FLOOR, 3)
+  # ROUND_HALF_UP      = RoundingModeClass.new(:ROUND_HALF_UP, 4)
+  # ROUND_HALF_DOWN    = RoundingModeClass.new(:ROUND_HALF_DOWN, 5)
+  # ROUND_HALF_CEILING = RoundingModeClass.new(:ROUND_HALF_CEILING, 6)
+  # ROUND_HALF_FLOOR   = RoundingModeClass.new(:ROUND_HALF_FLOOR, 7)
+  # ROUND_HALF_EVEN    = RoundingModeClass.new(:ROUND_HALF_EVEN, 8)
+  # ROUND_UNNECESSARY  = RoundingModeClass.new(:ROUND_UNNECESSARY, 9)
+
+  # # which mode is to be used instead when we do an multiplicative inversion?
+  # MUL_INVERSE_MODE = {
+  #   ROUND_UP           =>   ROUND_DOWN,
+  #   ROUND_DOWN         =>   ROUND_UP,
+  #   ROUND_CEILING      =>   ROUND_FLOOR,
+  #   ROUND_FLOOR        =>   ROUND_CEILING,
+  #   ROUND_HALF_UP      =>   ROUND_HALF_DOWN,
+  #   ROUND_HALF_DOWN    =>   ROUND_HALF_UP,
+  #   ROUND_HALF_CEILING =>   ROUND_HALF_FLOOR,
+  #   ROUND_HALF_FLOOR   =>   ROUND_HALF_CEILING,
+  #   ROUND_HALF_EVEN    =>   ROUND_HALF_EVEN,
+  #   ROUND_UNNECESSARY  =>   ROUND_UNNECESSARY
+  # }
+
+  # # which mode is to be used instead when we do an additive inversion?
+  # ADD_INVERSE_MODE = {
+  #   ROUND_UP           =>   ROUND_UP,
+  #   ROUND_DOWN         =>   ROUND_DOWN,
+  #   ROUND_CEILING      =>   ROUND_FLOOR,
+  #   ROUND_FLOOR        =>   ROUND_CEILING,
+  #   ROUND_HALF_UP      =>   ROUND_HALF_UP,
+  #   ROUND_HALF_DOWN    =>   ROUND_HALF_DOWN,
+  #   ROUND_HALF_CEILING =>   ROUND_HALF_FLOOR,
+  #   ROUND_HALF_FLOOR   =>   ROUND_HALF_CEILING,
+  #   ROUND_HALF_EVEN    =>   ROUND_HALF_EVEN,
+  #   ROUND_UNNECESSARY  =>   ROUND_UNNECESSARY
+  # }
 
   ZeroRoundingModeClass = Struct.new(:name, :num)
 
@@ -138,6 +465,14 @@ module LongDecimalRoundingMode
       num
     end
 
+    def to_long_s
+      "ZM(#{name} num=#{num})"
+    end
+
+    def to_s
+      "#{name}"
+    end
+
   end
 
   #
@@ -149,6 +484,12 @@ module LongDecimalRoundingMode
   ZERO_ROUND_TO_CLOSEST_PREFER_MINUS = ZeroRoundingModeClass.new(:ZERO_ROUND_TO_CLOSEST_PREFER_MINUS, 3)
   ZERO_ROUND_UNNECESSARY             = ZeroRoundingModeClass.new(:ZERO_ROUND_UNNECESSARY, 4)
 
+  ALL_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 ];
+
 end # LongDecimalRoundingMode
 
 # JRuby has a bug to be fixed in version > 1.2 that implies results of
@@ -185,6 +526,8 @@ if (RUBY_PLATFORM == 'java')
   end
 end
 
+
+
 #
 # add one method to Integer
 #
@@ -221,23 +564,25 @@ class Integer
   #                            use, zero_rounding_mode has to be used
   #                            to decide.
   #
-  def round_to_allowed_remainders(remainders,
+  def round_to_allowed_remainders(remainders_param,
                                   modulus,
                                   rounding_mode = LongDecimalRoundingMode::ROUND_UNNECESSARY,
                                   zero_rounding_mode = LongDecimalRoundingMode::ZERO_ROUND_UNNECESSARY)
 
-    raise TypeError, "remainders must be Array" unless remainders.kind_of? Array
-    raise TypeError, "remainders must be non-empty Array" unless remainders.length > 0
+    raise TypeError, "remainders must be Array" unless remainders_param.kind_of? Array
+    raise TypeError, "remainders must be non-empty Array" unless remainders_param.length > 0
     raise TypeError, "modulus #{modulus.inspect} must be integer" unless modulus.kind_of? Integer
     raise TypeError, "modulus #{modulus.inspect} must be >= 2" unless modulus >= 2
     raise TypeError, "rounding_mode #{rounding_mode.inspect} must be legal rounding rounding_mode" unless rounding_mode.kind_of? LongDecimalRoundingMode::RoundingModeClass
-    raise TypeError, "ROUND_HALF_EVEN is not applicable here" if rounding_mode == LongDecimalRoundingMode::ROUND_HALF_EVEN
+    raise TypeError, "#{rounding_mode} is not applicable here" if rounding_mode.minor == LongDecimalRoundingMode::MINOR_EVEN
+    raise TypeError, "#{rounding_mode} is not applicable here" if rounding_mode.minor == LongDecimalRoundingMode::MINOR_ODD
     raise TypeError, "zero_rounding_mode #{zero_rounding_mode.inspect} must be legal zero_rounding zero_rounding_mode" unless zero_rounding_mode.kind_of? LongDecimalRoundingMode::ZeroRoundingModeClass
 
+    remainders = remainders_param.clone
     r_self     = self % modulus
     r_self_00  = r_self
     remainders = remainders.collect do |r|
-      raise TypeError, "remainders must be numbers" unless r.kind_of? Integer
+      raise TypeError, "remainders must be integral numbers" unless r.kind_of? Integer
       r % modulus
     end
     remainders.sort!.uniq!
@@ -261,45 +606,79 @@ class Integer
         break
       end
     end
+    if (r_lower < 0)
+      raise ArgumentError, "self=#{self} r_self=#{r_self} r_lower=#{r_lower} r_upper=#{r_upper}"
+    end
+    if (r_upper < 0)
+      raise ArgumentError, "self=#{self} r_self=#{r_self} r_lower=#{r_lower} r_upper=#{r_upper}"
+    end
     lower = self - (r_self - r_lower)
     upper = self + (r_upper - r_self)
 
     unless (lower < self && self < upper)
-      raise ArgumentError, "self=#{self} not in (#{lower}, #{upper})"
+      raise ArgumentError, "self=#{self} not in (#{lower}, #{upper}) with r_self=#{r_self} r_lower=#{r_lower} r_upper=#{r_upper}"
     end
     if (rounding_mode == LongDecimalRoundingMode::ROUND_UNNECESSARY) then
       raise ArgumentError, "mode ROUND_UNNECESSARY not applicable, self=#{self.to_s} is in open interval (#{lower}, #{upper})"
     end
 
-    #     if (rounding_mode == LongDecimalRoundingMode::ROUND_FLOOR) then
-    #       return lower
-    #     elsif (rounding_mode == LongDecimalRoundingMode::ROUND_CEILING) then
-    #       return upper
-    #     end
+    if (rounding_mode == LongDecimalRoundingMode::ROUND_FLOOR) then
+      if (lower.nil?)
+        raise ArgumentError, "remainders=#{remainders} modulus=#{modulus} rounding_mode=#{rounding_mode} zero_rounding_mode=#{zero_rounding_mode}"
+      end
+      return lower
+    elsif (rounding_mode == LongDecimalRoundingMode::ROUND_CEILING) then
+      if (upper.nil?)
+        raise ArgumentError, "remainders=#{remainders} modulus=#{modulus} rounding_mode=#{rounding_mode} zero_rounding_mode=#{zero_rounding_mode}"
+      end
+      return upper
+    end
 
-    sign_self = self.sign
+    sign_self = self.sgn
     if (sign_self == 0) then
-      if (rounding_mode == LongDecimalRoundingMode::ROUND_UP || rounding_mode == LongDecimalRoundingMode::ROUND_DOWN \
-          || lower == -upper && (rounding_mode == LongDecimalRoundingMode::ROUND_HALF_UP || rounding_mode == LongDecimalRoundingMode::ROUND_HALF_DOWN))
+      if (rounding_mode == LongDecimalRoundingMode::ROUND_UP \
+          || rounding_mode == LongDecimalRoundingMode::ROUND_DOWN \
+          || rounding_mode.major == LongDecimalRoundingMode::MAJOR_GEOMETRIC \
+          || rounding_mode.major == LongDecimalRoundingMode::MAJOR_HARMONIC \
+          || rounding_mode.major == LongDecimalRoundingMode::MAJOR_QUADRATIC \
+          || lower == -upper && (rounding_mode.minor == LongDecimalRoundingMode::MINOR_UP || rounding_mode.minor == LongDecimalRoundingMode::MINOR_DOWN))
         if (zero_rounding_mode == LongDecimalRoundingMode::ZERO_ROUND_UNNECESSARY) then
-          raise ArgumentError, "self=#{self.to_s} is 0 in open interval (#{lower}, #{upper}) and cannot be resolved with ZERO_ROUND_UNNECESSARY"
+          raise ArgumentError, "self=#{self.to_s} is 0 in open interval (#{lower}, #{upper}) and cannot be resolved with ZERO_ROUND_UNNECESSARY (rounding_mode=#{rounding_mode} modulus=#{modulus} remainders=#{remainders}"
         elsif (zero_rounding_mode == LongDecimalRoundingMode::ZERO_ROUND_TO_CLOSEST_PREFER_PLUS \
                || zero_rounding_mode == LongDecimalRoundingMode::ZERO_ROUND_TO_CLOSEST_PREFER_MINUS) then
           diff = lower.abs <=> upper.abs
           if (diff < 0) then
+            if (lower.nil?)
+              raise ArgumentError, "remainders=#{remainders} modulus=#{modulus} rounding_mode=#{rounding_mode} zero_rounding_mode=#{zero_rounding_mode}"
+            end
             return lower
           elsif (diff > 0) then
+            if (upper.nil?)
+              raise ArgumentError, "remainders=#{remainders} modulus=#{modulus} rounding_mode=#{rounding_mode} zero_rounding_mode=#{zero_rounding_mode}"
+            end
             return upper
           elsif (zero_rounding_mode == LongDecimalRoundingMode::ZERO_ROUND_TO_CLOSEST_PREFER_PLUS) then
+            if (upper.nil?)
+              raise ArgumentError, "remainders=#{remainders} modulus=#{modulus} rounding_mode=#{rounding_mode} zero_rounding_mode=#{zero_rounding_mode}"
+            end
             return upper
           elsif (zero_rounding_mode == LongDecimalRoundingMode::ZERO_ROUND_TO_CLOSEST_PREFER_MINUS) then
+            if (lower.nil?)
+              raise ArgumentError, "remainders=#{remainders} modulus=#{modulus} rounding_mode=#{rounding_mode} zero_rounding_mode=#{zero_rounding_mode}"
+            end
             return lower
           else
             raise ArgumentError, "this case can never happen: zero_rounding_mode=#{zero_rounding_mode}"
           end
         elsif (zero_rounding_mode == LongDecimalRoundingMode::ZERO_ROUND_TO_PLUS) then
+          if (upper.nil?)
+            raise ArgumentError, "remainders=#{remainders} modulus=#{modulus} rounding_mode=#{rounding_mode} zero_rounding_mode=#{zero_rounding_mode}"
+          end
           return upper
         elsif (zero_rounding_mode == LongDecimalRoundingMode::ZERO_ROUND_TO_MINUS) then
+          if (lower.nil?)
+            raise ArgumentError, "remainders=#{remainders} modulus=#{modulus} rounding_mode=#{rounding_mode} zero_rounding_mode=#{zero_rounding_mode}"
+          end
           return lower
         else
           raise ArgumentError, "this case can never happen: zero_rounding_mode=#{zero_rounding_mode}"
@@ -307,45 +686,66 @@ class Integer
       end
     end
 
-    # now we can assume that sign_self (and self) is != 0, which allows to decide on the rounding_mode
-
-    if (rounding_mode == LongDecimalRoundingMode::ROUND_UP)
-      # ROUND_UP goes to the closest possible value away from zero
-      rounding_mode = (sign_self < 0) ? LongDecimalRoundingMode::ROUND_FLOOR : LongDecimalRoundingMode::ROUND_CEILING
-    elsif (rounding_mode == LongDecimalRoundingMode::ROUND_DOWN)
-      # ROUND_DOWN goes to the closest possible value towards zero or beyond zero
-      rounding_mode = (sign_self < 0) ? LongDecimalRoundingMode::ROUND_CEILING : LongDecimalRoundingMode::ROUND_FLOOR
-    elsif (rounding_mode == LongDecimalRoundingMode::ROUND_HALF_UP)
-      # ROUND_HALF_UP goes to the closest possible value preferring away from zero
-      rounding_mode = (sign_self < 0) ? LongDecimalRoundingMode::ROUND_HALF_FLOOR : LongDecimalRoundingMode::ROUND_HALF_CEILING
-    elsif (rounding_mode == LongDecimalRoundingMode::ROUND_HALF_DOWN)
-      # ROUND_HALF_DOWN goes to the closest possible value preferring towards zero or beyond zero
-      rounding_mode = (sign_self < 0) ? LongDecimalRoundingMode::ROUND_HALF_CEILING : LongDecimalRoundingMode::ROUND_HALF_FLOOR
-    end
-    if (rounding_mode == LongDecimalRoundingMode::ROUND_HALF_FLOOR \
-        || rounding_mode == LongDecimalRoundingMode::ROUND_HALF_CEILING) then
-      d_lower = self - lower
-      d_upper = upper - self
-      if (d_lower < d_upper) then
-        return lower
-      elsif (d_upper < d_lower) then
+    # for geometric and harmonic never round across 0
+    if (rounding_mode.major == LongDecimalRoundingMode::MAJOR_GEOMETRIC || rounding_mode.major == LongDecimalRoundingMode::MAJOR_HARMONIC || rounding_mode.major == LongDecimalRoundingMode::MAJOR_QUADRATIC)
+      if (sign_self > 0 && lower < 0)
+        if (upper.nil?)
+          raise ArgumentError, "remainders=#{remainders} modulus=#{modulus} rounding_mode=#{rounding_mode} zero_rounding_mode=#{zero_rounding_mode}"
+        end
         return upper
-      elsif (rounding_mode == LongDecimalRoundingMode::ROUND_HALF_FLOOR) then
-        rounding_mode = LongDecimalRoundingMode::ROUND_FLOOR
-      elsif (rounding_mode == LongDecimalRoundingMode::ROUND_HALF_CEILING) then
-        rounding_mode = LongDecimalRoundingMode::ROUND_CEILING
-      else
-        raise ArgumentError, "this case can never happen: rounding_mode=#{rounding_mode}"
+      elsif (sign_self < 0 && upper > 0)
+        if (lower.nil?)
+          raise ArgumentError, "remainders=#{remainders} modulus=#{modulus} rounding_mode=#{rounding_mode} zero_rounding_mode=#{zero_rounding_mode}"
+        end
+        return lower
       end
     end
 
-    if (rounding_mode == LongDecimalRoundingMode::ROUND_FLOOR) then
-      return lower
-    elsif (rounding_mode == LongDecimalRoundingMode::ROUND_CEILING) then
-      return upper
-    else
-      raise ArgumentError, "this case can never happen: rounding_mode=#{rounding_mode}"
-    end
+    # now we can assume that sign_self (and self) is != 0, which allows to decide on the rounding_mode
+    pick = rounding_mode.pick_value(self, sign_self, lower, upper, nil)
+    # if (rounding_mode == LongDecimalRoundingMode::ROUND_UP)
+    #   # ROUND_UP goes to the closest possible value away from zero
+    #   rounding_mode = (sign_self < 0) ? LongDecimalRoundingMode::ROUND_FLOOR : LongDecimalRoundingMode::ROUND_CEILING
+    # elsif (rounding_mode == LongDecimalRoundingMode::ROUND_DOWN)
+    #   # ROUND_DOWN goes to the closest possible value towards zero or beyond zero
+    #   rounding_mode = (sign_self < 0) ? LongDecimalRoundingMode::ROUND_CEILING : LongDecimalRoundingMode::ROUND_FLOOR
+    # elsif (rounding_mode.minor == LongDecimalRoundingMode::MINOR_UP)
+    #   # ROUND_*_UP goes to the closest possible value preferring away from zero
+    #   rounding_mode_minor = (sign_self < 0) ? LongDecimalRoundingMode::MINOR_FLOOR : LongDecimalRoundingMode::MINOR_CEILING
+    #   rounding_mode = LongDecimalRoundingMode::MODE_LOOKUP[[rounding_mode.major, rounding_mode_minor]]
+    # elsif (rounding_mode.minor == LongDecimalRoundingMode::MINOR_DOWN)
+    #   # ROUND_*_DOWN goes to the closest possible value preferring towards zero or beyond zero
+    #   rounding_mode_minor = (sign_self < 0) ? LongDecimalRoundingMode::MINOR_CEILING : LongDecimalRoundingMode::MINOR_FLOOR
+    #   rounding_mode = LongDecimalRoundingMode::MODE_LOOKUP[[rounding_mode.major, rounding_mode_minor]]
+    # end
+    # if (rounding_mode.minor == LongDecimalRoundingMode::MINOR_FLOOR \
+    #     || rounding_mode.minor == LongDecimalRoundingMode::MINOR_CEILING) then
+    #   d_lower = self - lower
+    #   d_upper = upper - self
+    #   if (d_lower < d_upper) then
+    #     return lower
+    #   elsif (d_upper < d_lower) then
+    #     return upper
+    #   elsif (rounding_mode == LongDecimalRoundingMode::ROUND_HALF_FLOOR) then
+    #     rounding_mode = LongDecimalRoundingMode::ROUND_FLOOR
+    #   elsif (rounding_mode == LongDecimalRoundingMode::ROUND_HALF_CEILING) then
+    #     rounding_mode = LongDecimalRoundingMode::ROUND_CEILING
+    #   else
+    #     raise ArgumentError, "this case can never happen: rounding_mode=#{rounding_mode}"
+    #   end
+    # end
+
+    # if (rounding_mode == LongDecimalRoundingMode::ROUND_FLOOR) then
+    #   return lower
+    # elsif (rounding_mode == LongDecimalRoundingMode::ROUND_CEILING) then
+    #   return upper
+    # else
+    #   raise ArgumentError, "this case can never happen: rounding_mode=#{rounding_mode}"
+    # end
+    if (pick.nil?)
+      raise ArgumentError, "remainders=#{remainders} modulus=#{modulus} rounding_mode=#{rounding_mode} zero_rounding_mode=#{zero_rounding_mode}"
+    end
+    return pick
   end
 end
 
@@ -353,7 +753,7 @@ end
 # common base class for LongDecimal and LongDecimalQuot
 #
 class LongDecimalBase < Numeric
-  @@RCS_ID='-$Id: long-decimal.rb,v 1.86 2011/01/23 20:55:32 bk1 Exp $-'
+  @@RCS_ID='-$Id: long-decimal.rb,v 1.87 2011/01/30 20:01:40 bk1 Exp $-'
 
   # allow easy check if running with version 1.9
   RUNNING_19 = RUBY_VERSION.match /^1\.9/
@@ -476,7 +876,53 @@ class LongDecimalBase < Numeric
       return LongDecimal(0, new_scale)
     end
 
-    divisor   = divisor
+    quot, rem = dividend.divmod(divisor)
+    sign_rem  = rem  <=> 0
+    if (sign_rem == 0)
+      # if self can be expressed without loss as LongDecimal with
+      # new_scale digits after the decimal point, just do it.
+      return LongDecimal(quot, new_scale)
+    end
+
+    # we do not expect negative signs of remainder.  To make sure that
+    # this does not cause problems in further code, we just throw an
+    # exception.  This should never happen (and did not happen during
+    # testing).
+    raise ArgumentError, "signs do not match self=#{self.to_s} f=#{factor} dividend=#{dividend} divisor=#{divisor} quot=#{quot} rem=#{rem}" if sign_rem <= 0
+
+    # now we have
+    # dividend == quot * divisor + rem
+    # where 0 < rem < quot (the case rem == 0 has already been handled
+    # so
+    # quot < divisor/dividend < quot+1
+    lower = quot
+    upper = quot+1
+    even = if (mode.minor == MINOR_EVEN || mode.minor == MINOR_ODD)
+             even = if (lower[0] == 1)
+                      upper
+                    else
+                      lower
+                    end
+           else
+             nil
+           end
+    value = mode.pick_value(Rational(dividend, divisor), sign_quot, lower, upper, even)
+    LongDecimal(value, new_scale)
+
+  end
+
+  #
+  # helper method for round_to_scale
+  # will be replaced by shorter implementation
+  #
+  def round_to_scale_helper_old(dividend, divisor, new_scale, mode)
+
+    sign_quot = dividend <=> 0
+    if sign_quot == 0 then
+      # finish zero without long calculations at once
+      return LongDecimal(0, new_scale)
+    end
+
     quot, rem = dividend.divmod(divisor)
     sign_rem  = rem  <=> 0
     if (sign_rem == 0)
@@ -523,33 +969,35 @@ class LongDecimalBase < Numeric
 
     else
 
-      if (mode == ROUND_HALF_CEILING)
+      if (mode.minor == MINOR_CEILING)
         # ROUND_HALF_CEILING goes to the closest allowed number >= self, even
         # for negative numbers.  Since sign is handled separately, it is
         # more conveniant to use ROUND_HALF_UP or ROUND_HALF_DOWN depending on the
         # sign.
-        mode = (sign_quot > 0) ? ROUND_HALF_UP : ROUND_HALF_DOWN
-
-      elsif (mode == ROUND_HALF_FLOOR)
+        minor_mode = (sign_quot > 0) ? MINOR_UP : MINOR_DOWN
+        mode = MODE_LOOKUP[[mode.major, minor_mode]]
+      elsif (mode.minor == MINOR_FLOOR)
         # ROUND_HALF_FLOOR goes to the closest allowed number <= self, even
         # for negative numbers.  Since sign is handled separately, it is
         # more conveniant to use ROUND_HALF_UP or ROUND_HALF_DOWN depending on the
         # sign.
-        mode = (sign_quot < 0) ? ROUND_HALF_UP : ROUND_HALF_DOWN
-
+        minor_mode = (sign_quot < 0) ? MINOR_UP : MINOR_DOWN
+        mode = MODE_LOOKUP[[mode.major, minor_mode]]
       end
 
       # handle the ROUND_HALF_... stuff and find the adequate ROUND_UP
       # or ROUND_DOWN to use
       abs_rem = rem.abs
-      half    = (abs_rem << 1) <=> divisor
-      if (mode == ROUND_HALF_UP || mode == ROUND_HALF_DOWN || mode == ROUND_HALF_EVEN) then
-        if (half < 0) then
+      direction_criteria    = nil
+      if (mode.major == MAJOR_HALF)
+        direction_criteria = (abs_rem << 1) <=> divisor
+
+        if (direction_criteria < 0) then
           mode = ROUND_DOWN
-        elsif half > 0 then
+        elsif direction_criteria > 0 then
           mode = ROUND_UP
         else
-          # half == 0
+          # direction_criteria == 0
           if (mode == ROUND_HALF_UP) then
             mode = ROUND_UP
           elsif (mode == ROUND_HALF_DOWN) then
@@ -583,7 +1031,7 @@ end # class LongDecimalBase
 # digits and the other one the position of the decimal point.
 #
 class LongDecimal < LongDecimalBase
-  @@RCS_ID='-$Id: long-decimal.rb,v 1.86 2011/01/23 20:55:32 bk1 Exp $-'
+  @@RCS_ID='-$Id: long-decimal.rb,v 1.87 2011/01/30 20:01:40 bk1 Exp $-'
 
   #  MINUS_ONE = LongDecimal(-1)
   #  ZERO      = LongDecimal(0)
@@ -731,7 +1179,7 @@ class LongDecimal < LongDecimalBase
       raise TypeError, "1st arg must not be empty string. \"#{num_str.inspect}\"" if len == 0
 
       # remove spaces and underscores
-      num_str.gsub!(/\s/, "")
+      num_str = num_str.gsub(/\s/, "")
       num_str.gsub!(/_/, "")
 
       # handle sign
@@ -894,6 +1342,7 @@ class LongDecimal < LongDecimalBase
     raise TypeError, "modulus #{modulus.inspect} must be >= 2" unless modulus >= 2
     raise TypeError, "rounding_mode #{rounding_mode.inspect} must be legal rounding rounding_mode" unless rounding_mode.kind_of? RoundingModeClass
     raise TypeError, "ROUND_HALF_EVEN is not applicable here" if rounding_mode == LongDecimalRoundingMode::ROUND_HALF_EVEN
+    raise TypeError, "ROUND_HALF_ODD is not applicable here" if rounding_mode == LongDecimalRoundingMode::ROUND_HALF_ODD
     raise TypeError, "zero_rounding_mode #{zero_rounding_mode.inspect} must be legal zero_rounding zero_rounding_mode" unless zero_rounding_mode.kind_of? ZeroRoundingModeClass
 
     if @scale < new_scale then
@@ -991,7 +1440,6 @@ 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
 
@@ -999,15 +1447,12 @@ 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
@@ -1016,7 +1461,6 @@ class LongDecimal < LongDecimalBase
     if (self < 0) then
       y = -(-self).to_f
       # t3
-      # puts "t3 #{self.to_s}=#{self.inspect} -> #{y}"
       return y
     end
 
@@ -1024,7 +1468,6 @@ 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
 
@@ -1034,7 +1477,6 @@ 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
 
@@ -1042,7 +1484,6 @@ 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
@@ -1062,13 +1503,11 @@ 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
 
@@ -1081,7 +1520,6 @@ 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
 
@@ -1092,7 +1530,6 @@ 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
@@ -1100,7 +1537,6 @@ 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
@@ -1116,7 +1552,6 @@ 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
@@ -1756,11 +2191,9 @@ 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))
@@ -1880,7 +2313,7 @@ end # LongDecimal
 #
 class LongDecimalQuot < LongDecimalBase
 
-  @@RCS_ID='-$Id: long-decimal.rb,v 1.86 2011/01/23 20:55:32 bk1 Exp $-'
+  @@RCS_ID='-$Id: long-decimal.rb,v 1.87 2011/01/30 20:01:40 bk1 Exp $-'
 
   #
   # constructor
@@ -1924,7 +2357,7 @@ class LongDecimalQuot < LongDecimalBase
       # digits before the decimal point.  Since division is usually
       # not expressable exactly in decimal digits, it is up to the
       # calling application to decide on the number of digits actually
-      # used for the result, which can be more that new_scale.
+      # used for the result, which can be more than new_scale.
       sx = first.scale
       sy = second.scale
       dx = first.sint_digits10
@@ -2096,7 +2529,6 @@ 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
@@ -2386,6 +2818,17 @@ class Numeric
     (self - 1).zero?
   end
 
+  def sgn
+    raw_sign = self <=> 0
+    if (raw_sign < 0)
+      -1
+    elsif (raw_sign == 0)
+      0
+    else
+      +1
+    end
+  end
+
 end # Numeric
 
 class Complex
@@ -2492,8 +2935,8 @@ class Rational
 
     # improved to_f, works better where numerator and denominator are integers beyond the range of float, but their Quotient is still expressable as Float
     def to_f
-      num = @numerator
-      den = @denominator
+      num = numerator
+      den = denominator
       sign = num <=> 0
       if (sign.zero?)
         return 0.0
@@ -2579,9 +3022,7 @@ 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
@@ -2736,6 +3177,60 @@ module LongMath
     end
   end
 
+  LOG_1E100 = Math.log(1e100)
+
+  #
+  # internal helper method for calculating the internal precision for power
+  #
+  def LongMath.calc_iprec_for_power(x, y, prec)
+
+    logx_f = LongMath.log_f(x.abs)
+    x1 = (x.abs - 1).abs
+    logx1_f = 0
+    if (x1 > 0)
+      logx1_f = LongMath.log_f(x1).abs
+    end
+    if (logx1_f > 5)
+      prec = (prec * Math.log(logx1_f) + 5)
+    end
+
+    y_f = nil
+    if (y.abs <= LongMath::MAX_FLOATABLE) then
+      y_f = y.to_f
+    else
+      y_f = y.round_to_scale(18, LongMath::ROUND_UP)
+    end
+
+    logx_y_f = logx_f * y_f
+
+    if (logx_y_f.abs > LongMath::MAX_FLOATABLE) then
+      raise ArgumentError, "power would be way too big: y*log(x)=#{logx_y_f}";
+    end
+    logx_y_f = logx_y_f.to_f unless logx_y_f.kind_of? Float
+
+    iprec_x  = calc_iprec_for_exp(logx_y_f.abs.ceil, prec, logx_y_f < 0)
+    iprec_y  = iprec_x
+    iprec    = iprec_x + 2
+    if (logx_f < 0)
+      iprec_x -= (-1.5 + logx_f/LOG10).round
+    end
+    if (y_f.abs < 1)
+      logy_f = LongMath.log_f(y.abs)
+      iprec_y -= (- 1.5 + logy_f/LOG10).round
+    end
+    if (iprec > prec_limit)
+      iprec = prec_limit
+    end
+    if (iprec_x > prec_limit)
+      iprec_x = prec_limit
+    end
+    if (iprec_y > prec_limit)
+      iprec_y = prec_limit
+    end
+    [ iprec, iprec_x, iprec_y, logx_y_f ]
+
+  end
+
   public
 
   #
@@ -2749,11 +3244,8 @@ 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
@@ -2980,7 +3472,7 @@ module LongMath
     check_is_int(x, "x")
     check_is_int(n, "n")
 
-    n2 = n<<1
+    n2 = n << 1
     n1 = n+1
     check_word_len(n2, "2*n")
 
@@ -3281,6 +3773,38 @@ module LongMath
     exp_internal(x, prec, mode)
   end
 
+  #
+  # calc the base-2-exponential function of x to the given precision as
+  # LongDecimal.  Only supports values of x such that the result still
+  # fits into a float (x <= 709).  This limitation is somewhat
+  # arbitrary, but it is enforced in order to avoid producing numbers
+  # with the exponential function that exceed the memory.
+  #
+  # Warning: this is a transcendental function that aims at producing
+  # results to the given precision, but minor inaccuracies of the
+  # result have to be expected under some circumstances, being off by
+  # one even more often.
+  #
+  def LongMath.exp2(x, prec, mode = LongMath.standard_mode) # down?
+    LongMath.power(2, x, prec, mode)
+  end
+
+  #
+  # calc the base-10-exponential function of x to the given precision as
+  # LongDecimal.  Only supports values of x such that the result still
+  # fits into a float (x <= 709).  This limitation is somewhat
+  # arbitrary, but it is enforced in order to avoid producing numbers
+  # with the exponential function that exceed the memory.
+  #
+  # Warning: this is a transcendental function that aims at producing
+  # results to the given precision, but minor inaccuracies of the
+  # result have to be expected under some circumstances, being off by
+  # one even more often.
+  #
+  def LongMath.exp10(x, prec, mode = LongMath.standard_mode) # down?
+    LongMath.power(10, x, prec, mode)
+  end
+
   private
 
   #
@@ -3302,15 +3826,24 @@ module LongMath
     iprec
   end
 
-  public
-
   #
   # internal functionality of exp.  exposes some more parameters, that
-  # should usually be set to defaut values, in order to allow better testing.
+  # should usually be set to default values, in order to allow better testing.
   # do not actually call this method unless you are testing exp.
   # create a bug report, if the default settings for the parameters do
   # not work correctly
   #
+  # x is the number of which we want to calculate the exponential function.
+  # prec is the precision that we need to achieve for the final result.
+  # final_mode is the rounding mode that we use for the end result
+  # j number of summands that are grouped together for better performance of the calculation
+  #   (defaults to the cube root of the desired number of base 2 digits to express the fractonal part of result.)
+  # k is an integer such that calculation of exp(x/2**k) has good convergence.  We calculate that and finally take a power of the result:
+  #   exp(x) = exp(x/2**k)**(2**k)
+  # iprec is the precision used internally during the calculation
+  # mode is the rounding mode used internally
+  # cache_result indicates if the result of the calculation should be cached.
+  #
   def LongMath.exp_internal(x, prec = nil, final_mode = LongMath.standard_mode, j = nil, k = nil, iprec = nil, mode = LongMath.standard_imode, cache_result = true) # down?
 
     if (prec.nil?) then
@@ -3330,16 +3863,20 @@ module LongMath
 
     # if the result would come out to zero anyway, cut the work
     xi = x.to_i
-    # if (xi < -LongMath::MAX_FLOATABLE) || -((xi.to_f - 1) / LOG10) > prec+10 then
     if (xi < -LongMath::MAX_FLOATABLE) || xi + 1 < -prec * LOG10 - LOG2 then
+      # the result is 1/4 of the smallest positive number that can be expressed with the given precision.
+      # this is rounded according to the final rounding mode, yielding 0.00000...00 or 0.00000...01.
       return LongDecimal(25, prec+2).round_to_scale(prec, final_mode)
     end
+
+    # if x is negative, do the calculation with -x and take 1/exp(-x) as the final result later.
     x_was_neg = false
     if (x < 0) then
       x = -x
       x_was_neg = true
     end
 
+    # calculate j and k if they are not given.
     if j.nil? || k.nil? then
       s1 = (prec * LOG10 / LOG2) ** (1.0/3.0)
       if (j.nil?) then
@@ -3361,21 +3898,25 @@ module LongMath
     check_is_int(j, "j")
     check_is_int(k, "k")
 
+    # calculate iprec if it is not given.
     if (iprec.nil?) then
       iprec = calc_iprec_for_exp(x, prec, x_was_neg)
     end
     iprec = check_is_prec(iprec, "iprec")
 
-    # we only cache exp(1)
+    # we only cache exp(1), exp(10), exp(100), exp(MAX_EXP_ABLE.to_i), otherwise cache_key is returned as nil.
     cache_key = get_cache_key("exp", x, mode, [1, 10, 100, MAX_EXP_ABLE.to_i])
     y_k = get_cached(cache_key, x, iprec)
 
+    # if the cache did not yield our result, calculate it.
     if (y_k.nil?) then
       y_k = exp_raw(x, prec, j, k, iprec, mode)
 
-      # keep result around for exp(1)
+      # keep result around for exp(1), exp(10), exp(100), exp(MAX_EXP_ABLE.to_i)
       set_cached(cache_key, y_k) if (cache_result)
     end
+
+    # take 1/exp(-x) as result, if x was negative.
     if (x_was_neg)
       y_k = y_k.reciprocal
     end
@@ -3388,25 +3929,48 @@ module LongMath
   # calculation of exp(x) with precision used internally.  Needs to be
   # rounded to be accurate to all digits that are provided.
   #
+  # x is the number of which we want to calculate the exponential function.
+  # prec is the precision that we need to achieve for the final result.
+  # final_mode is the rounding mode that we use for the end result
+  # j number of summands that are grouped together for better performance of the calculation
+  # k is an integer such that calculation of exp(x/2**k) has good convergence.  We calculate that and finally take a power of the result:
+  #   exp(x) = exp(x/2**k)**(2**k)
+  # iprec is the precision used internally during the calculation
+  # mode is the rounding mode used internally
+  # cache_result indicates if the result of the calculation should be cached.
+  #
   def LongMath.exp_raw(x, prec, j, k, iprec, mode)
     dprec = [ (iprec*0.9).round, prec ].max
 
+    # convert to LongDecimal, if necessary:
     unless (x.kind_of? LongDecimal)
       x = x.to_ld(iprec, mode)
     end
 
+    # we use this x_k in the Taylor row:
     x_k = (x / (1 << k)).round_to_scale(iprec, mode)
+    # x_k ** j
     x_j = (x_k ** j).round_to_scale(iprec, mode)
+    # vector with j entries
     s = [ LongDecimal(0) ] * j
     t = LongDecimal(1)
     last_t = 1
     f = 0
+
+    # do the Taylor sum
     loop do
+      # do the partial loop: i=0..j-1
+      # we avoid excessive multiplication with powers of x_k and keep these to the final calculation, thus having to apply them only once for each i.
       j.times do |i|
+        # s[i] = 1 / i! + x_k ** j / (i+j)! + x_k ** (2j) / (i+2*j)! + ...  + x_k ** (n*j) / f!
         s[i] += t
         f += 1
+        # adjust: t = x_k**(n*j)/f!
         t = (t / f).round_to_scale(iprec, mode)
+        break if (t.zero?)
       end
+      # multiply t by x_k**j.  Detect when we can stop, if summands are zero or irrelevant for final result.
+      break if (t.zero?)
       t = (t * x_j).round_to_scale(iprec, mode)
       break if (t.zero?)
       tr = t.round_to_scale(dprec, LongDecimal::ROUND_DOWN).abs
@@ -3415,6 +3979,8 @@ module LongMath
       break if (tr <= tu && last_t <= tu)
       last_t = tr
     end
+
+    # calculate result exp(x_k)
     x_i = 1
     y_k = LongDecimal(0)
     j.times do |i|
@@ -3423,6 +3989,8 @@ module LongMath
       end
       y_k += (s[i] * x_i).round_to_scale(iprec, mode)
     end
+
+    # square exp(x_k) k times to get exp(x):
     k.times do |i|
       y_k = y_k.square.round_to_scale(iprec, mode)
     end
@@ -3430,6 +3998,8 @@ module LongMath
     y_k
   end # exp_raw
 
+  public
+
   #
   # calculate approximation of sqrt of a LongDecimal.
   #
@@ -3476,7 +4046,7 @@ module LongMath
       return y_arr
     else
       y, r = y_arr
-      if ((mode == ROUND_HALF_EVEN || mode == ROUND_HALF_DOWN) && r > 0) then
+      if ((mode == ROUND_HALF_EVEN || mode == ROUND_HALF_ODD || mode == ROUND_HALF_DOWN) && r > 0) then
         mode = ROUND_HALF_UP
       end
       y = y.round_to_scale(prec, mode)
@@ -3544,7 +4114,7 @@ module LongMath
       return y_arr
     else
       y, r = y_arr
-      if ((mode == ROUND_HALF_EVEN || mode == ROUND_HALF_DOWN) && r > 0) then
+      if ((mode == ROUND_HALF_EVEN || mode == ROUND_HALF_ODD || mode == ROUND_HALF_DOWN) && r > 0) then
         mode = ROUND_HALF_UP
       end
       y = y.round_to_scale(prec, mode)
@@ -3699,6 +4269,904 @@ module LongMath
     return y
   end
 
+  #
+  # calculate the base 10 logarithm of x to the given precision as
+  # LongDecimal.
+  #
+  # Warning: this is a transcendental function that aims at producing
+  # results to the given precision, but minor inaccuracies of the
+  # result have to be expected under some circumstances, being off by
+  # one even more often.
+  #
+  def LongMath.log10(x, prec, mode = LongMath.standard_mode) # down?
+
+    prec = check_is_prec(prec, "prec")
+    check_is_mode(mode, "mode")
+    iprec = prec + 6
+    unless (x.kind_of? LongDecimal)
+      x = x.to_ld(iprec, mode)
+    end
+    if (x.one?) then
+      return LongDecimal.zero!(prec)
+    end
+
+    id = x.int_digits10
+    xx = x.move_point_left(id)
+    lnxx = log_internal(xx, iprec, mode)
+    ln10 = log_internal(10, iprec, mode)
+    y  = id + (lnxx / ln10).round_to_scale(prec, mode)
+    return y
+  end
+
+  #
+  # calculate the base 2 logarithm of x to the given precision as
+  # LongDecimal.
+  #
+  # Warning: this is a transcendental function that aims at producing
+  # results to the given precision, but minor inaccuracies of the
+  # result have to be expected under some circumstances, being off by
+  # one even more often.
+  #
+  def LongMath.log2(x, prec, mode = LongMath.standard_mode)
+
+    prec = check_is_prec(prec, "prec")
+    check_is_mode(mode, "mode")
+    iprec = prec + 6
+    unless (x.kind_of? LongDecimal)
+      x = x.to_ld(iprec, mode)
+    end
+    if (x.one?) then
+      return LongDecimal.zero!(prec)
+    end
+    id = x.int_digits2
+    xx = (x / (1 << id)).round_to_scale(x.scale+id)
+    lnxx = log_internal(xx, iprec, mode)
+    ln2  = log_internal(2.to_ld, iprec, mode)
+    y    = id + (lnxx / ln2).round_to_scale(prec, mode)
+    return y
+  end
+
+  #
+  # calculate the natural logarithm of x as floating point number,
+  # even if x cannot reasonably be expressed as Float.
+  #
+  # Warning: this is a transcendental function that aims at producing
+  # results to the given precision, but minor inaccuracies of the
+  # result have to be expected under some circumstances, being off by
+  # one even more often.
+  #
+  def LongMath.log_f(x)
+    raise TypeError, "x=#{x.inspect} must not be positive" unless x > 0
+    unless x.kind_of? LongDecimal
+      x_rounded = x.to_ld(18, LongDecimalRoundingMode::ROUND_HALF_UP)
+      if (x_rounded.one?)
+        # x rounds to 1, if we cut of the last digits?
+        # near 1 the derivative of log(x) is approximately 1, so we can assume log_f(x) ~ x-1
+        return x - 1
+      else
+        x = x_rounded
+      end
+    end
+    y = 0
+    while (x > LongMath::MAX_FLOATABLE)
+      y += LOG_1E100
+      x  = x.move_point_left(100)
+    end
+    while (x < LongMath::MIN_FLOATABLE)
+      y -= LOG_1E100
+      x  = x.move_point_right(100)
+    end
+    x_f = x.to_f
+    y  += Math.log(x_f)
+    y
+  end
+
+  # logarithms of integers to base 2
+  LOGARR = [ nil, \
+           0.0, \
+           1.0, \
+           1.58496250072116, \
+           2.0, \
+           2.32192809488736, \
+           2.58496250072116, \
+           2.8073549220576, \
+           3.0, \
+           3.16992500144231, \
+           3.32192809488736, \
+           3.4594316186373, \
+           3.58496250072116, \
+           3.70043971814109, \
+           3.8073549220576, \
+           3.90689059560852, \
+           4.0, \
+           4.08746284125034, \
+           4.16992500144231, \
+           4.24792751344359, \
+           4.32192809488736, \
+           4.39231742277876, \
+           4.4594316186373, \
+           4.52356195605701, \
+           4.58496250072116, \
+           4.64385618977472, \
+           4.70043971814109, \
+           4.75488750216347, \
+           4.8073549220576, \
+           4.85798099512757, \
+           4.90689059560852, \
+           4.95419631038688, \
+           5.0, \
+           5.04439411935845, \
+           5.08746284125034, \
+           5.12928301694497, \
+           5.16992500144231, \
+           5.20945336562895, \
+           5.24792751344359, \
+           5.28540221886225, \
+           5.32192809488736, \
+           5.35755200461808, \
+           5.39231742277876, \
+           5.4262647547021, \
+           5.4594316186373, \
+           5.49185309632967, \
+           5.52356195605701, \
+           5.55458885167764, \
+           5.58496250072116, \
+           5.61470984411521, \
+           5.64385618977472, \
+           5.6724253419715, \
+           5.70043971814109, \
+           5.7279204545632, \
+           5.75488750216347, \
+           5.78135971352466, \
+           5.8073549220576, \
+           5.83289001416474, \
+           5.85798099512757, \
+           5.88264304936184, \
+           5.90689059560852, \
+           5.93073733756289, \
+           5.95419631038688, \
+           5.97727992349992, \
+           6.0, \
+           6.02236781302845, \
+           6.04439411935845, \
+           6.06608919045777, \
+           6.08746284125034, \
+           6.10852445677817, \
+           6.12928301694497, \
+           6.14974711950468, \
+           6.16992500144231, \
+           6.18982455888002, \
+           6.20945336562895, \
+           6.22881869049588, \
+           6.24792751344359, \
+           6.2667865406949, \
+           6.28540221886225, \
+           6.3037807481771, \
+           6.32192809488736, \
+           6.33985000288463, \
+           6.35755200461808, \
+           6.37503943134693, \
+           6.39231742277876, \
+           6.4093909361377, \
+           6.4262647547021, \
+           6.44294349584873, \
+           6.4594316186373, \
+           6.4757334309664, \
+           6.49185309632967, \
+           6.5077946401987, \
+           6.52356195605701, \
+           6.53915881110803, \
+           6.55458885167764, \
+           6.56985560833095, \
+           6.58496250072116, \
+           6.59991284218713, \
+           6.61470984411521, \
+           6.62935662007961, \
+           6.64385618977473, \
+           6.6582114827518, \
+           6.6724253419715, \
+           6.68650052718322, \
+           6.70043971814109, \
+           6.71424551766612, \
+           6.7279204545632, \
+           6.74146698640115, \
+           6.75488750216347, \
+           6.76818432477693, \
+           6.78135971352466, \
+           6.79441586635011, \
+           6.8073549220576, \
+           6.82017896241519, \
+           6.83289001416474, \
+           6.84549005094438, \
+           6.85798099512757, \
+           6.8703647195834, \
+           6.88264304936184, \
+           6.89481776330794, \
+           6.90689059560852, \
+           6.9188632372746, \
+           6.93073733756289, \
+           6.94251450533924, \
+           6.95419631038688, \
+           6.96578428466209, \
+           6.97727992349992, \
+           6.98868468677217, \
+           7.0, \
+           7.01122725542325, \
+           7.02236781302845, \
+           7.03342300153745, \
+           7.04439411935845, \
+           7.05528243550119, \
+           7.06608919045777, \
+           7.07681559705083, \
+           7.08746284125034, \
+           7.09803208296053, \
+           7.10852445677817, \
+           7.11894107272351, \
+           7.12928301694497, \
+           7.13955135239879, \
+           7.14974711950468, \
+           7.15987133677839, \
+           7.16992500144231, \
+           7.17990909001493, \
+           7.18982455888002, \
+           7.19967234483636, \
+           7.20945336562895, \
+           7.21916852046216, \
+           7.22881869049588, \
+           7.23840473932508, \
+           7.24792751344359, \
+           7.25738784269265, \
+           7.2667865406949, \
+           7.27612440527424, \
+           7.28540221886225, \
+           7.29462074889163, \
+           7.3037807481771, \
+           7.31288295528436, \
+           7.32192809488736, \
+           7.33091687811462, \
+           7.33985000288462, \
+           7.34872815423108, \
+           7.35755200461808, \
+           7.36632221424582, \
+           7.37503943134693, \
+           7.38370429247405, \
+           7.39231742277876, \
+           7.40087943628218, \
+           7.4093909361377, \
+           7.4178525148859, \
+           7.4262647547021, \
+           7.43462822763673, \
+           7.44294349584873, \
+           7.45121111183233, \
+           7.4594316186373, \
+           7.467605550083, \
+           7.4757334309664, \
+           7.48381577726426, \
+           7.49185309632967, \
+           7.49984588708321, \
+           7.5077946401987, \
+           7.51569983828404, \
+           7.52356195605701, \
+           7.53138146051631, \
+           7.53915881110803, \
+           7.54689445988764, \
+           7.55458885167764, \
+           7.56224242422107, \
+           7.56985560833095, \
+           7.57742882803575, \
+           7.58496250072116, \
+           7.59245703726808, \
+           7.59991284218713, \
+           7.60733031374961, \
+           7.61470984411521, \
+           7.62205181945638, \
+           7.62935662007961, \
+           7.63662462054365, \
+           7.64385618977472, \
+           7.65105169117893, \
+           7.6582114827518, \
+           7.66533591718518, \
+           7.6724253419715, \
+           7.67948009950545, \
+           7.68650052718322, \
+           7.69348695749933, \
+           7.70043971814109, \
+           7.70735913208088, \
+           7.71424551766612, \
+           7.72109918870719, \
+           7.7279204545632, \
+           7.73470962022584, \
+           7.74146698640115, \
+           7.74819284958946, \
+           7.75488750216347, \
+           7.76155123244448, \
+           7.76818432477693, \
+           7.77478705960117, \
+           7.78135971352466, \
+           7.78790255939143, \
+           7.79441586635011, \
+           7.8008998999203, \
+           7.8073549220576, \
+           7.81378119121704, \
+           7.82017896241519, \
+           7.82654848729092, \
+           7.83289001416474, \
+           7.83920378809694, \
+           7.84549005094438, \
+           7.85174904141606, \
+           7.85798099512757, \
+           7.86418614465428, \
+           7.8703647195834, \
+           7.876516946565, \
+           7.88264304936184, \
+           7.88874324889826, \
+           7.89481776330794, \
+           7.90086680798075, \
+           7.90689059560852, \
+           7.91288933622996, \
+           7.9188632372746, \
+           7.92481250360578, \
+           7.93073733756289, \
+           7.93663793900257, \
+           7.94251450533924, \
+           7.94836723158468, \
+           7.95419631038688, \
+           7.96000193206808, \
+           7.96578428466209, \
+           7.97154355395077, \
+           7.97727992349992, \
+           7.98299357469431, \
+           7.98868468677217, \
+           7.99435343685886, \
+           8.0 ]
+
+  def LongMath.log2int(x)
+    unless x.kind_of? Integer
+      raise TypeError, "x=#{x.inspect} must be Integer"
+    end
+    if (x <= 0)
+      raise ArgumentError, "x=#{x} < 0"
+    end
+
+    s = x.size
+    l = [ 8 * s - 36 , 0 ].max
+
+    xx = x >> l
+    while xx >= 256
+      l += 1
+      xx = xx >> 1
+    end
+    yy = LOGARR[xx]
+    y = l + yy
+    y
+  end
+
+  #
+  # calc the power of x with exponent y to the given precision as
+  # LongDecimal.  Only supports values of y such that the result still
+  # fits into a float
+  #
+  # Warning: this is a transcendental function that aims at producing
+  # results to the given precision, but minor inaccuracies of the
+  # result have to be expected under some circumstances, being off by
+  # one even more often.
+  #
+  def LongMath.power(x, y, prec, mode = LongMath.standard_mode)
+
+    raise TypeError, "x=#{x} must be numeric" unless x.kind_of? Numeric
+    raise TypeError, "y=#{y} must be numeric" unless y.kind_of? Numeric
+    raise TypeError, "x=#{x.inspect} must not be greater #{MAX_FLOATABLE}" unless x.abs <= MAX_FLOATABLE
+    raise TypeError, "y=#{y.inspect} must not be greater #{MAX_FLOATABLE}" unless y.abs <= MAX_FLOATABLE
+    raise TypeError, "y=#{y.inspect} must not be negative if base is zero}" if y < 0 && x.zero?
+    raise TypeError, "x=#{x.inspect} must not negative" unless x >= 0
+    prec = check_is_prec(prec, "prec")
+    check_is_mode(mode, "mode")
+
+    # handle the special cases where base or exponent are 0 or 1 explicitely
+    if y.zero? then
+      return LongDecimal.one!(prec)
+    elsif x.zero? then
+      return LongDecimal.zero!(prec)
+    elsif y.one? then
+      return x.to_ld(prec, mode)
+    elsif x.one? then
+      return LongDecimal.one!(prec)
+    end
+
+    # could be result with our precision
+    # 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)
+    $stdout.flush
+    if (x < 1 && y > 0 || x > 1 && y < 0) then
+      if (logx_y_f <= - prec * LOG10 - LOG2) then
+        return LongDecimal.zero!(prec)
+      end
+    end
+
+    unless (x.kind_of? LongDecimalBase) || (x.kind_of? Integer)
+      x = x.to_ld(iprec_x, mode)
+    end
+    unless (y.kind_of? LongDecimalBase) || (y.kind_of? Integer)
+      y = y.to_ld(iprec_y, mode)
+    end
+
+    # try shortcut if exponent is an integer
+    if (y.kind_of? LongDecimalBase) && y.is_int? then
+      y = y.to_i
+    end
+    unless (y.kind_of? Integer)
+      y2 = y*2
+      if (y2.kind_of? LongDecimalBase) && y2.is_int? then
+        y2 = y2.to_i
+      end
+      if (y2.kind_of? Integer)
+        x = LongMath.sqrt(x, 2*iprec_x, mode)
+        y = y2
+      end
+    end
+    if (y.kind_of? Integer)
+      unless x.kind_of? LongDecimal
+        x = x.to_ld(iprec_x)
+      end
+      z = LongMath.ipower(x, y, 2*iprec, mode)
+      return z.to_ld(prec, mode)
+    end
+
+    # it can be assumed that the exponent is not an integer, so it should
+    # be converted into LongDecimal
+    unless (y.kind_of? LongDecimal)
+      y = y.to_ld(iprec_y, mode)
+    end
+
+    # if x < 1 && y < 0 then
+    # working with x < 1 should be improved, less precision needed
+    if x < 1 then
+      # since we do not allow x < 0 and we have handled x = 0 already,
+      # we can be sure that x is no integer, so it has been converted
+      # if necessary to LongDecimalBase
+      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)
+      $stdout.flush
+      if (x < 1 && y > 0 || x > 1 && y < 0) then
+        if (logx_y_f <= - prec * LOG10 - LOG2) then
+          return LongDecimal.zero!(prec)
+        end
+      end
+    end
+
+    # exponent is split in two parts, an integer part and a
+    # LongDecimal with absolute value <= 0.5
+    y0 = y.round_to_scale(0, LongMath.standard_imode).to_i
+    x0 = x
+    point_shift = 0
+    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
+    z0 = LongMath.ipower(x0, y0, iprec3, mode)
+    if (point_shift > 0)
+      unless z0.kind_of? LongDecimal
+        z0 = z0.to_ld(2*(iprec + point_shift))
+      end
+      z0 = z0.move_point_right(point_shift * y0)
+    end
+    y1 = y - y0
+    prec_extra = 0
+    if (y0 > 0)
+      prec_extra = (y0*Math.log10(x.to_f).abs).ceil
+    end
+    # z1 = LongMath.power_internal(x, y1, prec+prec_extra , mode)
+    z1 = LongMath.power_internal(x, y1, prec+prec_extra + 4, mode)
+    z  = z0 * z1
+    return z.to_ld(prec, mode)
+  end
+
+  #
+  # internal functionality to calculate the y-th power of x assuming
+  # that y is an integer
+  # prec is a hint on how much internal precision is needed at most
+  # final rounding is left to the caller
+  #
+  def LongMath.ipower(x, y, prec, mode)
+
+    t0 = Time.now
+    raise TypeError, "base x=#{x} must be numeric" unless x.kind_of? Numeric
+    raise TypeError, "exponent y=#{y} must be integer" unless y.kind_of? Integer
+    raise TypeError, "base x=#{x.inspect} must not be greater MAX_FLOATABLE=#{MAX_FLOATABLE}" unless x.abs <= MAX_FLOATABLE
+    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")
+
+    if (y.zero?)
+      return 1
+    elsif ! (x.kind_of? LongDecimalBase) || x.scale * y.abs <= prec
+      return x ** y
+    elsif (y < 0)
+      l = Math.log10(x.abs.to_f)
+      if (l > 0)
+        prec += (2*l).ceil
+      end
+      # return (1/LongMath.ipower(x, -y, prec + 2, mode)).round_to_scale(prec, mode)
+      xi = 1/x
+      xr = xi.round_to_scale(prec + 6, mode)
+      return LongMath.ipower(xr, -y, prec, mode)
+    else
+      # y > 0
+      cnt = 0
+      z  = x
+      y0 = y
+      x0 = x
+      while true do
+
+        cnt++
+        y -= 1
+        if (y.zero?)
+          break
+        end
+        while (y & 0x01) == 0 do
+
+          cnt++
+          y = y >> 1
+          x = (x*x)
+          if (x.kind_of? LongDecimalBase)
+            x = x.round_to_scale(prec+4, mode)
+          end
+          if (cnt > 1000)
+            cnt = 0
+          end
+
+        end
+        z *= x
+        if (z.kind_of? LongDecimalBase)
+          z = z.round_to_scale(prec+3, mode)
+          if (z.zero?)
+            break
+          end
+        end
+      end
+      z = z.round_to_scale(prec, mode)
+      return z
+    end
+  end
+
+  #
+  # internal functionality of exp.  exposes some more parameters, that
+  # should usually be set to defaut values, in order to allow better testing.
+  # do not actually call this method unless you are testing exp.
+  # create a bug report, if the default settings for the parameters do
+  # not work correctly
+  #
+  def LongMath.power_internal(x, y, prec = nil, final_mode = LongMath.standard_mode, iprec = nil, mode = LongMath.standard_imode)
+
+    if (prec.nil?) then
+      if (x.kind_of? LongDecimalBase) && (y.kind_of? LongDecimalBase)
+        prec = [x.scale, y.scale].max
+      elsif (x.kind_of? LongDecimalBase)
+        prec = x.scale
+      elsif (y.kind_of? LongDecimalBase)
+        prec = y.scale
+      else
+        raise ArgumentError, "precision must be supplied either as precision of x=#{x} or explicitely"
+      end
+    end
+    prec = check_is_prec(prec, "prec")
+
+    if (final_mode.nil?)
+      final_mode = LongMath.standard_mode
+    end
+    check_is_mode(final_mode, "final_mode")
+    check_is_mode(mode, "mode")
+
+    if y.zero? then
+      return LongDecimal.one!(prec)
+    elsif x.zero? then
+      return LongDecimal.zero!(prec)
+    end
+
+    if (iprec.nil?) then
+      iprec, iprec_x, iprec_y = calc_iprec_for_power(x, y, prec)
+    end
+    unless (x.kind_of? LongDecimal)
+      # x = x.to_ld(iprec, mode)
+      x = x.to_ld(iprec_x, mode)
+    end
+    unless (y.kind_of? LongDecimal)
+      # y = y.to_ld(iprec, mode)
+      y = y.to_ld(iprec_y, mode)
+    end
+
+    # logx = log(x, iprec, mode)
+    logx = log(x, iprec + 20, mode)
+    logx_y = logx*y
+    # xy = exp_internal(logx_y, prec + 1, mode)
+    # xy = exp_internal(logx_y, prec + 4, mode)
+    xy = exp_internal(logx_y, prec + 3, mode)
+    xy.round_to_scale(prec, final_mode)
+
+  end # power_internal
+
+  # helper for means
+  def LongMath.sign_check_for_mean(allow_different_signs, *args)
+    if (args.empty?)
+      raise ArgumentError, "cannot calculate mean of empty array"
+    end
+    first = args[0]
+    has_neg = false
+    has_pos = false
+    has_zero = false
+    all_same = true
+    result_sign = 0
+    args.each do |x|
+      if (! (x.kind_of? Numeric))
+        raise ArgumentError, "cannot calculate mean of a non-numeric array #{args.inspect}"
+      end
+      if (x.kind_of? Complex)
+        raise ArgumentError, "mean not supported for complex numbers args=#{args.inspect}"
+      end
+      if (all_same && x != first)
+        all_same = false
+      end
+      sign = x.sgn
+      if (sign < 0)
+        has_neg = true
+        result_sign = sign
+      elsif (sign > 0)
+        has_pos = true
+        result_sign = sign
+      else
+        has_zero = true
+      end
+      if (has_neg && has_pos && !allow_different_signs)
+        raise ArgumentError, "signs of parameters have to match for quadratic mean args=#{args.inspect}"
+      end
+    end
+    return result_sign, all_same, has_neg, has_zero, has_pos
+  end
+
+  public
+
+  # arithmetic mean
+  def LongMath.arithmetic_mean(new_scale, rounding_mode, *args)
+    if (args.empty?)
+      raise ArgumentError, "cannot calculate average of empty array"
+    end
+    sum = args.inject(0) do |psum,x|
+      psum + x
+    end
+    raw_result = if (sum.kind_of? Integer)
+        Rational(sum, args.size)
+    else
+        sum / args.size
+    end
+    result = raw_result.to_ld(new_scale, rounding_mode)
+    return result
+  end
+
+  class << LongMath
+    alias_method :average, :arithmetic_mean
+  end
+
+  # geometric mean
+  def LongMath.geometric_mean(new_scale, rounding_mode, *args)
+    result_sign, all_same, has_neg, has_zero, has_pos = sign_check_for_mean(true, *args)
+    if (all_same)
+      return args[0].to_ld(new_scale, rounding_mode)
+    end
+    if (has_zero)
+      return LongDecimal.zero!(new_scale)
+    end
+    prod = args.inject(1) do |pprod,x|
+      pprod * x.abs
+    end
+    result = nil
+    n = args.size
+    if (n == 0 || n == 1)
+      result = prod.to_ld(new_scale, rounding_mode)
+    elsif (n == 2)
+      result = LongMath.sqrt(prod, new_scale, rounding_mode)
+    elsif (n == 3)
+      result = LongMath.cbrt(prod, new_scale, rounding_mode)
+    else
+      result = LongMath.power(prod, Rational(1, args.size), new_scale, rounding_mode)
+    end
+    if (has_neg)
+      result = -result
+    end
+    return result
+  end
+
+  # harmonic mean
+  def LongMath.harmonic_mean(new_scale, rounding_mode, *args)
+    result_sign, all_same, has_neg, has_zero, has_pos = sign_check_for_mean(true, *args)
+    if (all_same)
+      return args[0].to_ld(new_scale, rounding_mode)
+    end
+    if (has_zero)
+      raise ArgumentError, "cannot calculate harmonic mean of argument list containing zero #{args.inspect}"
+    end
+    sum = args.inject(0) do |psum, x|
+      psum + if (x.kind_of? Integer)
+               Rational(1, x)
+             else
+               1/x
+             end
+    end
+    raw_result = args.size / sum
+    result = raw_result.to_ld(new_scale, rounding_mode)
+    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)
+    if (all_same)
+      return args[0].to_ld(new_scale, rounding_mode)
+    end
+    prec = (new_scale * 1.1 + 20).to_i
+    x = arithmetic_mean(prec, rounding_mode, *args)
+    y = geometric_mean(prec, rounding_mode, *args)
+    delta = 3*x.unit
+    while ((x-y).abs >= delta)
+      xn = arithmetic_mean(prec, rounding_mode, x, y)
+      yn = geometric_mean(prec, rounding_mode, x, y)
+      x = xn
+      y = yn
+    end
+    return x.round_to_scale(new_scale, rounding_mode)
+  end
+
+  # harmonic-geometric mean (HGM)
+  def LongMath.harmonic_geometric_mean(new_scale, rounding_mode, *args)
+    result_sign, all_same, has_neg, has_zero, has_pos = sign_check_for_mean(true, *args)
+    if (all_same)
+      return args[0].to_ld(new_scale, rounding_mode)
+    end
+    prec = (new_scale * 1.1 + 20).to_i
+    x = harmonic_mean(prec, rounding_mode, *args)
+    y = geometric_mean(prec, rounding_mode, *args)
+    delta = 3*x.unit
+    while ((x-y).abs >= delta)
+      xn = harmonic_mean(prec, rounding_mode, x, y)
+      yn = geometric_mean(prec, rounding_mode, x, y)
+      x = xn
+      y = yn
+    end
+    return x.round_to_scale(new_scale, rounding_mode)
+  end
+
+  # quadratic mean
+  def LongMath.quadratic_mean(new_scale, rounding_mode, *args)
+    result_sign, all_same, has_neg, has_zero, has_pos = sign_check_for_mean(true, *args)
+    if (all_same)
+      return args[0].to_ld(new_scale, rounding_mode)
+    end
+    sum = args.inject(0) do |psum, x|
+      psum + x*x
+    end
+    quot = if (sum.kind_of? Integer)
+             Rational(sum, args.size)
+           else
+             sum / args.size
+           end
+    result = LongMath.sqrt(quot, new_scale, rounding_mode)
+    if (has_neg)
+      result = -result
+    end
+    return result
+  end
+
+  # cubic mean
+  def LongMath.cubic_mean(new_scale, rounding_mode, *args)
+    result_sign, all_same, has_neg, has_zero, has_pos = sign_check_for_mean(false, *args)
+    if (all_same)
+      return args[0].to_ld(new_scale, rounding_mode)
+    end
+    sum = args.inject(0) 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
+    end
+    quot = if (sum.kind_of? Integer)
+             Rational(sum, args.size)
+           else
+             sum / args.size
+           end
+    result = LongMath.cbrt(quot, new_scale, rounding_mode)
+    return result
+  end
+
+  private
+
+  # helper class for round_sum
+  class RawElement
+    include LongDecimalRoundingMode
+
+    def initialize(element, new_scale, rounding_mode=ROUND_FLOOR)
+      @element = element
+      @rounded = element.to_ld(new_scale, rounding_mode)
+      @delta   = @element-@rounded
+    end
+
+    def add(epsilon)
+      @rounded += epsilon
+    end
+
+    attr_reader :element, :rounded, :delta
+
+    def <=>(other)
+      delta <=> other.delta
+    end
+  end
+
+  public
+
+  # round elements in such a way that round(new_scale, rounding_mode_sum, sum(elements)) = sum(elements_rounded)
+  # HAARE_NIEMEYER
+  def LongMath.round_sum_hm(new_scale, rounding_mode_sum, *elements)
+    if (elements.empty?)
+      return elements
+    end
+    raw_sum = elements.inject(0) do |psum,x|
+      psum + x
+    end
+    sum = raw_sum.to_ld(new_scale, rounding_mode_sum)
+    raw_elements = elements.map do |element|
+      RawElement.new(element, new_scale)
+    end
+    raw_elements_sum = raw_elements.inject(0) do |psum, element|
+      psum + element.rounded
+    end
+    delta = sum - raw_elements_sum
+    epsilon = LongDecimal(1, new_scale)
+    raw_elements_sorted = raw_elements.sort.reverse
+    n = (delta / epsilon).to_ld(0, ROUND_HALF_EVEN).to_i
+    puts "delta=#{delta} epsilon=#{epsilon} n=#{n} sum=#{sum} raw_sum=#{raw_sum}"
+    n.times do |i|
+      raw_elements_sorted[i].add(epsilon)
+    end
+    result = raw_elements.map do |x|
+      x.rounded
+    end
+  end
+
+  # round elements in such a way that round(new_scale, rounding_mode, sum(elements)) = sum(elements_rounded)
+  # where rounding_mode_set is
+  def LongMath.round_sum_divisor(new_scale, rounding_mode_sum, rounding_mode_set, *elements)
+    if (elements.empty?)
+      return elements
+    end
+    delta = -1
+    raw_sum = elements.inject(0) do |psum,x|
+      psum + x
+    end
+    sum = raw_sum.to_ld(new_scale, rounding_mode_sum)
+    raw_elements = elements.map do |element|
+      RawElement.new(element, new_scale, rounding_mode_set)
+    end
+    while (true)
+      raw_elements_sum = raw_elements.inject(0) do |psum, element|
+        psum + element.rounded
+      end
+      delta = sum - raw_elements_sum
+      if (delta == 0)
+        break
+      end
+      factor = (1 + delta/raw_elements_sum)
+      puts("delta=#{delta} raw_elements_sum=#{raw_elements_sum} factor=#{factor}")
+      raw_elements = raw_elements.map do |element|
+        RawElement.new(element.element * factor, new_scale, rounding_mode_set)
+      end
+    end
+    result = raw_elements.map do |x|
+      x.rounded
+    end
+  end
+
   @@standard_mode = ROUND_HALF_UP
 
   # default to be used as rounding mode when no explicit mode is provided