nio 0.2.3 → 0.2.4

data/test/test_repdec.rb

@@ -7,10 +7,8 @@
 # as published by the Free Software Foundation; either version 2
 # of the License, or (at your option) any later version.
 
-#require File.dirname(__FILE__) + '/test_helper.rb'
+#require File.dirname(__FILE__) + '/helper.rb'
 require 'test/unit'
-
-require 'nio/repdec'
 include Nio
 require 'yaml'
 
@@ -81,8 +79,8 @@ class TestRepdec < Test::Unit::TestCase
       assert_equal [1, 0], r.setS("Infinity").getQ
 
       assert_equal "-Infinity", r.setS("-Infinity").getS(0)
-      assert_equal [-1, 0], r.setS("-Infinity").getQ    
+      assert_equal [-1, 0], r.setS("-Infinity").getQ
     end
-   
+  
 end
  

data/test/test_rtnlzr.rb

@@ -1,30 +1,30 @@
 
-# Copyright (C) 2003-2005, Javier Goizueta <javier@goizueta.info>
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-require 'test/unit'
-
-require 'nio/rtnlzr'
-require 'nio/sugar'
+
+require File.dirname(__FILE__) + '/helper.rb'
 include Nio
 require 'yaml'
+require 'flt'
+require 'flt/float'
+require 'flt/math'
+require 'flt/bigdecimal'
 require 'bigdecimal/math'
 
-class TestRtnlzr < Test::Unit::TestCase
 
-  class BgMth
-    extend BigMath
-  end
+require 'bigdecimal/math'
+
+module BgMth
+  extend BigMath
+end
+
+
+class TestRtnlzr < Test::Unit::TestCase
 
   def setup
     
         $data = YAML.load(File.read(File.join(File.dirname(__FILE__) ,'data.yaml'))).collect{|x| [x].pack('H*').unpack('E')[0]}
     
   end
-  
+
   
     def test_basic_rtnlzr
       # basic Rtnlzr tests
@@ -34,7 +34,9 @@ class TestRtnlzr < Test::Unit::TestCase
       assert_equal [13,10], Rtnlzr.max_denominator(BigDecimal('1.3'),10)
       assert_equal [1,3], Rtnlzr.max_denominator(1.0/3,10)
       assert_equal [1,3], Rtnlzr.max_denominator(BigDecimal('1')/3,10)
-      
+      assert_equal [13,10], Rtnlzr.max_denominator(Flt.DecNum('1.3'),10)
+      assert_equal [1,3], Rtnlzr.max_denominator(Flt.DecNum('1')/3,10)
+
       # basic tests of Float#nio_r
       assert_equal Rational(1,3), (1.0/3.0).nio_r
       assert_equal Rational(2,3), (2.0/3.0).nio_r
@@ -42,57 +44,77 @@ class TestRtnlzr < Test::Unit::TestCase
       assert_equal Rational(89,217), (89.0/217.0).nio_r
 
       # rationalization of Floats using a tolerance
-      t = Tolerance.new(1e-15,:sig)
+      t = Flt.Tolerance(1e-15/2,:floating)
       assert_equal Rational(540429, 12500),43.23432.nio_r(t)
       assert_equal Rational(6636649, 206596193),0.032123772.nio_r(t)
       assert_equal Rational(280943, 2500000), 0.1123772.nio_r(t)
       assert_equal Rational(39152929, 12500), 3132.23432.nio_r(t)
       assert_equal Rational(24166771439, 104063), 232232.123223432.nio_r(t)
-      assert_equal Rational(792766404965, 637), 1244531247.98273123.nio_r(t)    
+      assert_equal Rational(792766404965, 637), 1244531247.98273123.nio_r(t)
       #$data.each do |x|
       #  assert t.equals?(x, x.nio_r(t).to_f), "out of tolerance: #{x.inspect} #{x.nio_r(t).inspect}"
       #end
-      
-      # rationalization with maximum denominator 
-      assert_equal Rational(9441014047197, 7586), (1244531247.98273123.nio_r(10000))  
+
+      # rationalization with maximum denominator
+      assert_equal Rational(9441014047197, 7586), (1244531247.98273123.nio_r(10000))
       assert_equal Rational(11747130449709, 9439), BigDecimal('1244531247.982731230').nio_r(10000)
-      
-      
+      assert_equal Rational(11747130449709, 9439), Flt.DecNum('1244531247.982731230').nio_r(10000)
+
+
       # approximate a value in [0.671,0.672];
       #  Float
-      assert_equal [43,64], Rtnlzr.new(Tolerance.new(0.0005)).rationalize(0.6715)
-      assert_equal [43,64], Rtnlzr.new(Tol(0.0005)).rationalize(0.6715)
+      assert_equal [43,64], Rtnlzr.new(Flt.Tolerance(0.0005)).rationalize(0.6715)
       assert_equal [43,64], Rtnlzr.new(Rational(5,10000)).rationalize(0.6715)
+      # BinNum
+      assert_equal [43,64], Rtnlzr.new(Flt.Tolerance(Flt.BinNum('0.0005'))).rationalize(Flt::BinNum('0.6715'))
+      assert_equal [43,64], Rtnlzr.new(Flt.Tolerance(Rational(5,10000))).rationalize(Flt::BinNum('0.6715'))
       #  BigDecimal
-      assert_equal [43,64], Rtnlzr.new(BigTolerance.new(BigDecimal('0.0005'))).rationalize(BigDecimal('0.6715'))
-      assert_equal [43,64], Rtnlzr.new(Tol(BigDecimal('0.0005'))).rationalize(BigDecimal('0.6715'))
+      assert_equal [43,64], Rtnlzr.new(Flt.Tolerance('0.0005')).rationalize(BigDecimal('0.6715'))
       assert_equal [43,64], Rtnlzr.new(Rational(5,10000)).rationalize(BigDecimal('0.6715'))
-      # 
+      # DecNum
+      assert_equal [43,64], Rtnlzr.new(Flt.Tolerance(Flt.DecNum('0.0005'))).rationalize(Flt::DecNum('0.6715'))
+      assert_equal [43,64], Rtnlzr.new(Flt.Tolerance(Rational(5,10000))).rationalize(Flt::DecNum('0.6715'))
+      #
       assert_equal Rational(43,64), 0.6715.nio_r(0.0005)
       assert_equal Rational(43,64), 0.6715.nio_r(Rational(5,10000))
       assert_equal Rational(47,70), 0.6715.nio_r(70)
       assert_equal Rational(45,67), 0.6715.nio_r(69)
       assert_equal Rational(2,3), 0.6715.nio_r(10)
-      
+
       # some PI tests
-      assert_equal Rational(899125804609,286200632530), BgMth.PI(64).nio_r(BigTolerance.new(BigDec('261E-24')))
-      assert_equal Rational(899125804609,286200632530), BgMth.PI(64).nio_r(Tol(BigDec('261E-24')))
-      assert_equal Rational(899125804609,286200632530), BgMth.PI(64).nio_r(BigDec('261E-24'))
-      assert_equal Rational(899125804609,286200632530), BgMth.PI(64).nio_r(BigDec(261E-24))
-      assert_equal Rational(899125804609,286200632530), BgMth.PI(64).nio_r(261E-24)  
-      
-      # BigDecimal tests
-      #t = BigTolerance.new(BigDecimal('1e-15'),:sig)
-      t = BigTolerance.decimals(20,:sig)    
+      assert_equal Rational(899125804609,286200632530), BgMth.PI(64).nio_r(Flt.Tolerance(Flt.DecNum('261E-24')))
+      assert_equal Rational(899125804609,286200632530), BgMth.PI(64).nio_r(Flt.Tolerance(Flt.DecNum('261E-24')))
+      assert_equal Rational(899125804609,286200632530), BgMth.PI(64).nio_r(Flt.DecNum('261E-24'))
+      assert_equal Rational(899125804609,286200632530), BgMth.PI(64).nio_r(261E-24)
+
+      assert_equal Rational(899125804609,286200632530), Flt::DecNum::Math.pi(64).nio_r(Flt.Tolerance(Flt.DecNum('261E-24')))
+      assert_equal Rational(899125804609,286200632530), Flt::DecNum::Math.pi(64).nio_r(Flt.Tolerance(Flt.DecNum('261E-24')))
+      assert_equal Rational(899125804609,286200632530), Flt::DecNum::Math.pi(64).nio_r(Flt.DecNum('261E-24'))
+      assert_equal Rational(899125804609,286200632530), Flt::DecNum::Math.pi(64).nio_r(261E-24)
+
+      # DecNum tests
+      #t = Flt.Tolerance(Flt.DecNum('1e-15'),:floating)
+      t = Flt.Tolerance(20,:sig_decimals)
       $data.each do |x|
-        x = BigDec(x,:exact)
+        x = Flt.BinNum(x).to_decimal_exact
         q = x.nio_r(t)
-        assert t.equals?(x, BigDec(q)), "out of tolerance: #{x.inspect} #{BigDec(q)}"
+        assert t.eq?(x, Flt.DecNum(q)), "out of tolerance: #{x.inspect} #{Flt.DecNum(q)}"
       end
+
+      # Flt tests
+      #t = Flt.Tolerance(Flt.DecNum('1e-15'),:floating)
+      t = Flt.Tolerance(20,:sig_decimals)
+      $data.each do |x|
+        x = Flt.BinNum(x)
+        q = x.nio_r(t)
+        assert t.eq?(x, Flt.BinNum(q)), "out of tolerance: #{x.inspect} #{Flt.BinNum(q)}"
+      end
+
+
     end
   
       def test_compare_algorithms
-        r = Rtnlzr.new(Tolerance.new(1e-5,:sig))
+        r = Rtnlzr.new(Flt.Tolerance(1e-5,:floating))
         ($data + $data.collect{|x| -x}).each do |x|
           q1 = r.rationalize_Knuth(x)
           q2 = r.rationalize_Horn(x)
@@ -105,7 +127,7 @@ class TestRtnlzr < Test::Unit::TestCase
           assert_equal q1, q3
           #assert_equal q1, q4
         end
-        r = Rtnlzr.new(Tolerance.epsilon)
+        r = Rtnlzr.new(Flt.Tolerance(:epsilon))
         ($data + $data.collect{|x| -x}).each do |x|
           q1 = r.rationalize_Knuth(x)
           q2 = r.rationalize_Horn(x)
@@ -118,8 +140,8 @@ class TestRtnlzr < Test::Unit::TestCase
           assert_equal q1, q3
           #assert_equal q1, q4
         end
-        
+
       end
-   
   
+
 end

data/test/test_tools.rb

@@ -1,5 +1,5 @@
 
-#require File.dirname(__FILE__) + '/test_helper.rb'
+#require File.dirname(__FILE__) + '/helper.rb'
 require 'test/unit'
 
 require 'nio/repdec'
@@ -35,6 +35,6 @@ class TestTools < Test::Unit::TestCase
     assert_equal(x.hash,y.hash)
     assert_equal(false,x.hash==z.hash)
   end
-   
+  
 end
  

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: nio
 version: !ruby/object:Gem::Version 
-  version: 0.2.3
+  version: 0.2.4
 platform: ruby
 authors: 
 - Javier Goizueta
@@ -9,9 +9,19 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-12-24 00:00:00 +01:00
+date: 2009-08-05 00:00:00 +02:00
 default_executable: 
 dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: flt
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.0
+    version: 
 - !ruby/object:Gem::Dependency 
   name: bones
   type: :development
@@ -41,7 +51,6 @@ files:
 - Rakefile
 - SOURCE.txt
 - lib/nio.rb
-- lib/nio/flttol.rb
 - lib/nio/fmt.rb
 - lib/nio/repdec.rb
 - lib/nio/rtnlzr.rb
@@ -64,13 +73,15 @@ files:
 - tasks/svn.rake
 - tasks/test.rake
 - test/data.yaml
+- test/helper.rb
 - test/test_fmt.rb
-- test/test_helper.rb
 - test/test_repdec.rb
 - test/test_rtnlzr.rb
 - test/test_tools.rb
 has_rdoc: true
 homepage: http://nio.rubyforge.org
+licenses: []
+
 post_install_message: 
 rdoc_options: 
 - --main
@@ -100,13 +111,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: nio
-rubygems_version: 1.2.0
+rubygems_version: 1.3.3
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: Numeric input/output
 test_files: 
 - test/test_fmt.rb
-- test/test_helper.rb
 - test/test_repdec.rb
 - test/test_rtnlzr.rb
 - test/test_tools.rb

data/lib/nio/flttol.rb

@@ -1,669 +0,0 @@
-# Floating point tolerance
-#--
-# Copyright (C) 2003-2005, Javier Goizueta <javier@goizueta.info>
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#++
-#
-# Author::    Javier Goizueta (mailto:javier@goizueta.info)
-# Copyright:: Copyright (c) 2002-2004 Javier Goizueta
-# License::   Distributes under the GPL license
-#
-# This module provides a numeric tolerance class for Float and BigDecimal.
-
-require 'bigdecimal'
-require 'bigdecimal/math' if RUBY_VERSION>='1.8.1'
-require 'nio/tools'
-
-
-class Float  
-  unless const_defined?(:RADIX) # old Ruby versions didn't have this
-    # Base of the Float representation
-    RADIX = 2
-    
-    x = 1.0
-    _bits_ = 0
-    while 1!=x+1
-      _bits_ += 1
-      x /= 2
-    end
-    if ((1.0+2*x)-1.0)>2*x
-      _bits_ -= 1
-    end
-              
-    # Number of RADIX-base digits of precision in a Float
-    MANT_DIG = _bits_
-    # Number of decimal digits that can be stored in a Float and recovered
-    DIG = ((MANT_DIG-1)*Math.log(RADIX)/Math.log(10)).floor
-    # Smallest value that added to 1.0 produces something different from 1.0
-    EPSILON = Math.ldexp(*Math.frexp(1).collect{|e| e.kind_of?(Integer) ? e-(MANT_DIG-1) : e})
-  end
-  # Decimal precision required to represent a Float and be able to recover its value  
-  DECIMAL_DIG = (MANT_DIG*Math.log(RADIX)/Math.log(10)).ceil+1
-end
-
-# :stopdoc:
-# A problem has been detected with Float#to_i() in some Ruby versiones
-# (it has been found in Ruby 1.8.4 compiled for x86_64_linux|)
-# This problem makes to_i produce an incorrect sign on some cases.
-# Here we try to detect the problem and apply a quick patch,
-# although this will slow down the method.
-if 4.611686018427388e+018.to_i < 0
-  class Float
-    alias _to_i to_i
-    def to_i
-      neg = (self < 0)
-      i = _to_i
-      i_neg = (i < 0)
-      i = -i if neg != i_neg
-      i
-    end
-  end  
-end
-# :startdoc:
-
-
-# This module contains some constructor-like module functions
-# to help with the creation of tolerances and big-decimals.
-#
-# =BigDec
-#   BigDec(x) -> a BigDecimal
-#   BigDec(x,precision) -> a BigDecimal
-#   BigDec(x,:exact) -> a BigDecimal
-# This is a shortcut to define a BigDecimal without using quotes
-# and a general conversion to BigDecimal method. 
-#
-# The second parameter can be :exact to try for an exact conversion
-#
-# Conversions from Float have issues that should be understood; :exact
-# conversion will use the exact internal value of the Float, and when
-# no precision is specified, a value as simple as possible expressed as
-# a fraction will be used.
-#
-# =Tol
-#  Tol(x) -> a Tolerance
-# This module function will convert its argument to a Noi::Tolerance
-# or a Noi::BigTolerance depending on its argument;
-#
-# Values of type Tolerance,Float,Integer (for Tolerance) or
-# BigTolerance,BigDecimal (for BigTolerance) are accepted.
-#
-# =BigTol
-#  BigTol(x) -> a BigTolerance
-# This module function will convert its argument to a Noi::BigTolerance
-#
-# Values of type BigTolerance or Numeric are accepted.
-module Nio
-  
-  # This class represents floating point tolerances for Float numbers
-  # and allows comparison within the specified tolerance.
-  class Tolerance
-    include StateEquivalent
-    
-    # The numeric class this tolerance applies to.
-    def num_class
-      Float
-    end
-    
-    # The tolerance mode is either :abs (absolute) :rel (relative) or :sig (significant).
-    # The last parameter is a flag to specify decimal mode for the :sig mode
-    def initialize(t=0.0, mode=:abs, decmode=false)
-      set t, mode, decmode
-    end
-    
-    
-    #This initializes a Tolerance with a given number of decimals
-    def decimals(d, mode=:abs, rounded=true)
-      
-      @mode = mode
-      @decimal_mode = true
-      @d = (d<=0 || d>Float::DIG) ? Float::DIG : d
-      @t = 10**(-@d)
-      @t *= 0.5 if rounded
-      
-      self
-    end
-    
-    #This initializes a Tolerance with a number of significant decimal digits
-    def sig_decimals(d, rounded=true)
-      decimals d, :sig, rounded
-    end
-    
-    #Initialize with a multiple of the internal floating-point precision.
-    def epsilon(times_epsilon=1, mode=:sig)
-      set Float::EPSILON*times_epsilon, mode
-    end
-    
-    # As #epsilon but using a somewhat bigger (about twice) precision that
-    # assures associative multiplication.
-    def big_epsilon(n=1, mode=:sig)
-      t = Math.ldexp(0.5*n,3-Float::MANT_DIG) # n*(2*Float::EPSILON/(1-0.5*Float::EPSILON)**2)
-      set t, mode
-    end
-    
-    # Initialize with a relative fraction
-    def fraction(f)
-      set f, :rel
-    end
-    # Initialize with a percentage
-    def percent(x)
-      fraction x/100.0
-    end
-    # Initialize with a per-mille value
-    def permille(x)
-      fraction x/1000.0
-    end
-    
-
-    #Shortcut notation for get_value
-    def [](x)
-      return x.nil? ? @t : get_value(x)
-    end
-    #Return tolerance relative to a magnitude
-    def get_value(x)  
-      rel(x)
-    end
-    #Essential equality within tolerance
-    def equals?(x,y)
-      
-      case @mode
-        when :sig
-          
-          if @decimal_mode
-            begin
-              x_exp = Math.log10(x.abs)
-              #x_exp = x_exp.finite? ? x_exp.ceil : 0
-              x_exp = x_exp.finite? ? x_exp.floor+1 : 0
-            rescue
-              x_exp = 0
-            end
-            begin 
-              y_exp = Math.log10(y.abs)
-              #y_exp = y_exp.finite? ? y_exp.ceil : 0
-              y_exp = y_exp.finite? ? y_exp.floor+1 : 0
-            rescue
-              y_exp = 0
-            end
-            (y-x).abs <= @t*(10**([x_exp,y_exp].min-@@dec_ref_exp))
-          else
-            z,x_exp = Math.frexp(x)
-            z,y_exp = Math.frexp(y)
-            (y-x).abs <= Math.ldexp(@t,[x_exp,y_exp].min-@@ref_exp) # (y-x).abs <= @t*(2**([x_exp,y_exp].min-@@ref_exp))
-          end
-          
-        when :rel
-          
-          (y-x).abs <= @t*([x.abs,y.abs].min) #reference value is 1
-          
-        when :abs
-          (x-y).abs<@t
-      end
-             
-    end
-    #Approximate equality within tolerance
-    def aprx_equals?(x,y)
-      
-      case @mode
-        when :sig
-          
-          if @decimal_mode
-            begin
-              x_exp = Math.log10(x.abs)
-              #x_exp = x_exp.finite? ? x_exp.ceil : 0
-              x_exp = x_exp.finite? ? x_exp.floor+1 : 0
-            rescue
-              x_exp = 0
-            end
-            begin 
-              y_exp = Math.log10(y.abs)
-              #y_exp = y_exp.finite? ? y_exp.ceil : 0
-              y_exp = y_exp.finite? ? y_exp.floor+1 : 0
-            rescue
-              y_exp = 0
-            end
-            (y-x).abs <= @t*(10**([x_exp,y_exp].max-@@dec_ref_exp))
-          else
-            z,x_exp = Math.frexp(x)
-            z,y_exp = Math.frexp(y)
-            (y-x).abs <= Math.ldexp(@t,[x_exp,y_exp].max-@@ref_exp) # (y-x).abs <= @t*(2**([x_exp,y_exp].max-@@ref_exp))
-          end
-          
-        when :rel
-          
-          (y-x).abs <= @t*([x.abs,y.abs].max) #reference value is 1
-          
-        when :abs
-          (x-y).abs<=@t    
-      end
-             
-    end
-    #Comparison within tolerance  
-    def greater_than?(x,y)
-      less_than?(y,x)
-    end
-    #Comparison within tolerance  
-    def less_than?(x,y)
-     
-     case @mode
-       when :sig
-         
-         if @decimal_mode
-           begin
-             x_exp = Math.log10(x.abs)
-             #x_exp = x_exp.finite? ? x_exp.ceil : 0
-             x_exp = x_exp.finite? ? x_exp.floor+1 : 0
-           rescue
-             x_exp = 0
-           end
-           begin 
-             y_exp = Math.log10(y.abs)
-             #y_exp = y_exp.finite? ? y_exp.ceil : 0
-             y_exp = y_exp.finite? ? y_exp.floor+1 : 0
-           rescue
-             y_exp = 0
-           end
-           y-x > @t*(10**([x_exp,y_exp].max-@@dec_ref_exp))
-         else
-           z,x_exp = Math.frexp(x)
-           z,y_exp = Math.frexp(y)
-           y-x > Math.ldexp(@t,[x_exp,y_exp].max-@@ref_exp) # y-x > @t*(2**([x_exp,y_exp].max-@@ref_exp))
-         end
-         
-       when :rel
-         
-         y-x > @t*([x.abs,y.abs].max) #reference value is 1
-         
-       when :abs
-         x-y<@t
-     end
-        
-    end
-    #Comparison within tolerance  
-    def zero?(x,compared_with=nil)
-      compared_with.nil? ? x.abs<@t : x.abs<rel(compared_with)
-    end
-
-    
-    # Returns true if the argument is approximately an integer
-    def apprx_i?(x)
-      equals?(x,x.round)
-    end
-    # If the argument is close to an integer it rounds it
-    # and returns it as an object of the specified class (by default, Integer)
-    def apprx_i(x,result=Integer)
-      r = x.round
-      return equals?(x,r) ? Nio.numeric_cast(r,result) : x
-    end
-      
-    
-    # Returns the magnitude of the tolerance
-    def magnitude
-      @t
-    end
-    # Returns the number of decimal digits of the tolerance
-    def num_decimals  
-      @d
-    end
-    # Returns true for decimal-mode tolerance
-    def decimal?
-      @decimal_mode
-    end
-    # Returns the mode (:abs, :rel, :sig) of the tolerance
-    def mode
-      @mode
-    end
-    
-    
-    private
-    
-    def set(t=0.0, mode=:abs, decmode=false)
-      
-      @t = t==0 ? Float::EPSILON : t.abs
-      @t = 0.5 if @t > 0.5
-      @mode = mode
-      @t = Float::EPSILON if @mode!=:abs && @t<Float::EPSILON
-      @decimal_mode = decmode
-      @d = @t==0 ? 0 : (-Math.log10(2*@t).floor).to_i
-      
-      self
-    end
-    
-    @@ref_exp = 1 # Math.frexp(1)[1] => tol. relative to [1,2)
-    
-    @@dec_ref_exp = 0 # tol. relative to [0.1,1)
-    
-    def rel(x)
-      r = @t
-      case @mode
-        when :sig
-          if @decimal_mode
-            d = x==0 ? 0 : (Math.log10(x.abs).floor+1).to_i
-            r = @t*(10**(d-@@dec_ref_exp))
-          else
-            x,exp = Math.frexp(x)
-            r = Math.ldexp(@t,exp-@@ref_exp)
-          end
-        when :rel
-          r = @t*x.abs
-      end
-      r
-    end  
-    
-  end
-  
-  def Tolerance.decimals(d=0, mode=:abs,rounded=true)
-    Tolerance.new.decimals(d,mode,rounded)
-  end
-  def Tolerance.sig_decimals(d=0, mode=:abs,rounded=true)
-    Tolerance.new.sig_decimals(d,rounded)
-  end
-  def Tolerance.epsilon(n=1, mode=:sig)
-    Tolerance.new.epsilon(n, mode)
-  end
-  def Tolerance.big_epsilon(n=1, mode=:sig)
-    Tolerance.new.big_epsilon(n, mode)
-  end
-  def Tolerance.fraction(f)
-    Tolerance.new.fraction(f)
-  end
-  def Tolerance.percent(p)
-    Tolerance.new.percent(p)
-  end
-  def Tolerance.permille(p)
-    Tolerance.new.permille(p)
-  end
-  
-  # This class represents floating point tolerances for BigDecimal numbers
-  # and allows comparison within the specified tolerance.
-  class BigTolerance
-    include StateEquivalent  
-    module BgMth # :nodoc:
-      extend BigMath if ::RUBY_VERSION>='1.8.1'
-    end
-
-    # The numeric class this tolerance applies to.
-    def num_class
-      BigDecimal
-    end
-
-    #The tolerance mode is either :abs (absolute) :rel (relative) or :sig
-    def initialize(t=BigDecimal('0'), mode=:abs, decmode=false)
-      set t, mode, decmode
-    end
-    
-    
-    #This initializes a BigTolerance with a given number of decimals
-    def decimals(d, mode=:abs, rounded=true)
-      
-      @mode = mode
-      @decimal_mode = true
-      @d = d==0 ? 16 : d
-      if rounded
-        @t = BigDecimal("0.5E#{-d}") # HALF*(BigDecimal(10)**(-d))
-      else
-        @t = BigDecimal("1E#{-d}") # BigDecimal(10)**(-d)
-      end
-      @ref_exp = BigDecimal('0.1').exponent # reference for significative mode: [0.1,1)
-      
-      self
-    end
-    
-    #This initializes a BigTolerance with a number of significative decimal digits
-    def sig_decimals(d, rounded=true)
-      decimals d, :sig, rounded
-    end
-    
-    def fraction(f)
-      set f, :rel
-    end
-    def percent(x)
-      fraction x*BigDecimal('0.01')
-    end
-    def permille(x)
-      fraction x*BigDecimal('0.001')
-    end
-    
-
-    #Shortcut notation for get_value
-    def [](x)
-      return x.nil? ? @t : get_value(x)
-    end
-    #Return tolerance relative to a magnitude
-    def get_value(x)  
-      rel(x)
-    end
-    #Essential equality within tolerance
-    def equals?(x,y)
-      
-      case @mode
-        when :sig
-          
-          x_exp = x.exponent
-          y_exp = y.exponent  
-          (y-x).abs <= @t*BigDecimal("1E#{[x_exp,y_exp].min-@ref_exp}")
-          
-        when :rel
-          
-          (y-x).abs <= @t*([x.abs,y.abs].min) #reference value is 1
-          
-        when :abs
-          (x-y).abs<@t
-      end
-             
-    end
-    #Approximate equality within tolerance
-    def aprx_equals?(x,y)
-      
-      case @mode
-        when :sig
-          
-          x_exp = x.exponent
-          y_exp = y.exponent  
-          (y-x).abs <= @t*BigDecimal("1E#{[x_exp,y_exp].max-@ref_exp}")
-          
-        when :rel
-          
-          (y-x).abs <= @t*([x.abs,y.abs].max) #reference value is 1
-          
-        when :abs
-          (x-y).abs<=@t
-      end
-             
-    end
-    #Comparison within tolerance
-    def greater_than?(x,y)
-      less_than?(y,x)
-    end
-    #Comparison within tolerance
-    def less_than?(x,y)
-     
-     case @mode
-       when :sig
-         
-         x_exp = x.exponent
-         y_exp = y.exponent  
-         y-x > @t*BigDecimal("1E#{[x_exp,y_exp].max-@ref_exp}")
-         
-       when :rel
-         
-         y-x > @t*([x.abs,y.abs].max) #reference value is 1
-         
-       when :abs
-         x-y<@t
-     end
-        
-    end
-    #Comparison within tolerance
-    def zero?(x,compared_with=nil)
-      compared_with.nil? ? x.abs<@t : x.abs<rel(compared_with)
-    end
-
-    
-    # Returns true if the argument is approximately an integer
-    def apprx_i?(x)
-      equals?(x,x.round)
-    end
-    # If the argument is close to an integer it rounds it
-    # and returns it as an object of the specified class (by default, Integer)
-    def apprx_i(x,result=Integer)
-      r = x.round
-      return equals?(x,r) ? Nio.numeric_cast(r,result) : x
-    end
-      
-    
-    # Returns the magnitude of the tolerance
-    def magnitude
-      @t
-    end
-    # Returns the number of decimal digits of the tolerance
-    def num_decimals  
-      @d
-    end
-    # Returns true for decimal-mode tolerance
-    def decimal?
-      @decimal_mode
-    end
-    # Returns the mode (:abs, :rel, :sig) of the tolerance
-    def mode
-      @mode
-    end
-    
-    
-    private
-    
-    HALF = BigDecimal('0.5')
-    
-    def set(t=BigDecimal('0'), mode=:abs, decmode=false)
-      
-      @t = t
-      @t = HALF if @t > HALF
-      raise TypeError,"El valor de tolerancia debe ser de tipo BigDecimal" if @t.class!=BigDecimal
-      @mode = mode
-      @decimal_mode = decmode
-      @d = @t.zero? ? 0 : -(@t*2).exponent+1
-      @ref_exp = BigDecimal('1').exponent # reference for significative mode: [1,10)
-      
-      self
-    end
-    
-    def rel(x)
-      r = @t
-      case @mode
-        when :sig
-          d = x==0 ? 0 : x.exponent
-          r = @t*BigDecimal("1E#{d-@ref_exp}")
-        when :rel
-          r = @t*x.abs
-      end
-      r
-    end  
-    
-  end
-  
-  def BigTolerance.decimals(d=0, mode=:abs)
-    BigTolerance.new.decimals(d,mode)
-  end
-  def BigTolerance.sig_decimals(d=0, mode=:abs)
-    BigTolerance.new.sig_decimals(d)
-  end
-  def BigTolerance.fraction(f)
-    BigTolerance.new.fraction(f)
-  end
-  def BigTolerance.percent(p)
-    BigTolerance.new.percent(p)
-  end
-  def BigTolerance.permille(p)
-    BigTolerance.new.permille(p)
-  end
-  
-  module_function
-  
-  #  Tol(x) -> a Tolerance
-  # This module function will convert its argument to a Noi::Tolerance
-  # or a Noi::BigTolerance depending on its argument;
-  #
-  # Values of type Tolerance,Float,Integer (for Tolerance) or
-  # BigTolerance,BigDecimal (for BigTolerance) are accepted.
-  def Tol(x) # :doc:
-    case x
-      when Tolerance
-        x
-      when BigTolerance
-        x
-      when BigDecimal
-        BigTolerance.new(x)
-      when Float
-        Tolerance.new(x)
-      when Integer
-        Tolerance.sig_decimals(x)
-      else # e.g. Rational
-        x 
-    end
-  end
-
-  #  BigTol(x) -> a BigTolerance
-  # This module function will convert its argument to a Noi::BigTolerance
-  #
-  # Values of type BigTolerance or Numeric are accepted.
-  def BigTol(x) # :doc:
-    case x
-      when BigTolerance
-        x
-      when Integer
-        BigTolerance.sig_decimals(x)
-      when Rational
-        x
-      else
-        BigTolerance.new(BigDec(x))
-    end
-  end
-  
-    #   BigDec(x) -> a BigDecimal
-    #   BigDec(x,precision) -> a BigDecimal
-    #   BigDec(x,:exact) -> a BigDecimal
-    # This is a shortcut to define a BigDecimal without using quotes
-    # and a general conversion to BigDecimal method. 
-    #
-    # The second parameter can be :exact to try for an exact conversion
-    #
-    # Conversions from Float have issues that should be understood; :exact
-    # conversion will use the exact internal value of the Float, and when
-    # no precision is specified, a value as simple as possible expressed as
-    # a fraction will be used.
-    def BigDec(x,prec=nil) # :doc:
-      if x.respond_to?(:to_str)
-        x = BigDecimal(x.to_str, prec||0)
-      else
-        case x
-          when Integer
-          x = BigDecimal(x.to_s)
-        when Rational
-          if prec && prec!=:exact
-            x = BigDecimal.new(x.numerator.to_s).div(x.denominator,prec)
-          else
-            x = BigDecimal.new(x.numerator.to_s)/BigDecimal.new(x.denominator.to_s)
-          end
-        when BigDecimal
-        when Float
-          x = nio_float_to_bigdecimal(x,prec)
-        end
-      end
-      x
-    end  
-  
-     def numeric_cast(value, type)
-       if value.respond_to?(:prec)
-         value.prec(type)
-        else
-          if type.kind_of?(BigDecimal)
-            BigDec(value)
-          else
-            Object.send type.to_s, value
-          end
-        end
-     end
-  
-end