flt 1.0.0 → 1.1.0

data/History.txt

@@ -1,4 +1,23 @@
-== 1.0.0 2009-07-22
+== 1.1.0 2009-11-30
+
+* New Features:
+  - Access Math functions through context
+  - Enhanced compatibility with Float
+  - Enhanced DecNum trigonometry
+  - Context eval method
+  - New methods integer_part(), fraction_part()
+
+* Maintenance changes:
+  - Minor internal refactoring.
+  - Avoid some warnings on Ruby 1.9
+  - Better documentation
+
+* Bugfixes:
+  - local context blocks didn't restore previous context on return or exceptions,
+  - Tolerance fix for near zero numbers
+  - Other internal problems
+
+== 1.0.0 2009-08-05
 
 * First release of the new Flt project (derived from the former Ruby-Decimal.)
   - New gem name: flt

data/lib/flt.rb

@@ -4,6 +4,7 @@ require 'flt/version'
 require 'flt/support'
 require 'flt/float'
 require 'flt/bigdecimal'
+require 'flt/num'
 require 'flt/dec_num'
 require 'flt/bin_num'
 require 'flt/tolerance'

data/lib/flt/bigdecimal.rb

@@ -1,9 +1,9 @@
 # Support classes for homogeneous treatment of BigDecimal and Num values by defining BigDecimal.context
 
-require 'flt'
+require 'flt/num'
+
 require 'bigdecimal'
 require 'bigdecimal/math'
-
 require 'singleton'
 
 # Context class with some of the Flt::Num context functionality, to allow the use of BigDecimal numbers
@@ -14,6 +14,10 @@ class Flt::BigDecimalContext
   include Singleton
   # TODO: Context class with precision, rounding, etc. (no singleton)
 
+  def eval
+    yield self
+  end
+
   def num_class
     BigDecimal
   end

data/lib/flt/bin_num.rb

@@ -19,13 +19,13 @@ class BinNum < Num
     # Multiply by an integral power of the base: x*(radix**n) for x,n integer;
     # returns an integer.
     def int_mult_radix_power(x,n)
-      x * ((n < 0) ? (2**n) : (1<<n))
+      n < 0 ? (x / (1<<(-n))) : (x * (1<<n))
     end
 
     # Divide by an integral power of the base: x/(radix**n) for x,n integer;
     # returns an integer.
     def int_div_radix_power(x,n)
-      x / ((n < 0) ? (2**n) : (1<<n))
+      n < 0 ? (x * (1<<(-n))) : (x / (1<<n))
     end
   end
 

data/lib/flt/dec_num.rb

@@ -1,4 +1,5 @@
 require 'flt/num'
+require 'flt/bigdecimal'
 
 module Flt
 
@@ -21,13 +22,13 @@ class DecNum < Num
     # Multiply by an integral power of the base: x*(radix**n) for x,n integer;
     # returns an integer.
     def int_mult_radix_power(x,n)
-      x * (10**n)
+      n < 0 ? (x / (10**(-n))) : (x * (10**n))
     end
 
     # Divide by an integral power of the base: x/(radix**n) for x,n integer;
     # returns an integer.
     def int_div_radix_power(x,n)
-      x / (10**n)
+      n < 0 ? (x * (10**(-n))) : (x / (10**n))
     end
   end
 

data/lib/flt/float.rb

@@ -2,7 +2,9 @@
 #
 # The set of constants with Float metadata is also augmented.
 
-require 'flt'
+require 'flt/num'
+require 'singleton'
+
 
 # Float constants.
 #
@@ -79,8 +81,6 @@ class Float
 
 end
 
-require 'singleton'
-
 # Context class with some of the Flt::Num context functionality, to allow the use of Float numbers
 # similarly to other Num values; this eases the implementation of functions compatible with either
 # Num or Float values.
@@ -425,9 +425,14 @@ class Flt::FloatContext
 
     def math_function(*methods) #:nodoc:
       methods.each do |method|
-        define_method(method) do |x|
-          Math.send(method, x.to_f)
+        define_method(method) do |*args|
+          x = args.shift.to_f
+          Math.send(method, x, *args)
         end
+        # TODO: consider injecting the math methods into Float
+        # Float.send(:define_method, method) do |*args|
+        #   Math.send(method, self, *args)
+        # end
       end
     end
 
@@ -441,8 +446,31 @@ class Flt::FloatContext
   float_binary_operator :power, :**
 
   math_function :log, :log10, :exp, :sqrt,
-                :sin, :cos, :tan, :asin, :acos, :atan,
+                :sin, :cos, :tan, :asin, :acos, :atan, :atan2,
                 :sinh, :cosh, :tanh, :asinh, :acosh, :atanh
+
+  def ln(x)
+    log(x)
+  end
+
+  def pi
+    Float::PI
+  end
+
+  def eval
+    yield self
+  end
+
+  def math(*parameters, &blk)
+    if parameters.empty?
+      self.instance_eval &blk
+    else
+      # needs instance_exe (available in Ruby 1.9, ActiveRecord; TODO: include implementation here)
+      self.instance_exec *parameters, &blk
+    end
+  end
+
+
 end
 
 # Return a (limited) context object for Float.

data/lib/flt/math.rb

@@ -1,5 +1,10 @@
 require 'flt/dec_num'
 
+# TODO:
+# * convert arguments as Context#_convert does, to accept non DecNum arguments
+# * Better precision (currently is within about 2 ulps of the correct result)
+# * Speed optimization
+
 module Flt
   class DecNum
     module Math
@@ -8,59 +13,360 @@ module Flt
 
       module_function
 
-      # Trinogometry
+      # Trigonometry
+
+      HALF = DecNum('0.5')
 
       # Pi
-      def pi(decimals=nil)
-        three = DecNum(3)
-        lasts, t, s, n, na, d, da = 0, three, 3, 1, 0, 0, 24
-        Flt::DecNum.context(:precision=>decimals) do |local_context|
-          local_context.precision += 2 # extra digits for intermediate steps
-          while s != lasts
-            lasts = s
-            n, na = n+na, na+8
-            d, da = d+da, da+32
-            t = (t * n) / d
-            s += t
+      $no_cache = false
+      @@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]
+          DecNum.context(:precision=>round_digits){+DecNum(+1,v.to_i,1-l)}
+      end
+
+      def e(decimals=nil)
+        DecNum.context do |local_context|
+          local_context.precision = decimals if decimals
+          DecNum(1).exp
         end
-        return +s
       end
 
       # Cosine of angle in radians
       def cos(x)
-        i, lasts, s, fact, num, sign = 0, 0, 1, 1, 1, 1
+        x = x.abs
+        rev_sign = false
+        s = nil
         DecNum.context do |local_context|
-          local_context.precision += 2 # extra digits for intermediate steps
+          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
+          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 *= x * x
-            sign *= -1
-            s += num / fact * sign
+            num *= x2
+            s += num / fact
           end
         end
-        return +s
+        return rev_sign ? (-s) : (+s)
       end
 
       # Sine of angle in radians
       def sin(x)
-        i, lasts, s, fact, num, sign = 1, 0, x, 1, x, 1
+        sign = x.sign
+        s = nil
         DecNum.context do |local_context|
-          local_context.precision += 2 # extra digits for intermediate steps
+          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 = +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 *= x * x
-            sign *= -1
-            s += num / fact * sign
+            num *= x2
+            s += num / fact
+          end
+        end
+        return (+s).copy_sign(sign)
+      end
+
+      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
+        end
+      end
+
+      # Arc-tangent.
+      def atan(x)
+        s = nil
+        DecNum.context do |local_context|
+          local_context.precision += 2
+          if x == 0
+            return DecNum.zero
+          elsif x.abs > 1
+            if x.infinite?
+              s = (pi*HALF).copy_sign(x)
+              break
+            else
+              c = (pi*HALF).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
         end
         return +s
       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 += pi.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 pi * (2 - x) / (4 * y)
+              end
+          end
+
+          if y != 0
+              return atan(DecNum.infinity(y.sign))
+          elsif x < 0
+              return pi.copy_sign(x)
+          else
+              return DecNum.zero
+          end
+      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 -pi*HALF
+          elsif x == 0
+              return DecNum.zero
+          elsif x == 1
+              return pi*HALF
+          end
+
+          DecNum.context do |local_context|
+            local_context.precision += 3
+            x = x/(1-x*x).sqrt
+            x = atan(x)
+          end
+          +x
+      end
+
+      def acos(x)
+
+        # We can compute acos(x) = pi/2 - asin(x)
+        # but we must take care with x near 1, where that formula would cause loss of precision
+
+        return DecNum.context.exception(Num::InvalidOperation, 'acos needs -1 <= x <= 2') if x.abs > 1
+
+        if x == -1
+            return pi
+        elsif x == 0
+            return +DecNum.context(:precision=>DecNum.context.precision+3){pi*HALF}
+        elsif x == 1
+            return DecNum.zero
+        end
+
+        # some identities:
+        #   acos(x) = pi/2 - asin(x) # (but this losses accuracy near x=+1)
+        #   acos(x) = pi/2 - atan(x/(1-x*x).sqrt) # this too
+        #   acos(x) = asin((1-x*x).sqrt) for x>=0; for x<=0  acos(x) = pi/2 - asin((1-x*x).sqrt)
+
+        if x < HALF
+          DecNum.context do |local_context|
+            local_context.precision += 3
+            x = x/(1-x*x).sqrt
+            x = pi*HALF - 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
+        end
+        +x
+
+      end
+
+      # TODO: degrees mode or radians/degrees conversion
+
+      def pi2(decimals=nil)
+        decimals ||= DecNum.context.precision
+        DecNum.context(:precision=>decimals) do
+          pi(decimals)*2
+        end
+      end
+
+      def invpi(decimals=nil)
+        decimals ||= DecNum.context.precision
+        DecNum.context(:precision=>decimals) do
+          DecNum(1)/pi(decimals)
+        end
+      end
+
+      def inv2pi(decimals=nil)
+        decimals ||= DecNum.context.precision
+        DecNum.context(:precision=>decimals) do
+          DecNum(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 +DecNum.context(:precision=>DecNum.context.precision*3){x.modulo(pi2)}
+          # This seems to be slower and less accurate:
+          # prec = DecNum.context.precision
+          # pi_2 = pi2(prec*2)
+          # return x if x < pi_2
+          # ex = x.fractional_exponent
+          # DecNum.context do |local_context|
+          #   # x.modulo(pi_2)
+          #   local_context.precision *= 2
+          #   if ex > prec
+          #     # consider exponent separately
+          #     fd = nil
+          #     excess = ex - prec
+          #     x = x.scaleb(prec-ex)
+          #     # now obtain 2*prec digits from inv2pi after the initial excess digits
+          #     digits = nil
+          #     inv_2pi = inv2pi(local_context.precision+excess)
+          #     DecNum.context do |extended_context|
+          #       extended_context.precision += excess
+          #       digits = (inv2pi.scaleb(excess)).fraction_part
+          #     end
+          #     x *= digits*pi_2
+          #   end
+          #   # compute the fractional part of the division by 2pi
+          #   inv_2pi ||= inv2pi
+          #   x = pi_2*((x*inv2pi).fraction_part)
+          # end
+          # +x
+        end
+
+        # 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
+            DecNum.context.precision *= 3
+            m = k0.nil? ? pi2 : pi/k0
+            a.divmod(m)+[m]
+          end
+          [r, k.modulo(k0*2).to_i, divisor]
+        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)
+          end
+        end
+      end
+    end
+
+    math_function :sin, :cos, :tan, :atan, :asin, :acos
+
+    def pi
+      Math.pi
+    end
+
+    def e
+      Math.e
+    end
+
   end # DecNum
 end # Flt

data/lib/flt/num.rb

@@ -413,6 +413,38 @@ class Num < Numeric
 
     end
 
+    # Evaluate a block under a context (set up the context as a local context)
+    #
+    # When we have a context object we can use this instead of using the context method of the
+    # numeric class, e.g.:
+    #   DecNum.context(context) { ... }
+    # This saves verbosity, specially when numeric class is not fixed, in which case
+    # we would have to write:
+    #   context.num_class.context(context) { ... }
+    # With this method, we simply write:
+    #   context.eval { ... }
+    def eval(&blk)
+      # TODO: consider other names for this method; use ? apply ? local ? with ?
+      num_class.context(self, &blk)
+    end
+
+    # Evalute a block under a context (set up the context as a local context) and inject the
+    # context methods (math and otherwise) into the block scope.
+    #
+    # This allows the use of regular algebraic notations for math functions,
+    # e.g. exp(x) instead of x.exp
+    def math(*parameters, &blk)
+      # TODO: consider renaming this to eval
+      num_class.context(self) do
+        if parameters.empty?
+          num_class.context.instance_eval &blk
+        else
+          # needs instance_exe (available in Ruby 1.9, ActiveRecord; TODO: include implementation here)
+          num_class.context.instance_exec *parameters, &blk
+        end
+      end
+    end
+
     # This gives access to the numeric class (Flt::Num-derived) this context is for.
     def num_class
       @num_class
@@ -1172,18 +1204,21 @@ class Num < Numeric
   # options to apply to the local scope.
   # Changes done to the current context are reversed when the scope is exited.
   def self.local_context(*args)
-    keep = self.context # use this so _context is initialized if necessary
-    self.context = define_context(*args) # this dups the assigned context
-    result = yield _context
-    # TODO: consider the convenience of copying the flags from DecNum.context to keep
-    # This way a local context does not affect the settings of the previous context,
-    # but flags are transferred.
-    # (this could be done always or be controlled by some option)
-    #   keep.flags = DecNum.context.flags
-    # Another alternative to consider: logically or the flags:
-    #   keep.flags ||= DecNum.context.flags # (this requires implementing || in Flags)
-    self._context = keep
-    result
+    begin
+      keep = self.context # use this so _context is initialized if necessary
+      self.context = define_context(*args) # this dups the assigned context
+      result = yield _context
+    ensure
+      # TODO: consider the convenience of copying the flags from DecNum.context to keep
+      # This way a local context does not affect the settings of the previous context,
+      # but flags are transferred.
+      # (this could be done always or be controlled by some option)
+      #   keep.flags = DecNum.context.flags
+      # Another alternative to consider: logically or the flags:
+      #   keep.flags ||= DecNum.context.flags # (this requires implementing || in Flags)
+      self._context = keep
+      result
+    end
   end
 
   class <<self
@@ -1232,11 +1267,11 @@ class Num < Numeric
     end
 
     def int_mult_radix_power(x,n)
-      x * self.radix**n
+      n < 0 ? (x / self.radix**(-n)) : (x * self.radix**n)
     end
 
     def int_div_radix_power(x,n)
-      x / self.radix**n
+      n < 0 ? (x * self.radix**(-n) ) : (x / self.radix**n)
     end
   end
 
@@ -2482,6 +2517,21 @@ class Num < Numeric
     @exp
   end
 
+  # Integer part (as a Num)
+  def integer_part
+    ans = _check_nans
+    return ans if ans
+    return_as_num = {:places=>0}
+    self.sign < 0 ? self.ceil(return_as_num) : self.floor(return_as_num)
+  end
+
+  # Fraction part (as a Num)
+  def fraction_part
+    ans = _check_nans
+    return ans if ans
+    self - self.integer_part
+  end
+
   # Return the value of the number as an signed integer and a scale.
   def to_int_scale
     if special?
@@ -3680,7 +3730,7 @@ class Num < Numeric
 
     # Parse numeric text literals (internal use)
     def _parser(txt)
-      md = /^\s*([-+])?(?:(?:(\d+)(?:\.(\d*))?|\.(\d+))(?:[eE]([-+]?\d+))?|Inf(?:inity)?|(s)?NaN(\d*))\s*$/i.match(txt)
+      md = /^\s*([-+])?(?:(?:(\d+)(?:\.(\d*))?|\.(\d+))(?:E([-+]?\d+))?|Inf(?:inity)?|(s)?NaN(\d*))\s*$/i.match(txt)
       if md
         OpenStruct.new :sign=>md[1], :int=>md[2], :frac=>md[3], :onlyfrac=>md[4], :exp=>md[5],
                        :signal=>md[6], :diag=>md[7]

data/lib/flt/support.rb

@@ -483,9 +483,9 @@ module Flt
                 float = true
                 context = BinNum::FloatContext
               end
-              x = context.num_class.context(context) do |context|
-                context.rounding = round_mode
-                Num.convert_exact(Num[eb].Num(sign, f, e), context.num_class, context)
+              x = context.num_class.context(context) do |loca_context|
+                local_context.rounding = round_mode
+                Num.convert_exact(Num[eb].Num(sign, f, e), local_context.num_class, local_context)
               end
               if float
                 x = x.to_f
@@ -593,7 +593,7 @@ module Flt
             min_exp = (e*Math.log(Float::RADIX)/Math.log(base)).ceil
             @float_min_max_exp_values[k] = min_max = [min_exp, max_exp]
           end
-          min_max.map{|e| e - 1} # adjust
+          min_max.map{|exp| exp - 1} # adjust
         end
       end
 
@@ -1330,6 +1330,25 @@ module Flt
   end # Support
 
 
-
-
-end # Flt
+end # Flt
+
+# The math method of context needs instance_exec to pass parameters to the blocks evaluated
+# with a modified self (pointing to a context object.) intance_exec is available in Ruby 1.9.1 and
+# is also defined by ActiveRecord. Here we use Mauricio Fernández implementation if it is not
+# available.
+class Object
+  unless defined? instance_exec
+    module InstanceExecHelper; end
+    include InstanceExecHelper
+    def instance_exec(*args, &block) # !> method redefined; discarding old instance_exec
+      mname = "__instance_exec_#{Thread.current.object_id.abs}_#{object_id.abs}"
+      InstanceExecHelper.module_eval{ define_method(mname, &block) }
+      begin
+        ret = send(mname, *args)
+      ensure
+        InstanceExecHelper.module_eval{ undef_method(mname) } rescue nil
+      end
+      ret
+    end
+  end
+end

data/lib/flt/tolerance.rb

@@ -3,17 +3,18 @@
 # Tolerance can be used to allow for a tolerance in floating-point comparisons.
 #
 # A Tolerance can be defined independently of the type (floating-point numeric class)
-# it will be used with; The actual tolerance value will be compute for a particular reference value:
+# it will be used with; The actual tolerance value will be compute for a particular reference value, and
+# for some kinds of tolerance (e.g. epsilon) a value is not available without a reference:
 #
 #   tol = Tolerance(3, :decimals)
-#   puts tol.value(DecNum('10.0')).inspect
-#   puts tol.value(10.0).inspect
-#   puts tol.value.inspect
+#   puts tol.value(DecNum('10.0')).inspect        # -> DecNum('0.0005')
+#   puts tol.value(10.0).inspect                  # ->  0.0005
+#   puts tol.value.inspect                        # -> Rational(1, 2000)
 #
 #   tol = Tolerance(:epsilon)
-#   puts tol.value(DecNum('10.0')).inspect
-#   puts tol.value(10.0).inspect
-#   puts tol.value.inspect
+#   puts tol.value(DecNum('10.0')).inspect        # -> DecNum('1.00E-26')
+#   puts tol.value(10.0).inspect                  # -> 2.22044604925031e-15
+#   puts tol.value.inspect                        # -> nil
 #
 # Tolerances can be:
 # * Absolute: the tolerance value is a fixed value independent of the values to be compared.
@@ -57,36 +58,36 @@
 # Examples:
 #
 #   tol = Tolerance(100, :absolute)
-#   puts tol.value(1.0)
-#   puts tol.value(1.5)
-#   puts tol.value(1.0E10)
-#   puts tol.eq?(11234.0, 11280.0)
+#   puts tol.value(1.0)                                   # -> 100.0
+#   puts tol.value(1.5)                                   # -> 100.0
+#   puts tol.value(1.0E10)                                # -> 100.0
+#   puts tol.eq?(11234.0, 11280.0)                        # -> true
 #
 #   tol = Tolerance(100, :relative)
-#   puts tol.value(1.0)
-#   puts tol.value(1.5)
-#   puts tol.value(1.0E10)
-#   puts tol.eq?(11234.0, 11280.0)
+#   puts tol.value(1.0)                                   # -> 100.0
+#   puts tol.value(1.5)                                   # -> 150.0
+#   puts tol.value(1.0E10)                                # -> 1000000000000.0
+#   puts tol.eq?(11234.0, 11280.0)                        # -> true
 #
 #   tol = Tolerance(100, :floating)
-#   puts tol.value(1.0)
-#   puts tol.value(1.5)
-#   puts tol.value(1.0E10)
-#   puts tol.eq?(11234.0, 11280.0)
+#   puts tol.value(1.0)                                   # -> 100.0
+#   puts tol.value(1.5)                                   # -> 200.0
+#   puts tol.value(1.0E10)                                # -> 1717986918400.0
+#   puts tol.eq?(11234.0, 11280.0)                        # -> true
 #
 #   tol = Tolerance(3, :sig_decimals)
-#   puts tol.eq?(1.234,1.23)
+#   puts tol.eq?(1.234,1.23)                              # -> true
 #
 #   tol = Tolerance(1, :ulps)
-#   puts tol.eq?(3.3433, 3.3433.next)
-#   puts tol.eq?(DecNum('1.1'), DecNum('1.1').next)
+#   puts tol.eq?(3.3433, 3.3433.next_plus)                # -> true
+#   puts tol.eq?(DecNum('1.1'), DecNum('1.1').next_plus)  # -> true
 #
 #   tol = Tolerance(1, :percent)
-#   puts tol.equal_to?(3.14159, Math::PI)
-#
+#   puts tol.equal_to?(3.14159, Math::PI)                 # -> true#
 
-require 'flt'
+require 'flt/num'
 require 'flt/float'
+require 'flt/bigdecimal'
 
 module Flt
 
@@ -339,7 +340,7 @@ module Flt
 
       num_class = xs.first.class
       context = num_class.context
-      xs = xs.map{|x| context.Num(x)}
+      xs = xs.map{|x| x = context.Num(x); x.zero? ? context.minimum_normal(context.sign(x)) : x}
       v = cast_value(num_class)
 
       # TODO: simplify using context

data/lib/flt/version.rb

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

data/test/test_basic.rb

@@ -50,6 +50,13 @@ def exp1(x, c=nil)
   return +y
 end
 
+def return_from_local_context
+  DecNum.context do |local_context|
+    local_context.precision += 2
+    return
+  end
+end
+
 class TestBasic < Test::Unit::TestCase
 
 
@@ -62,6 +69,8 @@ class TestBasic < Test::Unit::TestCase
 
     DecNum.context.precision = 4
     assert_equal 4, DecNum.context.precision
+    return_from_local_context
+    assert_equal 4, DecNum.context.precision
     assert_equal DecNum("0.3333"), DecNum(1)/DecNum(3)
     DecNum.context.precision = 10
     assert_equal 10, DecNum.context.precision

data/test/test_bin_arithmetic.rb

@@ -10,6 +10,14 @@ class TestBinArithmetic < Test::Unit::TestCase
     @test_float_data ||= Array.new(1000){random_num(Float)} + singular_nums(Float) # + special_nums(Float)
   end
 
+  # TODO: some of these tests may fail under some OSs due to the rounding of subnormal results.
+  #       On OSX, linux, etc. the rounding of subnormal Float results seems to be as performed by BinNum:
+  #       as if the exact result is rounded to the number of bits of the subnormal result.
+  #       But on Windows OSs (even under Cygwin) subnormal results seem to be rounded first to the
+  #       full Float precision (53 bits).
+  #       Consider avoid testing with subnormal results, at least on Winddows, or preparing test data,
+  #       including results, in a reliable machine.
+
   def test_addition
     float_emulation_context
     each_pair(@test_float_data) do |x, y|

data/test/test_trig.rb

@@ -0,0 +1,76 @@
+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
+
+
+  def setup
+    @data12 = {}
+    [:sin, :cos, :tan, :asin, :acos, :atan].each do |f|
+      @data12[f] = File.read(File.join(File.dirname(__FILE__), "trigtest/#{f}12.txt")).split("\n").map do |line|
+        line.split.map{|x| Flt::DecNum(x)}
+      end
+    end
+  end
+
+  def check(f)
+    DecNum.context(:precision=>12) do
+      data = @data12[f]
+      data.each do |x, result|
+        assert_equal result, DecNum::Math.send(f, x), "#{f}(#{x})==#{result}"
+      end
+    end
+  end
+
+  def check_relaxed(f, ulps=2)
+    DecNum.context(:precision=>12) do
+      data = @data12[f]
+      data.each do |x, result|
+        y = DecNum::Math.send(f, x)
+        err_ulps = (y-result).abs/result.ulp
+        assert err_ulps<=ulps, "#{f}(#{x})==#{result} to within #{ulps} ulps; error: #{err_ulps} ulps (#{y}) [#{DecNum.context.precision}]"
+      end
+    end
+  end
+
+
+  # def test_trig
+  #   DecNum.context(:precision=>12) do
+  #     @data12.keys.each do |f|
+  #       data = @data12[f]
+  #       data.each do |x, result|
+  #         assert_equal result, DecNum::Math.send(f, x), "#{f}(#{x})==#{result}"
+  #       end
+  #     end
+  #   end
+  # end
+
+  # separate tests per function
+
+  def test_sin
+    check_relaxed :sin
+  end
+
+  def test_cos
+    check_relaxed :cos
+  end
+
+  def test_tan
+    check_relaxed :tan
+  end
+
+  def test_asin
+    check_relaxed :asin
+  end
+
+  def test_acos
+    check_relaxed :acos
+  end
+
+  def test_atan
+    check_relaxed :atan
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: flt
 version: !ruby/object:Gem::Version 
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors: 
 - Javier Goizueta
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-08-05 00:00:00 +02:00
+date: 2009-11-30 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -87,6 +87,7 @@ files:
 - test/test_to_int.rb
 - test/test_to_rf.rb
 - test/test_tol.rb
+- test/test_trig.rb
 - test/test_ulp.rb
 has_rdoc: true
 homepage: http://flt.rubyforge.org
@@ -121,7 +122,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: flt
-rubygems_version: 1.3.3
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
 summary: Floating Point Numbers
@@ -144,4 +145,5 @@ test_files:
 - test/test_to_int.rb
 - test/test_to_rf.rb
 - test/test_tol.rb
+- test/test_trig.rb
 - test/test_ulp.rb