Source file
src/math/big/nat_test.go
1
2
3
4
5 package big
6
7 import (
8 "fmt"
9 "runtime"
10 "strings"
11 "testing"
12 )
13
14 var cmpTests = []struct {
15 x, y nat
16 r int
17 }{
18 {nil, nil, 0},
19 {nil, nat(nil), 0},
20 {nat(nil), nil, 0},
21 {nat(nil), nat(nil), 0},
22 {nat{0}, nat{0}, 0},
23 {nat{0}, nat{1}, -1},
24 {nat{1}, nat{0}, 1},
25 {nat{1}, nat{1}, 0},
26 {nat{0, _M}, nat{1}, 1},
27 {nat{1}, nat{0, _M}, -1},
28 {nat{1, _M}, nat{0, _M}, 1},
29 {nat{0, _M}, nat{1, _M}, -1},
30 {nat{16, 571956, 8794, 68}, nat{837, 9146, 1, 754489}, -1},
31 {nat{34986, 41, 105, 1957}, nat{56, 7458, 104, 1957}, 1},
32 }
33
34 func TestCmp(t *testing.T) {
35 for i, a := range cmpTests {
36 r := a.x.cmp(a.y)
37 if r != a.r {
38 t.Errorf("#%d got r = %v; want %v", i, r, a.r)
39 }
40 }
41 }
42
43 type funNN func(z, x, y nat) nat
44 type argNN struct {
45 z, x, y nat
46 }
47
48 var sumNN = []argNN{
49 {},
50 {nat{1}, nil, nat{1}},
51 {nat{1111111110}, nat{123456789}, nat{987654321}},
52 {nat{0, 0, 0, 1}, nil, nat{0, 0, 0, 1}},
53 {nat{0, 0, 0, 1111111110}, nat{0, 0, 0, 123456789}, nat{0, 0, 0, 987654321}},
54 {nat{0, 0, 0, 1}, nat{0, 0, _M}, nat{0, 0, 1}},
55 }
56
57 var prodNN = []argNN{
58 {},
59 {nil, nil, nil},
60 {nil, nat{991}, nil},
61 {nat{991}, nat{991}, nat{1}},
62 {nat{991 * 991}, nat{991}, nat{991}},
63 {nat{0, 0, 991 * 991}, nat{0, 991}, nat{0, 991}},
64 {nat{1 * 991, 2 * 991, 3 * 991, 4 * 991}, nat{1, 2, 3, 4}, nat{991}},
65 {nat{4, 11, 20, 30, 20, 11, 4}, nat{1, 2, 3, 4}, nat{4, 3, 2, 1}},
66
67 {
68 natFromString("11790184577738583171520872861412518665678211592275841109096961"),
69 natFromString("515377520732011331036461129765621272702107522001"),
70 natFromString("22876792454961"),
71 },
72
73
74
75 {
76 natFromString(strings.Repeat("1", 70000)),
77 natFromString("1" + strings.Repeat(strings.Repeat("0", 699)+"1", 99)),
78 natFromString(strings.Repeat("1", 700)),
79 },
80
81
82
83 {
84 natFromString(strings.Repeat("1", 20000)),
85 natFromString("1" + strings.Repeat("0", 9999) + "1"),
86 natFromString(strings.Repeat("1", 10000)),
87 },
88 }
89
90 func natFromString(s string) nat {
91 x, _, _, err := nat(nil).scan(strings.NewReader(s), 0, false)
92 if err != nil {
93 panic(err)
94 }
95 return x
96 }
97
98 func TestSet(t *testing.T) {
99 for _, a := range sumNN {
100 z := nat(nil).set(a.z)
101 if z.cmp(a.z) != 0 {
102 t.Errorf("got z = %v; want %v", z, a.z)
103 }
104 }
105 }
106
107 func testFunNN(t *testing.T, msg string, f funNN, a argNN) {
108 z := f(nil, a.x, a.y)
109 if z.cmp(a.z) != 0 {
110 t.Errorf("%s%+v\n\tgot z = %v; want %v", msg, a, z, a.z)
111 }
112 }
113
114 func TestFunNN(t *testing.T) {
115 for _, a := range sumNN {
116 arg := a
117 testFunNN(t, "add", nat.add, arg)
118
119 arg = argNN{a.z, a.y, a.x}
120 testFunNN(t, "add symmetric", nat.add, arg)
121
122 arg = argNN{a.x, a.z, a.y}
123 testFunNN(t, "sub", nat.sub, arg)
124
125 arg = argNN{a.y, a.z, a.x}
126 testFunNN(t, "sub symmetric", nat.sub, arg)
127 }
128
129 for _, a := range prodNN {
130 arg := a
131 testFunNN(t, "mul", nat.mul, arg)
132
133 arg = argNN{a.z, a.y, a.x}
134 testFunNN(t, "mul symmetric", nat.mul, arg)
135 }
136 }
137
138 var mulRangesN = []struct {
139 a, b uint64
140 prod string
141 }{
142 {0, 0, "0"},
143 {1, 1, "1"},
144 {1, 2, "2"},
145 {1, 3, "6"},
146 {10, 10, "10"},
147 {0, 100, "0"},
148 {0, 1e9, "0"},
149 {1, 0, "1"},
150 {100, 1, "1"},
151 {1, 10, "3628800"},
152 {1, 20, "2432902008176640000"},
153 {1, 100,
154 "933262154439441526816992388562667004907159682643816214685929" +
155 "638952175999932299156089414639761565182862536979208272237582" +
156 "51185210916864000000000000000000000000",
157 },
158 }
159
160 func TestMulRangeN(t *testing.T) {
161 for i, r := range mulRangesN {
162 prod := string(nat(nil).mulRange(r.a, r.b).utoa(10))
163 if prod != r.prod {
164 t.Errorf("#%d: got %s; want %s", i, prod, r.prod)
165 }
166 }
167 }
168
169
170 func allocBytes(f func()) uint64 {
171 var stats runtime.MemStats
172 runtime.ReadMemStats(&stats)
173 t := stats.TotalAlloc
174 f()
175 runtime.ReadMemStats(&stats)
176 return stats.TotalAlloc - t
177 }
178
179
180
181
182 func TestMulUnbalanced(t *testing.T) {
183 defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(1))
184 x := rndNat(50000)
185 y := rndNat(40)
186 allocSize := allocBytes(func() {
187 nat(nil).mul(x, y)
188 })
189 inputSize := uint64(len(x)+len(y)) * _S
190 if ratio := allocSize / uint64(inputSize); ratio > 10 {
191 t.Errorf("multiplication uses too much memory (%d > %d times the size of inputs)", allocSize, ratio)
192 }
193 }
194
195
196
197
198 func rndNat(n int) nat {
199 return nat(rndV(n)).norm()
200 }
201
202
203 func rndNat1(n int) nat {
204 x := nat(rndV(n)).norm()
205 if len(x) == 0 {
206 x.setWord(1)
207 }
208 return x
209 }
210
211 func BenchmarkMul(b *testing.B) {
212 mulx := rndNat(1e4)
213 muly := rndNat(1e4)
214 b.ResetTimer()
215 for i := 0; i < b.N; i++ {
216 var z nat
217 z.mul(mulx, muly)
218 }
219 }
220
221 func benchmarkNatMul(b *testing.B, nwords int) {
222 x := rndNat(nwords)
223 y := rndNat(nwords)
224 var z nat
225 b.ResetTimer()
226 for i := 0; i < b.N; i++ {
227 z.mul(x, y)
228 }
229 }
230
231 var mulBenchSizes = []int{10, 100, 1000, 10000, 100000}
232
233 func BenchmarkNatMul(b *testing.B) {
234 for _, n := range mulBenchSizes {
235 if isRaceBuilder && n > 1e3 {
236 continue
237 }
238 b.Run(fmt.Sprintf("%d", n), func(b *testing.B) {
239 benchmarkNatMul(b, n)
240 })
241 }
242 }
243
244 func TestNLZ(t *testing.T) {
245 var x Word = _B >> 1
246 for i := 0; i <= _W; i++ {
247 if int(nlz(x)) != i {
248 t.Errorf("failed at %x: got %d want %d", x, nlz(x), i)
249 }
250 x >>= 1
251 }
252 }
253
254 type shiftTest struct {
255 in nat
256 shift uint
257 out nat
258 }
259
260 var leftShiftTests = []shiftTest{
261 {nil, 0, nil},
262 {nil, 1, nil},
263 {natOne, 0, natOne},
264 {natOne, 1, natTwo},
265 {nat{1 << (_W - 1)}, 1, nat{0}},
266 {nat{1 << (_W - 1), 0}, 1, nat{0, 1}},
267 }
268
269 func TestShiftLeft(t *testing.T) {
270 for i, test := range leftShiftTests {
271 var z nat
272 z = z.shl(test.in, test.shift)
273 for j, d := range test.out {
274 if j >= len(z) || z[j] != d {
275 t.Errorf("#%d: got: %v want: %v", i, z, test.out)
276 break
277 }
278 }
279 }
280 }
281
282 var rightShiftTests = []shiftTest{
283 {nil, 0, nil},
284 {nil, 1, nil},
285 {natOne, 0, natOne},
286 {natOne, 1, nil},
287 {natTwo, 1, natOne},
288 {nat{0, 1}, 1, nat{1 << (_W - 1)}},
289 {nat{2, 1, 1}, 1, nat{1<<(_W-1) + 1, 1 << (_W - 1)}},
290 }
291
292 func TestShiftRight(t *testing.T) {
293 for i, test := range rightShiftTests {
294 var z nat
295 z = z.shr(test.in, test.shift)
296 for j, d := range test.out {
297 if j >= len(z) || z[j] != d {
298 t.Errorf("#%d: got: %v want: %v", i, z, test.out)
299 break
300 }
301 }
302 }
303 }
304
305 func BenchmarkZeroShifts(b *testing.B) {
306 x := rndNat(800)
307
308 b.Run("Shl", func(b *testing.B) {
309 for i := 0; i < b.N; i++ {
310 var z nat
311 z.shl(x, 0)
312 }
313 })
314 b.Run("ShlSame", func(b *testing.B) {
315 for i := 0; i < b.N; i++ {
316 x.shl(x, 0)
317 }
318 })
319
320 b.Run("Shr", func(b *testing.B) {
321 for i := 0; i < b.N; i++ {
322 var z nat
323 z.shr(x, 0)
324 }
325 })
326 b.Run("ShrSame", func(b *testing.B) {
327 for i := 0; i < b.N; i++ {
328 x.shr(x, 0)
329 }
330 })
331 }
332
333 type modWTest struct {
334 in string
335 dividend string
336 out string
337 }
338
339 var modWTests32 = []modWTest{
340 {"23492635982634928349238759823742", "252341", "220170"},
341 }
342
343 var modWTests64 = []modWTest{
344 {"6527895462947293856291561095690465243862946", "524326975699234", "375066989628668"},
345 }
346
347 func runModWTests(t *testing.T, tests []modWTest) {
348 for i, test := range tests {
349 in, _ := new(Int).SetString(test.in, 10)
350 d, _ := new(Int).SetString(test.dividend, 10)
351 out, _ := new(Int).SetString(test.out, 10)
352
353 r := in.abs.modW(d.abs[0])
354 if r != out.abs[0] {
355 t.Errorf("#%d failed: got %d want %s", i, r, out)
356 }
357 }
358 }
359
360 func TestModW(t *testing.T) {
361 if _W >= 32 {
362 runModWTests(t, modWTests32)
363 }
364 if _W >= 64 {
365 runModWTests(t, modWTests64)
366 }
367 }
368
369 var montgomeryTests = []struct {
370 x, y, m string
371 k0 uint64
372 out32, out64 string
373 }{
374 {
375 "0xffffffffffffffffffffffffffffffffffffffffffffffffe",
376 "0xffffffffffffffffffffffffffffffffffffffffffffffffe",
377 "0xfffffffffffffffffffffffffffffffffffffffffffffffff",
378 1,
379 "0x1000000000000000000000000000000000000000000",
380 "0x10000000000000000000000000000000000",
381 },
382 {
383 "0x000000000ffffff5",
384 "0x000000000ffffff0",
385 "0x0000000010000001",
386 0xff0000000fffffff,
387 "0x000000000bfffff4",
388 "0x0000000003400001",
389 },
390 {
391 "0x0000000080000000",
392 "0x00000000ffffffff",
393 "0x1000000000000001",
394 0xfffffffffffffff,
395 "0x0800000008000001",
396 "0x0800000008000001",
397 },
398 {
399 "0x0000000080000000",
400 "0x0000000080000000",
401 "0xffffffff00000001",
402 0xfffffffeffffffff,
403 "0xbfffffff40000001",
404 "0xbfffffff40000001",
405 },
406 {
407 "0x0000000080000000",
408 "0x0000000080000000",
409 "0x00ffffff00000001",
410 0xfffffeffffffff,
411 "0xbfffff40000001",
412 "0xbfffff40000001",
413 },
414 {
415 "0x0000000080000000",
416 "0x0000000080000000",
417 "0x0000ffff00000001",
418 0xfffeffffffff,
419 "0xbfff40000001",
420 "0xbfff40000001",
421 },
422 {
423 "0x3321ffffffffffffffffffffffffffff00000000000022222623333333332bbbb888c0",
424 "0x3321ffffffffffffffffffffffffffff00000000000022222623333333332bbbb888c0",
425 "0x33377fffffffffffffffffffffffffffffffffffffffffffff0000000000022222eee1",
426 0xdecc8f1249812adf,
427 "0x04eb0e11d72329dc0915f86784820fc403275bf2f6620a20e0dd344c5cd0875e50deb5",
428 "0x0d7144739a7d8e11d72329dc0915f86784820fc403275bf2f61ed96f35dd34dbb3d6a0",
429 },
430 {
431 "0x10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffffffffffff00000000000022222223333333333444444444",
432 "0x10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffffffffffff999999999999999aaabbbbbbbbcccccccccccc",
433 "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff33377fffffffffffffffffffffffffffffffffffffffffffff0000000000022222eee1",
434 0xdecc8f1249812adf,
435 "0x5c0d52f451aec609b15da8e5e5626c4eaa88723bdeac9d25ca9b961269400410ca208a16af9c2fb07d7a11c7772cba02c22f9711078d51a3797eb18e691295293284d988e349fa6deba46b25a4ecd9f715",
436 "0x92fcad4b5c0d52f451aec609b15da8e5e5626c4eaa88723bdeac9d25ca9b961269400410ca208a16af9c2fb07d799c32fe2f3cc5422f9711078d51a3797eb18e691295293284d8f5e69caf6decddfe1df6",
437 },
438 }
439
440 func TestMontgomery(t *testing.T) {
441 one := NewInt(1)
442 _B := new(Int).Lsh(one, _W)
443 for i, test := range montgomeryTests {
444 x := natFromString(test.x)
445 y := natFromString(test.y)
446 m := natFromString(test.m)
447 for len(x) < len(m) {
448 x = append(x, 0)
449 }
450 for len(y) < len(m) {
451 y = append(y, 0)
452 }
453
454 if x.cmp(m) > 0 {
455 _, r := nat(nil).div(nil, x, m)
456 t.Errorf("#%d: x > m (0x%s > 0x%s; use 0x%s)", i, x.utoa(16), m.utoa(16), r.utoa(16))
457 }
458 if y.cmp(m) > 0 {
459 _, r := nat(nil).div(nil, x, m)
460 t.Errorf("#%d: y > m (0x%s > 0x%s; use 0x%s)", i, y.utoa(16), m.utoa(16), r.utoa(16))
461 }
462
463 var out nat
464 if _W == 32 {
465 out = natFromString(test.out32)
466 } else {
467 out = natFromString(test.out64)
468 }
469
470
471
472
473 xi := &Int{abs: x}
474 yi := &Int{abs: y}
475 mi := &Int{abs: m}
476 p := new(Int).Mod(new(Int).Mul(xi, new(Int).Mul(yi, new(Int).ModInverse(new(Int).Lsh(one, uint(len(m))*_W), mi))), mi)
477 if out.cmp(p.abs.norm()) != 0 {
478 t.Errorf("#%d: out in table=0x%s, computed=0x%s", i, out.utoa(16), p.abs.norm().utoa(16))
479 }
480
481
482 k := new(Int).Mod(&Int{abs: m}, _B)
483 k = new(Int).Sub(_B, k)
484 k = new(Int).Mod(k, _B)
485 k0 := Word(new(Int).ModInverse(k, _B).Uint64())
486 if k0 != Word(test.k0) {
487 t.Errorf("#%d: k0 in table=%#x, computed=%#x\n", i, test.k0, k0)
488 }
489
490
491 z := nat(nil).montgomery(x, y, m, k0, len(m))
492 z = z.norm()
493 if z.cmp(out) != 0 {
494 t.Errorf("#%d: got 0x%s want 0x%s", i, z.utoa(16), out.utoa(16))
495 }
496 }
497 }
498
499 var expNNTests = []struct {
500 x, y, m string
501 out string
502 }{
503 {"0", "0", "0", "1"},
504 {"0", "0", "1", "0"},
505 {"1", "1", "1", "0"},
506 {"2", "1", "1", "0"},
507 {"2", "2", "1", "0"},
508 {"10", "100000000000", "1", "0"},
509 {"0x8000000000000000", "2", "", "0x40000000000000000000000000000000"},
510 {"0x8000000000000000", "2", "6719", "4944"},
511 {"0x8000000000000000", "3", "6719", "5447"},
512 {"0x8000000000000000", "1000", "6719", "1603"},
513 {"0x8000000000000000", "1000000", "6719", "3199"},
514 {
515 "2938462938472983472983659726349017249287491026512746239764525612965293865296239471239874193284792387498274256129746192347",
516 "298472983472983471903246121093472394872319615612417471234712061",
517 "29834729834729834729347290846729561262544958723956495615629569234729836259263598127342374289365912465901365498236492183464",
518 "23537740700184054162508175125554701713153216681790245129157191391322321508055833908509185839069455749219131480588829346291",
519 },
520 {
521 "11521922904531591643048817447554701904414021819823889996244743037378330903763518501116638828335352811871131385129455853417360623007349090150042001944696604737499160174391019030572483602867266711107136838523916077674888297896995042968746762200926853379",
522 "426343618817810911523",
523 "444747819283133684179",
524 "42",
525 },
526 }
527
528 func TestExpNN(t *testing.T) {
529 for i, test := range expNNTests {
530 x := natFromString(test.x)
531 y := natFromString(test.y)
532 out := natFromString(test.out)
533
534 var m nat
535 if len(test.m) > 0 {
536 m = natFromString(test.m)
537 }
538
539 z := nat(nil).expNN(x, y, m)
540 if z.cmp(out) != 0 {
541 t.Errorf("#%d got %s want %s", i, z.utoa(10), out.utoa(10))
542 }
543 }
544 }
545
546 func BenchmarkExp3Power(b *testing.B) {
547 const x = 3
548 for _, y := range []Word{
549 0x10, 0x40, 0x100, 0x400, 0x1000, 0x4000, 0x10000, 0x40000, 0x100000, 0x400000,
550 } {
551 b.Run(fmt.Sprintf("%#x", y), func(b *testing.B) {
552 var z nat
553 for i := 0; i < b.N; i++ {
554 z.expWW(x, y)
555 }
556 })
557 }
558 }
559
560 func fibo(n int) nat {
561 switch n {
562 case 0:
563 return nil
564 case 1:
565 return nat{1}
566 }
567 f0 := fibo(0)
568 f1 := fibo(1)
569 var f2 nat
570 for i := 1; i < n; i++ {
571 f2 = f2.add(f0, f1)
572 f0, f1, f2 = f1, f2, f0
573 }
574 return f1
575 }
576
577 var fiboNums = []string{
578 "0",
579 "55",
580 "6765",
581 "832040",
582 "102334155",
583 "12586269025",
584 "1548008755920",
585 "190392490709135",
586 "23416728348467685",
587 "2880067194370816120",
588 "354224848179261915075",
589 }
590
591 func TestFibo(t *testing.T) {
592 for i, want := range fiboNums {
593 n := i * 10
594 got := string(fibo(n).utoa(10))
595 if got != want {
596 t.Errorf("fibo(%d) failed: got %s want %s", n, got, want)
597 }
598 }
599 }
600
601 func BenchmarkFibo(b *testing.B) {
602 for i := 0; i < b.N; i++ {
603 fibo(1e0)
604 fibo(1e1)
605 fibo(1e2)
606 fibo(1e3)
607 fibo(1e4)
608 fibo(1e5)
609 }
610 }
611
612 var bitTests = []struct {
613 x string
614 i uint
615 want uint
616 }{
617 {"0", 0, 0},
618 {"0", 1, 0},
619 {"0", 1000, 0},
620
621 {"0x1", 0, 1},
622 {"0x10", 0, 0},
623 {"0x10", 3, 0},
624 {"0x10", 4, 1},
625 {"0x10", 5, 0},
626
627 {"0x8000000000000000", 62, 0},
628 {"0x8000000000000000", 63, 1},
629 {"0x8000000000000000", 64, 0},
630
631 {"0x3" + strings.Repeat("0", 32), 127, 0},
632 {"0x3" + strings.Repeat("0", 32), 128, 1},
633 {"0x3" + strings.Repeat("0", 32), 129, 1},
634 {"0x3" + strings.Repeat("0", 32), 130, 0},
635 }
636
637 func TestBit(t *testing.T) {
638 for i, test := range bitTests {
639 x := natFromString(test.x)
640 if got := x.bit(test.i); got != test.want {
641 t.Errorf("#%d: %s.bit(%d) = %v; want %v", i, test.x, test.i, got, test.want)
642 }
643 }
644 }
645
646 var stickyTests = []struct {
647 x string
648 i uint
649 want uint
650 }{
651 {"0", 0, 0},
652 {"0", 1, 0},
653 {"0", 1000, 0},
654
655 {"0x1", 0, 0},
656 {"0x1", 1, 1},
657
658 {"0x1350", 0, 0},
659 {"0x1350", 4, 0},
660 {"0x1350", 5, 1},
661
662 {"0x8000000000000000", 63, 0},
663 {"0x8000000000000000", 64, 1},
664
665 {"0x1" + strings.Repeat("0", 100), 400, 0},
666 {"0x1" + strings.Repeat("0", 100), 401, 1},
667 }
668
669 func TestSticky(t *testing.T) {
670 for i, test := range stickyTests {
671 x := natFromString(test.x)
672 if got := x.sticky(test.i); got != test.want {
673 t.Errorf("#%d: %s.sticky(%d) = %v; want %v", i, test.x, test.i, got, test.want)
674 }
675 if test.want == 1 {
676
677 for d := uint(1); d <= 3; d++ {
678 if got := x.sticky(test.i + d); got != 1 {
679 t.Errorf("#%d: %s.sticky(%d) = %v; want %v", i, test.x, test.i+d, got, 1)
680 }
681 }
682 }
683 }
684 }
685
686 func testSqr(t *testing.T, x nat) {
687 got := make(nat, 2*len(x))
688 want := make(nat, 2*len(x))
689 got = got.sqr(x)
690 want = want.mul(x, x)
691 if got.cmp(want) != 0 {
692 t.Errorf("basicSqr(%v), got %v, want %v", x, got, want)
693 }
694 }
695
696 func TestSqr(t *testing.T) {
697 for _, a := range prodNN {
698 if a.x != nil {
699 testSqr(t, a.x)
700 }
701 if a.y != nil {
702 testSqr(t, a.y)
703 }
704 if a.z != nil {
705 testSqr(t, a.z)
706 }
707 }
708 }
709
710 func benchmarkNatSqr(b *testing.B, nwords int) {
711 x := rndNat(nwords)
712 var z nat
713 b.ResetTimer()
714 for i := 0; i < b.N; i++ {
715 z.sqr(x)
716 }
717 }
718
719 var sqrBenchSizes = []int{
720 1, 2, 3, 5, 8, 10, 20, 30, 50, 80,
721 100, 200, 300, 500, 800,
722 1000, 10000, 100000,
723 }
724
725 func BenchmarkNatSqr(b *testing.B) {
726 for _, n := range sqrBenchSizes {
727 if isRaceBuilder && n > 1e3 {
728 continue
729 }
730 b.Run(fmt.Sprintf("%d", n), func(b *testing.B) {
731 benchmarkNatSqr(b, n)
732 })
733 }
734 }
735
736 func BenchmarkNatSetBytes(b *testing.B) {
737 const maxLength = 128
738 lengths := []int{
739
740 8, 24, maxLength,
741
742 7, 23, maxLength - 1,
743 }
744 n := make(nat, maxLength/_W)
745 buf := make([]byte, maxLength)
746 for _, l := range lengths {
747 b.Run(fmt.Sprint(l), func(b *testing.B) {
748 for i := 0; i < b.N; i++ {
749 n.setBytes(buf[:l])
750 }
751 })
752 }
753 }
754
755 func TestNatDiv(t *testing.T) {
756 sizes := []int{
757 1, 2, 5, 8, 15, 25, 40, 65, 100,
758 200, 500, 800, 1500, 2500, 4000, 6500, 10000,
759 }
760 for _, i := range sizes {
761 for _, j := range sizes {
762 a := rndNat1(i)
763 b := rndNat1(j)
764
765 if len(b) == 1 && b[0] == 1 {
766 b[0] = 2
767 }
768
769 c := rndNat1(len(b))
770 if len(c) == len(b) && c[len(c)-1] >= b[len(b)-1] {
771 c[len(c)-1] = 0
772 c = c.norm()
773 }
774
775 x := nat(nil).mul(a, b)
776 x = x.add(x, c)
777
778 var q, r nat
779 q, r = q.div(r, x, b)
780 if q.cmp(a) != 0 {
781 t.Fatalf("wrong quotient: got %s; want %s for %s/%s", q.utoa(10), a.utoa(10), x.utoa(10), b.utoa(10))
782 }
783 if r.cmp(c) != 0 {
784 t.Fatalf("wrong remainder: got %s; want %s for %s/%s", r.utoa(10), c.utoa(10), x.utoa(10), b.utoa(10))
785 }
786 }
787 }
788 }
789
790
791
792
793 func TestIssue37499(t *testing.T) {
794
795
796
797 u := natFromString("0x2b6c385a05be027f5c22005b63c42a1165b79ff510e1706b39f8489c1d28e57bb5ba4ef9fd9387a3e344402c0a453381")
798 v := natFromString("0x2b6c385a05be027f5c22005b63c42a1165b79ff510e1706c")
799
800 q := nat(nil).make(8)
801 q.divBasic(u, v)
802 q = q.norm()
803 if s := string(q.utoa(16)); s != "fffffffffffffffffffffffffffffffffffffffffffffffb" {
804 t.Fatalf("incorrect quotient: %s", s)
805 }
806 }
807
808
809
810
811 func TestIssue42552(t *testing.T) {
812 u := natFromString("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")
813 v := natFromString("0x838332321d443a3d30373d47301d47073847473a383d3030f25b3d3d3e00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002e00000000000000000041603038331c3d32f5303441e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e01c0a5459bfc7b9be9fcbb9d2383840464319434707303030f43a32f53034411c0a5459413820878787878787878787878787878787878787878787878787878787878787878787870630303a3a30334036605b923a6101f83638413943413960204337602043323801526040523241846038414143015238604060328452413841413638523c0240384141364036605b923a6101f83638413943413960204334602043323801526040523241846038414143015238604060328452413841413638523c02403841413638433030f25a8b83838383838383838383838383838383837d838383ffffffffffffffff838383838383838383000000000000000000030000007d26e27c7c8b83838383838383838383838383838383837d838383ffffffffffffffff83838383838383838383838383838383838383838383435960f535073030f3343200000000000000011881301938343030fa398383300000002300000000000000000000f11af4600c845252904141364138383c60406032414443095238010241414303364443434132305b595a15434160b042385341ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff47476043410536613603593a6005411c437405fcfcfcfcfcfcfc0000000000005a3b075815054359000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000")
814 q := nat(nil).make(16)
815 q.div(q, u, v)
816 }
817
View as plain text