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 "io" 10 "strings" 11 "testing" 12) 13 14func itoa(x nat, base int) []byte { 15 // special cases 16 switch { 17 case base < 2: 18 panic("illegal base") 19 case len(x) == 0: 20 return []byte("0") 21 } 22 23 // allocate buffer for conversion 24 i := x.bitLen()/log2(Word(base)) + 1 // +1: round up 25 s := make([]byte, i) 26 27 // don't destroy x 28 q := nat(nil).set(x) 29 30 // convert 31 for len(q) > 0 { 32 i-- 33 var r Word 34 q, r = q.divW(q, Word(base)) 35 s[i] = digits[r] 36 } 37 38 return s[i:] 39} 40 41var strTests = []struct { 42 x nat // nat value to be converted 43 b int // conversion base 44 s string // expected result 45}{ 46 {nil, 2, "0"}, 47 {nat{1}, 2, "1"}, 48 {nat{0xc5}, 2, "11000101"}, 49 {nat{03271}, 8, "3271"}, 50 {nat{10}, 10, "10"}, 51 {nat{1234567890}, 10, "1234567890"}, 52 {nat{0xdeadbeef}, 16, "deadbeef"}, 53 {nat{0x229be7}, 17, "1a2b3c"}, 54 {nat{0x309663e6}, 32, "o9cov6"}, 55} 56 57func TestString(t *testing.T) { 58 // test invalid base explicitly 59 var panicStr string 60 func() { 61 defer func() { 62 panicStr = recover().(string) 63 }() 64 natOne.utoa(1) 65 }() 66 if panicStr != "invalid base" { 67 t.Errorf("expected panic for invalid base") 68 } 69 70 for _, a := range strTests { 71 s := string(a.x.utoa(a.b)) 72 if s != a.s { 73 t.Errorf("string%+v\n\tgot s = %s; want %s", a, s, a.s) 74 } 75 76 x, b, _, err := nat(nil).scan(strings.NewReader(a.s), a.b, false) 77 if x.cmp(a.x) != 0 { 78 t.Errorf("scan%+v\n\tgot z = %v; want %v", a, x, a.x) 79 } 80 if b != a.b { 81 t.Errorf("scan%+v\n\tgot b = %d; want %d", a, b, a.b) 82 } 83 if err != nil { 84 t.Errorf("scan%+v\n\tgot error = %s", a, err) 85 } 86 } 87} 88 89var natScanTests = []struct { 90 s string // string to be scanned 91 base int // input base 92 frac bool // fraction ok 93 x nat // expected nat 94 b int // expected base 95 count int // expected digit count 96 ok bool // expected success 97 next rune // next character (or 0, if at EOF) 98}{ 99 // error: no mantissa 100 {}, 101 {s: "?"}, 102 {base: 10}, 103 {base: 36}, 104 {s: "?", base: 10}, 105 {s: "0x"}, 106 {s: "345", base: 2}, 107 108 // error: incorrect use of decimal point 109 {s: ".0"}, 110 {s: ".0", base: 10}, 111 {s: ".", base: 0}, 112 {s: "0x.0"}, 113 114 // no errors 115 {"0", 0, false, nil, 10, 1, true, 0}, 116 {"0", 10, false, nil, 10, 1, true, 0}, 117 {"0", 36, false, nil, 36, 1, true, 0}, 118 {"1", 0, false, nat{1}, 10, 1, true, 0}, 119 {"1", 10, false, nat{1}, 10, 1, true, 0}, 120 {"0 ", 0, false, nil, 10, 1, true, ' '}, 121 {"08", 0, false, nil, 10, 1, true, '8'}, 122 {"08", 10, false, nat{8}, 10, 2, true, 0}, 123 {"018", 0, false, nat{1}, 8, 1, true, '8'}, 124 {"0b1", 0, false, nat{1}, 2, 1, true, 0}, 125 {"0b11000101", 0, false, nat{0xc5}, 2, 8, true, 0}, 126 {"03271", 0, false, nat{03271}, 8, 4, true, 0}, 127 {"10ab", 0, false, nat{10}, 10, 2, true, 'a'}, 128 {"1234567890", 0, false, nat{1234567890}, 10, 10, true, 0}, 129 {"xyz", 36, false, nat{(33*36+34)*36 + 35}, 36, 3, true, 0}, 130 {"xyz?", 36, false, nat{(33*36+34)*36 + 35}, 36, 3, true, '?'}, 131 {"0x", 16, false, nil, 16, 1, true, 'x'}, 132 {"0xdeadbeef", 0, false, nat{0xdeadbeef}, 16, 8, true, 0}, 133 {"0XDEADBEEF", 0, false, nat{0xdeadbeef}, 16, 8, true, 0}, 134 135 // no errors, decimal point 136 {"0.", 0, false, nil, 10, 1, true, '.'}, 137 {"0.", 10, true, nil, 10, 0, true, 0}, 138 {"0.1.2", 10, true, nat{1}, 10, -1, true, '.'}, 139 {".000", 10, true, nil, 10, -3, true, 0}, 140 {"12.3", 10, true, nat{123}, 10, -1, true, 0}, 141 {"012.345", 10, true, nat{12345}, 10, -3, true, 0}, 142} 143 144func TestScanBase(t *testing.T) { 145 for _, a := range natScanTests { 146 r := strings.NewReader(a.s) 147 x, b, count, err := nat(nil).scan(r, a.base, a.frac) 148 if err == nil && !a.ok { 149 t.Errorf("scan%+v\n\texpected error", a) 150 } 151 if err != nil { 152 if a.ok { 153 t.Errorf("scan%+v\n\tgot error = %s", a, err) 154 } 155 continue 156 } 157 if x.cmp(a.x) != 0 { 158 t.Errorf("scan%+v\n\tgot z = %v; want %v", a, x, a.x) 159 } 160 if b != a.b { 161 t.Errorf("scan%+v\n\tgot b = %d; want %d", a, b, a.base) 162 } 163 if count != a.count { 164 t.Errorf("scan%+v\n\tgot count = %d; want %d", a, count, a.count) 165 } 166 next, _, err := r.ReadRune() 167 if err == io.EOF { 168 next = 0 169 err = nil 170 } 171 if err == nil && next != a.next { 172 t.Errorf("scan%+v\n\tgot next = %q; want %q", a, next, a.next) 173 } 174 } 175} 176 177var pi = "3" + 178 "14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651" + 179 "32823066470938446095505822317253594081284811174502841027019385211055596446229489549303819644288109756659334461" + 180 "28475648233786783165271201909145648566923460348610454326648213393607260249141273724587006606315588174881520920" + 181 "96282925409171536436789259036001133053054882046652138414695194151160943305727036575959195309218611738193261179" + 182 "31051185480744623799627495673518857527248912279381830119491298336733624406566430860213949463952247371907021798" + 183 "60943702770539217176293176752384674818467669405132000568127145263560827785771342757789609173637178721468440901" + 184 "22495343014654958537105079227968925892354201995611212902196086403441815981362977477130996051870721134999999837" + 185 "29780499510597317328160963185950244594553469083026425223082533446850352619311881710100031378387528865875332083" + 186 "81420617177669147303598253490428755468731159562863882353787593751957781857780532171226806613001927876611195909" + 187 "21642019893809525720106548586327886593615338182796823030195203530185296899577362259941389124972177528347913151" + 188 "55748572424541506959508295331168617278558890750983817546374649393192550604009277016711390098488240128583616035" + 189 "63707660104710181942955596198946767837449448255379774726847104047534646208046684259069491293313677028989152104" + 190 "75216205696602405803815019351125338243003558764024749647326391419927260426992279678235478163600934172164121992" + 191 "45863150302861829745557067498385054945885869269956909272107975093029553211653449872027559602364806654991198818" + 192 "34797753566369807426542527862551818417574672890977772793800081647060016145249192173217214772350141441973568548" + 193 "16136115735255213347574184946843852332390739414333454776241686251898356948556209921922218427255025425688767179" + 194 "04946016534668049886272327917860857843838279679766814541009538837863609506800642251252051173929848960841284886" + 195 "26945604241965285022210661186306744278622039194945047123713786960956364371917287467764657573962413890865832645" + 196 "99581339047802759009946576407895126946839835259570982582262052248940772671947826848260147699090264013639443745" + 197 "53050682034962524517493996514314298091906592509372216964615157098583874105978859597729754989301617539284681382" + 198 "68683868942774155991855925245953959431049972524680845987273644695848653836736222626099124608051243884390451244" + 199 "13654976278079771569143599770012961608944169486855584840635342207222582848864815845602850601684273945226746767" + 200 "88952521385225499546667278239864565961163548862305774564980355936345681743241125150760694794510965960940252288" + 201 "79710893145669136867228748940560101503308617928680920874760917824938589009714909675985261365549781893129784821" + 202 "68299894872265880485756401427047755513237964145152374623436454285844479526586782105114135473573952311342716610" + 203 "21359695362314429524849371871101457654035902799344037420073105785390621983874478084784896833214457138687519435" + 204 "06430218453191048481005370614680674919278191197939952061419663428754440643745123718192179998391015919561814675" + 205 "14269123974894090718649423196156794520809514655022523160388193014209376213785595663893778708303906979207734672" + 206 "21825625996615014215030680384477345492026054146659252014974428507325186660021324340881907104863317346496514539" + 207 "05796268561005508106658796998163574736384052571459102897064140110971206280439039759515677157700420337869936007" + 208 "23055876317635942187312514712053292819182618612586732157919841484882916447060957527069572209175671167229109816" + 209 "90915280173506712748583222871835209353965725121083579151369882091444210067510334671103141267111369908658516398" + 210 "31501970165151168517143765761835155650884909989859982387345528331635507647918535893226185489632132933089857064" + 211 "20467525907091548141654985946163718027098199430992448895757128289059232332609729971208443357326548938239119325" + 212 "97463667305836041428138830320382490375898524374417029132765618093773444030707469211201913020330380197621101100" + 213 "44929321516084244485963766983895228684783123552658213144957685726243344189303968642624341077322697802807318915" + 214 "44110104468232527162010526522721116603966655730925471105578537634668206531098965269186205647693125705863566201" + 215 "85581007293606598764861179104533488503461136576867532494416680396265797877185560845529654126654085306143444318" + 216 "58676975145661406800700237877659134401712749470420562230538994561314071127000407854733269939081454664645880797" + 217 "27082668306343285878569830523580893306575740679545716377525420211495576158140025012622859413021647155097925923" + 218 "09907965473761255176567513575178296664547791745011299614890304639947132962107340437518957359614589019389713111" + 219 "79042978285647503203198691514028708085990480109412147221317947647772622414254854540332157185306142288137585043" + 220 "06332175182979866223717215916077166925474873898665494945011465406284336639379003976926567214638530673609657120" + 221 "91807638327166416274888800786925602902284721040317211860820419000422966171196377921337575114959501566049631862" + 222 "94726547364252308177036751590673502350728354056704038674351362222477158915049530984448933309634087807693259939" + 223 "78054193414473774418426312986080998886874132604721569516239658645730216315981931951673538129741677294786724229" + 224 "24654366800980676928238280689964004824354037014163149658979409243237896907069779422362508221688957383798623001" + 225 "59377647165122893578601588161755782973523344604281512627203734314653197777416031990665541876397929334419521541" + 226 "34189948544473456738316249934191318148092777710386387734317720754565453220777092120190516609628049092636019759" + 227 "88281613323166636528619326686336062735676303544776280350450777235547105859548702790814356240145171806246436267" + 228 "94561275318134078330336254232783944975382437205835311477119926063813346776879695970309833913077109870408591337" 229 230// Test case for BenchmarkScanPi. 231func TestScanPi(t *testing.T) { 232 var x nat 233 z, _, _, err := x.scan(strings.NewReader(pi), 10, false) 234 if err != nil { 235 t.Errorf("scanning pi: %s", err) 236 } 237 if s := string(z.utoa(10)); s != pi { 238 t.Errorf("scanning pi: got %s", s) 239 } 240} 241 242func TestScanPiParallel(t *testing.T) { 243 const n = 2 244 c := make(chan int) 245 for i := 0; i < n; i++ { 246 go func() { 247 TestScanPi(t) 248 c <- 0 249 }() 250 } 251 for i := 0; i < n; i++ { 252 <-c 253 } 254} 255 256func BenchmarkScanPi(b *testing.B) { 257 for i := 0; i < b.N; i++ { 258 var x nat 259 x.scan(strings.NewReader(pi), 10, false) 260 } 261} 262 263func BenchmarkStringPiParallel(b *testing.B) { 264 var x nat 265 x, _, _, _ = x.scan(strings.NewReader(pi), 0, false) 266 if string(x.utoa(10)) != pi { 267 panic("benchmark incorrect: conversion failed") 268 } 269 b.RunParallel(func(pb *testing.PB) { 270 for pb.Next() { 271 x.utoa(10) 272 } 273 }) 274} 275 276func BenchmarkScan10Base2(b *testing.B) { ScanHelper(b, 2, 10, 10) } 277func BenchmarkScan100Base2(b *testing.B) { ScanHelper(b, 2, 10, 100) } 278func BenchmarkScan1000Base2(b *testing.B) { ScanHelper(b, 2, 10, 1000) } 279func BenchmarkScan10000Base2(b *testing.B) { ScanHelper(b, 2, 10, 10000) } 280func BenchmarkScan100000Base2(b *testing.B) { ScanHelper(b, 2, 10, 100000) } 281 282func BenchmarkScan10Base8(b *testing.B) { ScanHelper(b, 8, 10, 10) } 283func BenchmarkScan100Base8(b *testing.B) { ScanHelper(b, 8, 10, 100) } 284func BenchmarkScan1000Base8(b *testing.B) { ScanHelper(b, 8, 10, 1000) } 285func BenchmarkScan10000Base8(b *testing.B) { ScanHelper(b, 8, 10, 10000) } 286func BenchmarkScan100000Base8(b *testing.B) { ScanHelper(b, 8, 10, 100000) } 287 288func BenchmarkScan10Base10(b *testing.B) { ScanHelper(b, 10, 10, 10) } 289func BenchmarkScan100Base10(b *testing.B) { ScanHelper(b, 10, 10, 100) } 290func BenchmarkScan1000Base10(b *testing.B) { ScanHelper(b, 10, 10, 1000) } 291func BenchmarkScan10000Base10(b *testing.B) { ScanHelper(b, 10, 10, 10000) } 292func BenchmarkScan100000Base10(b *testing.B) { ScanHelper(b, 10, 10, 100000) } 293 294func BenchmarkScan10Base16(b *testing.B) { ScanHelper(b, 16, 10, 10) } 295func BenchmarkScan100Base16(b *testing.B) { ScanHelper(b, 16, 10, 100) } 296func BenchmarkScan1000Base16(b *testing.B) { ScanHelper(b, 16, 10, 1000) } 297func BenchmarkScan10000Base16(b *testing.B) { ScanHelper(b, 16, 10, 10000) } 298func BenchmarkScan100000Base16(b *testing.B) { ScanHelper(b, 16, 10, 100000) } 299 300func ScanHelper(b *testing.B, base int, x, y Word) { 301 b.StopTimer() 302 var z nat 303 z = z.expWW(x, y) 304 305 s := z.utoa(base) 306 if t := itoa(z, base); !bytes.Equal(s, t) { 307 b.Fatalf("scanning: got %s; want %s", s, t) 308 } 309 b.StartTimer() 310 311 for i := 0; i < b.N; i++ { 312 z.scan(bytes.NewReader(s), base, false) 313 } 314} 315 316func BenchmarkString10Base2(b *testing.B) { StringHelper(b, 2, 10, 10) } 317func BenchmarkString100Base2(b *testing.B) { StringHelper(b, 2, 10, 100) } 318func BenchmarkString1000Base2(b *testing.B) { StringHelper(b, 2, 10, 1000) } 319func BenchmarkString10000Base2(b *testing.B) { StringHelper(b, 2, 10, 10000) } 320func BenchmarkString100000Base2(b *testing.B) { StringHelper(b, 2, 10, 100000) } 321 322func BenchmarkString10Base8(b *testing.B) { StringHelper(b, 8, 10, 10) } 323func BenchmarkString100Base8(b *testing.B) { StringHelper(b, 8, 10, 100) } 324func BenchmarkString1000Base8(b *testing.B) { StringHelper(b, 8, 10, 1000) } 325func BenchmarkString10000Base8(b *testing.B) { StringHelper(b, 8, 10, 10000) } 326func BenchmarkString100000Base8(b *testing.B) { StringHelper(b, 8, 10, 100000) } 327 328func BenchmarkString10Base10(b *testing.B) { StringHelper(b, 10, 10, 10) } 329func BenchmarkString100Base10(b *testing.B) { StringHelper(b, 10, 10, 100) } 330func BenchmarkString1000Base10(b *testing.B) { StringHelper(b, 10, 10, 1000) } 331func BenchmarkString10000Base10(b *testing.B) { StringHelper(b, 10, 10, 10000) } 332func BenchmarkString100000Base10(b *testing.B) { StringHelper(b, 10, 10, 100000) } 333 334func BenchmarkString10Base16(b *testing.B) { StringHelper(b, 16, 10, 10) } 335func BenchmarkString100Base16(b *testing.B) { StringHelper(b, 16, 10, 100) } 336func BenchmarkString1000Base16(b *testing.B) { StringHelper(b, 16, 10, 1000) } 337func BenchmarkString10000Base16(b *testing.B) { StringHelper(b, 16, 10, 10000) } 338func BenchmarkString100000Base16(b *testing.B) { StringHelper(b, 16, 10, 100000) } 339 340func StringHelper(b *testing.B, base int, x, y Word) { 341 b.StopTimer() 342 var z nat 343 z = z.expWW(x, y) 344 z.utoa(base) // warm divisor cache 345 b.StartTimer() 346 347 for i := 0; i < b.N; i++ { 348 _ = z.utoa(base) 349 } 350} 351 352func BenchmarkLeafSize0(b *testing.B) { LeafSizeHelper(b, 10, 0) } // test without splitting 353func BenchmarkLeafSize1(b *testing.B) { LeafSizeHelper(b, 10, 1) } 354func BenchmarkLeafSize2(b *testing.B) { LeafSizeHelper(b, 10, 2) } 355func BenchmarkLeafSize3(b *testing.B) { LeafSizeHelper(b, 10, 3) } 356func BenchmarkLeafSize4(b *testing.B) { LeafSizeHelper(b, 10, 4) } 357func BenchmarkLeafSize5(b *testing.B) { LeafSizeHelper(b, 10, 5) } 358func BenchmarkLeafSize6(b *testing.B) { LeafSizeHelper(b, 10, 6) } 359func BenchmarkLeafSize7(b *testing.B) { LeafSizeHelper(b, 10, 7) } 360func BenchmarkLeafSize8(b *testing.B) { LeafSizeHelper(b, 10, 8) } 361func BenchmarkLeafSize9(b *testing.B) { LeafSizeHelper(b, 10, 9) } 362func BenchmarkLeafSize10(b *testing.B) { LeafSizeHelper(b, 10, 10) } 363func BenchmarkLeafSize11(b *testing.B) { LeafSizeHelper(b, 10, 11) } 364func BenchmarkLeafSize12(b *testing.B) { LeafSizeHelper(b, 10, 12) } 365func BenchmarkLeafSize13(b *testing.B) { LeafSizeHelper(b, 10, 13) } 366func BenchmarkLeafSize14(b *testing.B) { LeafSizeHelper(b, 10, 14) } 367func BenchmarkLeafSize15(b *testing.B) { LeafSizeHelper(b, 10, 15) } 368func BenchmarkLeafSize16(b *testing.B) { LeafSizeHelper(b, 10, 16) } 369func BenchmarkLeafSize32(b *testing.B) { LeafSizeHelper(b, 10, 32) } // try some large lengths 370func BenchmarkLeafSize64(b *testing.B) { LeafSizeHelper(b, 10, 64) } 371 372func LeafSizeHelper(b *testing.B, base, size int) { 373 b.StopTimer() 374 originalLeafSize := leafSize 375 resetTable(cacheBase10.table[:]) 376 leafSize = size 377 b.StartTimer() 378 379 for d := 1; d <= 10000; d *= 10 { 380 b.StopTimer() 381 var z nat 382 z = z.expWW(Word(base), Word(d)) // build target number 383 _ = z.utoa(base) // warm divisor cache 384 b.StartTimer() 385 386 for i := 0; i < b.N; i++ { 387 _ = z.utoa(base) 388 } 389 } 390 391 b.StopTimer() 392 resetTable(cacheBase10.table[:]) 393 leafSize = originalLeafSize 394 b.StartTimer() 395} 396 397func resetTable(table []divisor) { 398 if table != nil && table[0].bbb != nil { 399 for i := 0; i < len(table); i++ { 400 table[i].bbb = nil 401 table[i].nbits = 0 402 table[i].ndigits = 0 403 } 404 } 405} 406 407func TestStringPowers(t *testing.T) { 408 var p Word 409 for b := 2; b <= 16; b++ { 410 for p = 0; p <= 512; p++ { 411 x := nat(nil).expWW(Word(b), p) 412 xs := x.utoa(b) 413 xs2 := itoa(x, b) 414 if !bytes.Equal(xs, xs2) { 415 t.Errorf("failed at %d ** %d in base %d: %s != %s", b, p, b, xs, xs2) 416 } 417 } 418 if b >= 3 && testing.Short() { 419 break 420 } 421 } 422} 423