Source file
src/strconv/ftoa_test.go
1
2
3
4
5 package strconv_test
6
7 import (
8 "math"
9 "math/rand"
10 . "strconv"
11 "testing"
12 )
13
14 type ftoaTest struct {
15 f float64
16 fmt byte
17 prec int
18 s string
19 }
20
21 func fdiv(a, b float64) float64 { return a / b }
22
23 const (
24 below1e23 = 99999999999999974834176
25 above1e23 = 100000000000000008388608
26 )
27
28 var ftoatests = []ftoaTest{
29 {1, 'e', 5, "1.00000e+00"},
30 {1, 'f', 5, "1.00000"},
31 {1, 'g', 5, "1"},
32 {1, 'g', -1, "1"},
33 {1, 'x', -1, "0x1p+00"},
34 {1, 'x', 5, "0x1.00000p+00"},
35 {20, 'g', -1, "20"},
36 {20, 'x', -1, "0x1.4p+04"},
37 {1234567.8, 'g', -1, "1.2345678e+06"},
38 {1234567.8, 'x', -1, "0x1.2d687cccccccdp+20"},
39 {200000, 'g', -1, "200000"},
40 {200000, 'x', -1, "0x1.86ap+17"},
41 {200000, 'X', -1, "0X1.86AP+17"},
42 {2000000, 'g', -1, "2e+06"},
43 {1e10, 'g', -1, "1e+10"},
44
45
46 {400, 'g', 2, "4e+02"},
47 {40, 'g', 2, "40"},
48 {4, 'g', 2, "4"},
49 {.4, 'g', 2, "0.4"},
50 {.04, 'g', 2, "0.04"},
51 {.004, 'g', 2, "0.004"},
52 {.0004, 'g', 2, "0.0004"},
53 {.00004, 'g', 2, "4e-05"},
54 {.000004, 'g', 2, "4e-06"},
55
56 {0, 'e', 5, "0.00000e+00"},
57 {0, 'f', 5, "0.00000"},
58 {0, 'g', 5, "0"},
59 {0, 'g', -1, "0"},
60 {0, 'x', 5, "0x0.00000p+00"},
61
62 {-1, 'e', 5, "-1.00000e+00"},
63 {-1, 'f', 5, "-1.00000"},
64 {-1, 'g', 5, "-1"},
65 {-1, 'g', -1, "-1"},
66
67 {12, 'e', 5, "1.20000e+01"},
68 {12, 'f', 5, "12.00000"},
69 {12, 'g', 5, "12"},
70 {12, 'g', -1, "12"},
71
72 {123456700, 'e', 5, "1.23457e+08"},
73 {123456700, 'f', 5, "123456700.00000"},
74 {123456700, 'g', 5, "1.2346e+08"},
75 {123456700, 'g', -1, "1.234567e+08"},
76
77 {1.2345e6, 'e', 5, "1.23450e+06"},
78 {1.2345e6, 'f', 5, "1234500.00000"},
79 {1.2345e6, 'g', 5, "1.2345e+06"},
80
81
82 {1.2345e6, 'e', 3, "1.234e+06"},
83 {1.2355e6, 'e', 3, "1.236e+06"},
84 {1.2345, 'f', 3, "1.234"},
85 {1.2355, 'f', 3, "1.236"},
86 {1234567890123456.5, 'e', 15, "1.234567890123456e+15"},
87 {1234567890123457.5, 'e', 15, "1.234567890123458e+15"},
88 {108678236358137.625, 'g', -1, "1.0867823635813762e+14"},
89
90 {1e23, 'e', 17, "9.99999999999999916e+22"},
91 {1e23, 'f', 17, "99999999999999991611392.00000000000000000"},
92 {1e23, 'g', 17, "9.9999999999999992e+22"},
93
94 {1e23, 'e', -1, "1e+23"},
95 {1e23, 'f', -1, "100000000000000000000000"},
96 {1e23, 'g', -1, "1e+23"},
97
98 {below1e23, 'e', 17, "9.99999999999999748e+22"},
99 {below1e23, 'f', 17, "99999999999999974834176.00000000000000000"},
100 {below1e23, 'g', 17, "9.9999999999999975e+22"},
101
102 {below1e23, 'e', -1, "9.999999999999997e+22"},
103 {below1e23, 'f', -1, "99999999999999970000000"},
104 {below1e23, 'g', -1, "9.999999999999997e+22"},
105
106 {above1e23, 'e', 17, "1.00000000000000008e+23"},
107 {above1e23, 'f', 17, "100000000000000008388608.00000000000000000"},
108 {above1e23, 'g', 17, "1.0000000000000001e+23"},
109
110 {above1e23, 'e', -1, "1.0000000000000001e+23"},
111 {above1e23, 'f', -1, "100000000000000010000000"},
112 {above1e23, 'g', -1, "1.0000000000000001e+23"},
113
114 {fdiv(5e-304, 1e20), 'g', -1, "5e-324"},
115 {fdiv(-5e-304, 1e20), 'g', -1, "-5e-324"},
116
117 {32, 'g', -1, "32"},
118 {32, 'g', 0, "3e+01"},
119
120 {100, 'x', -1, "0x1.9p+06"},
121 {100, 'y', -1, "%y"},
122
123 {math.NaN(), 'g', -1, "NaN"},
124 {-math.NaN(), 'g', -1, "NaN"},
125 {math.Inf(0), 'g', -1, "+Inf"},
126 {math.Inf(-1), 'g', -1, "-Inf"},
127 {-math.Inf(0), 'g', -1, "-Inf"},
128
129 {-1, 'b', -1, "-4503599627370496p-52"},
130
131
132 {0.9, 'f', 1, "0.9"},
133 {0.09, 'f', 1, "0.1"},
134 {0.0999, 'f', 1, "0.1"},
135 {0.05, 'f', 1, "0.1"},
136 {0.05, 'f', 0, "0"},
137 {0.5, 'f', 1, "0.5"},
138 {0.5, 'f', 0, "0"},
139 {1.5, 'f', 0, "2"},
140
141
142 {2.2250738585072012e-308, 'g', -1, "2.2250738585072014e-308"},
143
144 {2.2250738585072011e-308, 'g', -1, "2.225073858507201e-308"},
145
146
147 {383260575764816448, 'f', 0, "383260575764816448"},
148 {383260575764816448, 'g', -1, "3.8326057576481645e+17"},
149
150
151 {498484681984085570, 'f', -1, "498484681984085570"},
152 {-5.8339553793802237e+23, 'g', -1, "-5.8339553793802237e+23"},
153
154
155 {123.45, '?', 0, "%?"},
156 {123.45, '?', 1, "%?"},
157 {123.45, '?', -1, "%?"},
158
159
160 {2.275555555555555, 'x', -1, "0x1.23456789abcdep+01"},
161 {2.275555555555555, 'x', 0, "0x1p+01"},
162 {2.275555555555555, 'x', 2, "0x1.23p+01"},
163 {2.275555555555555, 'x', 16, "0x1.23456789abcde000p+01"},
164 {2.275555555555555, 'x', 21, "0x1.23456789abcde00000000p+01"},
165 {2.2755555510520935, 'x', -1, "0x1.2345678p+01"},
166 {2.2755555510520935, 'x', 6, "0x1.234568p+01"},
167 {2.275555431842804, 'x', -1, "0x1.2345668p+01"},
168 {2.275555431842804, 'x', 6, "0x1.234566p+01"},
169 {3.999969482421875, 'x', -1, "0x1.ffffp+01"},
170 {3.999969482421875, 'x', 4, "0x1.ffffp+01"},
171 {3.999969482421875, 'x', 3, "0x1.000p+02"},
172 {3.999969482421875, 'x', 2, "0x1.00p+02"},
173 {3.999969482421875, 'x', 1, "0x1.0p+02"},
174 {3.999969482421875, 'x', 0, "0x1p+02"},
175 }
176
177 func TestFtoa(t *testing.T) {
178 for i := 0; i < len(ftoatests); i++ {
179 test := &ftoatests[i]
180 s := FormatFloat(test.f, test.fmt, test.prec, 64)
181 if s != test.s {
182 t.Error("testN=64", test.f, string(test.fmt), test.prec, "want", test.s, "got", s)
183 }
184 x := AppendFloat([]byte("abc"), test.f, test.fmt, test.prec, 64)
185 if string(x) != "abc"+test.s {
186 t.Error("AppendFloat testN=64", test.f, string(test.fmt), test.prec, "want", "abc"+test.s, "got", string(x))
187 }
188 if float64(float32(test.f)) == test.f && test.fmt != 'b' {
189 s := FormatFloat(test.f, test.fmt, test.prec, 32)
190 if s != test.s {
191 t.Error("testN=32", test.f, string(test.fmt), test.prec, "want", test.s, "got", s)
192 }
193 x := AppendFloat([]byte("abc"), test.f, test.fmt, test.prec, 32)
194 if string(x) != "abc"+test.s {
195 t.Error("AppendFloat testN=32", test.f, string(test.fmt), test.prec, "want", "abc"+test.s, "got", string(x))
196 }
197 }
198 }
199 }
200
201 func TestFtoaPowersOfTwo(t *testing.T) {
202 for exp := -2048; exp <= 2048; exp++ {
203 f := math.Ldexp(1, exp)
204 if !math.IsInf(f, 0) {
205 s := FormatFloat(f, 'e', -1, 64)
206 if x, _ := ParseFloat(s, 64); x != f {
207 t.Errorf("failed roundtrip %v => %s => %v", f, s, x)
208 }
209 }
210 f32 := float32(f)
211 if !math.IsInf(float64(f32), 0) {
212 s := FormatFloat(float64(f32), 'e', -1, 32)
213 if x, _ := ParseFloat(s, 32); float32(x) != f32 {
214 t.Errorf("failed roundtrip %v => %s => %v", f32, s, float32(x))
215 }
216 }
217 }
218 }
219
220 func TestFtoaRandom(t *testing.T) {
221 N := int(1e4)
222 if testing.Short() {
223 N = 100
224 }
225 t.Logf("testing %d random numbers with fast and slow FormatFloat", N)
226 for i := 0; i < N; i++ {
227 bits := uint64(rand.Uint32())<<32 | uint64(rand.Uint32())
228 x := math.Float64frombits(bits)
229
230 shortFast := FormatFloat(x, 'g', -1, 64)
231 SetOptimize(false)
232 shortSlow := FormatFloat(x, 'g', -1, 64)
233 SetOptimize(true)
234 if shortSlow != shortFast {
235 t.Errorf("%b printed as %s, want %s", x, shortFast, shortSlow)
236 }
237
238 prec := rand.Intn(12) + 5
239 shortFast = FormatFloat(x, 'e', prec, 64)
240 SetOptimize(false)
241 shortSlow = FormatFloat(x, 'e', prec, 64)
242 SetOptimize(true)
243 if shortSlow != shortFast {
244 t.Errorf("%b printed as %s, want %s", x, shortFast, shortSlow)
245 }
246 }
247 }
248
249 func TestFormatFloatInvalidBitSize(t *testing.T) {
250 defer func() {
251 if r := recover(); r == nil {
252 t.Fatalf("expected panic due to invalid bitSize")
253 }
254 }()
255 _ = FormatFloat(3.14, 'g', -1, 100)
256 }
257
258 var ftoaBenches = []struct {
259 name string
260 float float64
261 fmt byte
262 prec int
263 bitSize int
264 }{
265 {"Decimal", 33909, 'g', -1, 64},
266 {"Float", 339.7784, 'g', -1, 64},
267 {"Exp", -5.09e75, 'g', -1, 64},
268 {"NegExp", -5.11e-95, 'g', -1, 64},
269 {"LongExp", 1.234567890123456e-78, 'g', -1, 64},
270
271 {"Big", 123456789123456789123456789, 'g', -1, 64},
272 {"BinaryExp", -1, 'b', -1, 64},
273
274 {"32Integer", 33909, 'g', -1, 32},
275 {"32ExactFraction", 3.375, 'g', -1, 32},
276 {"32Point", 339.7784, 'g', -1, 32},
277 {"32Exp", -5.09e25, 'g', -1, 32},
278 {"32NegExp", -5.11e-25, 'g', -1, 32},
279 {"32Shortest", 1.234567e-8, 'g', -1, 32},
280 {"32Fixed8Hard", math.Ldexp(15961084, -125), 'e', 8, 32},
281 {"32Fixed9Hard", math.Ldexp(14855922, -83), 'e', 9, 32},
282
283 {"64Fixed1", 123456, 'e', 3, 64},
284 {"64Fixed2", 123.456, 'e', 3, 64},
285 {"64Fixed3", 1.23456e+78, 'e', 3, 64},
286 {"64Fixed4", 1.23456e-78, 'e', 3, 64},
287 {"64Fixed12", 1.23456e-78, 'e', 12, 64},
288 {"64Fixed16", 1.23456e-78, 'e', 16, 64},
289
290 {"64Fixed12Hard", math.Ldexp(6965949469487146, -249), 'e', 12, 64},
291 {"64Fixed17Hard", math.Ldexp(8887055249355788, 665), 'e', 17, 64},
292 {"64Fixed18Hard", math.Ldexp(6994187472632449, 690), 'e', 18, 64},
293
294
295
296 {"Slowpath64", 8.03413753080882349e+43, 'e', -1, 64},
297
298
299
300
301
302 {"SlowpathDenormal64", 622666234635.3213e-320, 'e', -1, 64},
303 }
304
305 func BenchmarkFormatFloat(b *testing.B) {
306 for _, c := range ftoaBenches {
307 b.Run(c.name, func(b *testing.B) {
308 for i := 0; i < b.N; i++ {
309 FormatFloat(c.float, c.fmt, c.prec, c.bitSize)
310 }
311 })
312 }
313 }
314
315 func BenchmarkAppendFloat(b *testing.B) {
316 dst := make([]byte, 30)
317 for _, c := range ftoaBenches {
318 b.Run(c.name, func(b *testing.B) {
319 for i := 0; i < b.N; i++ {
320 AppendFloat(dst[:0], c.float, c.fmt, c.prec, c.bitSize)
321 }
322 })
323 }
324 }
325
View as plain text