| // Copyright 2015 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| package big |
| |
| import ( |
| "bytes" |
| "fmt" |
| "io" |
| "math/bits" |
| "strings" |
| "testing" |
| ) |
| |
| func TestMaxBase(t *testing.T) { |
| if MaxBase != len(digits) { |
| t.Fatalf("%d != %d", MaxBase, len(digits)) |
| } |
| } |
| |
| // log2 computes the integer binary logarithm of x. |
| // The result is the integer n for which 2^n <= x < 2^(n+1). |
| // If x == 0, the result is -1. |
| func log2(x Word) int { |
| return bits.Len(uint(x)) - 1 |
| } |
| |
| func itoa(x nat, base int) []byte { |
| // special cases |
| switch { |
| case base < 2: |
| panic("illegal base") |
| case len(x) == 0: |
| return []byte("0") |
| } |
| |
| // allocate buffer for conversion |
| i := x.bitLen()/log2(Word(base)) + 1 // +1: round up |
| s := make([]byte, i) |
| |
| // don't destroy x |
| q := nat(nil).set(x) |
| |
| // convert |
| for len(q) > 0 { |
| i-- |
| var r Word |
| q, r = q.divW(q, Word(base)) |
| s[i] = digits[r] |
| } |
| |
| return s[i:] |
| } |
| |
| var strTests = []struct { |
| x nat // nat value to be converted |
| b int // conversion base |
| s string // expected result |
| }{ |
| {nil, 2, "0"}, |
| {nat{1}, 2, "1"}, |
| {nat{0xc5}, 2, "11000101"}, |
| {nat{03271}, 8, "3271"}, |
| {nat{10}, 10, "10"}, |
| {nat{1234567890}, 10, "1234567890"}, |
| {nat{0xdeadbeef}, 16, "deadbeef"}, |
| {nat{0x229be7}, 17, "1a2b3c"}, |
| {nat{0x309663e6}, 32, "o9cov6"}, |
| {nat{0x309663e6}, 62, "TakXI"}, |
| } |
| |
| func TestString(t *testing.T) { |
| // test invalid base explicitly |
| var panicStr string |
| func() { |
| defer func() { |
| panicStr = recover().(string) |
| }() |
| natOne.utoa(1) |
| }() |
| if panicStr != "invalid base" { |
| t.Errorf("expected panic for invalid base") |
| } |
| |
| for _, a := range strTests { |
| s := string(a.x.utoa(a.b)) |
| if s != a.s { |
| t.Errorf("string%+v\n\tgot s = %s; want %s", a, s, a.s) |
| } |
| |
| x, b, _, err := nat(nil).scan(strings.NewReader(a.s), a.b, false) |
| if x.cmp(a.x) != 0 { |
| t.Errorf("scan%+v\n\tgot z = %v; want %v", a, x, a.x) |
| } |
| if b != a.b { |
| t.Errorf("scan%+v\n\tgot b = %d; want %d", a, b, a.b) |
| } |
| if err != nil { |
| t.Errorf("scan%+v\n\tgot error = %s", a, err) |
| } |
| } |
| } |
| |
| var natScanTests = []struct { |
| s string // string to be scanned |
| base int // input base |
| frac bool // fraction ok |
| x nat // expected nat |
| b int // expected base |
| count int // expected digit count |
| err error // expected error |
| next rune // next character (or 0, if at EOF) |
| }{ |
| // invalid: no digits |
| {"", 0, false, nil, 10, 0, errNoDigits, 0}, |
| {"_", 0, false, nil, 10, 0, errNoDigits, 0}, |
| {"?", 0, false, nil, 10, 0, errNoDigits, '?'}, |
| {"?", 10, false, nil, 10, 0, errNoDigits, '?'}, |
| {"", 10, false, nil, 10, 0, errNoDigits, 0}, |
| {"", 36, false, nil, 36, 0, errNoDigits, 0}, |
| {"", 62, false, nil, 62, 0, errNoDigits, 0}, |
| {"0b", 0, false, nil, 2, 0, errNoDigits, 0}, |
| {"0o", 0, false, nil, 8, 0, errNoDigits, 0}, |
| {"0x", 0, false, nil, 16, 0, errNoDigits, 0}, |
| {"0x_", 0, false, nil, 16, 0, errNoDigits, 0}, |
| {"0b2", 0, false, nil, 2, 0, errNoDigits, '2'}, |
| {"0B2", 0, false, nil, 2, 0, errNoDigits, '2'}, |
| {"0o8", 0, false, nil, 8, 0, errNoDigits, '8'}, |
| {"0O8", 0, false, nil, 8, 0, errNoDigits, '8'}, |
| {"0xg", 0, false, nil, 16, 0, errNoDigits, 'g'}, |
| {"0Xg", 0, false, nil, 16, 0, errNoDigits, 'g'}, |
| {"345", 2, false, nil, 2, 0, errNoDigits, '3'}, |
| |
| // invalid: incorrect use of decimal point |
| {"._", 0, true, nil, 10, 0, errNoDigits, 0}, |
| {".0", 0, false, nil, 10, 0, errNoDigits, '.'}, |
| {".0", 10, false, nil, 10, 0, errNoDigits, '.'}, |
| {".", 0, true, nil, 10, 0, errNoDigits, 0}, |
| {"0x.", 0, true, nil, 16, 0, errNoDigits, 0}, |
| {"0x.g", 0, true, nil, 16, 0, errNoDigits, 'g'}, |
| {"0x.0", 0, false, nil, 16, 0, errNoDigits, '.'}, |
| |
| // invalid: incorrect use of separators |
| {"_0", 0, false, nil, 10, 1, errInvalSep, 0}, |
| {"0_", 0, false, nil, 10, 1, errInvalSep, 0}, |
| {"0__0", 0, false, nil, 8, 1, errInvalSep, 0}, |
| {"0x___0", 0, false, nil, 16, 1, errInvalSep, 0}, |
| {"0_x", 0, false, nil, 10, 1, errInvalSep, 'x'}, |
| {"0_8", 0, false, nil, 10, 1, errInvalSep, '8'}, |
| {"123_.", 0, true, nat{123}, 10, 0, errInvalSep, 0}, |
| {"._123", 0, true, nat{123}, 10, -3, errInvalSep, 0}, |
| {"0b__1000", 0, false, nat{0x8}, 2, 4, errInvalSep, 0}, |
| {"0o60___0", 0, false, nat{0600}, 8, 3, errInvalSep, 0}, |
| {"0466_", 0, false, nat{0466}, 8, 3, errInvalSep, 0}, |
| {"01234567_8", 0, false, nat{01234567}, 8, 7, errInvalSep, '8'}, |
| {"1_.", 0, true, nat{1}, 10, 0, errInvalSep, 0}, |
| {"0._1", 0, true, nat{1}, 10, -1, errInvalSep, 0}, |
| {"2.7_", 0, true, nat{27}, 10, -1, errInvalSep, 0}, |
| {"0x1.0_", 0, true, nat{0x10}, 16, -1, errInvalSep, 0}, |
| |
| // valid: separators are not accepted for base != 0 |
| {"0_", 10, false, nil, 10, 1, nil, '_'}, |
| {"1__0", 10, false, nat{1}, 10, 1, nil, '_'}, |
| {"0__8", 10, false, nil, 10, 1, nil, '_'}, |
| {"xy_z_", 36, false, nat{33*36 + 34}, 36, 2, nil, '_'}, |
| |
| // valid, no decimal point |
| {"0", 0, false, nil, 10, 1, nil, 0}, |
| {"0", 36, false, nil, 36, 1, nil, 0}, |
| {"0", 62, false, nil, 62, 1, nil, 0}, |
| {"1", 0, false, nat{1}, 10, 1, nil, 0}, |
| {"1", 10, false, nat{1}, 10, 1, nil, 0}, |
| {"0 ", 0, false, nil, 10, 1, nil, ' '}, |
| {"00 ", 0, false, nil, 8, 1, nil, ' '}, // octal 0 |
| {"0b1", 0, false, nat{1}, 2, 1, nil, 0}, |
| {"0B11000101", 0, false, nat{0xc5}, 2, 8, nil, 0}, |
| {"0B110001012", 0, false, nat{0xc5}, 2, 8, nil, '2'}, |
| {"07", 0, false, nat{7}, 8, 1, nil, 0}, |
| {"08", 0, false, nil, 10, 1, nil, '8'}, |
| {"08", 10, false, nat{8}, 10, 2, nil, 0}, |
| {"018", 0, false, nat{1}, 8, 1, nil, '8'}, |
| {"0o7", 0, false, nat{7}, 8, 1, nil, 0}, |
| {"0o18", 0, false, nat{1}, 8, 1, nil, '8'}, |
| {"0O17", 0, false, nat{017}, 8, 2, nil, 0}, |
| {"03271", 0, false, nat{03271}, 8, 4, nil, 0}, |
| {"10ab", 0, false, nat{10}, 10, 2, nil, 'a'}, |
| {"1234567890", 0, false, nat{1234567890}, 10, 10, nil, 0}, |
| {"A", 36, false, nat{10}, 36, 1, nil, 0}, |
| {"A", 37, false, nat{36}, 37, 1, nil, 0}, |
| {"xyz", 36, false, nat{(33*36+34)*36 + 35}, 36, 3, nil, 0}, |
| {"XYZ?", 36, false, nat{(33*36+34)*36 + 35}, 36, 3, nil, '?'}, |
| {"XYZ?", 62, false, nat{(59*62+60)*62 + 61}, 62, 3, nil, '?'}, |
| {"0x", 16, false, nil, 16, 1, nil, 'x'}, |
| {"0xdeadbeef", 0, false, nat{0xdeadbeef}, 16, 8, nil, 0}, |
| {"0XDEADBEEF", 0, false, nat{0xdeadbeef}, 16, 8, nil, 0}, |
| |
| // valid, with decimal point |
| {"0.", 0, false, nil, 10, 1, nil, '.'}, |
| {"0.", 10, true, nil, 10, 0, nil, 0}, |
| {"0.1.2", 10, true, nat{1}, 10, -1, nil, '.'}, |
| {".000", 10, true, nil, 10, -3, nil, 0}, |
| {"12.3", 10, true, nat{123}, 10, -1, nil, 0}, |
| {"012.345", 10, true, nat{12345}, 10, -3, nil, 0}, |
| {"0.1", 0, true, nat{1}, 10, -1, nil, 0}, |
| {"0.1", 2, true, nat{1}, 2, -1, nil, 0}, |
| {"0.12", 2, true, nat{1}, 2, -1, nil, '2'}, |
| {"0b0.1", 0, true, nat{1}, 2, -1, nil, 0}, |
| {"0B0.12", 0, true, nat{1}, 2, -1, nil, '2'}, |
| {"0o0.7", 0, true, nat{7}, 8, -1, nil, 0}, |
| {"0O0.78", 0, true, nat{7}, 8, -1, nil, '8'}, |
| {"0xdead.beef", 0, true, nat{0xdeadbeef}, 16, -4, nil, 0}, |
| |
| // valid, with separators |
| {"1_000", 0, false, nat{1000}, 10, 4, nil, 0}, |
| {"0_466", 0, false, nat{0466}, 8, 3, nil, 0}, |
| {"0o_600", 0, false, nat{0600}, 8, 3, nil, 0}, |
| {"0x_f0_0d", 0, false, nat{0xf00d}, 16, 4, nil, 0}, |
| {"0b1000_0001", 0, false, nat{0x81}, 2, 8, nil, 0}, |
| {"1_000.000_1", 0, true, nat{10000001}, 10, -4, nil, 0}, |
| {"0x_f00d.1e", 0, true, nat{0xf00d1e}, 16, -2, nil, 0}, |
| {"0x_f00d.1E2", 0, true, nat{0xf00d1e2}, 16, -3, nil, 0}, |
| {"0x_f00d.1eg", 0, true, nat{0xf00d1e}, 16, -2, nil, 'g'}, |
| } |
| |
| func TestScanBase(t *testing.T) { |
| for _, a := range natScanTests { |
| r := strings.NewReader(a.s) |
| x, b, count, err := nat(nil).scan(r, a.base, a.frac) |
| if err != a.err { |
| t.Errorf("scan%+v\n\tgot error = %v; want %v", a, err, a.err) |
| } |
| if x.cmp(a.x) != 0 { |
| t.Errorf("scan%+v\n\tgot z = %v; want %v", a, x, a.x) |
| } |
| if b != a.b { |
| t.Errorf("scan%+v\n\tgot b = %d; want %d", a, b, a.base) |
| } |
| if count != a.count { |
| t.Errorf("scan%+v\n\tgot count = %d; want %d", a, count, a.count) |
| } |
| next, _, err := r.ReadRune() |
| if err == io.EOF { |
| next = 0 |
| err = nil |
| } |
| if err == nil && next != a.next { |
| t.Errorf("scan%+v\n\tgot next = %q; want %q", a, next, a.next) |
| } |
| } |
| } |
| |
| var pi = "3" + |
| "14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651" + |
| "32823066470938446095505822317253594081284811174502841027019385211055596446229489549303819644288109756659334461" + |
| "28475648233786783165271201909145648566923460348610454326648213393607260249141273724587006606315588174881520920" + |
| "96282925409171536436789259036001133053054882046652138414695194151160943305727036575959195309218611738193261179" + |
| "31051185480744623799627495673518857527248912279381830119491298336733624406566430860213949463952247371907021798" + |
| "60943702770539217176293176752384674818467669405132000568127145263560827785771342757789609173637178721468440901" + |
| "22495343014654958537105079227968925892354201995611212902196086403441815981362977477130996051870721134999999837" + |
| "29780499510597317328160963185950244594553469083026425223082533446850352619311881710100031378387528865875332083" + |
| "81420617177669147303598253490428755468731159562863882353787593751957781857780532171226806613001927876611195909" + |
| "21642019893809525720106548586327886593615338182796823030195203530185296899577362259941389124972177528347913151" + |
| "55748572424541506959508295331168617278558890750983817546374649393192550604009277016711390098488240128583616035" + |
| "63707660104710181942955596198946767837449448255379774726847104047534646208046684259069491293313677028989152104" + |
| "75216205696602405803815019351125338243003558764024749647326391419927260426992279678235478163600934172164121992" + |
| "45863150302861829745557067498385054945885869269956909272107975093029553211653449872027559602364806654991198818" + |
| "34797753566369807426542527862551818417574672890977772793800081647060016145249192173217214772350141441973568548" + |
| "16136115735255213347574184946843852332390739414333454776241686251898356948556209921922218427255025425688767179" + |
| "04946016534668049886272327917860857843838279679766814541009538837863609506800642251252051173929848960841284886" + |
| "26945604241965285022210661186306744278622039194945047123713786960956364371917287467764657573962413890865832645" + |
| "99581339047802759009946576407895126946839835259570982582262052248940772671947826848260147699090264013639443745" + |
| "53050682034962524517493996514314298091906592509372216964615157098583874105978859597729754989301617539284681382" + |
| "68683868942774155991855925245953959431049972524680845987273644695848653836736222626099124608051243884390451244" + |
| "13654976278079771569143599770012961608944169486855584840635342207222582848864815845602850601684273945226746767" + |
| "88952521385225499546667278239864565961163548862305774564980355936345681743241125150760694794510965960940252288" + |
| "79710893145669136867228748940560101503308617928680920874760917824938589009714909675985261365549781893129784821" + |
| "68299894872265880485756401427047755513237964145152374623436454285844479526586782105114135473573952311342716610" + |
| "21359695362314429524849371871101457654035902799344037420073105785390621983874478084784896833214457138687519435" + |
| "06430218453191048481005370614680674919278191197939952061419663428754440643745123718192179998391015919561814675" + |
| "14269123974894090718649423196156794520809514655022523160388193014209376213785595663893778708303906979207734672" + |
| "21825625996615014215030680384477345492026054146659252014974428507325186660021324340881907104863317346496514539" + |
| "05796268561005508106658796998163574736384052571459102897064140110971206280439039759515677157700420337869936007" + |
| "23055876317635942187312514712053292819182618612586732157919841484882916447060957527069572209175671167229109816" + |
| "90915280173506712748583222871835209353965725121083579151369882091444210067510334671103141267111369908658516398" + |
| "31501970165151168517143765761835155650884909989859982387345528331635507647918535893226185489632132933089857064" + |
| "20467525907091548141654985946163718027098199430992448895757128289059232332609729971208443357326548938239119325" + |
| "97463667305836041428138830320382490375898524374417029132765618093773444030707469211201913020330380197621101100" + |
| "44929321516084244485963766983895228684783123552658213144957685726243344189303968642624341077322697802807318915" + |
| "44110104468232527162010526522721116603966655730925471105578537634668206531098965269186205647693125705863566201" + |
| "85581007293606598764861179104533488503461136576867532494416680396265797877185560845529654126654085306143444318" + |
| "58676975145661406800700237877659134401712749470420562230538994561314071127000407854733269939081454664645880797" + |
| "27082668306343285878569830523580893306575740679545716377525420211495576158140025012622859413021647155097925923" + |
| "09907965473761255176567513575178296664547791745011299614890304639947132962107340437518957359614589019389713111" + |
| "79042978285647503203198691514028708085990480109412147221317947647772622414254854540332157185306142288137585043" + |
| "06332175182979866223717215916077166925474873898665494945011465406284336639379003976926567214638530673609657120" + |
| "91807638327166416274888800786925602902284721040317211860820419000422966171196377921337575114959501566049631862" + |
| "94726547364252308177036751590673502350728354056704038674351362222477158915049530984448933309634087807693259939" + |
| "78054193414473774418426312986080998886874132604721569516239658645730216315981931951673538129741677294786724229" + |
| "24654366800980676928238280689964004824354037014163149658979409243237896907069779422362508221688957383798623001" + |
| "59377647165122893578601588161755782973523344604281512627203734314653197777416031990665541876397929334419521541" + |
| "34189948544473456738316249934191318148092777710386387734317720754565453220777092120190516609628049092636019759" + |
| "88281613323166636528619326686336062735676303544776280350450777235547105859548702790814356240145171806246436267" + |
| "94561275318134078330336254232783944975382437205835311477119926063813346776879695970309833913077109870408591337" |
| |
| // Test case for BenchmarkScanPi. |
| func TestScanPi(t *testing.T) { |
| var x nat |
| z, _, _, err := x.scan(strings.NewReader(pi), 10, false) |
| if err != nil { |
| t.Errorf("scanning pi: %s", err) |
| } |
| if s := string(z.utoa(10)); s != pi { |
| t.Errorf("scanning pi: got %s", s) |
| } |
| } |
| |
| func TestScanPiParallel(t *testing.T) { |
| const n = 2 |
| c := make(chan int) |
| for i := 0; i < n; i++ { |
| go func() { |
| TestScanPi(t) |
| c <- 0 |
| }() |
| } |
| for i := 0; i < n; i++ { |
| <-c |
| } |
| } |
| |
| func BenchmarkScanPi(b *testing.B) { |
| for i := 0; i < b.N; i++ { |
| var x nat |
| x.scan(strings.NewReader(pi), 10, false) |
| } |
| } |
| |
| func BenchmarkStringPiParallel(b *testing.B) { |
| var x nat |
| x, _, _, _ = x.scan(strings.NewReader(pi), 0, false) |
| if string(x.utoa(10)) != pi { |
| panic("benchmark incorrect: conversion failed") |
| } |
| b.RunParallel(func(pb *testing.PB) { |
| for pb.Next() { |
| x.utoa(10) |
| } |
| }) |
| } |
| |
| func BenchmarkScan(b *testing.B) { |
| const x = 10 |
| for _, base := range []int{2, 8, 10, 16} { |
| for _, y := range []Word{10, 100, 1000, 10000, 100000} { |
| if isRaceBuilder && y > 1000 { |
| continue |
| } |
| b.Run(fmt.Sprintf("%d/Base%d", y, base), func(b *testing.B) { |
| b.StopTimer() |
| var z nat |
| z = z.expWW(x, y) |
| |
| s := z.utoa(base) |
| if t := itoa(z, base); !bytes.Equal(s, t) { |
| b.Fatalf("scanning: got %s; want %s", s, t) |
| } |
| b.StartTimer() |
| |
| for i := 0; i < b.N; i++ { |
| z.scan(bytes.NewReader(s), base, false) |
| } |
| }) |
| } |
| } |
| } |
| |
| func BenchmarkString(b *testing.B) { |
| const x = 10 |
| for _, base := range []int{2, 8, 10, 16} { |
| for _, y := range []Word{10, 100, 1000, 10000, 100000} { |
| if isRaceBuilder && y > 1000 { |
| continue |
| } |
| b.Run(fmt.Sprintf("%d/Base%d", y, base), func(b *testing.B) { |
| b.StopTimer() |
| var z nat |
| z = z.expWW(x, y) |
| z.utoa(base) // warm divisor cache |
| b.StartTimer() |
| |
| for i := 0; i < b.N; i++ { |
| _ = z.utoa(base) |
| } |
| }) |
| } |
| } |
| } |
| |
| func BenchmarkLeafSize(b *testing.B) { |
| for n := 0; n <= 16; n++ { |
| b.Run(fmt.Sprint(n), func(b *testing.B) { LeafSizeHelper(b, 10, n) }) |
| } |
| // Try some large lengths |
| for _, n := range []int{32, 64} { |
| b.Run(fmt.Sprint(n), func(b *testing.B) { LeafSizeHelper(b, 10, n) }) |
| } |
| } |
| |
| func LeafSizeHelper(b *testing.B, base, size int) { |
| b.StopTimer() |
| originalLeafSize := leafSize |
| resetTable(cacheBase10.table[:]) |
| leafSize = size |
| b.StartTimer() |
| |
| for d := 1; d <= 10000; d *= 10 { |
| b.StopTimer() |
| var z nat |
| z = z.expWW(Word(base), Word(d)) // build target number |
| _ = z.utoa(base) // warm divisor cache |
| b.StartTimer() |
| |
| for i := 0; i < b.N; i++ { |
| _ = z.utoa(base) |
| } |
| } |
| |
| b.StopTimer() |
| resetTable(cacheBase10.table[:]) |
| leafSize = originalLeafSize |
| b.StartTimer() |
| } |
| |
| func resetTable(table []divisor) { |
| if table != nil && table[0].bbb != nil { |
| for i := 0; i < len(table); i++ { |
| table[i].bbb = nil |
| table[i].nbits = 0 |
| table[i].ndigits = 0 |
| } |
| } |
| } |
| |
| func TestStringPowers(t *testing.T) { |
| var p Word |
| for b := 2; b <= 16; b++ { |
| for p = 0; p <= 512; p++ { |
| if testing.Short() && p > 10 { |
| break |
| } |
| x := nat(nil).expWW(Word(b), p) |
| xs := x.utoa(b) |
| xs2 := itoa(x, b) |
| if !bytes.Equal(xs, xs2) { |
| t.Errorf("failed at %d ** %d in base %d: %s != %s", b, p, b, xs, xs2) |
| } |
| } |
| if b >= 3 && testing.Short() { |
| break |
| } |
| } |
| } |
