...
Run Format

Source file src/math/big/natconv_test.go

Documentation: math/big

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

View as plain text