long-decimal 0.01.03 → 0.02.01

data/README

@@ -1,32 +1,25 @@
 Version
 -------
 
-This version ($Name: ALPHA_01_03 $) is functionally mostly identical with the
-previous alpha-0.01.02.  Support for rounding to any given set of last
-digits, for example allowing only 0 and 5 as last digit, has been
-added and tests for this kind of functionality are considered to be
-complete.  This functionality is useful for rounding patterns within
-currencies where the smallest unit is 0.05, not 0.01, like CHF.  In
-this case, remainders 0 and 5 modulo 10 are required.  For currencies
-where the smallest unit is 0.02, it would be 0, 2, 4, 8 modulo 10.
-But this has been implemented in a more general way, so it would also
-be possible to restrict the rounding results to any set modulo any
-integral number >= 2.
-
-Extensive testing has shown that apart from this new functionality
-there seems to be an issue when calculating powers of LongDecimal
-where the base is slightly less than 1 and the exponent is a big
-positive number.  In some cases where this should result in 0, the
-calculations seem to take time forever.  This issue should not stop
-long-decimal from becoming beta, so its solution will be postponed and
-it will be resolved temporarily by moving it to a different library.
-Ideas how to solve these issues are there, so eventually this
-power-functionality will be working even for these cases.
-
-All other functionality did not show any bugs during intensive
+This version ($Name: BETA_02_01 $) is similar to the previous alpha-0.01.03.
+
+Improvements over the previous version:
+
+- full support for JRuby
+- workaround for a bug in JRuby's Fixnum-multiplication, which has
+  been fixed for the next JRuby-version, but not for the existing installed base.
+- calculation of powers with exponents having huge magnitude and with
+  bases close to 1 works better now.
+- new method initialize_copy needed for clone()
+- new method cbrt (cubic root)
+- improved to_f which works better near Float::MAX
+- new Method LongMath.log_f to obtain a Float-Approximation of the log
+  of a LongDecimal
+- more and improved runit-Tests
+
+All this functionality did not show any bugs during intensive
 testing, so it could be assumed that the whole library is good for
-beta and maybe even production/stable, apart from the issues
-mentioned above, which are being separated into another library.
+beta and possibly even quite soon for production/stable.
 
 This software development effort is hosted on RubyForge (
 http://rubyforge.org/ ) under the project name "long-decimal", to be
@@ -34,15 +27,15 @@ found directly with http://rubyforge.org/projects/long-decimal/ .  So
 you should feel encouraged to look if there is a newer version, when
 you install long-decimal.
 
-This version is an alpha-version, which might also be called
-"pre-beta".  Operations +, -, *, / and sqrt should be working properly
-and would justify calling this release at least beta.  Even log and exp
-should be fine.  log, log2, log10 and exp have been tested
-for more than a million random values and the current version should
-cover all of these correctly.  But it is still possible, that in some
-cases the result deviates in the last digit by 1 or 2 from the real
-result.  A deviation of slightly more than half of the unit of the
-last digit is already present.  Improving on this would require an
+This version is an beta-version.
+Operations +, -, *, / and sqrt should be working properly
+and could probably justify calling this release production/stable.
+Even log and exp should be fine.  log, log2, log10 and exp have been
+tested for several million random values and the current version
+should cover all of these correctly.  But it is still possible, that
+in some cases the result deviates in the last digit by 1 or 2 from the
+required result.  A deviation of slightly more than half of the unit of
+the last digit is already present.  Improving on this would require an
 extensive extension of internal functionality to provide rounding
 information in case of last digits being 50000..., where additional
 digits would reveal if this really needs to be rounded up or down.
@@ -52,8 +45,28 @@ Speed could be improved as well.
 
 It would be a good idea to do some more mathematical analysis on how
 many digits are needed internally to guarantee the correctness of the
-digits that are provided.  But this will not be considered as a
-requirement for the beta-version.
+digits that are provided.  But this will not be considered a
+requirement for the next versions to come.
+
+A unique feature of long-decimal is the method
+round_to_allowed_remainders().  This can be used for financial
+calculations, where the last digit is required to be 0 or 5, which can
+be achieved by calling
+l.round_to_allowed_remainders([0, 5], 10, LongDecimalRoundingMode::ROUND_HALF_UP)
+But this has been defined and developed in a more generic way, so the
+modulus (here 10) and the set of allowed digits can be chosen
+abritrarily, in which case the integral number, that is obtained by
+disregarding the decimal point, is rounded in such a way that its
+remainder modulo the modulus is in the list of allowed remainders,
+after which the decimal point is inserted again.
+
+Usage
+-----
+
+require 'rubygems'
+require 'long-decimal'
+
+(then use it.)
 
 Test
 ----
@@ -67,30 +80,72 @@ correctly.  The set of tests that is available now is considered to be
 complete.  As a policy a release is not created unless all tests
 succeed.  Running all tests can take a few minutes or even hours,
 depending on your machine.  Whatever is gained by making the software
-run faster is used up again by adding more tests.  This is the result
-of the test:
+run faster is used up again by adding more tests.  The regular tests are run by
+
+ruby test/testlongdecimal.rb
 
-Finished in 1160.808707 seconds.
+This is the result of the test:
 
-131 tests, 45612 assertions, 0 failures, 0 errors
+Finished in 5174.187655 seconds.
+134 tests, 9461909 assertions, 0 failures, 0 errors
 
 In addition random tests for exp, exp2, exp10, sqrt, log, log2 and
-log10 can be run for a long time, using the script test/testrandom.rb.
-Likewise tests for powers x to the yth with random x and y can be
-tested for a long time using test/testrandpower.rb
-
-These two require installation of the ruby-library crypt-isaac for its
-random numbers, which works well with Linux or Windows and Cygwin.  If
-you actually want to run this and find an error with it, please report
-it with the lines of output revealing the bug on
+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
+
+ruby test/testlongdecimal-extra.rb
+
+and its random tests 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
+
+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
+
+ruby test/testrandpower.rb
+
+These random tests require installation of the ruby-library
+crypt-isaac for its random numbers, which works well with Linux or
+Windows in combination with Cygwin.  Installation of crypt-isaac is
+slightly special.  You have to download the gem, then install it using
+gem install:
+
+$ cd /tmp
+$ wget http://rubyforge.org/frs/download.php/6461/crypt-isaac_0.9.1.gem
+$ su -l
+# cd /tmp
+# gem install ruby-isaac
+(you may need to adjust the URL for downloading the gem)
+
+ .... and then go into the directory, where the gem is
+ (/usr/local/lib/ruby/gems/1.8/gems/Crypt::ISAAC-0.9.1/ or
+ /usr/lib/ruby/gems/1.8/gems/Crypt::ISAAC-0.9.1/ or ...)
+
+# cd /usr/local/lib/ruby/gems/1.8/gems/Crypt::ISAAC-0.9.1/
+# ruby setup.rb install
+# exit
+$
+
+If you actually want to run tests for long-decimal or
+long-decimal-extra and find an error with it, please report it with
+the lines of output revealing the bug on
 http://rubyforge.org/projects/long-decimal/ -> tracker
 
 Install
 -------
 
 (REMARK: installation has only been successfully tested on Linux with
-ruby 1.8.4 and on Windows XP with Cygwin and ruby 1.8.4 and on Windows
-2000 with ruby 1.8.2)
+ruby 1.8.7 and on Windows 2000 with Cygwin and on Windows 2000 with
+native ruby)
 
 1. Using ruby-gems (preferred)
 - open a shell window
@@ -121,7 +176,7 @@ ruby 1.8.4 and on Windows XP with Cygwin and ruby 1.8.4 and on Windows
         $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.00.20/rdoc/index.html
+  /usr/local/lib/ruby/gems/1.8/doc/long-decimal-0.02.01/rdoc/index.html
 
 2. Installing from the sources (it is preferred to use the
    gem-installation, but since long-decimal is open-source-software you
@@ -135,7 +190,7 @@ ruby 1.8.4 and on Windows XP with Cygwin and ruby 1.8.4 and on Windows
 - 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-alpha-1_00.tar.gz
+  tar xfzvv long-decimal-beta-1_00.tar.gz
   cd long-decimal
 - now you can use rake for several operations
   - rake test
@@ -154,61 +209,62 @@ in the gem-file.  It is not provided as a separate file any more.
 Bugs
 ----
 
-Calculations of the kind
-0.99999999999 ** 12423153125316415423512345234
-that are performed using LongMath.power tend to take forever, if the
-exponent is really big.
-
-Method round_to_allowed_remainders() of LongDecimal has not been
-tested enough.
-
 It is considered somewhat arbitrary to disallow calculation
 exponential functions if the result could not be expressed as Float.
 This limitation should be removed, even though it has to be added,
-that results of exponentiation that go beyond Float can only be handled
-at a great cost of performance, because they really need more than 300
-digits.
+that results of exponentiation that go beyond Float can only be
+handled with quite significant calculation effort, because they really
+need more than 300 digits.
 
 Certain calculations are too slow.  Algorithms need to be optimized
 for speed.  The goal is to keep the algorithms in Ruby-code as long as
 possible to make it easier to optimize the algorithm.  If optimization
 beyond this level will be needed, C-code might be used, preferably
-based on an existing library.
+based on an existing library.  Since long-decimal is intending to
+provide full support for JRuby as well, equivalent implementations in
+Ruby or Java must be included for libraries written in C.
 
 Even though some mathematical background has already been invested,
-more effort from the theoretical side is needed in order to choose
-internal precision parameters in such a way that correctness of the
-result to all given digits can be guaranteed with a minimum of
+more effort from the theoretical side could be useful in order to
+choose internal precision parameters in such a way that correctness of
+the result to all given digits can be guaranteed with a minimum of
 overhead.  Currently parameters are probably slightly too careful,
 which slows calculations down.  But it is also possible that they are
-insufficient for certain calculations, yielding wrong results.
+insufficient for certain calculations, yielding slightly wrong results
+in some very rare situations, "wrong" meaning a deviation of a low
+multiple of the unit.
 
 rdoc-documentation and in-code comments are somewhat complete, but for
 a sophisticated library like this additional external documentation
-should be provided.  Currently this does not exist at all.
+should be provided in the long term.  Currently this does not exist at
+all.
 
 Please report any bugs you come across on
 http://rubyforge.org/projects/long-decimal -> Tracker.
 
-The status of long-decimal is considered to be alpha.
+The status of long-decimal is considered to be beta.
 
 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-2009
 
 Warranty
 --------
 
-This is a alpha-version.  Do not expect too much!  This is work in
-progress!  I do not take any responsibility.  Please use it as it is,
-change it according to the terms of the license or wait for a more
-stable version (for which I can't take any warranty either...)
+This is a beta-version.  Tests indicate that most functions work
+relyably in all situations and all functions work relyably in most
+situations.  But do not expect too much!  This is work in progress!  I
+do not take any responsibility.  Please use it as it is, change it
+according to the terms of the license or wait for a more stable
+version (for which I can't take any warranty either...)
 
 Author
 ------
 
 Karl Brodowsky
+IT Sky Consulting GmbH
 http://www.velofahren.de/cgi-bin/mailform.cgi
 (no direct mail address because I do not like spam)

data/Rakefile

@@ -1,8 +1,10 @@
 #
 # Rakefile for long-decimal project
 #
-# CVS-ID:    $Header: /var/cvs/long-decimal/long-decimal/Rakefile,v 1.3 2006/04/01 08:52:06 bk1 Exp $
-# CVS-Label: $Name: ALPHA_01_03 $
+# (C) Karl Brodowsky (IT Sky Consulting GmbH) 2006-2009
+#
+# CVS-ID:    $Header: /var/cvs/long-decimal/long-decimal/Rakefile,v 1.4 2009/04/15 19:29:37 bk1 Exp $
+# CVS-Label: $Name: BETA_02_01 $
 # Author:    $Author: bk1 $ (Karl Brodowsky)
 #
 

data/VERSION

@@ -1 +1 @@
-0.01.03
+0.02.01

data/install.rb

@@ -1,5 +1,11 @@
 #!/usr/bin/env ruby
 
+#
+# CVS-ID:    $Header: /var/cvs/long-decimal/long-decimal/install.rb,v 1.3 2009/04/15 19:29:37 bk1 Exp $
+# CVS-Label: $Name: BETA_02_01 $
+# Author:    $Author: bk1 $ (Karl Brodowsky)
+#
+
 require 'rbconfig'
 require 'fileutils'
 include FileUtils::Verbose

data/lib/long-decimal-extra.rb

@@ -1,8 +1,10 @@
 #
 # long-decimal-extra.rb -- Arbitrary precision decimals with fixed decimal point
 #
-# CVS-ID:    $Header: /var/cvs/long-decimal/long-decimal/lib/long-decimal-extra.rb,v 1.1 2007/08/19 19:23:33 bk1 Exp $
-# CVS-Label: $Name: ALPHA_01_03 $
+# (C) Karl Brodowsky (IT Sky Consulting GmbH) 2006-2009
+#
+# CVS-ID:    $Header: /var/cvs/long-decimal/long-decimal/lib/long-decimal-extra.rb,v 1.9 2009/04/21 16:56:49 bk1 Exp $
+# CVS-Label: $Name: BETA_02_01 $
 # Author:    $Author: bk1 $ (Karl Brodowsky)
 #
 require "complex"
@@ -13,6 +15,106 @@ require "bigdecimal"
 
 # require "bigdecimal/math"
 
+class Rational
+  alias :to_g :to_f
+
+  FLOAT_MAX_I = Float::MAX.to_i
+
+  def to_f
+    numerator   = @numerator
+    denominator = @denominator
+    sign        = numerator <=> 0
+    if (sign.zero?)
+      return 0.0
+    elsif sign < 0
+      numerator = -numerator
+    end
+    while numerator >= FLOAT_MAX_I || denominator >= FLOAT_MAX_I do
+      numerator   >>= 8
+      denominator >>= 8
+      if (denominator == 0)
+        raise ZeroDivisionError, "denominator too close to zero: #{@numerator}/{@denominator}"
+      elsif numerator == 0
+        return 0.0
+      end
+    end
+    return numerator.to_f / denominator.to_f
+  end
+end
+
+class LongDecimal
+
+  #
+  # convert self into Float
+  # this works straitforward by dividing numerator by power of 10 in
+  # float-arithmetic, in all cases where numerator and denominator are
+  # within the ranges expressable as Floats.  Goes via string
+  # representation otherwise.
+  #
+  def to_g
+    # handle overflow: raise exception
+    if (self.abs > LongMath::MAX_FLOATABLE) then
+      raise ArgumentError, "self=#{self.inspect} cannot be expressed as Float"
+    end
+
+    # handle underflow: return 0.0
+    if (self.abs < LongMath::MIN_FLOATABLE) then
+      puts "-> 0.0"
+      return 0.0
+    end
+
+    if (self < 0) then
+      puts "-> negate"
+      return -(-self).to_g
+    end
+
+    dividend = numerator
+    divisor  = denominator
+
+    if (divisor == 1) then
+      puts "-> /1"
+      return dividend.to_f
+    elsif dividend.abs <= LongMath::MAX_FLOATABLE then
+      puts "-> dividend <= MAX_FLOATABLE"
+      if (divisor.abs > LongMath::MAX_FLOATABLE) then
+        puts "-> divisor > MAX_FLOATABLE"
+        qe = scale - Float::MAX_10_EXP
+        q  = 10**qe
+        puts "-> q=#{q}"
+        f = (dividend / q).to_f
+        puts "-> f=#{f}"
+        d = LongMath::MAX_FLOATABLE10
+        puts "-> d=#{d}"
+        y = f / d
+        puts "-> y=#{y}"
+        return y
+      else
+        puts "-> divisor <= MAX_FLOATABLE"
+        f = dividend.to_f
+        return f / divisor
+      end
+    elsif dividend.abs < divisor
+      puts "-> < 1"
+      # self is between -1 and 1
+
+      # factor = dividend.abs.div(LongMath::MAX_FLOATABLE)
+      # digits = factor.to_ld.int_digits10
+      # return LongDecimal(dividend.div(10**digits), scale -digits).to_f
+      return self.to_s.to_f
+    else
+      puts "-> >= 1"
+      q = dividend.abs / divisor
+      if (q.abs > 1000000000000000000000)
+        puts "-> > 1000000000000000000000"
+        return q.to_f
+      else
+        puts "-> <= 1000000000000000000000"
+        return self.to_s.to_f
+      end
+    end
+  end
+end
+
 #
 # LongMath provides some helper functions to support LongDecimal and
 # LongDecimalQuot, mostly operating on integers.  They are used
@@ -91,29 +193,50 @@ module LongMath
     return y
   end
 
+
+  #
+  # calculate the natural logarithm of x as floating point number,
+  # even if x cannot reasonably be expressed as Float.
+  #
+  def LongMath.log_f(x)
+    raise TypeError, "x=#{x.inspect} must not be positive" unless x > 0
+    unless x.kind_of? LongDecimal
+      x = x.to_ld(18, LongDecimalRoundingMode::ROUND_HALF_UP)
+    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
+
   private
 
+  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 = nil
-    if (x.abs <= LongMath::MAX_FLOATABLE)
-      x_f    = x.to_f
-      logx_f = Math.log(x_f.abs)
-    else
-      logx_f = LongMath.log(x, 15, LongMath::ROUND_UP)
-    end
+    logx_f = LongMath.log_f(x.abs)
 
     y_f = nil
     if (y.abs <= LongMath::MAX_FLOATABLE) then
       y_f = y.to_f
     else
-      y_f = y.round_to_scale(15, LongMath::ROUND_UP)
+      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
@@ -126,21 +249,9 @@ module LongMath
       iprec_x -= (logx_f/LOG10).round
     end
     if (y_f.abs < 1)
-      logy_f = nil
-      if (y_f.kind_of? Float) then
-        logy_f = Math.log(y_f.abs)
-      else
-        logy_f = LongMath.log(y_f.abs, 15, LongMath::ROUND_UP)
-        if (logy_f.abs > LongMath::MAX_FLOATABLE) then
-          raise ArgumentError, "exponent would be way too big: y=#{y} logy_f=#{logy_f}";
-        end
-        logy_f = logy_f.to_f
-      end
-      # puts("x=#{x} y=#{y} x_f=#{x_f} y_f=#{y_f} logx_f=#{logx_f} logy_f=#{logy_f} logx_y_f=#{logx_y_f}\n")
+      logy_f = LongMath.log_f(y.abs)
       iprec_y -= (logy_f/LOG10).round
     end
-    # puts("x=#{x} y=#{y} x_f=#{x_f} y_f=#{y_f} logx_f=#{logx_f} logy_f=#{logy_f} logx_y_f=#{logx_y_f}\n")
-    # puts("\niprec: x=#{x} y=#{y} iprec=#{iprec} iprec_x=#{iprec_x} iprec_y=#{iprec_y}\n")
     [ iprec, iprec_x, iprec_y, logx_y_f ]
 
   end
@@ -149,8 +260,8 @@ module LongMath
 
   #
   # calc the power of x with exponent y to the given precision as
-  # LongDecimal.  Only supports values of y such that exp(y) still
-  # fits into a float (y <= 709)
+  # LongDecimal.  Only supports values of y such that the result still
+  # fits into a float
   #
   def LongMath.power(x, y, prec, mode = LongMath.standard_mode)
 
@@ -158,8 +269,7 @@ module LongMath
     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 greater #{MAX_EXP_ABLE}" unless y <= MAX_EXP_ABLE
-    # raise TypeError, "x=#{x.inspect} must not negative" unless x >= 0 || (y.kind_of? Integer) || (y.kind_of? LongDecimalBase) && y.is_int?
+    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
     check_is_prec(prec, "prec")
     check_is_mode(mode, "mode")
@@ -175,17 +285,18 @@ module LongMath
       return LongDecimal.one!(prec)
     end
 
-    # els
     # 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)
+    # 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
     end
-    # puts("x=#{x} y=#{y} iprec=#{iprec} iprec_x=#{iprec_x} iprec_y=#{iprec_y} prec=#{prec}")
 
     unless (x.kind_of? LongDecimalBase) || (x.kind_of? Integer)
       x = x.to_ld(iprec_x, mode)
@@ -202,7 +313,6 @@ module LongMath
       y2 = y*2
       if (y2.kind_of? LongDecimalBase) && y2.is_int? then
         y2 = y2.to_i
-        puts("y2=#{y2}")
       end
       if (y2.kind_of? Integer)
         x = LongMath.sqrt(x, 2*iprec_x, mode)
@@ -211,19 +321,15 @@ module LongMath
     end
     if (y.kind_of? Integer)
       unless x.kind_of? LongDecimal
-        # x = x.to_ld(prec)
         x = x.to_ld(iprec_x)
       end
-      # z = x ** y
       z = LongMath.ipower(x, y, 2*iprec, mode)
-      # puts("x=#{x} y=#{y} z=#{z} y int")
       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(prec, mode)
       y = y.to_ld(iprec_y, mode)
     end
 
@@ -235,14 +341,33 @@ module LongMath
       # if necessary to LongDecimalBase
       y = -y
       x = (1/x).round_to_scale(iprec_x*2, mode)
-      iprec, iprec_x, iprec_y = calc_iprec_for_power(x, y, prec)
+      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
+      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
-    # z0 = x**y0
-    z0 = LongMath.ipower(x, y0, 2*iprec, mode)
+    x0 = x
+    point_shift = 0
+    while x0 > LongMath::MAX_FLOATABLE
+      x0 = x0.move_point_left(100)
+      point_shift += 100
+    end
+    z0 = LongMath.ipower(x0, y0, 2*(iprec + point_shift), 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)
@@ -263,14 +388,84 @@ module LongMath
   #
   def LongMath.ipower(x, y, prec, mode)
 
-    raise TypeError, "x=#{x} must be numeric" unless x.kind_of? Numeric
-    raise TypeError, "y=#{y} must be integer" unless y.kind_of? Integer
-    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
+    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
     check_is_prec(prec, "prec")
     check_is_mode(mode, "mode")
 
-    cnt = 0
+    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)
+      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
+      # 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
+      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)
+            puts("ipower x=#{x} y=#{y} cnt=#{cnt} z=#{z} t=#{Time.now - t0}")
+            cnt = 0
+          end
+
+        end
+        z = (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 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_with_measurement(x, y, prec, mode)
+
+    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
+    check_is_prec(prec, "prec")
+    check_is_mode(mode, "mode")
 
     if (y.zero?)
       return 1
@@ -284,8 +479,10 @@ module LongMath
       return 1/LongMath.ipower(x, -y, prec, mode)
     else
       # y > 0
-      # puts("ipower y>0 x=#{x} y=#{y} prec=#{prec}")
+      cnt = 0
       z  = x
+      y0 = y
+      x0 = x
       while true do
 
         cnt++
@@ -313,8 +510,8 @@ module LongMath
         end
 
       end
+      return z
     end
-    return z
   end
 
   #