1// Copyright 2015 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. 4 5package big 6 7import ( 8 "bytes" 9 "fmt" 10 "math" 11 "math/bits" 12 "strconv" 13 "testing" 14) 15 16var zero_ float64 17 18func TestFloatSetFloat64String(t *testing.T) { 19 inf := math.Inf(0) 20 nan := math.NaN() 21 22 for _, test := range []struct { 23 s string 24 x float64 // NaNs represent invalid inputs 25 }{ 26 // basics 27 {"0", 0}, 28 {"-0", -zero_}, 29 {"+0", 0}, 30 {"1", 1}, 31 {"-1", -1}, 32 {"+1", 1}, 33 {"1.234", 1.234}, 34 {"-1.234", -1.234}, 35 {"+1.234", 1.234}, 36 {".1", 0.1}, 37 {"1.", 1}, 38 {"+1.", 1}, 39 40 // various zeros 41 {"0e100", 0}, 42 {"-0e+100", -zero_}, 43 {"+0e-100", 0}, 44 {"0E100", 0}, 45 {"-0E+100", -zero_}, 46 {"+0E-100", 0}, 47 48 // various decimal exponent formats 49 {"1.e10", 1e10}, 50 {"1e+10", 1e10}, 51 {"+1e-10", 1e-10}, 52 {"1E10", 1e10}, 53 {"1.E+10", 1e10}, 54 {"+1E-10", 1e-10}, 55 56 // infinities 57 {"Inf", inf}, 58 {"+Inf", inf}, 59 {"-Inf", -inf}, 60 {"inf", inf}, 61 {"+inf", inf}, 62 {"-inf", -inf}, 63 64 // invalid numbers 65 {"", nan}, 66 {"-", nan}, 67 {"0x", nan}, 68 {"0e", nan}, 69 {"1.2ef", nan}, 70 {"2..3", nan}, 71 {"123..", nan}, 72 {"infinity", nan}, 73 {"foobar", nan}, 74 75 // invalid underscores 76 {"_", nan}, 77 {"0_", nan}, 78 {"1__0", nan}, 79 {"123_.", nan}, 80 {"123._", nan}, 81 {"123._4", nan}, 82 {"1_2.3_4_", nan}, 83 {"_.123", nan}, 84 {"_123.456", nan}, 85 {"10._0", nan}, 86 {"10.0e_0", nan}, 87 {"10.0e0_", nan}, 88 {"0P-0__0", nan}, 89 90 // misc decimal values 91 {"3.14159265", 3.14159265}, 92 {"-687436.79457e-245", -687436.79457e-245}, 93 {"-687436.79457E245", -687436.79457e245}, 94 {".0000000000000000000000000000000000000001", 1e-40}, 95 {"+10000000000000000000000000000000000000000e-0", 1e40}, 96 97 // decimal mantissa, binary exponent 98 {"0p0", 0}, 99 {"-0p0", -zero_}, 100 {"1p10", 1 << 10}, 101 {"1p+10", 1 << 10}, 102 {"+1p-10", 1.0 / (1 << 10)}, 103 {"1024p-12", 0.25}, 104 {"-1p10", -1024}, 105 {"1.5p1", 3}, 106 107 // binary mantissa, decimal exponent 108 {"0b0", 0}, 109 {"-0b0", -zero_}, 110 {"0b0e+10", 0}, 111 {"-0b0e-10", -zero_}, 112 {"0b1010", 10}, 113 {"0B1010E2", 1000}, 114 {"0b.1", 0.5}, 115 {"0b.001", 0.125}, 116 {"0b.001e3", 125}, 117 118 // binary mantissa, binary exponent 119 {"0b0p+10", 0}, 120 {"-0b0p-10", -zero_}, 121 {"0b.1010p4", 10}, 122 {"0b1p-1", 0.5}, 123 {"0b001p-3", 0.125}, 124 {"0b.001p3", 1}, 125 {"0b0.01p2", 1}, 126 {"0b0.01P+2", 1}, 127 128 // octal mantissa, decimal exponent 129 {"0o0", 0}, 130 {"-0o0", -zero_}, 131 {"0o0e+10", 0}, 132 {"-0o0e-10", -zero_}, 133 {"0o12", 10}, 134 {"0O12E2", 1000}, 135 {"0o.4", 0.5}, 136 {"0o.01", 0.015625}, 137 {"0o.01e3", 15.625}, 138 139 // octal mantissa, binary exponent 140 {"0o0p+10", 0}, 141 {"-0o0p-10", -zero_}, 142 {"0o.12p6", 10}, 143 {"0o4p-3", 0.5}, 144 {"0o0014p-6", 0.1875}, 145 {"0o.001p9", 1}, 146 {"0o0.01p7", 2}, 147 {"0O0.01P+2", 0.0625}, 148 149 // hexadecimal mantissa and exponent 150 {"0x0", 0}, 151 {"-0x0", -zero_}, 152 {"0x0p+10", 0}, 153 {"-0x0p-10", -zero_}, 154 {"0xff", 255}, 155 {"0X.8p1", 1}, 156 {"-0X0.00008p16", -0.5}, 157 {"-0X0.00008P+16", -0.5}, 158 {"0x0.0000000000001p-1022", math.SmallestNonzeroFloat64}, 159 {"0x1.fffffffffffffp1023", math.MaxFloat64}, 160 161 // underscores 162 {"0_0", 0}, 163 {"1_000.", 1000}, 164 {"1_2_3.4_5_6", 123.456}, 165 {"1.0e0_0", 1}, 166 {"1p+1_0", 1024}, 167 {"0b_1000", 0x8}, 168 {"0b_1011_1101", 0xbd}, 169 {"0x_f0_0d_1eP+0_8", 0xf00d1e00}, 170 } { 171 var x Float 172 x.SetPrec(53) 173 _, ok := x.SetString(test.s) 174 if math.IsNaN(test.x) { 175 // test.s is invalid 176 if ok { 177 t.Errorf("%s: want parse error", test.s) 178 } 179 continue 180 } 181 // test.s is valid 182 if !ok { 183 t.Errorf("%s: got parse error", test.s) 184 continue 185 } 186 f, _ := x.Float64() 187 want := new(Float).SetFloat64(test.x) 188 if x.Cmp(want) != 0 || x.Signbit() != want.Signbit() { 189 t.Errorf("%s: got %v (%v); want %v", test.s, &x, f, test.x) 190 } 191 } 192} 193 194func fdiv(a, b float64) float64 { return a / b } 195 196const ( 197 below1e23 = 99999999999999974834176 198 above1e23 = 100000000000000008388608 199) 200 201func TestFloat64Text(t *testing.T) { 202 for _, test := range []struct { 203 x float64 204 format byte 205 prec int 206 want string 207 }{ 208 {0, 'f', 0, "0"}, 209 {math.Copysign(0, -1), 'f', 0, "-0"}, 210 {1, 'f', 0, "1"}, 211 {-1, 'f', 0, "-1"}, 212 213 {0.001, 'e', 0, "1e-03"}, 214 {0.459, 'e', 0, "5e-01"}, 215 {1.459, 'e', 0, "1e+00"}, 216 {2.459, 'e', 1, "2.5e+00"}, 217 {3.459, 'e', 2, "3.46e+00"}, 218 {4.459, 'e', 3, "4.459e+00"}, 219 {5.459, 'e', 4, "5.4590e+00"}, 220 221 {0.001, 'f', 0, "0"}, 222 {0.459, 'f', 0, "0"}, 223 {1.459, 'f', 0, "1"}, 224 {2.459, 'f', 1, "2.5"}, 225 {3.459, 'f', 2, "3.46"}, 226 {4.459, 'f', 3, "4.459"}, 227 {5.459, 'f', 4, "5.4590"}, 228 229 {0, 'b', 0, "0"}, 230 {math.Copysign(0, -1), 'b', 0, "-0"}, 231 {1.0, 'b', 0, "4503599627370496p-52"}, 232 {-1.0, 'b', 0, "-4503599627370496p-52"}, 233 {4503599627370496, 'b', 0, "4503599627370496p+0"}, 234 235 {0, 'p', 0, "0"}, 236 {math.Copysign(0, -1), 'p', 0, "-0"}, 237 {1024.0, 'p', 0, "0x.8p+11"}, 238 {-1024.0, 'p', 0, "-0x.8p+11"}, 239 240 // all test cases below from strconv/ftoa_test.go 241 {1, 'e', 5, "1.00000e+00"}, 242 {1, 'f', 5, "1.00000"}, 243 {1, 'g', 5, "1"}, 244 {1, 'g', -1, "1"}, 245 {20, 'g', -1, "20"}, 246 {1234567.8, 'g', -1, "1.2345678e+06"}, 247 {200000, 'g', -1, "200000"}, 248 {2000000, 'g', -1, "2e+06"}, 249 250 // g conversion and zero suppression 251 {400, 'g', 2, "4e+02"}, 252 {40, 'g', 2, "40"}, 253 {4, 'g', 2, "4"}, 254 {.4, 'g', 2, "0.4"}, 255 {.04, 'g', 2, "0.04"}, 256 {.004, 'g', 2, "0.004"}, 257 {.0004, 'g', 2, "0.0004"}, 258 {.00004, 'g', 2, "4e-05"}, 259 {.000004, 'g', 2, "4e-06"}, 260 261 {0, 'e', 5, "0.00000e+00"}, 262 {0, 'f', 5, "0.00000"}, 263 {0, 'g', 5, "0"}, 264 {0, 'g', -1, "0"}, 265 266 {-1, 'e', 5, "-1.00000e+00"}, 267 {-1, 'f', 5, "-1.00000"}, 268 {-1, 'g', 5, "-1"}, 269 {-1, 'g', -1, "-1"}, 270 271 {12, 'e', 5, "1.20000e+01"}, 272 {12, 'f', 5, "12.00000"}, 273 {12, 'g', 5, "12"}, 274 {12, 'g', -1, "12"}, 275 276 {123456700, 'e', 5, "1.23457e+08"}, 277 {123456700, 'f', 5, "123456700.00000"}, 278 {123456700, 'g', 5, "1.2346e+08"}, 279 {123456700, 'g', -1, "1.234567e+08"}, 280 281 {1.2345e6, 'e', 5, "1.23450e+06"}, 282 {1.2345e6, 'f', 5, "1234500.00000"}, 283 {1.2345e6, 'g', 5, "1.2345e+06"}, 284 285 {1e23, 'e', 17, "9.99999999999999916e+22"}, 286 {1e23, 'f', 17, "99999999999999991611392.00000000000000000"}, 287 {1e23, 'g', 17, "9.9999999999999992e+22"}, 288 289 {1e23, 'e', -1, "1e+23"}, 290 {1e23, 'f', -1, "100000000000000000000000"}, 291 {1e23, 'g', -1, "1e+23"}, 292 293 {below1e23, 'e', 17, "9.99999999999999748e+22"}, 294 {below1e23, 'f', 17, "99999999999999974834176.00000000000000000"}, 295 {below1e23, 'g', 17, "9.9999999999999975e+22"}, 296 297 {below1e23, 'e', -1, "9.999999999999997e+22"}, 298 {below1e23, 'f', -1, "99999999999999970000000"}, 299 {below1e23, 'g', -1, "9.999999999999997e+22"}, 300 301 {above1e23, 'e', 17, "1.00000000000000008e+23"}, 302 {above1e23, 'f', 17, "100000000000000008388608.00000000000000000"}, 303 {above1e23, 'g', 17, "1.0000000000000001e+23"}, 304 305 {above1e23, 'e', -1, "1.0000000000000001e+23"}, 306 {above1e23, 'f', -1, "100000000000000010000000"}, 307 {above1e23, 'g', -1, "1.0000000000000001e+23"}, 308 309 {5e-304 / 1e20, 'g', -1, "5e-324"}, 310 {-5e-304 / 1e20, 'g', -1, "-5e-324"}, 311 {fdiv(5e-304, 1e20), 'g', -1, "5e-324"}, // avoid constant arithmetic 312 {fdiv(-5e-304, 1e20), 'g', -1, "-5e-324"}, // avoid constant arithmetic 313 314 {32, 'g', -1, "32"}, 315 {32, 'g', 0, "3e+01"}, 316 317 {100, 'x', -1, "0x1.9p+06"}, 318 319 // {math.NaN(), 'g', -1, "NaN"}, // Float doesn't support NaNs 320 // {-math.NaN(), 'g', -1, "NaN"}, // Float doesn't support NaNs 321 {math.Inf(0), 'g', -1, "+Inf"}, 322 {math.Inf(-1), 'g', -1, "-Inf"}, 323 {-math.Inf(0), 'g', -1, "-Inf"}, 324 325 {-1, 'b', -1, "-4503599627370496p-52"}, 326 327 // fixed bugs 328 {0.9, 'f', 1, "0.9"}, 329 {0.09, 'f', 1, "0.1"}, 330 {0.0999, 'f', 1, "0.1"}, 331 {0.05, 'f', 1, "0.1"}, 332 {0.05, 'f', 0, "0"}, 333 {0.5, 'f', 1, "0.5"}, 334 {0.5, 'f', 0, "0"}, 335 {1.5, 'f', 0, "2"}, 336 337 // https://www.exploringbinary.com/java-hangs-when-converting-2-2250738585072012e-308/ 338 {2.2250738585072012e-308, 'g', -1, "2.2250738585072014e-308"}, 339 // https://www.exploringbinary.com/php-hangs-on-numeric-value-2-2250738585072011e-308/ 340 {2.2250738585072011e-308, 'g', -1, "2.225073858507201e-308"}, 341 342 // Issue 2625. 343 {383260575764816448, 'f', 0, "383260575764816448"}, 344 {383260575764816448, 'g', -1, "3.8326057576481645e+17"}, 345 346 // Issue 15918. 347 {1, 'f', -10, "1"}, 348 {1, 'f', -11, "1"}, 349 {1, 'f', -12, "1"}, 350 } { 351 // The test cases are from the strconv package which tests float64 values. 352 // When formatting values with prec = -1 (shortest representation), 353 // the actually available mantissa precision matters. 354 // For denormalized values, that precision is < 53 (SetFloat64 default). 355 // Compute and set the actual precision explicitly. 356 f := new(Float).SetPrec(actualPrec(test.x)).SetFloat64(test.x) 357 got := f.Text(test.format, test.prec) 358 if got != test.want { 359 t.Errorf("%v: got %s; want %s", test, got, test.want) 360 continue 361 } 362 363 if test.format == 'b' && test.x == 0 { 364 continue // 'b' format in strconv.Float requires knowledge of bias for 0.0 365 } 366 if test.format == 'p' { 367 continue // 'p' format not supported in strconv.Format 368 } 369 370 // verify that Float format matches strconv format 371 want := strconv.FormatFloat(test.x, test.format, test.prec, 64) 372 if got != want { 373 t.Errorf("%v: got %s; want %s (strconv)", test, got, want) 374 } 375 } 376} 377 378// actualPrec returns the number of actually used mantissa bits. 379func actualPrec(x float64) uint { 380 if mant := math.Float64bits(x); x != 0 && mant&(0x7ff<<52) == 0 { 381 // x is denormalized 382 return 64 - uint(bits.LeadingZeros64(mant&(1<<52-1))) 383 } 384 return 53 385} 386 387func TestFloatText(t *testing.T) { 388 const defaultRound = ^RoundingMode(0) 389 390 for _, test := range []struct { 391 x string 392 round RoundingMode 393 prec uint 394 format byte 395 digits int 396 want string 397 }{ 398 {"0", defaultRound, 10, 'f', 0, "0"}, 399 {"-0", defaultRound, 10, 'f', 0, "-0"}, 400 {"1", defaultRound, 10, 'f', 0, "1"}, 401 {"-1", defaultRound, 10, 'f', 0, "-1"}, 402 403 {"1.459", defaultRound, 100, 'e', 0, "1e+00"}, 404 {"2.459", defaultRound, 100, 'e', 1, "2.5e+00"}, 405 {"3.459", defaultRound, 100, 'e', 2, "3.46e+00"}, 406 {"4.459", defaultRound, 100, 'e', 3, "4.459e+00"}, 407 {"5.459", defaultRound, 100, 'e', 4, "5.4590e+00"}, 408 409 {"1.459", defaultRound, 100, 'E', 0, "1E+00"}, 410 {"2.459", defaultRound, 100, 'E', 1, "2.5E+00"}, 411 {"3.459", defaultRound, 100, 'E', 2, "3.46E+00"}, 412 {"4.459", defaultRound, 100, 'E', 3, "4.459E+00"}, 413 {"5.459", defaultRound, 100, 'E', 4, "5.4590E+00"}, 414 415 {"1.459", defaultRound, 100, 'f', 0, "1"}, 416 {"2.459", defaultRound, 100, 'f', 1, "2.5"}, 417 {"3.459", defaultRound, 100, 'f', 2, "3.46"}, 418 {"4.459", defaultRound, 100, 'f', 3, "4.459"}, 419 {"5.459", defaultRound, 100, 'f', 4, "5.4590"}, 420 421 {"1.459", defaultRound, 100, 'g', 0, "1"}, 422 {"2.459", defaultRound, 100, 'g', 1, "2"}, 423 {"3.459", defaultRound, 100, 'g', 2, "3.5"}, 424 {"4.459", defaultRound, 100, 'g', 3, "4.46"}, 425 {"5.459", defaultRound, 100, 'g', 4, "5.459"}, 426 427 {"1459", defaultRound, 53, 'g', 0, "1e+03"}, 428 {"2459", defaultRound, 53, 'g', 1, "2e+03"}, 429 {"3459", defaultRound, 53, 'g', 2, "3.5e+03"}, 430 {"4459", defaultRound, 53, 'g', 3, "4.46e+03"}, 431 {"5459", defaultRound, 53, 'g', 4, "5459"}, 432 433 {"1459", defaultRound, 53, 'G', 0, "1E+03"}, 434 {"2459", defaultRound, 53, 'G', 1, "2E+03"}, 435 {"3459", defaultRound, 53, 'G', 2, "3.5E+03"}, 436 {"4459", defaultRound, 53, 'G', 3, "4.46E+03"}, 437 {"5459", defaultRound, 53, 'G', 4, "5459"}, 438 439 {"3", defaultRound, 10, 'e', 40, "3.0000000000000000000000000000000000000000e+00"}, 440 {"3", defaultRound, 10, 'f', 40, "3.0000000000000000000000000000000000000000"}, 441 {"3", defaultRound, 10, 'g', 40, "3"}, 442 443 {"3e40", defaultRound, 100, 'e', 40, "3.0000000000000000000000000000000000000000e+40"}, 444 {"3e40", defaultRound, 100, 'f', 4, "30000000000000000000000000000000000000000.0000"}, 445 {"3e40", defaultRound, 100, 'g', 40, "3e+40"}, 446 447 // make sure "stupid" exponents don't stall the machine 448 {"1e1000000", defaultRound, 64, 'p', 0, "0x.88b3a28a05eade3ap+3321929"}, 449 {"1e646456992", defaultRound, 64, 'p', 0, "0x.e883a0c5c8c7c42ap+2147483644"}, 450 {"1e646456993", defaultRound, 64, 'p', 0, "+Inf"}, 451 {"1e1000000000", defaultRound, 64, 'p', 0, "+Inf"}, 452 {"1e-1000000", defaultRound, 64, 'p', 0, "0x.efb4542cc8ca418ap-3321928"}, 453 {"1e-646456993", defaultRound, 64, 'p', 0, "0x.e17c8956983d9d59p-2147483647"}, 454 {"1e-646456994", defaultRound, 64, 'p', 0, "0"}, 455 {"1e-1000000000", defaultRound, 64, 'p', 0, "0"}, 456 457 // minimum and maximum values 458 {"1p2147483646", defaultRound, 64, 'p', 0, "0x.8p+2147483647"}, 459 {"0x.8p2147483647", defaultRound, 64, 'p', 0, "0x.8p+2147483647"}, 460 {"0x.8p-2147483647", defaultRound, 64, 'p', 0, "0x.8p-2147483647"}, 461 {"1p-2147483649", defaultRound, 64, 'p', 0, "0x.8p-2147483648"}, 462 463 // TODO(gri) need tests for actual large Floats 464 465 {"0", defaultRound, 53, 'b', 0, "0"}, 466 {"-0", defaultRound, 53, 'b', 0, "-0"}, 467 {"1.0", defaultRound, 53, 'b', 0, "4503599627370496p-52"}, 468 {"-1.0", defaultRound, 53, 'b', 0, "-4503599627370496p-52"}, 469 {"4503599627370496", defaultRound, 53, 'b', 0, "4503599627370496p+0"}, 470 471 // issue 9939 472 {"3", defaultRound, 350, 'b', 0, "1720123961992553633708115671476565205597423741876210842803191629540192157066363606052513914832594264915968p-348"}, 473 {"03", defaultRound, 350, 'b', 0, "1720123961992553633708115671476565205597423741876210842803191629540192157066363606052513914832594264915968p-348"}, 474 {"3.", defaultRound, 350, 'b', 0, "1720123961992553633708115671476565205597423741876210842803191629540192157066363606052513914832594264915968p-348"}, 475 {"3.0", defaultRound, 350, 'b', 0, "1720123961992553633708115671476565205597423741876210842803191629540192157066363606052513914832594264915968p-348"}, 476 {"3.00", defaultRound, 350, 'b', 0, "1720123961992553633708115671476565205597423741876210842803191629540192157066363606052513914832594264915968p-348"}, 477 {"3.000", defaultRound, 350, 'b', 0, "1720123961992553633708115671476565205597423741876210842803191629540192157066363606052513914832594264915968p-348"}, 478 479 {"3", defaultRound, 350, 'p', 0, "0x.cp+2"}, 480 {"03", defaultRound, 350, 'p', 0, "0x.cp+2"}, 481 {"3.", defaultRound, 350, 'p', 0, "0x.cp+2"}, 482 {"3.0", defaultRound, 350, 'p', 0, "0x.cp+2"}, 483 {"3.00", defaultRound, 350, 'p', 0, "0x.cp+2"}, 484 {"3.000", defaultRound, 350, 'p', 0, "0x.cp+2"}, 485 486 {"0", defaultRound, 64, 'p', 0, "0"}, 487 {"-0", defaultRound, 64, 'p', 0, "-0"}, 488 {"1024.0", defaultRound, 64, 'p', 0, "0x.8p+11"}, 489 {"-1024.0", defaultRound, 64, 'p', 0, "-0x.8p+11"}, 490 491 {"0", defaultRound, 64, 'x', -1, "0x0p+00"}, 492 {"0", defaultRound, 64, 'x', 0, "0x0p+00"}, 493 {"0", defaultRound, 64, 'x', 1, "0x0.0p+00"}, 494 {"0", defaultRound, 64, 'x', 5, "0x0.00000p+00"}, 495 {"3.25", defaultRound, 64, 'x', 0, "0x1p+02"}, 496 {"-3.25", defaultRound, 64, 'x', 0, "-0x1p+02"}, 497 {"3.25", defaultRound, 64, 'x', 1, "0x1.ap+01"}, 498 {"-3.25", defaultRound, 64, 'x', 1, "-0x1.ap+01"}, 499 {"3.25", defaultRound, 64, 'x', -1, "0x1.ap+01"}, 500 {"-3.25", defaultRound, 64, 'x', -1, "-0x1.ap+01"}, 501 {"1024.0", defaultRound, 64, 'x', 0, "0x1p+10"}, 502 {"-1024.0", defaultRound, 64, 'x', 0, "-0x1p+10"}, 503 {"1024.0", defaultRound, 64, 'x', 5, "0x1.00000p+10"}, 504 {"8191.0", defaultRound, 53, 'x', -1, "0x1.fffp+12"}, 505 {"8191.5", defaultRound, 53, 'x', -1, "0x1.fff8p+12"}, 506 {"8191.53125", defaultRound, 53, 'x', -1, "0x1.fff88p+12"}, 507 {"8191.53125", defaultRound, 53, 'x', 4, "0x1.fff8p+12"}, 508 {"8191.53125", defaultRound, 53, 'x', 3, "0x1.000p+13"}, 509 {"8191.53125", defaultRound, 53, 'x', 0, "0x1p+13"}, 510 {"8191.533203125", defaultRound, 53, 'x', -1, "0x1.fff888p+12"}, 511 {"8191.533203125", defaultRound, 53, 'x', 5, "0x1.fff88p+12"}, 512 {"8191.533203125", defaultRound, 53, 'x', 4, "0x1.fff9p+12"}, 513 514 {"8191.53125", defaultRound, 53, 'x', -1, "0x1.fff88p+12"}, 515 {"8191.53125", ToNearestEven, 53, 'x', 5, "0x1.fff88p+12"}, 516 {"8191.53125", ToNearestAway, 53, 'x', 5, "0x1.fff88p+12"}, 517 {"8191.53125", ToZero, 53, 'x', 5, "0x1.fff88p+12"}, 518 {"8191.53125", AwayFromZero, 53, 'x', 5, "0x1.fff88p+12"}, 519 {"8191.53125", ToNegativeInf, 53, 'x', 5, "0x1.fff88p+12"}, 520 {"8191.53125", ToPositiveInf, 53, 'x', 5, "0x1.fff88p+12"}, 521 522 {"8191.53125", defaultRound, 53, 'x', 4, "0x1.fff8p+12"}, 523 {"8191.53125", defaultRound, 53, 'x', 3, "0x1.000p+13"}, 524 {"8191.53125", defaultRound, 53, 'x', 0, "0x1p+13"}, 525 {"8191.533203125", defaultRound, 53, 'x', -1, "0x1.fff888p+12"}, 526 {"8191.533203125", defaultRound, 53, 'x', 6, "0x1.fff888p+12"}, 527 {"8191.533203125", defaultRound, 53, 'x', 5, "0x1.fff88p+12"}, 528 {"8191.533203125", defaultRound, 53, 'x', 4, "0x1.fff9p+12"}, 529 530 {"8191.53125", ToNearestEven, 53, 'x', 4, "0x1.fff8p+12"}, 531 {"8191.53125", ToNearestAway, 53, 'x', 4, "0x1.fff9p+12"}, 532 {"8191.53125", ToZero, 53, 'x', 4, "0x1.fff8p+12"}, 533 {"8191.53125", ToZero, 53, 'x', 2, "0x1.ffp+12"}, 534 {"8191.53125", AwayFromZero, 53, 'x', 4, "0x1.fff9p+12"}, 535 {"8191.53125", ToNegativeInf, 53, 'x', 4, "0x1.fff8p+12"}, 536 {"-8191.53125", ToNegativeInf, 53, 'x', 4, "-0x1.fff9p+12"}, 537 {"8191.53125", ToPositiveInf, 53, 'x', 4, "0x1.fff9p+12"}, 538 {"-8191.53125", ToPositiveInf, 53, 'x', 4, "-0x1.fff8p+12"}, 539 540 // issue 34343 541 {"0x.8p-2147483648", ToNearestEven, 4, 'p', -1, "0x.8p-2147483648"}, 542 {"0x.8p-2147483648", ToNearestEven, 4, 'x', -1, "0x1p-2147483649"}, 543 } { 544 f, _, err := ParseFloat(test.x, 0, test.prec, ToNearestEven) 545 if err != nil { 546 t.Errorf("%v: %s", test, err) 547 continue 548 } 549 if test.round != defaultRound { 550 f.SetMode(test.round) 551 } 552 553 got := f.Text(test.format, test.digits) 554 if got != test.want { 555 t.Errorf("%v: got %s; want %s", test, got, test.want) 556 } 557 558 // compare with strconv.FormatFloat output if possible 559 // ('p' format is not supported by strconv.FormatFloat, 560 // and its output for 0.0 prints a biased exponent value 561 // as in 0p-1074 which makes no sense to emulate here) 562 if test.prec == 53 && test.format != 'p' && f.Sign() != 0 && (test.round == ToNearestEven || test.round == defaultRound) { 563 f64, acc := f.Float64() 564 if acc != Exact { 565 t.Errorf("%v: expected exact conversion to float64", test) 566 continue 567 } 568 got := strconv.FormatFloat(f64, test.format, test.digits, 64) 569 if got != test.want { 570 t.Errorf("%v: got %s; want %s", test, got, test.want) 571 } 572 } 573 } 574} 575 576func TestFloatFormat(t *testing.T) { 577 for _, test := range []struct { 578 format string 579 value any // float32, float64, or string (== 512bit *Float) 580 want string 581 }{ 582 // from fmt/fmt_test.go 583 {"%+.3e", 0.0, "+0.000e+00"}, 584 {"%+.3e", 1.0, "+1.000e+00"}, 585 {"%+.3f", -1.0, "-1.000"}, 586 {"%+.3F", -1.0, "-1.000"}, 587 {"%+.3F", float32(-1.0), "-1.000"}, 588 {"%+07.2f", 1.0, "+001.00"}, 589 {"%+07.2f", -1.0, "-001.00"}, 590 {"%+10.2f", +1.0, " +1.00"}, 591 {"%+10.2f", -1.0, " -1.00"}, 592 {"% .3E", -1.0, "-1.000E+00"}, 593 {"% .3e", 1.0, " 1.000e+00"}, 594 {"%+.3g", 0.0, "+0"}, 595 {"%+.3g", 1.0, "+1"}, 596 {"%+.3g", -1.0, "-1"}, 597 {"% .3g", -1.0, "-1"}, 598 {"% .3g", 1.0, " 1"}, 599 {"%b", float32(1.0), "8388608p-23"}, 600 {"%b", 1.0, "4503599627370496p-52"}, 601 602 // from fmt/fmt_test.go: old test/fmt_test.go 603 {"%e", 1.0, "1.000000e+00"}, 604 {"%e", 1234.5678e3, "1.234568e+06"}, 605 {"%e", 1234.5678e-8, "1.234568e-05"}, 606 {"%e", -7.0, "-7.000000e+00"}, 607 {"%e", -1e-9, "-1.000000e-09"}, 608 {"%f", 1234.5678e3, "1234567.800000"}, 609 {"%f", 1234.5678e-8, "0.000012"}, 610 {"%f", -7.0, "-7.000000"}, 611 {"%f", -1e-9, "-0.000000"}, 612 {"%g", 1234.5678e3, "1.2345678e+06"}, 613 {"%g", float32(1234.5678e3), "1.2345678e+06"}, 614 {"%g", 1234.5678e-8, "1.2345678e-05"}, 615 {"%g", -7.0, "-7"}, 616 {"%g", -1e-9, "-1e-09"}, 617 {"%g", float32(-1e-9), "-1e-09"}, 618 {"%E", 1.0, "1.000000E+00"}, 619 {"%E", 1234.5678e3, "1.234568E+06"}, 620 {"%E", 1234.5678e-8, "1.234568E-05"}, 621 {"%E", -7.0, "-7.000000E+00"}, 622 {"%E", -1e-9, "-1.000000E-09"}, 623 {"%G", 1234.5678e3, "1.2345678E+06"}, 624 {"%G", float32(1234.5678e3), "1.2345678E+06"}, 625 {"%G", 1234.5678e-8, "1.2345678E-05"}, 626 {"%G", -7.0, "-7"}, 627 {"%G", -1e-9, "-1E-09"}, 628 {"%G", float32(-1e-9), "-1E-09"}, 629 630 {"%20.6e", 1.2345e3, " 1.234500e+03"}, 631 {"%20.6e", 1.2345e-3, " 1.234500e-03"}, 632 {"%20e", 1.2345e3, " 1.234500e+03"}, 633 {"%20e", 1.2345e-3, " 1.234500e-03"}, 634 {"%20.8e", 1.2345e3, " 1.23450000e+03"}, 635 {"%20f", 1.23456789e3, " 1234.567890"}, 636 {"%20f", 1.23456789e-3, " 0.001235"}, 637 {"%20f", 12345678901.23456789, " 12345678901.234568"}, 638 {"%-20f", 1.23456789e3, "1234.567890 "}, 639 {"%20.8f", 1.23456789e3, " 1234.56789000"}, 640 {"%20.8f", 1.23456789e-3, " 0.00123457"}, 641 {"%g", 1.23456789e3, "1234.56789"}, 642 {"%g", 1.23456789e-3, "0.00123456789"}, 643 {"%g", 1.23456789e20, "1.23456789e+20"}, 644 {"%20e", math.Inf(1), " +Inf"}, 645 {"%-20f", math.Inf(-1), "-Inf "}, 646 647 // from fmt/fmt_test.go: comparison of padding rules with C printf 648 {"%.2f", 1.0, "1.00"}, 649 {"%.2f", -1.0, "-1.00"}, 650 {"% .2f", 1.0, " 1.00"}, 651 {"% .2f", -1.0, "-1.00"}, 652 {"%+.2f", 1.0, "+1.00"}, 653 {"%+.2f", -1.0, "-1.00"}, 654 {"%7.2f", 1.0, " 1.00"}, 655 {"%7.2f", -1.0, " -1.00"}, 656 {"% 7.2f", 1.0, " 1.00"}, 657 {"% 7.2f", -1.0, " -1.00"}, 658 {"%+7.2f", 1.0, " +1.00"}, 659 {"%+7.2f", -1.0, " -1.00"}, 660 {"%07.2f", 1.0, "0001.00"}, 661 {"%07.2f", -1.0, "-001.00"}, 662 {"% 07.2f", 1.0, " 001.00"}, 663 {"% 07.2f", -1.0, "-001.00"}, 664 {"%+07.2f", 1.0, "+001.00"}, 665 {"%+07.2f", -1.0, "-001.00"}, 666 667 // from fmt/fmt_test.go: zero padding does not apply to infinities 668 {"%020f", math.Inf(-1), " -Inf"}, 669 {"%020f", math.Inf(+1), " +Inf"}, 670 {"% 020f", math.Inf(-1), " -Inf"}, 671 {"% 020f", math.Inf(+1), " Inf"}, 672 {"%+020f", math.Inf(-1), " -Inf"}, 673 {"%+020f", math.Inf(+1), " +Inf"}, 674 {"%20f", -1.0, " -1.000000"}, 675 676 // handle %v like %g 677 {"%v", 0.0, "0"}, 678 {"%v", -7.0, "-7"}, 679 {"%v", -1e-9, "-1e-09"}, 680 {"%v", float32(-1e-9), "-1e-09"}, 681 {"%010v", 0.0, "0000000000"}, 682 683 // *Float cases 684 {"%.20f", "1e-20", "0.00000000000000000001"}, 685 {"%.20f", "-1e-20", "-0.00000000000000000001"}, 686 {"%30.20f", "-1e-20", " -0.00000000000000000001"}, 687 {"%030.20f", "-1e-20", "-00000000.00000000000000000001"}, 688 {"%030.20f", "+1e-20", "000000000.00000000000000000001"}, 689 {"% 030.20f", "+1e-20", " 00000000.00000000000000000001"}, 690 691 // erroneous formats 692 {"%s", 1.0, "%!s(*big.Float=1)"}, 693 } { 694 value := new(Float) 695 switch v := test.value.(type) { 696 case float32: 697 value.SetPrec(24).SetFloat64(float64(v)) 698 case float64: 699 value.SetPrec(53).SetFloat64(v) 700 case string: 701 value.SetPrec(512).Parse(v, 0) 702 default: 703 t.Fatalf("unsupported test value: %v (%T)", v, v) 704 } 705 706 if got := fmt.Sprintf(test.format, value); got != test.want { 707 t.Errorf("%v: got %q; want %q", test, got, test.want) 708 } 709 } 710} 711 712func BenchmarkParseFloatSmallExp(b *testing.B) { 713 for i := 0; i < b.N; i++ { 714 for _, s := range []string{ 715 "1e0", 716 "1e-1", 717 "1e-2", 718 "1e-3", 719 "1e-4", 720 "1e-5", 721 "1e-10", 722 "1e-20", 723 "1e-50", 724 "1e1", 725 "1e2", 726 "1e3", 727 "1e4", 728 "1e5", 729 "1e10", 730 "1e20", 731 "1e50", 732 } { 733 var x Float 734 _, _, err := x.Parse(s, 0) 735 if err != nil { 736 b.Fatalf("%s: %v", s, err) 737 } 738 } 739 } 740} 741 742func BenchmarkParseFloatLargeExp(b *testing.B) { 743 for i := 0; i < b.N; i++ { 744 for _, s := range []string{ 745 "1e0", 746 "1e-10", 747 "1e-20", 748 "1e-30", 749 "1e-40", 750 "1e-50", 751 "1e-100", 752 "1e-500", 753 "1e-1000", 754 "1e-5000", 755 "1e-10000", 756 "1e10", 757 "1e20", 758 "1e30", 759 "1e40", 760 "1e50", 761 "1e100", 762 "1e500", 763 "1e1000", 764 "1e5000", 765 "1e10000", 766 } { 767 var x Float 768 _, _, err := x.Parse(s, 0) 769 if err != nil { 770 b.Fatalf("%s: %v", s, err) 771 } 772 } 773 } 774} 775 776func TestFloatScan(t *testing.T) { 777 var floatScanTests = []struct { 778 input string 779 format string 780 output string 781 remaining int 782 wantErr bool 783 }{ 784 0: {"10.0", "%f", "10", 0, false}, 785 1: {"23.98+2.0", "%v", "23.98", 4, false}, 786 2: {"-1+1", "%v", "-1", 2, false}, 787 3: {" 00000", "%v", "0", 0, false}, 788 4: {"-123456p-78", "%b", "-4.084816388e-19", 0, false}, 789 5: {"+123", "%b", "123", 0, false}, 790 6: {"-1.234e+56", "%e", "-1.234e+56", 0, false}, 791 7: {"-1.234E-56", "%E", "-1.234e-56", 0, false}, 792 8: {"-1.234e+567", "%g", "-1.234e+567", 0, false}, 793 9: {"+1234567891011.234", "%G", "1.234567891e+12", 0, false}, 794 795 // Scan doesn't handle ±Inf. 796 10: {"Inf", "%v", "", 3, true}, 797 11: {"-Inf", "%v", "", 3, true}, 798 12: {"-Inf", "%v", "", 3, true}, 799 } 800 801 var buf bytes.Buffer 802 for i, test := range floatScanTests { 803 x := new(Float) 804 buf.Reset() 805 buf.WriteString(test.input) 806 _, err := fmt.Fscanf(&buf, test.format, x) 807 if test.wantErr { 808 if err == nil { 809 t.Errorf("#%d want non-nil err", i) 810 } 811 continue 812 } 813 814 if err != nil { 815 t.Errorf("#%d error: %s", i, err) 816 } 817 818 if x.String() != test.output { 819 t.Errorf("#%d got %s; want %s", i, x.String(), test.output) 820 } 821 if buf.Len() != test.remaining { 822 t.Errorf("#%d got %d bytes remaining; want %d", i, buf.Len(), test.remaining) 823 } 824 } 825} 826