float-formats 0.1.1 → 0.2.0

data/test/test_float_formats.rb

@@ -0,0 +1,208 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+require 'yaml'
+
+include Flt
+
+class TestFloatFormats < Test::Unit::TestCase
+
+  def setup
+  end
+  
+    def test_nextprev
+      for tn in %w{IEEE_SINGLE IEEE_DOUBLE IEEE_EXTENDED IEEE_DEC32 IEEE_DEC64 IEEE_DEC128}
+          t = eval(tn)
+          z = t.from_text('0')
+          assert t.min_value.next_minus==z,"#{tn}: prv min == 0"
+          assert z.next_plus==t.min_value,"#{tn}: nxt 0 == min"
+
+          mz = t.from_text('-0')
+          assert t.min_value(-1).next_plus==mz,"#{tn}: nxt -min == -0"
+          assert mz.next_minus==t.min_value(-1),"#{tn}: prv -0 == -min"
+
+          assert z.next_minus==t.min_value(-1),"#{tn}: prv 0 == -min"
+          assert mz.next_plus==t.min_value,"#{tn}: nxt -0 == min"
+      end
+        
+      for tn in %w{
+            APPLE XS128 
+            BORLAND48
+            MBF_SINGLE MBF_DOUBLE 
+            IEEE_SINGLE IEEE_DOUBLE IEEE_EXTENDED IEEE_128 
+            IEEE_DEC32 IEEE_DEC64 IEEE_DEC128
+            XS256 XS256_DOUBLE 
+            SATURN SATURN_X HP_CLASSIC
+            VAX_F VAX_D PDP11_F PDP11_D VAX_G VAX_H
+            IBM32 IBM64 IBM128 IBMX
+            CDC_SINGLE CDC_DOUBLE
+            CRAY
+            UNIVAC_SINGLE UNIVAC_DOUBLE
+            WANG2200
+            C51_BCD_FLOAT C51_BCD_DOUBLE C51_BCD_LONG_DOUBLE
+            }
+        t = eval(tn)
+        u = t.from_text('1')
+        mu = t.from_text('-1')
+        assert u.next_plus.minus == mu.next_minus,"#{tn}: -nxt 1 == prv -1"
+        assert mu.next_plus == u.next_minus.minus,"#{tn}: nxt -1 == -prv 1"
+         
+      end        
+        
+    end
+    
+  TEST_DATA = YAML.load(File.read(File.join(File.dirname(__FILE__),'test_data.yaml')))
+
+
+  def test_all
+
+    TEST_DATA.keys.each do |t|
+        
+        flt = eval(t)
+        
+        base = TEST_DATA[t]['base']
+        
+      td = TEST_DATA[t]['parameters']
+      
+      #puts "def test_#{t}_parameters"
+        for pair in td  
+          attrb,v = pair.to_a.first      
+          #puts "  assert_equal #{v}, #{t}.#{attrb}"
+          assert_equal v, flt.send(attrb), "#{t}.#{attrb} == #{v}"
+        end  
+      #puts "end"
+      
+      
+      td = TEST_DATA[t]['numerals']
+      #puts "def test_#{t}_numerals"
+        for pair in td
+          v,rep = pair.to_a.first      
+          v_expr = "#{t}.from_text('#{v}')"
+          expr = base==:bytes ? "(#{v_expr}).to_hex(true)" : "(#{v_expr}).to_bits_text(#{base}).upcase"
+          #puts "  assert_equal '#{rep}', #{expr}"
+          assert_equal rep, eval(expr), "#{expr} == '#{rep}'"
+          #puts "---"
+        end
+      #puts "end"
+
+
+      td = TEST_DATA[t]['special']
+      #puts "def test_#{t}_special"
+        for pair in td
+          v,rep = pair.to_a.first            
+          #next if v=='epsilon'
+          v_expr = "#{t}.#{v}"
+          expr = base==:bytes ? "(#{v_expr}).to_hex(true)" : "(#{v_expr}).to_bits_text(#{base}).upcase"
+          assert_equal rep, eval(expr), "#{expr} == '#{rep}'"
+        end
+      #puts "end"
+        
+
+      td = TEST_DATA[t]['values']
+      #puts "def test_#{t}_values"
+        for pair in td
+          v,rep = pair.to_a.first      
+          v_expr = "#{t}.from_number(#{v})"
+          expr = base==:bytes ? "(#{v_expr}).to_hex(true)" : "(#{v_expr}).to_bits_text(#{base}).upcase"
+          assert_equal rep, eval(expr), "#{expr} == '#{rep}'"
+        end
+      #puts "end"
+
+
+    end  
+      
+  end 
+
+
+
+  def test_hp71b
+    assert_equal(-499, HP71B.radix_min_exp)
+    assert_equal(499, HP71B.radix_max_exp)
+
+    fmt = Nio::Fmt.prec(12)
+    assert_equal  '9.99999999999E499', HP71B.max_value.to_text(fmt)
+    assert_equal '0000000000001501', HP71B.min_value.to_bits_text(16)
+    assert_equal '1E-510', HP71B.min_value.to_text(fmt)
+    assert_equal '1E-499', HP71B.min_normalized_value.to_text(fmt)
+
+    assert_equal '9210000000000999',HP71B.from_text('-0.21').to_bits_text(16)
+    assert_equal '0100000000000001',HP71B.from_text('10').to_bits_text(16)
+    assert_equal '9000000000000000',HP71B.from_text('-0').to_bits_text(16)
+    assert_equal '0000510000000501', HP71B.from_text('0.0051E-499').to_bits_text(16)
+
+    assert_equal '0000000000000F01',HP71B.nan.to_bits_text(16).upcase
+    assert_equal 'NAN', HP71B.nan.to_text.upcase
+    assert_equal '0000000000000F00', HP71B.infinity.to_bits_text(16).upcase
+    assert_equal '+INFINITY', HP71B.infinity.to_text.upcase
+    assert_equal '9000000000000F00', HP71B.infinity.minus.to_bits_text(16).upcase
+  end
+  def test_quad
+    assert_equal "3fff 0000 0000 0000 0000 0000 0000 0000".tr(' ',''), IEEE_binary128_BE.from_text('1').to_hex.downcase
+    assert_equal "7ffe ffff ffff ffff ffff ffff ffff ffff".tr(' ',''), IEEE_binary128_BE.max_value.to_hex.downcase
+    assert_equal '1.19E4932', IEEE_binary128.max_value.to_text(Nio::Fmt.prec(4))
+    assert_equal "c000 0000 0000 0000 0000 0000 0000 0000".tr(' ',''), IEEE_binary128_BE.from_text('-2').to_hex.downcase
+    assert_equal "0000 0000 0000 0000 0000 0000 0000 0000".tr(' ',''), IEEE_binary128_BE.from_text('0').to_hex.downcase
+    assert_equal "8000 0000 0000 0000 0000 0000 0000 0000".tr(' ',''), IEEE_binary128_BE.from_text('-0').to_hex.downcase
+    assert_equal "7fff 0000 0000 0000 0000 0000 0000 0000".tr(' ',''), IEEE_binary128_BE.infinity.to_hex.downcase
+    assert_equal "ffff 0000 0000 0000 0000 0000 0000 0000".tr(' ',''), IEEE_binary128_BE.infinity(-1).to_hex.downcase
+    assert_equal "3ffd 5555 5555 5555 5555 5555 5555 5555".tr(' ',''), IEEE_binary128_BE.from_number(Rational(1,3)).to_hex.downcase
+    assert_equal "3fff 0000 0000 0000 0000 0000 0000 0001".tr(' ',''), IEEE_binary128_BE.from_text('1').next_plus.to_hex.downcase    
+  end
+  def test_half
+    assert_equal "3c00", IEEE_binary16_BE.from_text('1').to_hex.downcase
+    assert_equal "7bff", IEEE_binary16_BE.max_value.to_hex.downcase
+    assert_equal '65504', IEEE_binary16_BE.max_value.to_text(Nio::Fmt.approx_mode(:exact))
+    assert_equal "0400", IEEE_binary16_BE.min_normalized_value.to_hex.downcase
+    assert_equal "6.103515625E-5", IEEE_binary16_BE.min_normalized_value.to_text(Nio::Fmt.approx_mode(:exact))
+    assert_equal "0001", IEEE_binary16_BE.min_value.to_hex.downcase
+    assert_equal "5.9604644775390625E-8", IEEE_binary16_BE.min_value.to_text(Nio::Fmt.approx_mode(:exact))
+    assert_equal "0000", IEEE_binary16_BE.from_text('0').to_hex.downcase
+    assert_equal "8000", IEEE_binary16_BE.from_text('-0').to_hex.downcase
+    assert_equal "7c00".tr(' ',''), IEEE_binary16_BE.infinity.to_hex.downcase
+    assert_equal "fc00".tr(' ',''), IEEE_binary16_BE.infinity(-1).to_hex.downcase
+  end
+  def test_special
+    assert_equal '+Infinity', IEEE_binary32.from_number(1.0/0.0).to_text 
+    assert_equal '-Infinity', IEEE_binary32.from_number(-1.0/0.0).to_text 
+    assert_equal '+Infinity', IEEE_binary32.from_text('+Infinity').to_text 
+    assert_equal '-Infinity', IEEE_binary32.from_text('-Infinity').to_text 
+    assert_equal 'NAN', IEEE_binary32.from_number(0.0/0.0).to_text.upcase
+    assert_equal 'NAN', IEEE_binary32.from_text('NaN').to_text.upcase
+  end
+  
+  def test_double_double
+    
+    assert_equal 128, IEEE_DOUBLE_DOUBLE.total_bits
+    assert_equal 16, IEEE_DOUBLE_DOUBLE.total_bytes
+    assert_equal 107, IEEE_DOUBLE_DOUBLE.significand_digits
+    assert_equal 31, IEEE_DOUBLE_DOUBLE.decimal_digits_stored
+    assert_equal 34, IEEE_DOUBLE_DOUBLE.decimal_digits_necessary
+    assert_equal 308, IEEE_DOUBLE_DOUBLE.decimal_max_exp
+    assert_equal(-307, IEEE_DOUBLE_DOUBLE.decimal_min_exp)
+    assert_equal 1023, IEEE_DOUBLE_DOUBLE.radix_max_exp
+    assert_equal(-1022, IEEE_DOUBLE_DOUBLE.radix_min_exp)
+    fmt = Nio::Fmt.prec(2).approx_mode(:exact).approx_mode(:exact)
+    assert_equal '1.8E308', IEEE_DOUBLE_DOUBLE.max_value.to_text(fmt)
+    assert_equal '2.2E-308', IEEE_DOUBLE_DOUBLE.min_normalized_value.to_text(fmt)
+    assert_equal '4.9E-324', IEEE_DOUBLE_DOUBLE.half.min_value.to_text(fmt)
+        
+    assert_equal "0.5", IEEE_DOUBLE_DOUBLE('0.5').to_text
+    assert_equal "000000000000E03F0000000000000000", IEEE_DOUBLE_DOUBLE('0.5').to_hex
+    assert_equal "000000000000E03F0000000000004039", IEEE_DOUBLE_DOUBLE('0.5').next_plus.to_hex
+    assert_equal "9A9999999999B93F9A999999999959BC", IEEE_DOUBLE_DOUBLE('0.1').to_hex
+    assert_equal "9A9999999999B93F99999999999959BC", IEEE_DOUBLE_DOUBLE('0.1').next_plus.to_hex
+    
+    assert_equal IEEE_DOUBLE_DOUBLE('0.5'), IEEE_DOUBLE_DOUBLE.join_halfs(*IEEE_DOUBLE_DOUBLE('0.5').split_halfs)
+    assert_equal IEEE_DOUBLE_DOUBLE('0.5').next_plus, IEEE_DOUBLE_DOUBLE.join_halfs(*IEEE_DOUBLE_DOUBLE('0.5').next_plus.split_halfs)
+    assert_equal IEEE_DOUBLE_DOUBLE('0.1'), IEEE_DOUBLE_DOUBLE.join_halfs(*IEEE_DOUBLE_DOUBLE('0.1').split_halfs)
+    assert_equal IEEE_DOUBLE_DOUBLE('0.1').next_plus, IEEE_DOUBLE_DOUBLE.join_halfs(*IEEE_DOUBLE_DOUBLE('0.1').next_plus.split_halfs)
+        
+    assert_equal "00000000000050390000000000000000", IEEE_DOUBLE_DOUBLE.epsilon.to_hex    
+    assert_equal "000000000000F87F0000000000000000", IEEE_DOUBLE_DOUBLE.nan.to_hex
+    assert_equal "NAN", IEEE_DOUBLE_DOUBLE.nan.to_text.upcase
+    assert_equal "000000000000F07F0000000000000000", IEEE_DOUBLE_DOUBLE.infinity.to_hex
+    assert_equal "+INFINITY", IEEE_DOUBLE_DOUBLE.infinity.to_text.upcase
+    assert_equal "00000000000000000000000000000000", IEEE_DOUBLE_DOUBLE.zero.to_hex
+    assert_equal "0", IEEE_DOUBLE_DOUBLE.zero.to_text.upcase        
+  end
+  
+
+end

data/test/test_helper.rb

@@ -1,3 +1,4 @@
-require 'rubygems'
+require 'rubygems'
 require 'test/unit'
+$:.unshift File.dirname(__FILE__) + '/../lib'
 require File.dirname(__FILE__) + '/../lib/float-formats'

data/test/test_native-float.rb

@@ -1,77 +1,84 @@
-require File.dirname(__FILE__) + '/test_helper.rb'
-require File.dirname(__FILE__) + '/../lib/float-formats/native.rb'
-require 'yaml'
-
-require 'test/unit'
-
-include FltPnt
-
-class TestNativeFloat < Test::Unit::TestCase
-    def test_nextprev
-      assert Float::MIN_N.prev==Float::MAX_D
-      assert Float::MIN_N==Float::MAX_D.next
-      assert Float::MIN_D.prev==0.0
-      assert Float::MIN_D==0.0.next
-
-      assert((-Float::MIN_N).next==-Float::MAX_D)
-      assert(-(Float::MIN_N.prev)==-Float::MAX_D)
-      assert((-Float::MIN_D).next==0.0)
-      assert((-Float::MIN_D)==0.0.prev)
-
-
-      assert(-(1.0.next) == (-1.0).prev)
-      assert((-1.0).next == -(1.0.prev))
-    end
-    
-    def test_hex
-      if Float::RADIX==2 && Float::MANT_DIG==53
-        assert_equal((1.0+Float::EPSILON),hex_to_float('0x1.0000000000001p0'))
-        assert_equal '0x10000000000001p-52', hex_from_float(1.0+Float::EPSILON)
-      end
-      assert_equal 1.0, hex_to_float(hex_from_float(1.0))
-      assert_equal(-1.0, hex_to_float(hex_from_float(-1.0)))
-      assert_equal 1.0e-5, hex_to_float(hex_from_float(1.0e-5))
-      assert_equal(-1.0e-5, hex_to_float(hex_from_float(-1.0e-5)))
-      
-      assert_equal(+1,float_to_integral_sign_significand_exponent(+0.0).first)
-      assert_equal(-1,float_to_integral_sign_significand_exponent(-0.0).first)
-      assert_not_equal hex_from_float(-0.0), hex_from_float(+0.0)
-      assert_equal hex_to_float(hex_from_float(-0.0)), hex_to_float(hex_from_float(+0.0))
-      
-    end
-    
-    
-    def check_ulp_around(x)
-      assert_equal x-x.prev, x.prev.ulp
-      assert_equal x-x.prev, x.ulp
-      assert_equal x.next-x, x.next.ulp
-      assert_equal x.next.next-x.next, x.next.next.ulp
-    end
-    
-    def test_ulp
-      r = Float::RADIX
-      assert_equal Float::MIN_D, 0.0.ulp
-      assert_equal Float::MIN_D, Float::MIN_D.ulp
-      assert_equal Float::MIN_D, Float::MIN_D.next.ulp
-      assert_equal Float::MIN_D, (0.5*(Float::MIN_D+Float::MAX_D)).ulp
-      assert_equal Float::MIN_D, Float::MAX_D.prev.ulp
-      assert_equal Float::MIN_D, Float::MAX_D.ulp
-      assert_equal Float::MIN_D, Float::MIN_N.ulp
-      assert_equal Float::MIN_D, Float::MIN_N.next.ulp
-      assert_equal Float::MIN_D, (r*Float::MIN_N).prev.ulp
-      assert_equal Float::MIN_D, (r*Float::MIN_N).ulp
-      assert_equal r*Float::MIN_D, (r*Float::MIN_N).next.ulp
-      check_ulp_around 1.0
-      assert_equal 1.0.next-1.0, 1.5.ulp
-      check_ulp_around r.to_f
-      check_ulp_around Math.ldexp(1,10)
-      check_ulp_around Math.ldexp(1,-10)
-      check_ulp_around Float::MAX/r
-      assert_equal Float::MAX-Float::MAX.prev, Float::MAX.prev.ulp
-      assert_equal Float::MAX-Float::MAX.prev, Float::MAX.ulp
-      assert_equal Float::MAX-Float::MAX.prev, (1.0/0.0).ulp
-      assert((0.0/0.0).ulp.nan?)
-      assert_equal Math.ldexp(1,10)-Math.ldexp(1,10).prev, Math.ldexp(1,10).prev.ulp
-    end
-    
-end
+require File.dirname(__FILE__) + '/test_helper.rb'
+require File.dirname(__FILE__) + '/../lib/float-formats/native.rb'
+require 'yaml'
+
+require 'test/unit'
+
+include Flt
+
+class TestNativeFloat < Test::Unit::TestCase
+    def test_nextprev
+      num_class = Float
+      context = num_class.context
+
+      assert context.next_minus(context.minimum_normal)==context.maximum_subnormal
+      assert context.minimum_normal==context.next_plus(context.maximum_subnormal)
+      assert context.next_minus(context.minimum_nonzero)==context.zero
+      assert context.minimum_nonzero==context.next_plus(context.zero)
+
+      assert(context.next_plus(-context.minimum_normal)==-context.maximum_subnormal)
+      assert(-context.next_minus(context.minimum_normal)==-context.maximum_subnormal)
+      assert(context.next_plus(-context.minimum_nonzero)==context.zero)
+      assert((-context.minimum_nonzero)==context.next_minus(context.zero))
+
+
+      assert(-(context.next_plus(1.0)) == context.next_minus(-1.0))
+      assert(context.next_plus(-1.0) == -(context.next_minus(1.0)))
+    end
+
+    def test_hex
+      if Float::RADIX==2 && Float::MANT_DIG==53
+        assert_equal((1.0+Float::EPSILON),hex_to_float('0x1.0000000000001p0'))
+        assert_equal '0x10000000000001p-52', hex_from_float(1.0+Float::EPSILON)
+      end
+      assert_equal 1.0, hex_to_float(hex_from_float(1.0))
+      assert_equal(-1.0, hex_to_float(hex_from_float(-1.0)))
+      assert_equal 1.0e-5, hex_to_float(hex_from_float(1.0e-5))
+      assert_equal(-1.0e-5, hex_to_float(hex_from_float(-1.0e-5)))
+
+      assert_equal(+1,float_to_integral_sign_significand_exponent(+0.0).first)
+      assert_equal(-1,float_to_integral_sign_significand_exponent(-0.0).first)
+      assert_not_equal hex_from_float(-0.0), hex_from_float(+0.0)
+      assert_equal hex_to_float(hex_from_float(-0.0)), hex_to_float(hex_from_float(+0.0))
+
+    end
+
+
+    def check_ulp_around(x)
+      context = Float.context
+      assert_equal x-context.next_minus(x), context.ulp(context.next_minus(x))
+      assert_equal x-context.next_minus(x), context.ulp(x)
+      assert_equal context.next_plus(x)-x, context.ulp(context.next_plus(x))
+      assert_equal context.next_plus(context.next_plus(x))-context.next_plus(x), context.ulp(context.next_plus(context.next_plus(x)))
+    end
+
+    def test_ulp
+      num_class = Float
+      context = num_class.context
+      r = context.radix
+      assert_equal context.minimum_nonzero, context.ulp(context.zero)
+      assert_equal context.minimum_nonzero, context.ulp(context.minimum_nonzero)
+      assert_equal context.minimum_nonzero, context.ulp(context.next_plus(context.minimum_nonzero))
+      assert_equal context.minimum_nonzero, context.ulp((context.minimum_nonzero+context.maximum_subnormal)*0.5)
+      assert_equal context.minimum_nonzero, context.ulp(context.next_minus(context.maximum_subnormal))
+      assert_equal context.minimum_nonzero, context.ulp(context.maximum_subnormal)
+      assert_equal context.minimum_nonzero, context.ulp(context.minimum_normal)
+      assert_equal context.minimum_nonzero, context.ulp(context.next_plus(context.minimum_normal))
+      assert_equal context.minimum_nonzero, context.ulp(context.next_minus(context.minimum_normal*r))
+      assert_equal context.minimum_nonzero, context.ulp(context.minimum_normal*r)
+      assert_equal context.minimum_nonzero*r, context.ulp(context.next_plus((context.minimum_normal*r)))
+      check_ulp_around 1.0
+      assert_equal context.next_plus(1.0)-1.0, context.ulp(1.5)
+      check_ulp_around r.to_f
+      check_ulp_around Math.ldexp(1,10)
+      check_ulp_around Math.ldexp(1,-10)
+      check_ulp_around context.maximum_finite/r
+      assert_equal context.maximum_finite-context.next_minus(context.maximum_finite), context.ulp(context.next_minus(context.maximum_finite))
+      assert_equal context.maximum_finite-context.next_minus(context.maximum_finite), context.ulp(context.maximum_finite)
+      assert_equal context.maximum_finite-context.next_minus(context.maximum_finite), context.ulp(1.0/0.0)
+      assert(context.nan?(context.ulp(0.0/0.0)))
+      x = Math.ldexp(1,10)
+      assert_equal x-context.next_minus(x), context.ulp(context.next_minus(x))
+    end
+
+end

metadata

@@ -1,87 +1,150 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.2
-specification_version: 1
 name: float-formats
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
-date: 2007-12-15 00:00:00 +01:00
-summary: Floating-Point Formats
-require_paths: 
-- lib
-email: javier@goizueta.info
-homepage: http://float-formats.rubyforge.org
-rubyforge_project: float-formats
-description: Floating-Point Formats
-autorequire: 
-default_executable: 
-bindir: bin
-has_rdoc: true
-required_ruby_version: !ruby/object:Gem::Version::Requirement 
-  requirements: 
-  - - ">"
-    - !ruby/object:Gem::Version 
-      version: 0.0.0
-  version: 
+  version: 0.2.0
 platform: ruby
-signing_key: 
-cert_chain: 
-post_install_message: 
 authors: 
 - Javier Goizueta
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-08-06 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: nio
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.2.4
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: nio
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.2.0
+    version: 
+- !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
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.1.1
+    version: 
+description: Floating-Point Formats
+email: javier@goizueta.info
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- License.txt
+- README.txt
 files: 
 - History.txt
 - License.txt
 - Manifest.txt
 - README.txt
 - Rakefile
-- config/hoe.rb
-- config/requirements.rb
 - lib/float-formats.rb
-- lib/float-formats/version.rb
 - lib/float-formats/bytes.rb
 - lib/float-formats/classes.rb
 - lib/float-formats/formats.rb
 - lib/float-formats/native.rb
-- script/destroy
-- script/destroy.cmd
-- script/generate
-- script/generate.cmd
-- script/txt2html
-- script/txt2html.cmd
+- lib/float-formats/version.rb
 - setup.rb
-- tasks/deployment.rake
-- tasks/environment.rake
-- tasks/website.rake
-- test/test_float-formats.rb
-- test/test_helper.rb
-- test/test_data.yaml
+- tasks/ann.rake
+- tasks/bones.rake
+- tasks/gem.rake
+- tasks/git.rake
+- tasks/manifest.rake
+- tasks/notes.rake
+- tasks/post_load.rake
+- tasks/rdoc.rake
+- tasks/rubyforge.rake
+- tasks/setup.rb
+- tasks/spec.rake
+- tasks/svn.rake
+- tasks/test.rake
 - test/gen_test_data.rb
-- test/test_native-float.rb
-test_files: 
-- test/test_float-formats.rb
+- test/test_arithmetic.rb
+- test/test_bytes.rb
+- test/test_data.yaml
+- test/test_float_formats.rb
 - test/test_helper.rb
 - test/test_native-float.rb
+has_rdoc: true
+homepage: http://float-formats.rubyforge.org
+licenses: []
+
+post_install_message: 
 rdoc_options: 
 - --main
 - README.txt
-extra_rdoc_files: 
-- History.txt
-- License.txt
-- Manifest.txt
+- --title
+- Float-Formats Documentation
+- --opname
+- index.html
+- --line-numbers
+- --inline-source
+- --main
 - README.txt
-executables: []
-
-extensions: []
-
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
 requirements: []
 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: nio
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Version::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 0.2.1
-    version: 
+rubyforge_project: float-formats
+rubygems_version: 1.3.3
+signing_key: 
+specification_version: 3
+summary: Floating-Point Formats
+test_files: 
+- test/test_arithmetic.rb
+- test/test_bytes.rb
+- test/test_float_formats.rb
+- test/test_helper.rb
+- test/test_native-float.rb