nio 0.2.3 → 0.2.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,99 +1,69 @@
1
- # This file provides some syntactic sugar for the Nio module.
2
- # Some methods here: #to_r(), #to_xr, may collide with methods in other
3
- # libraries.
4
- #
5
- # This non mondule-function is equivalent to +Nio::Fmt.convert+
6
- # Nio.convert(x, type, arpx=true)
7
- # There's also a module-function synonim useful for including the Nio namespace:
8
- # Nio.nio_convert(x, type, aprx=true)
9
- # (the convert() method seems too likely for name collisions)
10
- # Some aliases for nio_write and nio_read:
11
- # fmt << x -> x.nio_write(fmt)
12
- # fmt.write(x) -> x.nio_write(fmt)
13
- # Fmt << x -> x.nio_write()
14
- # Fmt.write(x) -> x.nio_write()
15
- # fmt >> [cls,txt] -> cls.nio_read(txt, fmt)
16
- # fmt.read(cls,txt) -> cls.nio_read(txt, fmt)
17
- # Fmt >> [cls,txt] -> cls.nio_read(txt)
18
- # Fmt.read(cls,txt) -> cls.nio_read(txt)
19
- # Also methods #to_r and #to_xr are added to Float,BigDecimal, etc. as
20
- # synonims for #nio_r, #nio_xr
21
-
22
- require 'nio/rtnlzr'
23
- require 'nio/fmt'
24
-
25
- # This is not a module function: this provides a shorthand access to Nio::Fmt.convert
26
- def Nio.convert(x, type, mode=:approx)
27
- Nio::Fmt.convert x, type, mode
28
- end
29
-
30
- module Nio
31
- module_function
32
- # This module function can be used after <tt>import Nio</tt>
33
- def nio_convert(x, type, mode=:approx)
34
- Nio::Fmt.convert x, type, mode
35
- end
36
- # :stopdoc:
37
- class Fmt
38
- def <<(x)
39
- x.nio_write(self)
40
- end
41
- def write(x)
42
- x.nio_write(self)
43
- end
44
- def Fmt.<<(x)
45
- x.nio_write
46
- end
47
- def Fmt.write(x)
48
- x.nio_write
49
- end
50
- def >>(cls_txt)
51
- cls,txt = cls_txt
52
- cls.nio_read(txt,self)
53
- end
54
- def read(cls,txt)
55
- cls.nio_read(txt,self)
56
- end
57
- def Fmt.>>(cls_txt)
58
- cls,txt = cls_txt
59
- cls.nio_read(txt)
60
- end
61
- def Fmt.read(cls,txt)
62
- cls.nio_read(txt)
63
- end
64
- end
65
- # :startdoc:
66
- end
67
-
68
- # to be considered: for cls in [Float,BigDecimal,Integer,Rational]
69
- # def cls.<<(txt_fmt); txt,fmt=txt_fmt; cls.nio_read(txt,fmt); end
70
-
71
- # :stopdoc:
72
-
73
- #~ class Numeric
74
- #~ def to_xr
75
- #~ nio_xr
76
- #~ end
77
- #~ end
78
-
79
- for cls in [Integer,Rational,Float,BigDecimal]
80
- cls.class_eval {
81
- def to_xr
82
- nio_xr
83
- end
84
- }
85
- end
86
-
87
- class Float
88
- def to_r(tol = Nio::Tolerance.big_epsilon)
89
- nio_r(tol)
90
- end
91
- end
92
- class BigFloat
93
- def to_r(tol = nil)
94
- nio_r(tol)
95
- end
96
- end
97
-
98
- # :startdoc:
99
-
1
+ # This file provides some syntactic sugar for the Nio module.
2
+ # Some methods here: #to_r(), #to_xr, may collide with methods in other
3
+ # libraries.
4
+ #
5
+ # This non mondule-function is equivalent to +Nio::Fmt.convert+
6
+ # Nio.convert(x, type, arpx=true)
7
+ # There's also a module-function synonim useful for including the Nio namespace:
8
+ # Nio.nio_convert(x, type, aprx=true)
9
+ # (the convert() method seems too likely for name collisions)
10
+ # Some aliases for nio_write and nio_read:
11
+ # fmt << x -> x.nio_write(fmt)
12
+ # fmt.write(x) -> x.nio_write(fmt)
13
+ # Fmt << x -> x.nio_write()
14
+ # Fmt.write(x) -> x.nio_write()
15
+ # fmt >> [cls,txt] -> cls.nio_read(txt, fmt)
16
+ # fmt.read(cls,txt) -> cls.nio_read(txt, fmt)
17
+ # Fmt >> [cls,txt] -> cls.nio_read(txt)
18
+ # Fmt.read(cls,txt) -> cls.nio_read(txt)
19
+ # Also methods #to_r and #to_xr are added to Float,BigDecimal, etc. as
20
+ # synonims for #nio_r, #nio_xr
21
+
22
+ require 'nio/rtnlzr'
23
+ require 'nio/fmt'
24
+
25
+ # This is not a module function: this provides a shorthand access to Nio::Fmt.convert
26
+ def Nio.convert(x, type, mode=:approx)
27
+ Nio::Fmt.convert x, type, mode
28
+ end
29
+
30
+ module Nio
31
+ module_function
32
+ # This module function can be used after <tt>import Nio</tt>
33
+ def nio_convert(x, type, mode=:approx)
34
+ Nio::Fmt.convert x, type, mode
35
+ end
36
+ # :stopdoc:
37
+ class Fmt
38
+ def <<(x)
39
+ x.nio_write(self)
40
+ end
41
+ def write(x)
42
+ x.nio_write(self)
43
+ end
44
+ def Fmt.<<(x)
45
+ x.nio_write
46
+ end
47
+ def Fmt.write(x)
48
+ x.nio_write
49
+ end
50
+ def >>(cls_txt)
51
+ cls,txt = cls_txt
52
+ cls.nio_read(txt,self)
53
+ end
54
+ def read(cls,txt)
55
+ cls.nio_read(txt,self)
56
+ end
57
+ def Fmt.>>(cls_txt)
58
+ cls,txt = cls_txt
59
+ cls.nio_read(txt)
60
+ end
61
+ def Fmt.read(cls,txt)
62
+ cls.nio_read(txt)
63
+ end
64
+ end
65
+ # :startdoc:
66
+ end
67
+
68
+ # to be considered: for cls in [Float,BigDecimal,Integer,Rational]
69
+ # def cls.<<(txt_fmt); txt,fmt=txt_fmt; cls.nio_read(txt,fmt); end
@@ -2,7 +2,7 @@ module Nio #:nodoc:
2
2
  module VERSION #:nodoc:
3
3
  MAJOR = 0
4
4
  MINOR = 2
5
- TINY = 3
5
+ TINY = 4
6
6
 
7
7
  STRING = [MAJOR, MINOR, TINY].join('.')
8
8
  end
@@ -1,37 +1,67 @@
1
1
  # nuweb build tasks
2
2
  namespace :nuweb do
3
3
 
4
+ NUWEB_PRODUCTS = []
5
+ NUWEB_SOURCES = Dir['source/**/*.w']
6
+
7
+ NUWEB_SOURCES.each do |input_fn|
8
+ products = []
9
+ File.open(input_fn) do |input|
10
+ meta = '@'
11
+ input.each_line do |line|
12
+ if /^\s*%#{meta}r(.)%/.match(line)
13
+ meta = $1
14
+ elsif /^\s*[^#{meta}]?#{meta}(?:o|O)\s*(\S.*)\s*$/.match(line)
15
+ products << $1
16
+ end
17
+ end
18
+ end
19
+ NUWEB_PRODUCTS.concat products
20
+ products.each do |product|
21
+ file product => [input_fn] do |t|
22
+ puts "nuweb -t #{input_fn}"
23
+ puts `nuweb -t #{input_fn}`
24
+ touch product
25
+ end
26
+ end
27
+ end
28
+
29
+ %w{lib test}.each do |dir|
30
+ sources = Dir["source/#{dir}/**/*"]
31
+ NUWEB_SOURCES.concat sources
32
+ NUWEB_PRODUCTS.concat sources.map{|s| s.sub("source/#{dir}/","#{dir}/")}
33
+ rule(/\A#{dir}\/.*/ =>[proc{|tn| tn.sub(/\A#{dir}\//, "source/#{dir}/") }]) do |t|
34
+ if t.source
35
+ if File.directory?(t.source)
36
+ cp_r t.source, t.name
37
+ else
38
+ cp t.source, t.name
39
+ end
40
+ end
41
+ end
42
+ end
43
+
4
44
  desc "Generate Ruby code from nuweb source"
5
- task :tangle => Dir['source/*.w'].collect{|fn| fn.gsub /\.w/,'.ws'}+
6
- Dir['source/lib/**/*.rb'].collect{|fn| fn.gsub('source/lib/','lib/')}+
7
- Dir['source/test/**/*'].collect{|fn| fn.gsub('source/test/','test/')}+
8
- [:test]
45
+ task :tangle => NUWEB_PRODUCTS + [:test]
9
46
 
10
47
  # directory 'lib'
11
48
  # directory 'lib/nio'
12
49
  # directory 'source/pdf'
13
50
 
14
- rule '.ws' => ['.w'] do |t|
15
- puts "build dir: #{Dir.pwd}"
16
- puts "nuweb -t #{t.source}"
17
- puts `nuweb -t #{t.source}`
18
- File.open(t.name,'w'){|f| f.puts "sentinel"}
19
- end
20
-
21
- clean_exts = ['*.tex','*.dvi','*.log','*.aux','*.out','*.ws']
22
- clobber_dirs = ['lib', 'source/pdf', 'test']
23
- clobber_exceptions = ['test/data.yaml', 'test/test_helper.rb']
51
+ clean_exts = ['*.tex','*.dvi','*.log','*.aux','*.out']
52
+ clobber_exts = []
53
+ generated_dirs = ['lib', 'test', 'source/pdf']
24
54
 
25
55
  desc "Remove all nuweb generated files"
26
- task :clobber=>[:clean] do |t|
27
- clobber_dirs.map{|dir| Dir["#{dir}/**/*"]}.flatten.each do |fn|
56
+ task :clobber=>['^clobber'] do |t|
57
+ generated_dirs.map{|dir| Dir["#{dir}/**/*"]}.flatten.each do |fn|
28
58
  rm fn unless File.directory?(fn)
29
59
  end
30
60
  end
31
61
 
32
- desc "Clean up nuweb temporary files"
62
+ desc "Clean up nuweb weave temporary files"
33
63
  task :clean do |t|
34
- rm_r clean_exts.collect{|x| Dir.glob('*'+x)+Dir.glob('source/*'+x)+Dir.glob('source/pdf/*'+x)}.flatten
64
+ rm_r clean_exts.collect{|x| Dir.glob('source/*'+x)+Dir.glob('source/pdf/*'+x)}.flatten
35
65
  end
36
66
 
37
67
  desc "Generate nuweb source code documentation"
@@ -75,22 +105,14 @@ namespace :nuweb do
75
105
  w_to_pdf t.source
76
106
  end
77
107
 
78
- rule /\Alib\/.*\.rb/ =>[proc{|tn| tn.sub(/\Alib\//, 'source/lib/') }] do |t|
79
- cp t.source, t.name if t.source
80
- end
81
-
82
- rule /\Atest\/.*/ =>[proc{|tn| tn.sub(/\Atest\//, 'source/test/') }] do |t|
83
- cp t.source, t.name if t.source
84
- end
85
-
86
108
  namespace :docs do
87
109
 
88
- task :package=>['nuweb:weave']
89
110
  Rake::PackageTask.new('nio-source-pdf', Nio::VERSION::STRING) do |p|
90
111
  # generate same formats as for the gem contents
91
112
  p.need_tar = PROJ.gem.need_tar
92
113
  p.need_zip = PROJ.gem.need_zip
93
- p.package_files.include "source/pdf/**/*.pdf"
114
+ pdf_files = Dir['source/**/*.w'].map{|fn| File.join 'source','pdf',File.basename(fn,'.w')+'.pdf'}
115
+ p.package_files.include *pdf_files
94
116
  end
95
117
 
96
118
  end
@@ -113,13 +135,11 @@ namespace :nuweb do
113
135
 
114
136
  end
115
137
 
116
- task :clobber=>'nuweb:clobber'
138
+ task :clobber=>'nuweb:clean'
117
139
  task :clean=>'nuweb:clean'
118
140
 
119
- Rake::Task['gem:package'].enhance ['nuweb:tangle']
120
- Rake::Task['gem:release'].clear_prerequisites.enhance ['gem'] # remove clobber prerequisite
141
+ gem_package_prerequisites = Rake::Task['gem:package'].prerequisites.dup
142
+ Rake::Task['gem:package'].clear_prerequisites.enhance ['nuweb:tangle']+gem_package_prerequisites
121
143
 
122
144
  desc 'Generate code and documentation from nuweb sources'
123
145
  task :nuweb => ['nuweb:tangle', 'nuweb:weave']
124
-
125
- STDERR.puts "TTT #{Rake::Task['gem:package'].prerequisites.inspect}"
@@ -1,5 +1,6 @@
1
1
  require 'test/unit'
2
2
  require File.dirname(__FILE__) + '/../lib/nio'
3
+ require File.dirname(__FILE__) + '/../lib/nio/sugar'
3
4
  require 'yaml'
4
5
 
5
6
  module PrepareData
@@ -30,3 +31,7 @@ module PrepareData
30
31
  end
31
32
 
32
33
  PrepareData.init
34
+
35
+ def BigDec(x)
36
+ BigDecimal.new(x.to_s)
37
+ end
@@ -7,26 +7,24 @@
7
7
  # as published by the Free Software Foundation; either version 2
8
8
  # of the License, or (at your option) any later version.
9
9
 
10
- #require File.dirname(__FILE__) + '/test_helper.rb'
10
+ require File.dirname(__FILE__) + '/helper.rb'
11
11
  require 'test/unit'
12
- require 'nio/rtnlzr'
13
- require 'nio/repdec'
14
- require 'nio/fmt'
12
+ require 'flt/bigdecimal'
15
13
  include Nio
16
14
  require 'yaml'
17
15
 
18
16
  def neighbours(x)
19
- f,e = Math.frexp(x)
17
+ f,e = Math.frexp(x)
20
18
  e = Float::MIN_EXP if f==0
21
19
  e = [Float::MIN_EXP,e].max
22
- dx = Math.ldexp(1,e-Float::MANT_DIG) #Math.ldexp(Math.ldexp(1.0,-Float::MANT_DIG),e)
20
+ dx = Math.ldexp(1,e-Float::MANT_DIG) #Math.ldexp(Math.ldexp(1.0,-Float::MANT_DIG),e)
23
21
  high = x + dx
24
22
  if e==Float::MIN_EXP || f!=0.5 #0.5==Math.ldexp(2**(bits-1),-Float::MANT_DIG)
25
23
  low = x - dx
26
24
  else
27
- low = x - dx/2 # x - Math.ldexp(Math.ldexp(1.0,-Float::MANT_DIG),e-1)
25
+ low = x - dx/2 # x - Math.ldexp(Math.ldexp(1.0,-Float::MANT_DIG),e-1)
28
26
  end
29
- [low, high]
27
+ [low, high]
30
28
  end
31
29
 
32
30
  def prv(x)
@@ -55,59 +53,59 @@ class TestFmt < Test::Unit::TestCase
55
53
  Fmt.default = Fmt.new
56
54
 
57
55
  end
58
-
56
+
59
57
 
60
58
  def test_basic_fmt
61
59
  # test correct rounding: 1.448997445238699 -> 6525704354437805*2^-52
62
60
  assert_equal Rational(6525704354437805,4503599627370496), Float.nio_read('1.448997445238699').nio_xr
63
-
64
- assert_equal "0",0.0.nio_write
65
- assert_equal "0",0.nio_write
66
- assert_equal "0",BigDecimal('0').nio_write
67
- assert_equal "0",Rational(0,1).nio_write
68
-
69
- assert_equal "123456789",123456789.0.nio_write
70
- assert_equal "123456789",123456789.nio_write
71
- assert_equal "123456789",BigDecimal('123456789').nio_write
72
- assert_equal "123456789",Rational(123456789,1).nio_write
73
- assert_equal "123456789.25",123456789.25.nio_write
74
- assert_equal "123456789.25",BigDecimal('123456789.25').nio_write
75
- assert_equal "123456789.25",(Rational(123456789)+Rational(1,4)).nio_write
61
+
62
+ assert_equal "0",0.0.nio_write
63
+ assert_equal "0",0.nio_write
64
+ assert_equal "0",BigDecimal('0').nio_write
65
+ assert_equal "0",Rational(0,1).nio_write
66
+
67
+ assert_equal "123456789",123456789.0.nio_write
68
+ assert_equal "123456789",123456789.nio_write
69
+ assert_equal "123456789",BigDecimal('123456789').nio_write
70
+ assert_equal "123456789",Rational(123456789,1).nio_write
71
+ assert_equal "123456789.25",123456789.25.nio_write
72
+ assert_equal "123456789.25",BigDecimal('123456789.25').nio_write
73
+ assert_equal "123456789.25",(Rational(123456789)+Rational(1,4)).nio_write
76
74
  end
77
75
 
78
76
  def test_basic_fmt_float
79
77
 
80
78
  assert_equal 2,Float::RADIX
81
79
  assert_equal 53,Float::MANT_DIG
82
-
80
+
83
81
  fmt = Fmt.new {|f|
84
- f.rep! '[','','...',0,true
82
+ f.rep! '[','','...',0,true
85
83
  f.width! 20,:right,'*'
86
84
  }
87
- fmt.sep! '.',',',[3]
88
-
85
+ fmt.sep! '.',',',[3]
86
+
89
87
  assert_equal "0.1",0.1.nio_write
90
88
  assert_equal "0.10000000000000001",0.1.nio_write(Fmt.mode(:gen,:exact).show_all_digits)
91
89
  assert_equal "0.10000000000000001",0.1.nio_write(Fmt.mode(:gen,:exact).show_all_digits(true))
92
90
  assert_equal "0.10000000000000001",0.1.nio_write(Fmt.mode(:gen,:exact,:show_all_digits=>true))
93
91
  assert_equal "0.1000000000000000055511151231257827021181583404541015625",0.1.nio_write(Fmt.mode(:gen,:exact,:approx=>:exact))
94
-
95
-
96
- assert_equal "******643,454,333.32",fmt.nio_write_formatted(fmt.nio_read_formatted("643,454,333.32"))
97
- assert_equal "******643.454.333,32",fmt.sep(',').nio_write_formatted(fmt.nio_read_formatted("643,454,333.32"))
92
+
93
+
94
+ assert_equal "******643,454,333.32",fmt.nio_write_formatted(fmt.nio_read_formatted("643,454,333.32"))
95
+ assert_equal "******643.454.333,32",fmt.sep(',').nio_write_formatted(fmt.nio_read_formatted("643,454,333.32"))
98
96
  fmt.pad0s! 10
99
97
  num = fmt.nio_read_formatted("0.3333...")
100
98
  assert_equal "0000000.[3",fmt.nio_write_formatted(num)
101
99
  fmt.mode! :fix, 3
102
100
  assert_equal "000000.333",fmt.nio_write_formatted(num)
103
- num = fmt.nio_read_formatted("-0.666...")
101
+ num = fmt.nio_read_formatted("-0.666...")
104
102
  fmt.prec! :exact
105
103
  fmt.sep! ',','.'
106
104
  assert_equal "-000000,[6",fmt.nio_write_formatted(num)
107
105
  fmt.width! 20,:center,'*'
108
106
  fmt.mode! :fix,3
109
107
  assert_equal "*******-0,667*******",fmt.nio_write_formatted(num)
110
- num = fmt.nio_read_formatted("0,5555")
108
+ num = fmt.nio_read_formatted("0,5555")
111
109
  fmt.prec! :exact
112
110
  assert_equal "*******0,5555*******",fmt.nio_write_formatted(num)
113
111
 
@@ -116,15 +114,15 @@ class TestFmt < Test::Unit::TestCase
116
114
  assert_equal 11123.2343,x
117
115
  assert_equal "11.123,2343", x.nio_write
118
116
  assert_equal "11123,2343", x.nio_write(Fmt[:comma])
119
-
117
+
120
118
  x = Float.nio_read("-1234,5678901234e-33")
121
119
  # assert_equal -1.2345678901234e-030, x
122
120
  assert_equal "-1,2345678901234E-30", x.nio_write()
123
121
  assert_equal "-0,0000000000000000000000000000012346",x.nio_write(Fmt[:comma].mode(:sig,5))
124
122
 
125
- assert_equal "0,333...",
123
+ assert_equal "0,333...",
126
124
  (1.0/3).nio_write(Fmt.prec(:exact).show_all_digits(true).approx_mode(:simplify))
127
-
125
+
128
126
  fmt = Fmt.default
129
127
  if RUBY_VERSION>='1.9.0'
130
128
  assert_raises RuntimeError do fmt.prec! 4 end
@@ -134,42 +132,28 @@ class TestFmt < Test::Unit::TestCase
134
132
  fmt = Fmt.default {|f| f.prec! 4 }
135
133
  assert_equal "1,235", 1.23456.nio_write(fmt)
136
134
  assert_equal "1,23456", 1.23456.nio_write()
137
-
135
+
138
136
  Fmt.default = Fmt.new
139
137
  assert_equal '11123.2343', 11123.2343.nio_write
140
138
  end
141
139
 
142
140
  def test_tol_fmt_float
143
- tol = Tolerance.new.decimals(12,:sig)
141
+ tol = Flt.Tolerance(12, :sig_decimals)
144
142
  fmt = Fmt.prec(12,:sig)
145
143
  $data.each do |x|
146
- assert tol.equals?(x, Float.nio_read(x.nio_write(fmt),fmt)), "out of tolerance: #{x.inspect} #{Float.nio_read(x.nio_write(fmt),fmt)}"
147
- assert tol.equals?(-x, Float.nio_read((-x).nio_write(fmt),fmt)), "out of tolerance: #{(-x).inspect} #{Float.nio_read((-x).nio_write(fmt),fmt)}"
144
+ assert tol.eq?(x, Float.nio_read(x.nio_write(fmt),fmt)), "out of tolerance: #{x.inspect} #{Float.nio_read(x.nio_write(fmt),fmt)}"
145
+ assert tol.eq?(-x, Float.nio_read((-x).nio_write(fmt),fmt)), "out of tolerance: #{(-x).inspect} #{Float.nio_read((-x).nio_write(fmt),fmt)}"
148
146
  end
149
147
  end
150
148
 
151
- def test_BigDec
152
- assert_equal "0",BigDec(0).nio_write
153
- fmt = Fmt.mode(:gen,:exact)
154
- assert_equal "0",BigDec(0).nio_write(fmt)
155
- $data.each do |x|
156
- x = BigDecimal(x.to_s)
157
- assert_equal x,BigDecimal.nio_read(x.nio_write(fmt),fmt)
158
- end
159
- assert_equal "1E500",BigDec('1E500').nio_write
160
- assert_equal "1E-500",BigDec('1E-500').nio_write
161
- assert_equal "-1E500",BigDec('-1E500').nio_write
162
- assert_equal "-1E-500",BigDec('-1E-500').nio_write
163
- end
164
-
165
149
  def test_Rational
166
- assert_equal "0",Rational(0,1).nio_write
150
+ assert_equal "0",Rational(0,1).nio_write
167
151
  fmt = Fmt.mode(:gen,:exact)
168
152
  assert_equal "0",Rational(0,1).nio_write(fmt)
169
153
  $data.each do |x|
170
154
  x = x.nio_xr # nio_r
171
155
  assert_equal x,Rational.nio_read(x.nio_write(fmt),fmt)
172
- end
156
+ end
173
157
  end
174
158
 
175
159
  def test_float_bases
@@ -185,7 +169,7 @@ class TestFmt < Test::Unit::TestCase
185
169
  assert_equal(-x,Float.nio_read((-x).nio_write(nfmt2),nfmt2))
186
170
  assert_equal(-x,Float.nio_read((-x).nio_write(nfmt8),nfmt8))
187
171
  assert_equal(-x,Float.nio_read((-x).nio_write(nfmt10),nfmt10))
188
- assert_equal(-x,Float.nio_read((-x).nio_write(nfmt16),nfmt16))
172
+ assert_equal(-x,Float.nio_read((-x).nio_write(nfmt16),nfmt16))
189
173
  end
190
174
  end
191
175
 
@@ -194,31 +178,29 @@ class TestFmt < Test::Unit::TestCase
194
178
  end
195
179
 
196
180
  def test_big_decimal_bases
197
-
198
- assert_equal "0.1999A",(BigDec(1)/10).nio_write(Fmt.new.base(16).prec(5))
199
- assert_equal "0.1999...",(BigDec(1)/10).nio_write(Fmt.mode(:gen,:exact,:round=>:inf,:approx=>:simplify).base(16))
200
-
181
+
182
+ assert_equal "0.1999A",(Flt.DecNum(1)/10).normalize.nio_write(Fmt.new.base(16).prec(5))
183
+ assert_equal "0.1999...",(Flt.DecNum(1)/10).nio_write(Fmt.mode(:gen,:exact,:round=>:inf,:approx=>:simplify).base(16))
184
+
201
185
  nfmt2 = Fmt[:comma].base(2).prec(:exact)
202
186
  nfmt8 = Fmt[:comma].base(8).prec(:exact)
203
187
  nfmt10 = Fmt[:comma].base(10).prec(:exact)
204
188
  nfmt16 = Fmt[:comma].base(16).prec(:exact)
205
- $data.each do |x|
206
- x = BigDec(x.to_s)
207
- xs,xdig,xb,xe = x.split
208
- ndig = xdig.size
209
- round_dig = ndig-xe
189
+ $data.each do |x|
190
+ x = Flt.DecNum(x.to_s)
191
+ round_dig = x.number_of_digits - x.adjusted_exponent - 1
210
192
  # note that BigDecimal.nio_read produces a BigDecimal with the exact value of the text representation
211
193
  # since the representation here is only aproximate (because of the base difference), we must
212
194
  # round the results to the precision of the original number
213
- assert_equal(x,BigDecimal.nio_read(x.nio_write(nfmt2),nfmt2).round(round_dig))
214
- assert_equal(x,BigDecimal.nio_read(x.nio_write(nfmt8),nfmt8).round(round_dig))
215
- assert_equal(x,BigDecimal.nio_read(x.nio_write(nfmt10),nfmt10).round(round_dig))
216
- assert_equal(x,BigDecimal.nio_read(x.nio_write(nfmt16),nfmt16).round(round_dig))
217
- assert_equal(-x,BigDecimal.nio_read((-x).nio_write(nfmt2),nfmt2).round(round_dig))
218
- assert_equal(-x,BigDecimal.nio_read((-x).nio_write(nfmt8),nfmt8).round(round_dig))
219
- assert_equal(-x,BigDecimal.nio_read((-x).nio_write(nfmt10),nfmt10).round(round_dig))
220
- assert_equal(-x,BigDecimal.nio_read((-x).nio_write(nfmt16),nfmt16).round(round_dig))
221
- end
195
+ assert_equal(x,Flt::DecNum.nio_read(x.nio_write(nfmt2),nfmt2).round(round_dig))
196
+ assert_equal(x,Flt::DecNum.nio_read(x.nio_write(nfmt8),nfmt8).round(round_dig))
197
+ assert_equal(x,Flt::DecNum.nio_read(x.nio_write(nfmt10),nfmt10).round(round_dig))
198
+ assert_equal(x,Flt::DecNum.nio_read(x.nio_write(nfmt16),nfmt16).round(round_dig))
199
+ assert_equal(-x,Flt::DecNum.nio_read((-x).nio_write(nfmt2),nfmt2).round(round_dig))
200
+ assert_equal(-x,Flt::DecNum.nio_read((-x).nio_write(nfmt8),nfmt8).round(round_dig))
201
+ assert_equal(-x,Flt::DecNum.nio_read((-x).nio_write(nfmt10),nfmt10).round(round_dig))
202
+ assert_equal(-x,Flt::DecNum.nio_read((-x).nio_write(nfmt16),nfmt16).round(round_dig))
203
+ end
222
204
  end
223
205
 
224
206
  def test_exact_all_float
@@ -231,10 +213,10 @@ class TestFmt < Test::Unit::TestCase
231
213
  assert_equal "0.66666666666666662965923251249478198587894439697265625", (2.0/3.0).nio_write(fmt)
232
214
  assert_equal "-0.333333333333333314829616256247390992939472198486328125", (-1.0/3.0).nio_write(fmt)
233
215
  assert_equal "-0.66666666666666662965923251249478198587894439697265625", (-2.0/3.0).nio_write(fmt)
234
- assert_equal "1267650600228229401496703205376", (2.0**100).nio_write(fmt)
216
+ assert_equal "1267650600228229401496703205376", (2.0**100).nio_write(fmt)
235
217
  assert_equal "0.10000000000000001942890293094023945741355419158935546875", nxt(0.1).nio_write(fmt)
236
218
  assert_equal "1023.9999999999998863131622783839702606201171875", prv(1024).nio_write(fmt)
237
-
219
+
238
220
  assert_equal "2.225073858507201383090232717332404064219215980462331830553327416887204434813918195854283159012511020564067339731035811005152434161553460108856012385377718821130777993532002330479610147442583636071921565046942503734208375250806650616658158948720491179968591639648500635908770118304874799780887753749949451580451605050915399856582470818645113537935804992115981085766051992433352114352390148795699609591288891602992641511063466313393663477586513029371762047325631781485664350872122828637642044846811407613911477062801689853244110024161447421618567166150540154285084716752901903161322778896729707373123334086988983175067838846926092773977972858659654941091369095406136467568702398678315290680984617210924625396728515625E-308",
239
221
  MIN_N.nio_write(fmt)
240
222
  assert_equal "2.2250738585072008890245868760858598876504231122409594654935248025624400092282356951787758888037591552642309780950434312085877387158357291821993020294379224223559819827501242041788969571311791082261043971979604000454897391938079198936081525613113376149842043271751033627391549782731594143828136275113838604094249464942286316695429105080201815926642134996606517803095075913058719846423906068637102005108723282784678843631944515866135041223479014792369585208321597621066375401613736583044193603714778355306682834535634005074073040135602968046375918583163124224521599262546494300836851861719422417646455137135420132217031370496583210154654068035397417906022589503023501937519773030945763173210852507299305089761582519159720757232455434770912461317493580281734466552734375E-308",
@@ -248,8 +230,24 @@ class TestFmt < Test::Unit::TestCase
248
230
 
249
231
  end
250
232
 
233
+ def test_float_bin_num_coherence
234
+ Flt::BinNum.context(Flt::BinNum::FloatContext) do
235
+ [0.1, Float::MIN_D, Float::MIN_N, Float::MAX, 0.0, 1.0, 1.0/3].each do |x|
236
+ y = Flt::BinNum(x)
237
+ c = Float.context
238
+ assert_equal c.split(x), c.split(y) unless x.zero?
239
+ assert_equal x.nio_write(Fmt.prec(:exact)), y.nio_write(Fmt.prec(:exact))
240
+ assert_equal x.nio_write(Fmt.prec(:exact).show_all_digits), y.nio_write(Fmt.prec(:exact).show_all_digits)
241
+ assert_equal x.nio_write(Fmt.prec(:exact).approx_mode(:exact)), y.nio_write(Fmt.prec(:exact).approx_mode(:exact))
242
+ assert_equal x.nio_write(Fmt.mode(:fix,20).insignificant_digits('#')), y.nio_write(Fmt.mode(:fix,20).insignificant_digits('#'))
243
+ assert_equal x.nio_write(Fmt.mode(:fix,20)), y.nio_write(Fmt.mode(:fix,20))
244
+ assert_equal x.nio_write(Fmt.mode(:fix,20,:approx_mode=>:exact)), y.nio_write(Fmt.mode(:fix,20,:approx_mode=>:exact))
245
+ end
246
+ end
247
+ end
248
+
251
249
  def test_float_nonsig
252
-
250
+
253
251
  assert_equal "100.000000000000000#####", 100.0.nio_write(Fmt.prec(20,:fix).insignificant_digits('#'))
254
252
 
255
253
  fmt = Fmt.mode(:sci,20).insignificant_digits('#').sci_digits(1)
@@ -265,12 +263,12 @@ class TestFmt < Test::Unit::TestCase
265
263
  assert_equal "333.33333333333331###E-3", (1.0/3).nio_write(fmt)
266
264
  assert_equal "3.3333333333333335###E6", (1E7/3).nio_write(fmt)
267
265
  assert_equal "33.333333333333334###E-9",(1E-7/3).nio_write(fmt)
268
-
266
+
269
267
  fmt = Fmt[:comma].mode(:sci,20).insignificant_digits('#').sci_digits(0)
270
268
  assert_equal "0,33333333333333331###E0",(1.0/3).nio_write(fmt)
271
269
  assert_equal "0,33333333333333335###E7",(1E7/3).nio_write(fmt)
272
270
  assert_equal "0,33333333333333334###E-7",(1E-7/3).nio_write(fmt)
273
-
271
+
274
272
  fmt = Fmt.mode(:sci,20).insignificant_digits('#').sci_digits(0)
275
273
  assert_equal "0.10000000000000001###E0",(1E-1).nio_write(fmt)
276
274
  assert_equal "0.50000000000000000###E0",(0.5).nio_write(fmt)
@@ -281,65 +279,65 @@ class TestFmt < Test::Unit::TestCase
281
279
  assert_equal "0.5###################E-323",MIN_D.nio_write(fmt)
282
280
  assert_equal "0.64000000000000000###E2",(64.0).nio_write(fmt)
283
281
  assert_equal "0.6400000000000001####E2",(nxt(64.0)).nio_write(fmt)
284
- assert_equal "0.6409999999999999####E2",(64.1).nio_write(fmt)
282
+ assert_equal "0.6409999999999999####E2",(64.1).nio_write(fmt)
285
283
  assert_equal "0.6412312300000001####E2",(64.123123).nio_write(fmt)
286
284
  assert_equal "0.10000000000000001###E0",(0.1).nio_write(fmt)
287
- assert_equal "0.6338253001141148####E30",nxt(Math.ldexp(0.5,100)).nio_write(fmt)
285
+ assert_equal "0.6338253001141148####E30",nxt(Math.ldexp(0.5,100)).nio_write(fmt)
288
286
  assert_equal "0.39443045261050599###E-30",nxt(Math.ldexp(0.5,-100)).nio_write(fmt)
289
287
  assert_equal "0.10##################E-322",nxt(MIN_D).nio_write(fmt)
290
288
  assert_equal "0.15##################E-322",nxt(nxt(MIN_D)).nio_write(fmt)
291
-
289
+
292
290
  # note: 1E23 is equidistant from 2 Floats; one or the other will be chosen based on the rounding mode
293
291
  x = Float.nio_read('1E23',Fmt.prec(:exact,:gen,:round=>:even))
294
292
  assert_equal "1E23",x.nio_write(Fmt.prec(:exact,:gen,:round=>:zero))
295
293
  assert_equal "9.999999999999999E22",x.nio_write(Fmt.prec(:exact,:gen,:round=>:inf))
296
- assert_equal "1E23",x.nio_write(Fmt.prec(:exact,:gen,:round=>:even))
294
+ assert_equal "1E23",x.nio_write(Fmt.prec(:exact,:gen,:round=>:even))
297
295
 
298
296
  x = Float.nio_read('1E23',Fmt.prec(:exact,:gen,:round=>:zero))
299
297
  assert_equal "1E23",x.nio_write(Fmt.prec(:exact,:gen,:round=>:zero))
300
298
  assert_equal "9.999999999999999E22",x.nio_write(Fmt.prec(:exact,:gen,:round=>:inf))
301
- assert_equal "1E23",x.nio_write(Fmt.prec(:exact,:gen,:round=>:even))
299
+ assert_equal "1E23",x.nio_write(Fmt.prec(:exact,:gen,:round=>:even))
302
300
 
303
301
  x = Float.nio_read('1E23',Fmt.prec(:exact,:gen,:round=>:inf))
304
302
  assert_equal "1E23",x.nio_write(Fmt.prec(:exact,:gen,:round=>:inf))
305
303
  assert_equal "1.0000000000000001E23",x.nio_write(Fmt.prec(:exact,:gen,:round=>:zero))
306
- assert_equal "1.0000000000000001E23",x.nio_write(Fmt.prec(:exact,:gen,:round=>:even))
304
+ assert_equal "1.0000000000000001E23",x.nio_write(Fmt.prec(:exact,:gen,:round=>:even))
307
305
 
308
306
  x = Float.nio_read('-1E23',Fmt.prec(:exact,:gen,:round=>:even))
309
307
  assert_equal "-1E23",x.nio_write(Fmt.prec(:exact,:gen,:round=>:zero))
310
308
  assert_equal "-9.999999999999999E22",x.nio_write(Fmt.prec(:exact,:gen,:round=>:inf))
311
- assert_equal "-1E23",x.nio_write(Fmt.prec(:exact,:gen,:round=>:even))
309
+ assert_equal "-1E23",x.nio_write(Fmt.prec(:exact,:gen,:round=>:even))
312
310
 
313
311
  x = Float.nio_read('-1E23',Fmt.prec(:exact,:gen,:round=>:zero))
314
312
  assert_equal "-1E23",x.nio_write(Fmt.prec(:exact,:gen,:round=>:zero))
315
313
  assert_equal "-9.999999999999999E22",x.nio_write(Fmt.prec(:exact,:gen,:round=>:inf))
316
- assert_equal "-1E23",x.nio_write(Fmt.prec(:exact,:gen,:round=>:even))
314
+ assert_equal "-1E23",x.nio_write(Fmt.prec(:exact,:gen,:round=>:even))
317
315
 
318
316
  x = Float.nio_read('-1E23',Fmt.prec(:exact,:gen,:round=>:inf))
319
317
  assert_equal "-1E23",x.nio_write(Fmt.prec(:exact,:gen,:round=>:inf))
320
318
  assert_equal "-1.0000000000000001E23",x.nio_write(Fmt.prec(:exact,:gen,:round=>:zero))
321
- assert_equal "-1.0000000000000001E23",x.nio_write(Fmt.prec(:exact,:gen,:round=>:even))
322
-
323
- # note: for 64.1 there's only one closest Float;
319
+ assert_equal "-1.0000000000000001E23",x.nio_write(Fmt.prec(:exact,:gen,:round=>:even))
320
+
321
+ # note: for 64.1 there's only one closest Float;
324
322
  # but it can be univocally expressed in decimal either as 64.09999999999999 or 64.1
325
323
  x = Float.nio_read('64.1',Fmt.prec(:exact,:gen,:round=>:even))
326
324
  assert_equal "64.09999999999999",x.nio_write(Fmt.prec(:exact,:gen).show_all_digits(true))
327
325
  assert_equal "64.1",x.nio_write(Fmt.prec(:exact,:gen))
328
-
326
+
329
327
  # to do: exact conversion of Rational(32095022417, 54517) should throw and exception
330
328
  # (unless RepDec.max_d is greater than 27300 or so)
331
-
332
-
329
+
330
+
333
331
  end
334
332
 
335
333
  def test_special
336
334
  assert BigDecimal.nio_read("NaN").nan?
337
335
  assert Float.nio_read("NaN").nan?
338
- assert_equal "NAN", BigDec("NaN").nio_write.upcase
336
+ assert_equal "NAN", Flt.DecNum("NaN").nio_write.upcase
339
337
  assert_equal "NAN", BigDecimal.nio_read("NaN").nio_write.upcase
340
338
  assert_equal "NAN", Float.nio_read("NaN").nio_write.upcase
341
339
  assert_raises ZeroDivisionError do Rational.nio_read("NaN") end
342
-
340
+
343
341
  assert !BigDecimal.nio_read('Infinity').finite?
344
342
  assert !BigDecimal.nio_read('+Infinity').finite?
345
343
  assert !BigDecimal.nio_read('-Infinity').finite?
@@ -357,7 +355,7 @@ class TestFmt < Test::Unit::TestCase
357
355
  assert_equal '+Infinity', Float.nio_read('Infinity').nio_write
358
356
  assert_equal '+Infinity', Float.nio_read('+Infinity').nio_write
359
357
  assert_equal '-Infinity', Float.nio_read('-Infinity').nio_write
360
-
358
+
361
359
  end
362
360
 
363
361
  def test_conversions
@@ -368,12 +366,12 @@ class TestFmt < Test::Unit::TestCase
368
366
  assert_equal BigDecimal(x_txt), x_d
369
367
  assert_equal Fmt.convert(x_d,Float,:exact), x_f
370
368
  assert_equal Fmt.convert(x_d,Float,:approx), x_f
371
-
372
- x_d = BigDec(355)/226
369
+
370
+ x_d = BigDecimal('355')/226
373
371
  x_f = Float(355)/226
374
372
  assert_equal Fmt.convert(x_d,Float,:exact), x_f
375
373
  assert_equal Fmt.convert(x_d,Float,:approx), x_f
376
-
374
+
377
375
  end
378
376
 
379
377
  def test_sign
@@ -405,6 +403,6 @@ class TestFmt < Test::Unit::TestCase
405
403
  assert_equal '+1.23E+5', 1.23E5.nio_write(Fmt.mode(:sci).show_exp_plus.show_plus)
406
404
  assert_equal '-1.23E+5', -1.23E5.nio_write(Fmt.mode(:sci).show_exp_plus.show_plus)
407
405
  end
408
-
406
+
409
407
 
410
408
  end