...

Source file src/strconv/ftoa_test.go

Documentation: strconv

     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.
     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  	// g conversion and zero suppression
    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  	// Round to even
    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"},   // avoid constant arithmetic
   115  	{fdiv(-5e-304, 1e20), 'g', -1, "-5e-324"}, // avoid constant arithmetic
   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  	// fixed bugs
   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  	// https://www.exploringbinary.com/java-hangs-when-converting-2-2250738585072012e-308/
   142  	{2.2250738585072012e-308, 'g', -1, "2.2250738585072014e-308"},
   143  	// https://www.exploringbinary.com/php-hangs-on-numeric-value-2-2250738585072011e-308/
   144  	{2.2250738585072011e-308, 'g', -1, "2.225073858507201e-308"},
   145  
   146  	// Issue 2625.
   147  	{383260575764816448, 'f', 0, "383260575764816448"},
   148  	{383260575764816448, 'g', -1, "3.8326057576481645e+17"},
   149  
   150  	// Issue 29491.
   151  	{498484681984085570, 'f', -1, "498484681984085570"},
   152  	{-5.8339553793802237e+23, 'g', -1, "-5.8339553793802237e+23"},
   153  
   154  	// Issue 52187
   155  	{123.45, '?', 0, "%?"},
   156  	{123.45, '?', 1, "%?"},
   157  	{123.45, '?', -1, "%?"},
   158  
   159  	// rounding
   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  	// From testdata/testfp.txt
   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  	// Trigger slow path (see issue #15672).
   295  	// The shortest is: 8.034137530808823e+43
   296  	{"Slowpath64", 8.03413753080882349e+43, 'e', -1, 64},
   297  	// This denormal is pathological because the lower/upper
   298  	// halfways to neighboring floats are:
   299  	// 622666234635.321003e-320 ~= 622666234635.321e-320
   300  	// 622666234635.321497e-320 ~= 622666234635.3215e-320
   301  	// making it hard to find the 3rd digit
   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