1 // Copyright 2009 The Go Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style
3 // license that can be found in the LICENSE file.
17 type atofTest
struct {
23 var atoftests
= []atofTest
{
27 {"1x", "0", ErrSyntax
},
28 {"1.1.", "0", ErrSyntax
},
29 {"1e23", "1e+23", nil},
30 {"1E23", "1e+23", nil},
31 {"100000000000000000000000", "1e+23", nil},
32 {"1e-100", "1e-100", nil},
33 {"123456700", "1.234567e+08", nil},
34 {"99999999999999974834176", "9.999999999999997e+22", nil},
35 {"100000000000000000000001", "1.0000000000000001e+23", nil},
36 {"100000000000000008388608", "1.0000000000000001e+23", nil},
37 {"100000000000000016777215", "1.0000000000000001e+23", nil},
38 {"100000000000000016777216", "1.0000000000000003e+23", nil},
40 {"-0.1", "-0.1", nil},
42 {"1e-20", "1e-20", nil},
43 {"625e-3", "0.625", nil},
56 {"0e+01234567890123456789", "0", nil},
57 {"0.00e-01234567890123456789", "0", nil},
58 {"-0e+01234567890123456789", "-0", nil},
59 {"-0.00e-01234567890123456789", "-0", nil},
60 {"0e291", "0", nil}, // issue 15364
61 {"0e292", "0", nil}, // issue 15364
62 {"0e347", "0", nil}, // issue 15364
63 {"0e348", "0", nil}, // issue 15364
64 {"-0e291", "-0", nil},
65 {"-0e292", "-0", nil},
66 {"-0e347", "-0", nil},
67 {"-0e348", "-0", nil},
76 {"-Inf", "-Inf", nil},
77 {"+INF", "+Inf", nil},
78 {"-Infinity", "-Inf", nil},
79 {"+INFINITY", "+Inf", nil},
80 {"Infinity", "+Inf", nil},
83 {"1.7976931348623157e308", "1.7976931348623157e+308", nil},
84 {"-1.7976931348623157e308", "-1.7976931348623157e+308", nil},
85 // next float64 - too large
86 {"1.7976931348623159e308", "+Inf", ErrRange
},
87 {"-1.7976931348623159e308", "-Inf", ErrRange
},
88 // the border is ...158079
90 {"1.7976931348623158e308", "1.7976931348623157e+308", nil},
91 {"-1.7976931348623158e308", "-1.7976931348623157e+308", nil},
92 // borderline - too large
93 {"1.797693134862315808e308", "+Inf", ErrRange
},
94 {"-1.797693134862315808e308", "-Inf", ErrRange
},
97 {"1e308", "1e+308", nil},
98 {"2e308", "+Inf", ErrRange
},
99 {"1e309", "+Inf", ErrRange
},
102 {"1e310", "+Inf", ErrRange
},
103 {"-1e310", "-Inf", ErrRange
},
104 {"1e400", "+Inf", ErrRange
},
105 {"-1e400", "-Inf", ErrRange
},
106 {"1e400000", "+Inf", ErrRange
},
107 {"-1e400000", "-Inf", ErrRange
},
110 {"1e-305", "1e-305", nil},
111 {"1e-306", "1e-306", nil},
112 {"1e-307", "1e-307", nil},
113 {"1e-308", "1e-308", nil},
114 {"1e-309", "1e-309", nil},
115 {"1e-310", "1e-310", nil},
116 {"1e-322", "1e-322", nil},
118 {"5e-324", "5e-324", nil},
119 {"4e-324", "5e-324", nil},
120 {"3e-324", "5e-324", nil},
122 {"2e-324", "0", nil},
124 {"1e-350", "0", nil},
125 {"1e-400000", "0", nil},
127 // try to overflow exponent
128 {"1e-4294967296", "0", nil},
129 {"1e+4294967296", "+Inf", ErrRange
},
130 {"1e-18446744073709551616", "0", nil},
131 {"1e+18446744073709551616", "+Inf", ErrRange
},
134 {"1e", "0", ErrSyntax
},
135 {"1e-", "0", ErrSyntax
},
136 {".e-1", "0", ErrSyntax
},
137 {"1\x00.2", "0", ErrSyntax
},
139 // http://www.exploringbinary.com/java-hangs-when-converting-2-2250738585072012e-308/
140 {"2.2250738585072012e-308", "2.2250738585072014e-308", nil},
141 // http://www.exploringbinary.com/php-hangs-on-numeric-value-2-2250738585072011e-308/
142 {"2.2250738585072011e-308", "2.225073858507201e-308", nil},
144 // A very large number (initially wrongly parsed by the fast algorithm).
145 {"4.630813248087435e+307", "4.630813248087435e+307", nil},
147 // A different kind of very large number.
148 {"22.222222222222222", "22.22222222222222", nil},
149 {"2." + strings
.Repeat("2", 4000) + "e+1", "22.22222222222222", nil},
151 // Exactly halfway between 1 and math.Nextafter(1, 2).
152 // Round to even (down).
153 {"1.00000000000000011102230246251565404236316680908203125", "1", nil},
154 // Slightly lower; still round down.
155 {"1.00000000000000011102230246251565404236316680908203124", "1", nil},
156 // Slightly higher; round up.
157 {"1.00000000000000011102230246251565404236316680908203126", "1.0000000000000002", nil},
158 // Slightly higher, but you have to read all the way to the end.
159 {"1.00000000000000011102230246251565404236316680908203125" + strings
.Repeat("0", 10000) + "1", "1.0000000000000002", nil},
162 var atof32tests
= []atofTest
{
163 // Exactly halfway between 1 and the next float32.
164 // Round to even (down).
165 {"1.000000059604644775390625", "1", nil},
167 {"1.000000059604644775390624", "1", nil},
169 {"1.000000059604644775390626", "1.0000001", nil},
170 // Slightly higher, but you have to read all the way to the end.
171 {"1.000000059604644775390625" + strings
.Repeat("0", 10000) + "1", "1.0000001", nil},
173 // largest float32: (1<<128) * (1 - 2^-24)
174 {"340282346638528859811704183484516925440", "3.4028235e+38", nil},
175 {"-340282346638528859811704183484516925440", "-3.4028235e+38", nil},
176 // next float32 - too large
177 {"3.4028236e38", "+Inf", ErrRange
},
178 {"-3.4028236e38", "-Inf", ErrRange
},
179 // the border is 3.40282356779...e+38
181 {"3.402823567e38", "3.4028235e+38", nil},
182 {"-3.402823567e38", "-3.4028235e+38", nil},
183 // borderline - too large
184 {"3.4028235678e38", "+Inf", ErrRange
},
185 {"-3.4028235678e38", "-Inf", ErrRange
},
187 // Denormals: less than 2^-126
188 {"1e-38", "1e-38", nil},
189 {"1e-39", "1e-39", nil},
190 {"1e-40", "1e-40", nil},
191 {"1e-41", "1e-41", nil},
192 {"1e-42", "1e-42", nil},
193 {"1e-43", "1e-43", nil},
194 {"1e-44", "1e-44", nil},
195 {"6e-45", "6e-45", nil}, // 4p-149 = 5.6e-45
196 {"5e-45", "6e-45", nil},
198 {"1e-45", "1e-45", nil}, // 1p-149 = 1.4e-45
199 {"2e-45", "1e-45", nil},
201 // 2^92 = 8388608p+69 = 4951760157141521099596496896 (4.9517602e27)
202 // is an exact power of two that needs 8 decimal digits to be correctly
204 // The float32 before is 16777215p+68 = 4.95175986e+27
205 // The halfway is 4.951760009. A bad algorithm that thinks the previous
206 // float32 is 8388607p+69 will shorten incorrectly to 4.95176e+27.
207 {"4951760157141521099596496896", "4.9517602e+27", nil},
210 type atofSimpleTest
struct {
216 atofRandomTests
[]atofSimpleTest
217 benchmarksRandomBits
[1024]string
218 benchmarksRandomNormal
[1024]string
222 // The atof routines return NumErrors wrapping
223 // the error and the string. Convert the table above.
224 for i
:= range atoftests
{
225 test
:= &atoftests
[i
]
227 test
.err
= &NumError
{"ParseFloat", test
.in
, test
.err
}
230 for i
:= range atof32tests
{
231 test
:= &atof32tests
[i
]
233 test
.err
= &NumError
{"ParseFloat", test
.in
, test
.err
}
237 // Generate random inputs for tests and benchmarks
238 rand
.Seed(time
.Now().UnixNano())
240 atofRandomTests
= make([]atofSimpleTest
, 100)
242 atofRandomTests
= make([]atofSimpleTest
, 10000)
244 for i
:= range atofRandomTests
{
245 n
:= uint64(rand
.Uint32())<<32 |
uint64(rand
.Uint32())
246 x
:= math
.Float64frombits(n
)
247 s
:= FormatFloat(x
, 'g', -1, 64)
248 atofRandomTests
[i
] = atofSimpleTest
{x
, s
}
251 for i
:= range benchmarksRandomBits
{
252 bits
:= uint64(rand
.Uint32())<<32 |
uint64(rand
.Uint32())
253 x
:= math
.Float64frombits(bits
)
254 benchmarksRandomBits
[i
] = FormatFloat(x
, 'g', -1, 64)
257 for i
:= range benchmarksRandomNormal
{
258 x
:= rand
.NormFloat64()
259 benchmarksRandomNormal
[i
] = FormatFloat(x
, 'g', -1, 64)
263 func testAtof(t
*testing
.T
, opt
bool) {
264 oldopt
:= SetOptimize(opt
)
265 for i
:= 0; i
< len(atoftests
); i
++ {
266 test
:= &atoftests
[i
]
267 out
, err
:= ParseFloat(test
.in
, 64)
268 outs
:= FormatFloat(out
, 'g', -1, 64)
269 if outs
!= test
.out ||
!reflect
.DeepEqual(err
, test
.err
) {
270 t
.Errorf("ParseFloat(%v, 64) = %v, %v want %v, %v",
271 test
.in
, out
, err
, test
.out
, test
.err
)
274 if float64(float32(out
)) == out
{
275 out
, err
:= ParseFloat(test
.in
, 32)
276 out32
:= float32(out
)
277 if float64(out32
) != out
{
278 t
.Errorf("ParseFloat(%v, 32) = %v, not a float32 (closest is %v)", test
.in
, out
, float64(out32
))
281 outs
:= FormatFloat(float64(out32
), 'g', -1, 32)
282 if outs
!= test
.out ||
!reflect
.DeepEqual(err
, test
.err
) {
283 t
.Errorf("ParseFloat(%v, 32) = %v, %v want %v, %v # %v",
284 test
.in
, out32
, err
, test
.out
, test
.err
, out
)
288 for _
, test
:= range atof32tests
{
289 out
, err
:= ParseFloat(test
.in
, 32)
290 out32
:= float32(out
)
291 if float64(out32
) != out
{
292 t
.Errorf("ParseFloat(%v, 32) = %v, not a float32 (closest is %v)", test
.in
, out
, float64(out32
))
295 outs
:= FormatFloat(float64(out32
), 'g', -1, 32)
296 if outs
!= test
.out ||
!reflect
.DeepEqual(err
, test
.err
) {
297 t
.Errorf("ParseFloat(%v, 32) = %v, %v want %v, %v # %v",
298 test
.in
, out32
, err
, test
.out
, test
.err
, out
)
304 func TestAtof(t
*testing
.T
) { testAtof(t
, true) }
306 func TestAtofSlow(t
*testing
.T
) { testAtof(t
, false) }
308 func TestAtofRandom(t
*testing
.T
) {
309 for _
, test
:= range atofRandomTests
{
310 x
, _
:= ParseFloat(test
.s
, 64)
313 t
.Errorf("number %s badly parsed as %b (expected %b)", test
.s
, x
, test
.x
)
315 case math
.IsNaN(test
.x
) && math
.IsNaN(x
):
318 t
.Logf("tested %d random numbers", len(atofRandomTests
))
321 var roundTripCases
= []struct {
326 // This test will break the optimized conversion if the
327 // FPU is using 80-bit registers instead of 64-bit registers,
328 // usually because the operating system initialized the
329 // thread with 80-bit precision and the Go runtime didn't
330 // fix the FP control word.
331 {8865794286000691 << 39, "4.87402195346389e+27"},
332 {8865794286000692 << 39, "4.8740219534638903e+27"},
335 func TestRoundTrip(t
*testing
.T
) {
336 for _
, tt
:= range roundTripCases
{
337 old
:= SetOptimize(false)
338 s
:= FormatFloat(tt
.f
, 'g', -1, 64)
340 t
.Errorf("no-opt FormatFloat(%b) = %s, want %s", tt
.f
, s
, tt
.s
)
342 f
, err
:= ParseFloat(tt
.s
, 64)
343 if f
!= tt
.f || err
!= nil {
344 t
.Errorf("no-opt ParseFloat(%s) = %b, %v want %b, nil", tt
.s
, f
, err
, tt
.f
)
347 s
= FormatFloat(tt
.f
, 'g', -1, 64)
349 t
.Errorf("opt FormatFloat(%b) = %s, want %s", tt
.f
, s
, tt
.s
)
351 f
, err
= ParseFloat(tt
.s
, 64)
352 if f
!= tt
.f || err
!= nil {
353 t
.Errorf("opt ParseFloat(%s) = %b, %v want %b, nil", tt
.s
, f
, err
, tt
.f
)
359 // TestRoundTrip32 tries a fraction of all finite positive float32 values.
360 func TestRoundTrip32(t
*testing
.T
) {
366 for i
:= uint32(0); i
< 0xff<<23; i
+= step
{
367 f
:= math
.Float32frombits(i
)
371 s
:= FormatFloat(float64(f
), 'g', -1, 32)
373 parsed
, err
:= ParseFloat(s
, 32)
374 parsed32
:= float32(parsed
)
377 t
.Errorf("ParseFloat(%q, 32) gave error %s", s
, err
)
378 case float64(parsed32
) != parsed
:
379 t
.Errorf("ParseFloat(%q, 32) = %v, not a float32 (nearest is %v)", s
, parsed
, parsed32
)
381 t
.Errorf("ParseFloat(%q, 32) = %b (expected %b)", s
, parsed32
, f
)
385 t
.Logf("tested %d float32's", count
)
388 func BenchmarkAtof64Decimal(b
*testing
.B
) {
389 for i
:= 0; i
< b
.N
; i
++ {
390 ParseFloat("33909", 64)
394 func BenchmarkAtof64Float(b
*testing
.B
) {
395 for i
:= 0; i
< b
.N
; i
++ {
396 ParseFloat("339.7784", 64)
400 func BenchmarkAtof64FloatExp(b
*testing
.B
) {
401 for i
:= 0; i
< b
.N
; i
++ {
402 ParseFloat("-5.09e75", 64)
406 func BenchmarkAtof64Big(b
*testing
.B
) {
407 for i
:= 0; i
< b
.N
; i
++ {
408 ParseFloat("123456789123456789123456789", 64)
412 func BenchmarkAtof64RandomBits(b
*testing
.B
) {
413 for i
:= 0; i
< b
.N
; i
++ {
414 ParseFloat(benchmarksRandomBits
[i%1024
], 64)
418 func BenchmarkAtof64RandomFloats(b
*testing
.B
) {
419 for i
:= 0; i
< b
.N
; i
++ {
420 ParseFloat(benchmarksRandomNormal
[i%1024
], 64)
424 func BenchmarkAtof32Decimal(b
*testing
.B
) {
425 for i
:= 0; i
< b
.N
; i
++ {
426 ParseFloat("33909", 32)
430 func BenchmarkAtof32Float(b
*testing
.B
) {
431 for i
:= 0; i
< b
.N
; i
++ {
432 ParseFloat("339.778", 32)
436 func BenchmarkAtof32FloatExp(b
*testing
.B
) {
437 for i
:= 0; i
< b
.N
; i
++ {
438 ParseFloat("12.3456e32", 32)
442 var float32strings
[4096]string
444 func BenchmarkAtof32Random(b
*testing
.B
) {
446 for i
:= range float32strings
{
447 n
= (99991*n
+ 42) % (0xff << 23)
448 float32strings
[i
] = FormatFloat(float64(math
.Float32frombits(n
)), 'g', -1, 32)
451 for i
:= 0; i
< b
.N
; i
++ {
452 ParseFloat(float32strings
[i%4096
], 32)