github.com/guyezi/gofrontend@v0.0.0-20200228202240-7a62a49e62c0/libgo/go/math/big/sqrt_test.go (about) 1 // Copyright 2017 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 big 6 7 import ( 8 "fmt" 9 "math" 10 "math/rand" 11 "runtime" 12 "testing" 13 ) 14 15 // TestFloatSqrt64 tests that Float.Sqrt of numbers with 53bit mantissa 16 // behaves like float math.Sqrt. 17 func TestFloatSqrt64(t *testing.T) { 18 // This test fails for gccgo on 386 with a one ULP difference, 19 // presumably due to the use of extended precision floating 20 // point. 21 if runtime.Compiler == "gccgo" && runtime.GOARCH == "386" { 22 t.Skip("skipping on gccgo for 386; gets a one ULP difference") 23 } 24 25 for i := 0; i < 1e5; i++ { 26 if i == 1e2 && testing.Short() { 27 break 28 } 29 r := rand.Float64() 30 31 got := new(Float).SetPrec(53) 32 got.Sqrt(NewFloat(r)) 33 want := NewFloat(math.Sqrt(r)) 34 if got.Cmp(want) != 0 { 35 t.Fatalf("Sqrt(%g) =\n got %g;\nwant %g", r, got, want) 36 } 37 } 38 } 39 40 func TestFloatSqrt(t *testing.T) { 41 for _, test := range []struct { 42 x string 43 want string 44 }{ 45 // Test values were generated on Wolfram Alpha using query 46 // 'sqrt(N) to 350 digits' 47 // 350 decimal digits give up to 1000 binary digits. 48 {"0.03125", "0.17677669529663688110021109052621225982120898442211850914708496724884155980776337985629844179095519659187673077886403712811560450698134215158051518713749197892665283324093819909447499381264409775757143376369499645074628431682460775184106467733011114982619404115381053858929018135497032545349940642599871090667456829147610370507757690729404938184321879"}, 49 {"0.125", "0.35355339059327376220042218105242451964241796884423701829416993449768311961552675971259688358191039318375346155772807425623120901396268430316103037427498395785330566648187639818894998762528819551514286752738999290149256863364921550368212935466022229965238808230762107717858036270994065090699881285199742181334913658295220741015515381458809876368643757"}, 50 {"0.5", "0.70710678118654752440084436210484903928483593768847403658833986899536623923105351942519376716382078636750692311545614851246241802792536860632206074854996791570661133296375279637789997525057639103028573505477998580298513726729843100736425870932044459930477616461524215435716072541988130181399762570399484362669827316590441482031030762917619752737287514"}, 51 {"2.0", "1.4142135623730950488016887242096980785696718753769480731766797379907324784621070388503875343276415727350138462309122970249248360558507372126441214970999358314132226659275055927557999505011527820605714701095599716059702745345968620147285174186408891986095523292304843087143214508397626036279952514079896872533965463318088296406206152583523950547457503"}, 52 {"3.0", "1.7320508075688772935274463415058723669428052538103806280558069794519330169088000370811461867572485756756261414154067030299699450949989524788116555120943736485280932319023055820679748201010846749232650153123432669033228866506722546689218379712270471316603678615880190499865373798593894676503475065760507566183481296061009476021871903250831458295239598"}, 53 {"4.0", "2.0"}, 54 55 {"1p512", "1p256"}, 56 {"4p1024", "2p512"}, 57 {"9p2048", "3p1024"}, 58 59 {"1p-1024", "1p-512"}, 60 {"4p-2048", "2p-1024"}, 61 {"9p-4096", "3p-2048"}, 62 } { 63 for _, prec := range []uint{24, 53, 64, 65, 100, 128, 129, 200, 256, 400, 600, 800, 1000} { 64 x := new(Float).SetPrec(prec) 65 x.Parse(test.x, 10) 66 67 got := new(Float).SetPrec(prec).Sqrt(x) 68 want := new(Float).SetPrec(prec) 69 want.Parse(test.want, 10) 70 if got.Cmp(want) != 0 { 71 t.Errorf("prec = %d, Sqrt(%v) =\ngot %g;\nwant %g", 72 prec, test.x, got, want) 73 } 74 75 // Square test. 76 // If got holds the square root of x to precision p, then 77 // got = √x + k 78 // for some k such that |k| < 2**(-p). Thus, 79 // got² = (√x + k)² = x + 2k√n + k² 80 // and the error must satisfy 81 // err = |got² - x| ≈ | 2k√n | < 2**(-p+1)*√n 82 // Ignoring the k² term for simplicity. 83 84 // err = |got² - x| 85 // (but do intermediate steps with 32 guard digits to 86 // avoid introducing spurious rounding-related errors) 87 sq := new(Float).SetPrec(prec+32).Mul(got, got) 88 diff := new(Float).Sub(sq, x) 89 err := diff.Abs(diff).SetPrec(prec) 90 91 // maxErr = 2**(-p+1)*√x 92 one := new(Float).SetPrec(prec).SetInt64(1) 93 maxErr := new(Float).Mul(new(Float).SetMantExp(one, -int(prec)+1), got) 94 95 if err.Cmp(maxErr) >= 0 { 96 t.Errorf("prec = %d, Sqrt(%v) =\ngot err %g;\nwant maxErr %g", 97 prec, test.x, err, maxErr) 98 } 99 } 100 } 101 } 102 103 func TestFloatSqrtSpecial(t *testing.T) { 104 for _, test := range []struct { 105 x *Float 106 want *Float 107 }{ 108 {NewFloat(+0), NewFloat(+0)}, 109 {NewFloat(-0), NewFloat(-0)}, 110 {NewFloat(math.Inf(+1)), NewFloat(math.Inf(+1))}, 111 } { 112 got := new(Float).Sqrt(test.x) 113 if got.neg != test.want.neg || got.form != test.want.form { 114 t.Errorf("Sqrt(%v) = %v (neg: %v); want %v (neg: %v)", 115 test.x, got, got.neg, test.want, test.want.neg) 116 } 117 } 118 119 } 120 121 // Benchmarks 122 123 func BenchmarkFloatSqrt(b *testing.B) { 124 for _, prec := range []uint{64, 128, 256, 1e3, 1e4, 1e5, 1e6} { 125 x := NewFloat(2) 126 z := new(Float).SetPrec(prec) 127 b.Run(fmt.Sprintf("%v", prec), func(b *testing.B) { 128 b.ReportAllocs() 129 for n := 0; n < b.N; n++ { 130 z.Sqrt(x) 131 } 132 }) 133 } 134 }