long-decimal 0.00.06 → 0.00.07

data/README

@@ -6,13 +6,21 @@ load "longdecimal.rb"
 to your ruby-file.  Please read the code to get an idea how to use this.
 
 To test on Linux/Unix:
-put longdecimal.rb and testlongdecimal.rb into the same directory,
-do 
-chmod +x testlongdecimal.rb
-and run it
-./testlongdecimal.rb
+go into a directory long-decimal, put longdecimal.rb into a
+sub-directory lib and testlongdecimal.rb into a sub-directory test.
+This is the directory structure you get when unpacking the tar.gz
+archive.  Then:
 
-Licence
+chmod +x test/testlongdecimal.rb
+
+and run it:
+
+./test/testlongdecimal.rb
+
+You should not get any error nor any failure.  The tests will take a
+minute or so, depending on the CPU-speed of your machine.
+
+License
 -------
 
 Ruby's license or LGPL
@@ -31,3 +39,4 @@ Author
 
 Karl Brodowsky
 http://www.velofahren.de/cgi-bin/mailform.cgi
+(no direct mail address because I do not like spam)

data/VERSION

@@ -1 +1 @@
-0.00.06
+0.00.07

data/lib/longdecimal.rb

@@ -1,8 +1,8 @@
 #
 # longdecimal.rb -- Arbitrary precision decimals with fixed decimal point
 #
-# CVS-ID:    $Header: /var/cvs/long-decimal/long-decimal/lib/longdecimal.rb,v 1.2 2006/02/25 20:05:53 bk1 Exp $
-# CVS-Label: $Name: PRE_ALPHA_0_06 $
+# CVS-ID:    $Header: /var/cvs/long-decimal/long-decimal/lib/longdecimal.rb,v 1.3 2006/02/28 09:57:10 bk1 Exp $
+# CVS-Label: $Name: PRE_ALPHA_0_07 $
 # Author:    $Author: bk1 $ (Karl Brodowsky)
 #
 require "complex"
@@ -11,33 +11,190 @@ require "rational"
 # require "bigdecimal/math"
 
 #
-# add a functionality to find gcd with a high power of some number
-# probably Integer is not the right place for this stuff, because it
-# is quite special and should go to some kind of Math-like class in the
-# future.
+# helper functions to support LongDecimal and LongDecimalQuot
+# functions for LongDecimal that do not go as methods of LongDecimal
 #
-class Integer
+module LongMath
 
   MAX_FLOATABLE = Float::MAX.to_i
   MIN_FLOATABLE = Float::MIN.to_i
 
   #
-  # find the gcd of self with b^n0 where n0 is a sufficiently high
-  # exponent such that gcd(self, b^m) = gcd(self, b^n)
+  # helper method: checks if word_len is of reasonable for splitting a
+  # number into parts
+  #
+  def LongMath.check_word_len(word_len)
+    raise TypeError, "word_len must be a positive number <= 1024" unless (word_len.kind_of? Fixnum) && word_len > 0 && word_len <= 1024
+    word_len
+  end
+
+  # private :check_word_len
+
+  #
+  # split number x into parts of word_len bits each
+  # such that the concatenation of these parts as bit patterns is x
+  #
+  def LongMath.split_to_words(x, word_len = 32)
+    check_word_len(word_len)
+    raise TypeError, "x must be Integer" unless x.kind_of? Integer
+    m = x.abs
+    s = (x <=> 0)
+    bit_pattern = (1 << word_len) - 1
+    words = []
+    while (m != 0 || words.length == 0) do
+      w = m & bit_pattern
+      m = m >> word_len
+      words.unshift(w)
+    end
+    if (s < 0) then
+      words[0] = -words[0]
+    end
+    words
+  end
+
+  #
+  # concatenate numbers given in words as bit patterns
+  #
+  def LongMath.merge_from_words(words, word_len = 32)
+    check_word_len(word_len)
+    raise TypeError, "words must be array of length > 0" unless (words.kind_of? Array) && words.length > 0
+    y = 0
+    s = (words[0] <=> 0)
+    if (s < 0) then
+      words[0] = -words[0]
+    end
+    words.each do |w|
+      y = y << word_len
+      y += w
+    end
+    if (s < 0) then
+      y = -y
+    end
+    y
+  end
+
+  #
+  # calculate the square root of an integer using bitwise algorithm
+  #
+  def LongMath.sqrtb(x)
+    a = sqrtb_with_remainder(x)
+    a[0]
+  end
+
+  def LongMath.sqrtb_with_remainder(x)
+    raise TypeError, "x must be integer" unless x.kind_of? Integer
+
+    s = (x <=> 0)
+    if (s == 0) then
+      return [0, 0]
+    elsif (s < 0)
+      a = sqrtb_with_remainder(-x)
+      return [ Complex(0, a[0]), a[1]]
+    end
+
+    xwords = split_to_words(x, 2)
+    xi = xwords[0] - 1
+    yi = 1
+
+    1.upto(xwords.length-1) do |i|
+      xi = (xi << 2) + xwords[i]
+      d0 = (yi << 2) + 1
+      r  = xi - d0
+      b  = 0
+      if (r >= 0) then
+        b  = 1
+        xi = r
+      end
+      yi = (yi << 1) + b
+    end
+    return [yi, xi]
+  end
+
+  #
+  # calculate the square root of an integer using larger chunks of the number
+  #
+  def LongMath.sqrtw(x, n = 16)
+    a = sqrtw_with_remainder(x, n)
+    a[0]
+  end
+
+  def LongMath.sqrtw_with_remainder(x, n = 16)
+    raise TypeError, "x must be integer" unless x.kind_of? Integer
+    raise TypeError, "n must be an integer" unless (n.kind_of? Integer)
+    n2 = n<<1
+    n1 = n+1
+    check_word_len(n2)
+
+    s = (x <=> 0)
+    if (s == 0) then
+      return [0, 0]
+    elsif (s < 0)
+      a = sqrtw_with_remainder(-x)
+      return [ Complex(0, a[0]), a[1]]
+    end
+
+    xwords = split_to_words(x, n2)
+    if (xwords.length == 1) then
+      return sqrtb_with_remainder(xwords[0])
+    end
+
+    # puts(xwords.inspect + "\n")
+    xi = (xwords[0] << n2) + xwords[1]
+    a  = sqrtb_with_remainder(xi)
+    yi = a[0]
+    if (xwords.length <= 2) then
+      return a
+    end
+
+    xi -= yi*yi
+    2.upto(xwords.length-1) do |i|
+      xi = (xi << n2) + xwords[i]
+      d0 = (yi << n1)
+      q  = (xi / d0).to_i
+      q0 = q
+      j  = 0
+      was_negative = false
+      while (true) do
+        d = d0 + q
+        r = xi - (q * d)
+        break if (0 <= r && (r < d || was_negative))
+        # puts("i=#{i} j=#{j} q=#{q} d0=#{d0} d=#{d} r=#{r} yi=#{yi} xi=#{xi}\n")
+        if (r < 0) then
+          was_negative = true
+          q = q-1
+        else
+          q = q+1
+        end
+        j += 1
+        if (j > 10) then
+          puts("i=#{i} j=#{j} q=#{q} q0=#{q0} d0=#{d0} d=#{d} r=#{r} yi=#{yi} xi=#{xi}\n")
+          break
+        end
+      end
+      xi = r
+      yi = (yi << n) + q
+    end
+    return [ yi, xi ]
+  end
+
+  #
+  # find the gcd of x with b^n0 where n0 is a sufficiently high
+  # exponent such that gcd(x, b^m) = gcd(x, b^n)
   # for all m, n > n0
   #
-  def gcd_with_high_power(b)
-    raise ZeroDivisionError, "gcd_with_high_power of zero with \"#{b.inspect}\" would be infinity" if self.zero?
+  def LongMath.gcd_with_high_power(x, b)
+    raise TypeError, "gcd_with_high_power can only be calculated for integers, but x=#{x.inspect} is no integer." unless x.kind_of? Integer
+    raise ZeroDivisionError, "gcd_with_high_power of zero with \"#{b.inspect}\" would be infinity" if x.zero?
     raise TypeError, "gcd_with_high_power can only be calculated for integers \"#{b.inspect}\" is no integer" unless b.kind_of? Integer
     raise ZeroDivisionError, "gcd_with_high_power with b < 2 is not defined. b=\"#{b.inspect}\"" if b < 2
-    s = self.abs
+    s = x.abs
     exponent = 1
     b = b.abs
     if (b < s && s < MAX_FLOATABLE)
       exponent = (Math.log(s) / Math.log(b)).ceil
     end
-    power    = b**exponent
-    result   = 1
+    power  = b**exponent
+    result = 1
     begin
       f = s.gcd(power)
       s /= f
@@ -51,45 +208,40 @@ class Integer
   # self.  Only works for prime numbers
   # works even for numbers that exceed the range of Float
   #
-  def multiplicity_of_factor(prime_number)
-    power = gcd_with_high_power(prime_number)
-    if (power.abs < MAX_FLOATABLE) then
-      result = (Math.log(power) / Math.log(prime_number)).round
-    else
-      e = (Math.log(MAX_FLOATABLE) / Math.log(prime_number)).floor
-      result = 0
-      partial = prime_number ** e
-      while (power > partial) do
-        power /= partial
-        result += e
+  def LongMath.multiplicity_of_factor(x, prime_number)
+
+    if (x.kind_of? Rational) || (x.kind_of? LongDecimalQuot) then
+      m1 = multiplicity_of_factor(x.numerator, prime_number)
+      m2 = multiplicity_of_factor(x.denominator, prime_number)
+      return m1 - m2
+
+    elsif (x.kind_of? LongDecimal)
+      m1 = x.numerator.multiplicity_of_factor(prime_number)
+      if (prime_number == 2 || prime_number == 5) then
+        return m1 - x.scale
+      else
+        return m1
       end
-      result += (Math.log(power) / Math.log(prime_number)).round
-      # result = (BigMath.log(BigDecimal(power.to_s + ".0", power.size)) / BigMath.log(BigDecimal(prime_number.to_s + ".0", prime_number.size))).round
-      # raise TypeError, "numbers are too big p=#{prime_number} power=#{power}"
-    end
-    result
-  end
-end
 
-#
-# add some functionality to Rational.
-# probably Rational is not the right place for this stuff, because it
-# is quite special and should go to some kind of Math-like class in the
-# future.
-#
-class Rational
+    elsif (x.kind_of? Integer)
 
-  #
-  # find the exponent of the highest power of b that divides
-  # self.  Count negative, if it divides the denominator
-  # Only works for prime numbers
-  # @todo: needs some improvements, in order to work well for numbers
-  #        that exceed the range of Float
-  #
-  def multiplicity_of_factor(prime_number)
-    m1 = numerator.multiplicity_of_factor(prime_number)
-    m2 = denominator.multiplicity_of_factor(prime_number)
-    m1 - m2
+      power = gcd_with_high_power(x, prime_number)
+      if (power.abs < MAX_FLOATABLE) then
+        result = (Math.log(power) / Math.log(prime_number)).round
+      else
+        e = (Math.log(MAX_FLOATABLE) / Math.log(prime_number)).floor
+        result = 0
+        partial = prime_number ** e
+        while (power > partial) do
+          power /= partial
+          result += e
+        end
+        result += (Math.log(power) / Math.log(prime_number)).round
+      end
+      return result
+    else
+      raise TypeError, "type of x is not supported #{x.class} #{x.inpect}"
+    end
   end
 
 end
@@ -134,7 +286,7 @@ end
 # digits and the other one the position of the decimal point.
 #
 class LongDecimal < Numeric
-  @RCS_ID='-$Id: longdecimal.rb,v 1.2 2006/02/25 20:05:53 bk1 Exp $-'
+  @RCS_ID='-$Id: longdecimal.rb,v 1.3 2006/02/28 09:57:10 bk1 Exp $-'
 
   include LongDecimalRoundingMode
 
@@ -242,8 +394,8 @@ class LongDecimal < Numeric
       # we need to come up with a better rule here.
       # if denominator is any product of powers of 2 and 5, we do not need to round
       denom = x.denominator
-      mul_2 = denom.multiplicity_of_factor(2)
-      mul_5 = denom.multiplicity_of_factor(5)
+      mul_2 = LongMath.multiplicity_of_factor(denom, 2)
+      mul_5 = LongMath.multiplicity_of_factor(denom, 5)
       iscale = [mul_2, mul_5].max
       scale += iscale
       denom /= 2 ** mul_2
@@ -640,7 +792,7 @@ class LongDecimal < Numeric
     end
     if (q.kind_of? LongDecimal) || (q.kind_of? LongDecimalQuot) then
       if (new_scale.nil?) then
-	new_scale = q.scale
+        new_scale = q.scale
       end
       q.round_to_scale(new_scale, rounding_mode)
     else
@@ -694,20 +846,6 @@ class LongDecimal < Numeric
     return q, self - other * q
   end
 
-  #
-  # find the exponent of the highest power of prime number p that divides
-  # self.  Only works for prime numbers
-  # works even for numbers that exceed the range of Float
-  #
-  def multiplicity_of_factor(prime_number)
-    m1 = numerator.multiplicity_of_factor(prime_number)
-    if (prime_number == 2 || prime_number == 5) then
-      m1 - scale
-    else
-      m1
-    end
-  end
-
   def %(other)
     q, r = divmod other
     r
@@ -837,12 +975,29 @@ class LongDecimal < Numeric
   protected :move_point_left_int, :move_point_right_int
 
   #
-  # calculate the sqare of self
+  # calculate the square of self
   #
   def square
     self * self
   end
 
+  def sqrt(new_scale, rounding_mode)
+    raise TypeError, "new_scale #{new_scale.inspect} must be integer" unless new_scale.kind_of? Integer
+    raise TypeError, "new_scale #{new_scale.inspect} must be >= 0" unless new_scale >= 0
+    raise TypeError, "mode #{mode.inspect} must be legal rounding mode" unless rounding_mode.kind_of? RoundingModeClass
+
+    new_scale1 = new_scale + 1
+    old_scale  = (new_scale1 << 1)
+    x = round_to_scale(old_scale, rounding_mode)
+    root, rem = LongMath.sqrtb_with_remainder(x.int_val)
+    if (rem > 0 && (rounding_mode == ROUND_HALF_EVEN || rounding_mode == ROUND_HALF_DOWN)) then
+      rounding_mode = ROUND_HALF_UP
+    end
+    y = LongDecimal(root, new_scale1)
+    y.round_to_scale(new_scale, rounding_mode)
+  end
+
+
   #
   # calculate the multiplicative inverse
   #
@@ -940,7 +1095,6 @@ class LongDecimal < Numeric
     sprintf("LongDecimal(%s, %s)", int_val.inspect, scale.inspect)
   end
 
-
 end
 
 #
@@ -950,7 +1104,7 @@ end
 #
 class LongDecimalQuot < Numeric
 
-  @RCS_ID='-$Id: longdecimal.rb,v 1.2 2006/02/25 20:05:53 bk1 Exp $-'
+  @RCS_ID='-$Id: longdecimal.rb,v 1.3 2006/02/28 09:57:10 bk1 Exp $-'
 
   include LongDecimalRoundingMode
 
@@ -1115,15 +1269,6 @@ class LongDecimalQuot < Numeric
 #     end
 #   end
 
-  #
-  # find the exponent of the highest power of prime number p that divides
-  # self.  Only works for prime numbers
-  # works even for numbers that exceed the range of Float
-  #
-  def multiplicity_of_factor(prime_number)
-    rat.multiplicity_of_factor(prime_number)
-  end
-
   def square
     self * self
   end

data/test/testlongdecimal.rb

@@ -2,8 +2,8 @@
 #
 # testlongdecimal.rb -- runit test for longdecimal.rb
 #
-# CVS-ID:    $Header: /var/cvs/long-decimal/long-decimal/test/testlongdecimal.rb,v 1.2 2006/02/25 19:52:11 bk1 Exp $
-# CVS-Label: $Name: PRE_ALPHA_0_06 $
+# CVS-ID:    $Header: /var/cvs/long-decimal/long-decimal/test/testlongdecimal.rb,v 1.3 2006/02/28 09:57:10 bk1 Exp $
+# CVS-Label: $Name: PRE_ALPHA_0_07 $
 # Author:    $Author: bk1 $ (Karl Brodowsky)
 #
 
@@ -15,38 +15,126 @@ load "lib/longdecimal.rb"
 
 class TestLongDecimal_class < RUNIT::TestCase
 
-  @RCS_ID='-$Id: testlongdecimal.rb,v 1.2 2006/02/25 19:52:11 bk1 Exp $-'
+  @RCS_ID='-$Id: testlongdecimal.rb,v 1.3 2006/02/28 09:57:10 bk1 Exp $-'
+
+  def check_sqrtb(x, s)
+    y = LongMath.sqrtb(x)
+    z = y * y
+    zz = (y+1)*(y+1)
+    assert(0 <= y, "sqrt must be >= 0" + s)
+    assert(z <= x && x < zz, "y=#{y}=sqrt(#{x}) and x in [#{z}, #{zz})" + s)
+    y
+  end
+
+  def _test_sqrtb
+    assert_equal(Complex(0,1), LongMath.sqrtb(-1), "sqrt(-1)=i")
+    1024.times do |x|
+      check_sqrtb(x, " loop x=#{x}")
+    end
+    512.times do |i|
+      x1 = i*i
+      y = check_sqrtb(x1, " i*i i=#{i}")
+      assert_equal(i, y, "i=#{i} y=#{y}")
+      if (i > 0) then
+	x2 = x1 + 1
+	y = check_sqrtb(x2, " i*i+1 i=#{i}")
+	assert_equal(i, y, "i=#{i} y=#{y}")
+	x0 = x1 - 1
+	y = check_sqrtb(x0, " i*i-1 i=#{i}")
+	assert_equal(i-1, y, "i=#{i} y=#{y}")
+      end
+      
+      x1 = 1 << i
+      y = check_sqrtb(x1, " 2**i i=#{i}")
+      if (i[0] == 0)
+	assert_equal(1 << (i>>1), y, "2^(i/2) i=#{i} y=#{y}")
+      end
+      if (i > 0) then
+	check_sqrtb(x1-1, " 2**i-1 i=#{i}")
+	check_sqrtb(x1+1, " 2**i+1 i=#{i}")
+      end
+
+      x1 = 3 << i
+      check_sqrtb(x1, " 3*2**i i=#{i}")
+      check_sqrtb(x1-1, " 3*2**i-1 i=#{i}")
+      check_sqrtb(x1+1, " 3*2**i+1 i=#{i}")
+    end
+  end
+
+  def check_sqrtw(x, s)
+    y = LongMath.sqrtw(x)
+    z = y * y
+    zz = (y+1)*(y+1)
+    assert(0 <= y, "sqrt must be >= 0" + s)
+    assert(z <= x && x < zz, "y=#{y}=sqrt(#{x}) and x in [#{z}, #{zz})" + s)
+    y
+  end
+
+  def test_sqrtw
+    assert_equal(Complex(0,1), LongMath.sqrtw(-1), "sqrt(-1)=i")
+    1024.times do |x|
+      check_sqrtw(x, " loop x=#{x}")
+    end
+    1024.times do |i|
+      x1 = i*i
+      y = check_sqrtw(x1, " i*i i=#{i}")
+      assert_equal(i, y, "i=#{i} y=#{y}")
+      if (i > 0) then
+	x2 = x1 + 1
+	y = check_sqrtw(x2, " i*i+1 i=#{i}")
+	assert_equal(i, y, "i=#{i} y=#{y}")
+	x0 = x1 - 1
+	y = check_sqrtw(x0, " i*i-1 i=#{i}")
+	assert_equal(i-1, y, "i=#{i} y=#{y}")
+      end
+      
+      x1 = 1 << i
+      y = check_sqrtw(x1, " 2**i i=#{i}")
+      if (i[0] == 0)
+	assert_equal(1 << (i>>1), y, "2^(i/2) i=#{i} y=#{y}")
+      end
+      if (i > 0) then
+	check_sqrtw(x1-1, " 2**i-1 i=#{i}")
+	check_sqrtw(x1+1, " 2**i+1 i=#{i}")
+      end
+
+      x1 = 3 << i
+      check_sqrtw(x1, " 3*2**i i=#{i}")
+      check_sqrtw(x1-1, " 3*2**i-1 i=#{i}")
+      check_sqrtw(x1+1, " 3*2**i+1 i=#{i}")
+    end
+  end
 
   def test_gcd_with_high_power
     n = 224
-    assert_equal(32, n.gcd_with_high_power(2), "2-part of 224 is 32")
-    assert_equal(7, n.gcd_with_high_power(7), "7-part of 224 is 7")
-    assert_equal(1, n.gcd_with_high_power(3), "3-part of 224 is 1")
+    assert_equal(32, LongMath.gcd_with_high_power(n, 2), "2-part of 224 is 32")
+    assert_equal(7, LongMath.gcd_with_high_power(n, 7), "7-part of 224 is 7")
+    assert_equal(1, LongMath.gcd_with_high_power(n, 3), "3-part of 224 is 1")
   end
 
   def test_multiplicity_of_factor
     n = 224
-    assert_equal(5, n.multiplicity_of_factor(2), "ny_2(224) is 5")
-    assert_equal(1, n.multiplicity_of_factor(7), "ny_7(224) is 1")
-    assert_equal(0, n.multiplicity_of_factor(3), "ny_3(224) is 0")
+    assert_equal(5, LongMath.multiplicity_of_factor(n, 2), "ny_2(224) is 5")
+    assert_equal(1, LongMath.multiplicity_of_factor(n, 7), "ny_7(224) is 1")
+    assert_equal(0, LongMath.multiplicity_of_factor(n, 3), "ny_3(224) is 0")
   end
 
   def test_rat_multiplicity_of_factor
     n = Rational(224, 225)
-    assert_equal(5, n.multiplicity_of_factor(2), "ny_2(n) is 5")
-    assert_equal(1, n.multiplicity_of_factor(7), "ny_7(n) is 1")
-    assert_equal(-2, n.multiplicity_of_factor(3), "ny_3(n) is -2")
-    assert_equal(-2, n.multiplicity_of_factor(5), "ny_5(n) is -2")
-    assert_equal(0, n.multiplicity_of_factor(11), "ny_11(n) is 0")
+    assert_equal(5, LongMath.multiplicity_of_factor(n, 2), "ny_2(n) is 5")
+    assert_equal(1, LongMath.multiplicity_of_factor(n, 7), "ny_7(n) is 1")
+    assert_equal(-2, LongMath.multiplicity_of_factor(n, 3), "ny_3(n) is -2")
+    assert_equal(-2, LongMath.multiplicity_of_factor(n, 5), "ny_5(n) is -2")
+    assert_equal(0, LongMath.multiplicity_of_factor(n, 11), "ny_11(n) is 0")
   end
 
   def test_rat_long_multiplicity_of_factor
     n = Rational(224*(10**600+1), 225*(5**800))
-    assert_equal(5, n.multiplicity_of_factor(2), "ny_2(n) is 5")
-    assert_equal(1, n.multiplicity_of_factor(7), "ny_7(n) is 1")
-    assert_equal(-2, n.multiplicity_of_factor(3), "ny_3(n) is -2")
-    assert_equal(-802, n.multiplicity_of_factor(5), "ny_5(n) is -2")
-    assert_equal(0, n.multiplicity_of_factor(11), "ny_11(n) is 0")
+    assert_equal(5, LongMath.multiplicity_of_factor(n, 2), "ny_2(n) is 5")
+    assert_equal(1, LongMath.multiplicity_of_factor(n, 7), "ny_7(n) is 1")
+    assert_equal(-2, LongMath.multiplicity_of_factor(n, 3), "ny_3(n) is -2")
+    assert_equal(-802, LongMath.multiplicity_of_factor(n, 5), "ny_5(n) is -2")
+    assert_equal(0, LongMath.multiplicity_of_factor(n, 11), "ny_11(n) is 0")
   end
 
   def test_int_init

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: long-decimal
 version: !ruby/object:Gem::Version 
-  version: 0.00.06
-date: 2006-02-25 00:00:00 +01:00
+  version: 0.00.07
+date: 2006-02-28 00:00:00 +01:00
 summary: LongDecimal for numbers with fixed point
 require_paths: 
 - lib