flt 1.2.0 → 1.2.1

data/History.txt

@@ -1,3 +1,13 @@
+== 1.2.1 2010-06-16
+
+* New features
+  - Trigonometry for BinNum and reorganization of Math modules.
+
+* Bugfixes
+  - Context#elimit= didn't work
+  - atan could be inaccurate for small arguments
+  - asin could be inaccurate for arguments near 1
+
 == 1.2.0 2010-06-15
 
 * New Features

data/README.txt

@@ -498,6 +498,29 @@ Note also that if we normalize a value we will change it's precision to that of
   puts x.normalize.number_of_digits                # -> 53
   puts x.normalize.to_s                            # -> 0.125
 
+== Mathematical functions
+
+There are two mathematical functions modules analogous to Ruby's Math for Float,
+Flt::DecNum::Math and Flt::BinNum::Math.
+Currently they consist of basic trigonometric functions, including hypot, and the
+constants e and pi.
+
+Its functions can be accessed in a number of ways:
+
+  require 'flt/math'
+  DecNum.context(:precision=>10) do |context|
+    # As module functions:
+    puts DecNum::Math.sin(1)*DecNum::Math.pi        # -> 2.643559064
+    # As functions of a context object:
+    puts context.sin(1)*context.pi                  # -> 2.643559064
+    # Through a math block:
+      puts DecNum.context.math{sin(1)*pi}           # -> 2.643559064
+      puts DecNum.math{sin(1)*pi}                   # -> 2.643559064
+    # And can be included to be used ans private instance methods:
+      include DecNum::Math
+      puts sin(1)*pi                                # -> 2.643559064
+  end
+
 == More Information
 
 * Decimal Floating point type: see the base Flt::Num class and the Flt::DecNum class
@@ -507,6 +530,7 @@ Note also that if we normalize a value we will change it's precision to that of
 * Floating Point Tolerance: see the flt/tolerance.rb[link:files/lib/flt/tolerance_rb.html] file
   and the Flt::Tolerance class
 * Constructors: see Flt.DecNum(), Flt.BinNum() and Flt.Tolerance().
+* Mathematical functions: see Flt::MathBase.
 
 = DecNum vs BigDecimal
 
@@ -567,7 +591,7 @@ EXPAND+
 
 = Roadmap
 
-* Math (trigonometry) functions for DecNum & BinNum (reorganization of DecNum::Math)
+* Trigonometry optimizations
 * Complex support.
 * Implement the missing GDA functions:
   rotate, shift, trim, and, or, xor, invert,

data/lib/flt/bin_num.rb

@@ -205,7 +205,7 @@ class BinNum < Num
       if special?
         super
       else
-        Math.ldexp(@sign*@coeff, @exp)
+        ::Math.ldexp(@sign*@coeff, @exp)
       end
     end
   end

data/lib/flt/math.rb

@@ -1,460 +1,587 @@
 require 'flt/dec_num'
 
 module Flt
-  class DecNum
-    module Math
 
-      extend Flt # to access constructor methods DecNum
+  # Mathematical functions. The angular units used by these functions can be specified
+  # with the +angle+ attribute of the context. The accepted values are:
+  # * :rad for radians
+  # * :deg for degrees
+  # * :grad for gradians
+  module MathBase
 
-      module_function
+    # Cosine of an angle given in the units specified by DecNum.context.angle.
+    def cos(x)
+      cos_base(num_class.Num(x))
+    end
 
-      # Trigonometry
+    # Sine of an angle given in the units specified by DecNum.context.angle.
+    def sin(x)
+      sin_base(num_class.Num(x))
+    end
 
-      HALF = DecNum('0.5')
+    # Tangent of an angle given in the units specified by DecNum.context.angle.
+    def tan(x)
+      tan_base(num_class.Num(x))
+    end
 
-      # Pi
-      @@pi_cache = nil # truncated pi digits as a string
-      @@pi_cache_digits = 0
-      PI_MARGIN = 10
-      def pi(round_digits=nil)
+    # Arc-tangent. The result is in the units specified by DecNum.context.angle.
+    # If the angular units are radians the result is in [-pi/2, pi/2]; it is in [-90,90] in degrees.
+    def atan(x)
+      atan_base(num_class.Num(x))
+    end
 
-        round_digits ||= DecNum.context.precision
-        digits = round_digits
-          if @@pi_cache_digits <= digits # we need at least one more truncated digit
-             continue = true
-             while continue
-               margin = PI_MARGIN # margin to reduce recomputing with more digits to avoid ending in 0 or 5
-               digits += margin + 1
-               fudge = 10
-               unity = 10**(digits+fudge)
-               v = 4*(4*iarccot(5, unity) - iarccot(239, unity))
-               v = v.to_s[0,digits]
-               # if the last digit is 0 or 5 the truncated value may not be good for rounding
-               loop do
-                 #last_digit = v%10
-                 last_digit = v[-1,1].to_i
-                 continue = (last_digit==5 || last_digit==0)
-                 if continue && margin>0
-                   # if we have margin we back-up one digit
-                   margin -= 1
-                   v = v[0...-1]
-                 else
-                   break
-                 end
-               end
-             end
-             @@pi_cache_digits = digits + margin - PI_MARGIN # @pi_cache.size
-             @@pi_cache = v # DecNum(+1, v, 1-digits) # cache truncated value
-          end
-          # Now we avoid rounding too much because it is slow
-          l = round_digits + 1
-          while (l<@@pi_cache_digits) && [0,5].include?(@@pi_cache[l-1,1].to_i)
-            l += 1
-          end
-          v = @@pi_cache[0,l]
-          DecNum.context(:precision=>round_digits){+DecNum(+1,v.to_i,1-l)}
-      end
+    # Arc-tangent with two arguments (principal value of the argument of the complex number x+i*y).
+    # The result is in the units specified by DecNum.context.angle.
+    # If the angular units are radians the result is in [-pi, pi]; it is in [-180,180] in degrees.
+    def atan2(y, x)
+      atan2_base(num_class.Num(y), num_class.Num(x))
+    end
 
-      def e(decimals=nil)
-        DecNum.context do |local_context|
-          local_context.precision = decimals if decimals
-          DecNum(1).exp
-        end
-      end
+    # Arc-sine. The result is in the units specified by DecNum.context.angle.
+    # If the angular units are radians the result is in [-pi/2, pi/2]; it is in [-90,90] in degrees.
+    def asin(x)
+      asin_base(num_class.Num(x))
+    end
 
-      # Cosine of an angle given in the units specified by DecNum.context.angle:
-      # * :rad for radians
-      # * :deg for degrees
-      # * :grad for gradians
-      def cos(x)
-        x = x.abs
-        rev_sign = false
-        s = nil
-        DecNum.context do |local_context|
-          local_context.precision += 3 # extra digits for intermediate steps
-          x,k,pi_2 = reduce_angle2(x,2)
-          rev_sign = true if k>1
-          if k % 2 == 0
-            x = pi_2 - x
-          else
-            rev_sign = !rev_sign
-          end
-          x = to_rad(x)
-          i, lasts, fact, num = 1, 0, 1, DecNum(x)
-          s = num
-          x2 = -x*x
-          while s != lasts
-            lasts = s
-            i += 2
-            fact *= i * (i-1)
-            num *= x2
-            s += num / fact
-          end
-        end
-        return rev_sign ? (-s) : (+s)
-      end
+    # Arc-cosine. The result is in the units specified by DecNum.context.angle.
+    # If the angular units are radians the result is in [-pi/2, pi/2]; it is in [-90,90] in degrees.
+    def acos(x)
+      acos_base(num_class.Num(x))
+    end
 
-      # Sine of an angle given in the units specified by DecNum.context.angle:
-      # * :rad for radians
-      # * :deg for degrees
-      # * :grad for gradians
-      def sin(x)
-        sign = x.sign
-        s = nil
-        DecNum.context do |local_context|
-          local_context.precision += 3 # extra digits for intermediate steps
-          x = x.abs if sign<0
-          x,k,pi_2 = reduce_angle2(x,2)
-          sign = -sign if k>1
-          x = pi_2 - x if k % 2 == 1
-          x = to_rad(x)
-          i, lasts, fact, num = 1, 0, 1, DecNum(x)
-          s = num
-          x2 = -x*x
-          while s != lasts
-            lasts = s
-            i += 2
-            fact *= i * (i-1)
-            num *= x2
-            s += num / fact
-          end
-        end
-        return (+s).copy_sign(sign)
-      end
+    # Length of the hypotenuse of a right-angle triangle (modulus or absolute value of the complex x+i*y).
+    def hypot(x, y)
+      hypot_base(num_class.Num(x), num_class.Num(y))
+    end
 
-      # Tangent of an angle
-      def tan(x)
-        +DecNum.context do |local_context|
-          local_context.precision += 2 # extra digits for intermediate steps
-          s,c = sin(x), cos(x)
-          s/c
+    private
+
+    def cos_base(x)
+      x = x.abs
+      rev_sign = false
+      s = nil
+      num_class.context do |local_context|
+        local_context.precision += 3 # extra digits for intermediate steps
+        x,k,pi_2 = reduce_angle2(x,2)
+        rev_sign = true if k>1
+        if k % 2 == 0
+          x = pi_2 - x
+        else
+          rev_sign = !rev_sign
+        end
+        x = to_rad(x)
+        i, lasts, fact, num = 1, 0, 1, num_class.Num(x)
+        s = num
+        x2 = -x*x
+        while s != lasts
+          lasts = s
+          i += 2
+          fact *= i * (i-1)
+          num *= x2
+          s += num / fact
         end
       end
+      return rev_sign ? (-s) : (+s)
+    end
 
-      # Arc-tangent in units specified by DecNum.context.angle
-      def atan(x)
-        s = nil
-        conversion = true
-        DecNum.context do |local_context|
-          local_context.precision += 2
-          if x == 0
-            return DecNum.zero
-          elsif x.abs > 1
-            if x.infinite?
-              s = (quarter_cycle).copy_sign(x)
-              conversion = false
-              break
-            else
-              # c = (quarter_cycle).copy_sign(x)
-              c = (HALF*pi).copy_sign(x)
-              x = 1 / x
-            end
-          end
-          local_context.precision += 2
-          x_squared = x ** 2
-          y = x_squared / (1 + x_squared)
-          y_over_x = y / x
-          i = DecNum.zero; lasts = 0; s = y_over_x; coeff = 1; num = y_over_x
-          while s != lasts
-            lasts = s
-            i += 2
-            coeff *= i / (i + 1)
-            num *= y
-            s += coeff * num
-          end
-          if c && c!= 0
-            s = c - s
-          end
+    def sin_base(x)
+      sign = x.sign
+      s = nil
+      num_class.context do |local_context|
+        local_context.precision += 3 # extra digits for intermediate steps
+        x = x.abs if sign<0
+        x,k,pi_2 = reduce_angle2(x,2)
+        sign = -sign if k>1
+        x = pi_2 - x if k % 2 == 1
+        x = to_rad(x)
+        i, lasts, fact, num = 1, 0, 1, num_class.Num(x)
+        s = num
+        x2 = -x*x
+        while s != lasts
+          lasts = s
+          i += 2
+          fact *= i * (i-1)
+          num *= x2
+          s += num / fact
         end
-        return conversion ? rad_to(s) : +s
       end
+      return (+s).copy_sign(sign)
+    end
 
-      def atan2(y, x)
-          abs_y = y.abs
-          abs_x = x.abs
-          y_is_real = !x.infinite?
-
-          if x != 0
-              if y_is_real
-                  a = y!=0 ? atan(y / x) : DecNum.zero
-                  a += half_cycle.copy_sign(y) if x < 0
-                  return a
-              elsif abs_y == abs_x
-                  x = DecNum(1).copy_sign(x)
-                  y = DecNum(1).copy_sign(y)
-                  return half_cycle * (2 - x) / (4 * y)
-              end
-          end
+    def tan_base(x)
+      +num_class.context do |local_context|
+        local_context.precision += 2 # extra digits for intermediate steps
+        s,c = sin(x), cos(x)
+        s/c
+      end
+    end
 
-          if y != 0
-              return atan(DecNum.infinity(y.sign))
-          elsif x < 0
-              return half_cycle.copy_sign(x)
+    def atan_base(x)
+      s = nil
+      conversion = true
+      extra_prec = num_class.radix==2 ? 4 : 2
+      num_class.context do |local_context|
+        local_context.precision += extra_prec
+        if x == 0
+          return DecNum.zero
+        elsif x.abs > 1
+          if x.infinite?
+            s = (quarter_cycle).copy_sign(x)
+            conversion = false
+            break
           else
-              return DecNum.zero
+            # c = (quarter_cycle).copy_sign(x)
+            c = (half*pi).copy_sign(x)
+            x = 1 / x
           end
+        end
+        local_context.precision += extra_prec
+        x_squared = x ** 2
+        if x_squared.zero? || x_squared.subnormal?
+          s = x
+          s = c - s if c && c!=0
+          break
+        end
+        y = x_squared / (1 + x_squared)
+        y_over_x = y / x
+        i = num_class.zero; lasts = 0; s = y_over_x; coeff = 1; num = y_over_x
+        while s != lasts
+          lasts = s
+          i += 2
+          coeff *= i / (i + 1)
+          num *= y
+          s += coeff * num
+        end
+        if c && c!= 0
+          s = c - s
+        end
       end
+      return conversion ? rad_to(s) : +s
+    end
 
-      def asin(x)
-        x = +x
-        return DecNum.context.exception(Num::InvalidOperation, 'asin needs -1 <= x <= 1') if x.abs > 1
-
-          if x == -1
-              return -quarter_cycle
-          elsif x == 0
-              return DecNum.zero
-          elsif x == 1
-              return quarter_cycle
-          end
-
-          DecNum.context do |local_context|
-            local_context.precision += 3
-            x = x/(1-x*x).sqrt
-            x = atan(x)
-          end
-          +x
-      end
+    def atan2_base(y, x)
+        abs_y = y.abs
+        abs_x = x.abs
+        y_is_real = !x.infinite?
+
+        if x != 0
+            if y_is_real
+                a = y!=0 ? atan(y / x) : num_class.zero
+                a += half_cycle.copy_sign(y) if x < 0
+                return a
+            elsif abs_y == abs_x
+                x = num_class.Num(1).copy_sign(x)
+                y = num_class.Num(1).copy_sign(y)
+                return half_cycle * (2 - x) / (4 * y)
+            end
+        end
 
-      def acos(x)
+        if y != 0
+            return atan(num_class.infinity(y.sign))
+        elsif x < 0
+            return half_cycle.copy_sign(x)
+        else
+            return num_class.zero
+        end
+    end
 
-        return DecNum.context.exception(Num::InvalidOperation, 'acos needs -1 <= x <= 2') if x.abs > 1
+    def asin_base(x)
+      x = +x
+      return num_class.context.exception(Num::InvalidOperation, 'asin needs -1 <= x <= 1') if x.abs > 1
 
         if x == -1
-            return half_cycle
+            return -quarter_cycle
         elsif x == 0
-            return quarter_cycle
+            return num_class.zero
         elsif x == 1
-            return DecNum.zero
+            return quarter_cycle
         end
 
-        if x < HALF
-          DecNum.context do |local_context|
-            local_context.precision += 3
-            x = x/(1-x*x).sqrt
-            x = quarter_cycle - atan(x)
-          end
-        else
-          # valid for x>=0
-          DecNum.context do |local_context|
-            local_context.precision += 3
-            x = (1-x*x).sqrt
-            x = asin(x)
-          end
+        num_class.context do |local_context|
+          local_context.precision += 3
+          x = x/(1-x*x).sqrt
+          x = atan(x)
         end
         +x
+    end
+
+    def acos_base(x)
 
+      return num_class.context.exception(Num::InvalidOperation, 'acos needs -1 <= x <= 2') if x.abs > 1
+
+      if x == -1
+          return half_cycle
+      elsif x == 0
+          return quarter_cycle
+      elsif x == 1
+          return num_class.zero
       end
 
-      def hypot(x, y)
-        DecNum.context do |local_context|
-          local_context.precision += 3
-          (x*x + y*y).sqrt
+      required_precision = num_class.context.precision
+
+      if x < half
+        num_class.context(:precision=>required_precision+2) do
+          x = x/(1-x*x).sqrt
+          x = quarter_cycle - atan(x)
         end
-      end
+      else
+        # valid for x>=0
+        num_class.context(:precision=>required_precision+3) do
 
-      # TODO: add angular units to context; add support for degrees
+          # x = (1-x*x).sqrt # x*x may require double precision if x*x is near 1
+          x = (1-BinNum.context(:precision=>required_precision*2){x*x}).sqrt
 
-      def pi2(decimals=nil)
-        decimals ||= DecNum.context.precision
-        DecNum.context(:precision=>decimals) do
-          pi(decimals)*2
+          x = asin(x)
         end
       end
+      +x
+
+    end
+
+    def hypot_base(x, y)
+      num_class.context do |local_context|
+        local_context.precision += 3
+        (x*x + y*y).sqrt
+      end
+    end
+
+    def e(digits=nil)
+      num_class.context do |local_context|
+        local_context.precision = digits if digits
+        num_class.Num(1).exp
+      end
+    end
 
-      def invpi(decimals=nil)
-        decimals ||= DecNum.context.precision
-        DecNum.context(:precision=>decimals) do
-          DecNum(1)/pi(decimals)
+    def pi2(decimals=nil)
+      decimals ||= DecNum.context.precision
+      num_class.context(:precision=>decimals) do
+        pi(decimals)*2
+      end
+    end
+
+    def invpi(decimals=nil)
+      decimals ||= DecNum.context.precision
+      num_class.context(:precision=>decimals) do
+        num_class.Num(1)/pi(decimals)
+      end
+    end
+
+    def inv2pi(decimals=nil)
+      decimals ||= DecNum.context.precision
+      num_class.context(:precision=>decimals) do
+        num_class.Num(1)/pi2(decimals)
+      end
+    end
+
+    # class <<self
+    #   private
+
+      def iarccot(x, unity)
+        xpow = unity / x
+        n = 1
+        sign = 1
+        sum = 0
+        loop do
+            term = xpow / n
+            break if term == 0
+            sum += sign * (xpow/n)
+            xpow /= x*x
+            n += 2
+            sign = -sign
         end
+        sum
+      end
+
+      def modtwopi(x)
+        return +num_class.context(:precision=>num_class.context.precision*3){x.modulo(one_cycle)}
       end
 
-      def inv2pi(decimals=nil)
-        decimals ||= DecNum.context.precision
-        DecNum.context(:precision=>decimals) do
-          DecNum(1)/pi2(decimals)
+      # Reduce angle to [0,2Pi)
+      def reduce_angle(a)
+        modtwopi(a)
+      end
+
+      # Reduce angle to [0,Pi/k0) (result is not rounded to precision)
+      def reduce_angle2(a,k0=nil) # divisor of pi or nil for pi*2
+        # we could reduce first to pi*2 to avoid the mod k0 operation
+        k,r,divisor = DecNum.context do
+          num_class.context.precision *= 3
+          m = k0.nil? ? one_cycle : half_cycle/k0
+          a.divmod(m)+[m]
         end
+        [r, k.modulo(k0*2).to_i, divisor]
       end
 
-      # class <<self
-      #   private
-
-        def iarccot(x, unity)
-          xpow = unity / x
-          n = 1
-          sign = 1
-          sum = 0
-          loop do
-              term = xpow / n
-              break if term == 0
-              sum += sign * (xpow/n)
-              xpow /= x*x
-              n += 2
-              sign = -sign
-          end
-          sum
+      def one_cycle
+        case num_class.context.angle
+        when :rad
+          pi2
+        when :deg
+          num_class.Num(360)
+        when :grad
+          num_class.Num(400)
         end
+      end
 
-        def modtwopi(x)
-          return +DecNum.context(:precision=>DecNum.context.precision*3){x.modulo(one_cycle)}
+      def half_cycle
+        case num_class.context.angle
+        when :rad
+          pi
+        when :deg
+          num_class.Num(180)
+        when :grad
+          num_class.Num(200)
         end
+      end
 
-        # Reduce angle to [0,2Pi)
-        def reduce_angle(a)
-          modtwopi(a)
+      def quarter_cycle
+        case DecNum.context.angle
+        when :rad
+          half*pi
+        when :deg
+          num_class.Num(90)
+        when :grad
+          num_class.Num(100)
         end
+      end
 
-        # Reduce angle to [0,Pi/k0) (result is not rounded to precision)
-        def reduce_angle2(a,k0=nil) # divisor of pi or nil for pi*2
-          # we could reduce first to pi*2 to avoid the mod k0 operation
-          k,r,divisor = DecNum.context do
-            DecNum.context.precision *= 3
-            m = k0.nil? ? one_cycle : half_cycle/k0
-            a.divmod(m)+[m]
-          end
-          [r, k.modulo(k0*2).to_i, divisor]
+      def to_rad(x)
+        case num_class.context.angle
+        when :rad
+          +x
+        else
+          +num_class.context(:precision=>num_class.context.precision+3){x*pi/half_cycle}
         end
+      end
 
-        def one_cycle
-          case DecNum.context.angle
-          when :rad
-            pi2
-          when :deg
-            DecNum(360)
-          when :grad
-            DecNum(400)
-          end
+      def to_deg(x)
+        case num_class.context.angle
+        when :deg
+          +x
+        else
+          +num_class.context(:precision=>num_class.context.precision+3){x*num_class.Num(180)/half_cycle}
         end
+      end
 
-        def half_cycle
-          case DecNum.context.angle
-          when :rad
-            pi
-          when :deg
-            DecNum(180)
-          when :grad
-            DecNum(200)
-          end
+      def to_grad(x)
+        case DecNum.context.angle
+        when :deg
+          +x
+        else
+          +num_class.context(:precision=>num_class.context.precision+3){x*num_class.Num(200)/half_cycle}
         end
+      end
 
-        def quarter_cycle
-          case DecNum.context.angle
-          when :rad
-            HALF*pi
-          when :deg
-            DecNum(90)
-          when :grad
-            DecNum(100)
-          end
+      def to_angle(angular_units, x)
+        return +x if angular_units == num_class.context.angle
+        case angular_units
+        when :rad
+          to_rad(x)
+        when :deg
+          to_deg(x)
+        when :grad
+          to_grad(x)
         end
+      end
 
-        def to_rad(x)
-          case DecNum.context.angle
-          when :rad
-            +x
-          else
-            +DecNum.context(:precision=>DecNum.context.precision+3){x*pi/half_cycle}
-          end
+      def rad_to(x)
+        case num_class.context.angle
+        when :rad
+          +x
+        else
+          +num_class.context(:precision=>num_class.context.precision+3){x*half_cycle/pi}
         end
+      end
 
-        def to_deg(x)
-          case DecNum.context.angle
-          when :deg
-            +x
-          else
-            +DecNum.context(:precision=>DecNum.context.precision+3){x*DecNum(180)/half_cycle}
-          end
+      def deg_to(x)
+        case num_class.context.angle
+        when :deg
+          +x
+        else
+          +num_class.context(:precision=>num_class.context.precision+3){x*half_cycle/num_class.Num(180)}
         end
+      end
 
-        def to_grad(x)
-          case DecNum.context.angle
-          when :deg
-            +x
-          else
-            +DecNum.context(:precision=>DecNum.context.precision+3){x*DecNum(200)/half_cycle}
-          end
+      def grad_to(x)
+        case num_class.context.angle
+        when :grad
+          +x
+        else
+          +num_class.context(:precision=>num_class.context.precision+3){x*half_cycle/num_class.Num(200)}
         end
+      end
 
-        def to_angle(angular_units, x)
-          return +x if angular_units == DecNum.context.angle
-          case angular_units
-          when :rad
-            to_rad(x)
-          when :deg
-            to_deg(x)
-          when :grad
-            to_grad(x)
-          end
+      def angle_to(x, angular_units)
+        return +x if angular_units == num_class.context.angle
+        case angular_units
+        when :rad
+          rad_to(x)
+        when :deg
+          deg_to(x)
+        when :grad
+          grad_to(x)
         end
+      end
 
-        def rad_to(x)
-          case DecNum.context.angle
-          when :rad
-            +x
-          else
-            +DecNum.context(:precision=>DecNum.context.precision+3){x*half_cycle/pi}
-          end
+    #end
+
+  end
+
+
+  class DecNum
+
+    module Math
+
+      extend Flt # to access constructor methods DecNum
+
+      include MathBase # make available for instance methods
+      extend MathBase # make available for class methods
+
+      module Support
+        #private
+        def num_class
+          DecNum
         end
 
-        def deg_to(x)
-          case DecNum.context.angle
-          when :deg
-            +x
-          else
-            +DecNum.context(:precision=>DecNum.context.precision+3){x*half_cycle/DecNum(180)}
-          end
+        def half
+          num_class.Num('0.5')
         end
+      end
 
-        def grad_to(x)
-          case DecNum.context.angle
-          when :grad
-            +x
-          else
-            +DecNum.context(:precision=>DecNum.context.precision+3){x*half_cycle/DecNum(200)}
+      include Support
+      extend Support
+
+      module_function
+
+
+      # Pi
+      @@pi_cache = nil # truncated pi digits as a string
+      @@pi_cache_digits = 0
+      PI_MARGIN = 10
+      def pi(round_digits=nil)
+
+        round_digits ||= DecNum.context.precision
+        digits = round_digits
+          if @@pi_cache_digits <= digits # we need at least one more truncated digit
+             continue = true
+             while continue
+               margin = PI_MARGIN # margin to reduce recomputing with more digits to avoid ending in 0 or 5
+               digits += margin + 1
+               fudge = 10
+               unity = 10**(digits+fudge)
+               v = 4*(4*iarccot(5, unity) - iarccot(239, unity))
+               v = v.to_s[0,digits]
+               # if the last digit is 0 or 5 the truncated value may not be good for rounding
+               loop do
+                 #last_digit = v%10
+                 last_digit = v[-1,1].to_i
+                 continue = (last_digit==5 || last_digit==0)
+                 if continue && margin>0
+                   # if we have margin we back-up one digit
+                   margin -= 1
+                   v = v[0...-1]
+                 else
+                   break
+                 end
+               end
+             end
+             @@pi_cache_digits = digits + margin - PI_MARGIN # @pi_cache.size
+             @@pi_cache = v # DecNum(+1, v, 1-digits) # cache truncated value
           end
+          # Now we avoid rounding too much because it is slow
+          l = round_digits + 1
+          while (l<@@pi_cache_digits) && [0,5].include?(@@pi_cache[l-1,1].to_i)
+            l += 1
+          end
+          v = @@pi_cache[0,l]
+          num_class.context(:precision=>round_digits){+num_class.Num(+1,v.to_i,1-l)}
+      end
+
+
+    end # DecNum::Math
+
+    class DecNum::Context
+      include DecNum::Math
+      public :sin, :cos, :tan, :atan, :asin, :acos, :atan2, :hypot, :pi, :e
+    end
+
+    def self.pi
+      self::Math.pi
+    end
+
+    def self.e
+      self::Math.e
+    end
+
+  end # DecNum
+
+  class BinNum
+
+    module Math
+
+      extend Flt # to access constructor methods DecNum
+
+      include MathBase # make available for instance methods
+      extend MathBase # make available for class methods
+
+      module Support
+        #private
+        def num_class
+          BinNum
         end
 
-        def angle_to(x, angular_units)
-          return +x if angular_units == DecNum.context.angle
-          case angular_units
-          when :rad
-            rad_to(x)
-          when :deg
-            deg_to(x)
-          when :grad
-            grad_to(x)
-          end
+        def half
+          num_class.Num('0.5')
         end
+      end
 
-      #end
-
-    end # Math
-
-    class <<self
-      private
-      # declare math functions and inject them into the context class
-      def math_function(*functions)
-        functions.each do |f|
-          # TODO: consider injecting the math methods into the numeric class
-          # define_method(f) do |*args|
-          #   Math.send(f, self, *args)
-          # end
-          Num::ContextBase.send :define_method,f do |*args|
-            x = Num(args.shift)
-            Math.send(f, x, *args)
+      include Support
+      extend Support
+
+      module_function
+
+      # Pi
+      @@pi = nil
+      @@pi_cache = [num_class.Num(3), 3, 1, 0, 0, 24]
+      @@pi_digits = 0
+      def pi(round_digits=nil)
+        round_digits ||= num_class.context.precision
+        if @@pi_digits < round_digits
+          # provisional implementation (very slow)
+          lasts = 0
+          t, s, n, na, d, da = @@pi_cache
+          num_class.context do |local_context|
+            local_context.precision = round_digits + 6
+            while s != lasts
+              lasts = s
+              n, na = n+na, na+8
+              d, da = d+da, da+32
+              t = (t * n) / d
+              s += t
+            end
           end
+          @pi_cache = [t, s, n, na, d, da]
+          @@pi = s
+          @@pi_digits = round_digits
         end
+        num_class.context(:precision=>round_digits){+@@pi}
       end
-    end
 
-    math_function :sin, :cos, :tan, :atan, :asin, :acos, :atan2, :hypot
+    end # BinNum::Math
 
-    def pi
-      Math.pi
+    class BinNum::Context
+      include BinNum::Math
+      public :sin, :cos, :tan, :atan, :asin, :acos, :atan2, :hypot, :pi, :e
     end
 
-    def e
-      Math.e
+    def self.pi
+      self::Math.pi
     end
 
-  end # DecNum
+    def self.e
+      self::Math.e
+    end
+
+  end # BinNum
+
 end # Flt

data/lib/flt/num.rb

@@ -519,7 +519,7 @@ class Num < Numeric
     # if e > 0 it is taken as emax and emin=1-emax
     # if e < 0  it is taken as emin and emax=1-emin
     def elimit=(e)
-      @emin, @emax = [elimit, 1-elimit].sort
+      @emin, @emax = [e, 1-e].sort
     end
 
     # synonym for precision()
@@ -1261,10 +1261,7 @@ class Num < Numeric
     def nan()
       new [+1, nil, :nan]
     end
-  end
-
 
-  class <<self
     def int_radix_power(n)
       self.radix**n
     end
@@ -1276,6 +1273,11 @@ class Num < Numeric
     def int_div_radix_power(x,n)
       n < 0 ? (x * self.radix**(-n) ) : (x / self.radix**n)
     end
+
+    def math(*args, &blk)
+      self.context.math(*args, &blk)
+    end
+
   end
 
   # A floating point-number value can be defined by:
@@ -4068,7 +4070,7 @@ class Num < Numeric
     def log2_lb(c)
         raise ArgumentError, "The argument to _log2_lb should be nonnegative." if c <= 0
         str_c = c.to_s(16)
-        return LOG2_MULT*4*str_c.length - LOG2_LB_CORRECTION[str_c[0,1].to_i(16)]
+        return LOG2_MULT*4*str_c.length - LOG2_LB_CORRECTION[str_c[0,1].to_i(16)-1]
     end
 
     LOG10_MULT = 100

data/lib/flt/version.rb

@@ -2,7 +2,7 @@ module Flt
   module VERSION #:nodoc:
     MAJOR = 1
     MINOR = 2
-    TINY  = 0
+    TINY  = 1
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/test/test_trig.rb

@@ -1,8 +1,6 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
 require File.dirname(__FILE__) + '/../lib/flt/math'
 
-# TODO: Currently tests only with 12 digits of precision; test with more precision.
-
 class TestTrig < Test::Unit::TestCase
 
 
@@ -14,14 +12,16 @@ class TestTrig < Test::Unit::TestCase
         radix = $2.to_i
         prec = $3.to_i
         angle = $4.to_sym
+        num_class = Flt::Num[radix]
         @data[radix] ||= {}
         @data[radix][angle] ||= {}
         @data[radix][angle][prec] ||= {}
         @data[radix][angle][prec][method] = File.read(fn).split("\n").map do |line|
-          line.split.map{|x| Flt::DecNum(x)}
+          line.split.map{|x| num_class.Num(x, :base=>radix)}
         end
       end
     end
+    BinNum.context = BinNum::IEEEDoubleContext
   end
 
   def check(f, radix=10, angle=:rad)
@@ -31,7 +31,7 @@ class TestTrig < Test::Unit::TestCase
         class_num.context.traps[DecNum::DivisionByZero] = false
         data = @data[radix][angle][prec][f]
         data.each do |x, result|
-          assert_equal result, class_num::Math.send(f, x), "#{f}(#{x})==#{result} [#{radix} #{angle} #{prec}]"
+          assert_equal result, class_num::Math.send(f, x), "#{f}(#{x})==#{result}\ninput: #{x.to_int_scale.inspect} [#{radix} #{angle} #{prec}]"
         end
       end
     end
@@ -43,14 +43,33 @@ class TestTrig < Test::Unit::TestCase
       class_num.context(:precision=>prec, :angle=>angle) do
         class_num.context.traps[DecNum::DivisionByZero] = false
         data = @data[radix][angle][prec][f]
-        data.each do |x, result|
-          y = class_num::Math.send(f, x)
-          if result.special?
-            assert_equal result, y, "#{f}(#{x})==#{result} [#{radix} #{angle} #{prec}]"
-          else
-            err_ulps = (y-result).abs/result.ulp
-            assert err_ulps<=ulps, "#{f}(#{x})==#{result} to within #{ulps} ulps; error: #{err_ulps} ulps (#{y}) [#{radix} #{angle} #{prec}]"
+        unless data.nil?
+          data.each do |x, result|
+            y = class_num::Math.send(f, x)
+            if result.special?
+              assert_equal result, y, "#{f}(#{x})==#{result} [#{radix} #{angle} #{prec}]"
+            else
+              err_ulps = (y-result).abs/result.ulp
+              assert err_ulps<=ulps, "#{f}(#{x})==#{result} to within #{ulps} ulps; error: #{err_ulps} ulps (#{y})\ninput: #{x.to_int_scale.inspect} [#{radix} #{angle} #{prec}]"
+            end
           end
+        else
+          STDERR.puts "Missing data for radix #{radix.inspect} angle #{angle.inspect} prec #{prec.inspect} #{f.inspect}"
+        end
+      end
+    end
+  end
+
+  def check_bin(f)
+    class_num = BinNum
+    @data[2][:rad].keys.each do |prec|
+      class_num.context do
+        #class_num.context.traps[DecNum::DivisionByZero] = false
+        data = @data[2][:rad][53][f]
+        data.each do |x, result|
+          x = class_num.Num(x)
+          result = ::Math.send(f, x.to_f)
+          assert_equal result, class_num::Math.send(f, x), "#{f}(#{x})==#{result} [bin]"
         end
       end
     end
@@ -104,4 +123,32 @@ class TestTrig < Test::Unit::TestCase
     check_relaxed :atan, 10, :deg
   end
 
+  def test_sin_bin
+    check_relaxed :sin, 2, :rad
+  end
+
+  def test_cos_bin
+    check_relaxed :cos, 2, :rad
+  end
+
+  def test_tan_bin
+    check_relaxed :tan, 2, :rad
+  end
+
+  def test_asin_bin
+    check_relaxed :asin, 2, :rad
+  end
+
+  def test_acos_bin
+    check_relaxed :acos, 2, :rad
+  end
+
+  def test_atan_bin
+    check_relaxed :atan, 2, :rad
+  end
+
+  # def test_bin
+  #   check_bin :sin
+  # end
+
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 1
   - 2
-  - 0
-  version: 1.2.0
+  - 1
+  version: 1.2.1
 platform: ruby
 authors: 
 - Javier Goizueta
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-15 00:00:00 +02:00
+date: 2010-06-16 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency