1 // Copyright 2009 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.
19 func isNormalized(x *Int) bool {
24 return x.abs[len(x.abs)-1] != 0
27 type funZZ func(z, x, y *Int) *Int
33 {NewInt(0), NewInt(0), NewInt(0)},
34 {NewInt(1), NewInt(1), NewInt(0)},
35 {NewInt(1111111110), NewInt(123456789), NewInt(987654321)},
36 {NewInt(-1), NewInt(-1), NewInt(0)},
37 {NewInt(864197532), NewInt(-123456789), NewInt(987654321)},
38 {NewInt(-1111111110), NewInt(-123456789), NewInt(-987654321)},
42 {NewInt(0), NewInt(0), NewInt(0)},
43 {NewInt(0), NewInt(1), NewInt(0)},
44 {NewInt(1), NewInt(1), NewInt(1)},
45 {NewInt(-991 * 991), NewInt(991), NewInt(-991)},
46 // TODO(gri) add larger products
49 func TestSignZ(t *testing.T) {
51 for _, a := range sumZZ {
55 t.Errorf("got %d; want %d for z = %v", s, e, a.z)
60 func TestSetZ(t *testing.T) {
61 for _, a := range sumZZ {
64 if !isNormalized(&z) {
65 t.Errorf("%v is not normalized", z)
67 if (&z).Cmp(a.z) != 0 {
68 t.Errorf("got z = %v; want %v", z, a.z)
73 func TestAbsZ(t *testing.T) {
75 for _, a := range sumZZ {
84 t.Errorf("got z = %v; want %v", z, e)
89 func testFunZZ(t *testing.T, msg string, f funZZ, a argZZ) {
92 if !isNormalized(&z) {
93 t.Errorf("%s%v is not normalized", msg, z)
95 if (&z).Cmp(a.z) != 0 {
96 t.Errorf("%s%+v\n\tgot z = %v; want %v", msg, a, &z, a.z)
100 func TestSumZZ(t *testing.T) {
101 AddZZ := func(z, x, y *Int) *Int { return z.Add(x, y) }
102 SubZZ := func(z, x, y *Int) *Int { return z.Sub(x, y) }
103 for _, a := range sumZZ {
105 testFunZZ(t, "AddZZ", AddZZ, arg)
107 arg = argZZ{a.z, a.y, a.x}
108 testFunZZ(t, "AddZZ symmetric", AddZZ, arg)
110 arg = argZZ{a.x, a.z, a.y}
111 testFunZZ(t, "SubZZ", SubZZ, arg)
113 arg = argZZ{a.y, a.z, a.x}
114 testFunZZ(t, "SubZZ symmetric", SubZZ, arg)
118 func TestProdZZ(t *testing.T) {
119 MulZZ := func(z, x, y *Int) *Int { return z.Mul(x, y) }
120 for _, a := range prodZZ {
122 testFunZZ(t, "MulZZ", MulZZ, arg)
124 arg = argZZ{a.z, a.y, a.x}
125 testFunZZ(t, "MulZZ symmetric", MulZZ, arg)
129 // mulBytes returns x*y via grade school multiplication. Both inputs
130 // and the result are assumed to be in big-endian representation (to
131 // match the semantics of Int.Bytes and Int.SetBytes).
132 func mulBytes(x, y []byte) []byte {
133 z := make([]byte, len(x)+len(y))
137 for j := len(y) - 1; j >= 0; j-- {
142 for i := len(x) - 1; i >= 0; i-- {
143 t := int(z[k]) + int(x[i])*d + carry
144 z[k], carry = byte(t), t>>8
152 // normalize (remove leading 0's)
154 for i < len(z) && z[i] == 0 {
161 func checkMul(a, b []byte) bool {
168 z2.SetBytes(mulBytes(a, b))
170 return z1.Cmp(&z2) == 0
173 func TestMul(t *testing.T) {
174 if err := quick.Check(checkMul, nil); err != nil {
179 var mulRangesZ = []struct {
183 // entirely positive ranges are covered by mulRangesN
190 {0, -1, "1"}, // empty range
191 {-1, -100, "1"}, // empty range
192 {-1, 1, "0"}, // range includes 0
193 {-1e9, 0, "0"}, // range includes 0
194 {-1e9, 1e9, "0"}, // range includes 0
195 {-10, -1, "3628800"}, // 10!
196 {-20, -2, "-2432902008176640000"}, // -20!
198 "-933262154439441526816992388562667004907159682643816214685929" +
199 "638952175999932299156089414639761565182862536979208272237582" +
200 "511852109168640000000000000000000000", // -99!
204 func TestMulRangeZ(t *testing.T) {
206 // test entirely positive ranges
207 for i, r := range mulRangesN {
208 prod := tmp.MulRange(int64(r.a), int64(r.b)).String()
210 t.Errorf("#%da: got %s; want %s", i, prod, r.prod)
214 for i, r := range mulRangesZ {
215 prod := tmp.MulRange(r.a, r.b).String()
217 t.Errorf("#%db: got %s; want %s", i, prod, r.prod)
222 var stringTests = []struct {
230 {in: "a", ok: false},
231 {in: "z", ok: false},
232 {in: "+", ok: false},
233 {in: "-", ok: false},
234 {in: "0b", ok: false},
235 {in: "0x", ok: false},
236 {in: "2", base: 2, ok: false},
237 {in: "0b2", base: 0, ok: false},
238 {in: "08", ok: false},
239 {in: "8", base: 8, ok: false},
240 {in: "0xg", base: 0, ok: false},
241 {in: "g", base: 16, ok: false},
242 {"0", "0", 0, 0, true},
243 {"0", "0", 10, 0, true},
244 {"0", "0", 16, 0, true},
245 {"+0", "0", 0, 0, true},
246 {"-0", "0", 0, 0, true},
247 {"10", "10", 0, 10, true},
248 {"10", "10", 10, 10, true},
249 {"10", "10", 16, 16, true},
250 {"-10", "-10", 16, -16, true},
251 {"+10", "10", 16, 16, true},
252 {"0x10", "16", 0, 16, true},
253 {in: "0x10", base: 16, ok: false},
254 {"-0x10", "-16", 0, -16, true},
255 {"+0x10", "16", 0, 16, true},
256 {"00", "0", 0, 0, true},
257 {"0", "0", 8, 0, true},
258 {"07", "7", 0, 7, true},
259 {"7", "7", 8, 7, true},
260 {"023", "19", 0, 19, true},
261 {"23", "23", 8, 19, true},
262 {"cafebabe", "cafebabe", 16, 0xcafebabe, true},
263 {"0b0", "0", 0, 0, true},
264 {"-111", "-111", 2, -7, true},
265 {"-0b111", "-7", 0, -7, true},
266 {"0b1001010111", "599", 0, 0x257, true},
267 {"1001010111", "1001010111", 2, 0x257, true},
270 func format(base int) string {
282 func TestGetString(t *testing.T) {
284 for i, test := range stringTests {
293 t.Errorf("#%da got %s; want %s", i, s, test.out)
297 s := fmt.Sprintf(format(test.base), z)
299 t.Errorf("#%db got %s; want %s", i, s, test.out)
304 func TestSetString(t *testing.T) {
306 for i, test := range stringTests {
307 // initialize to a non-zero value so that issues with parsing
309 tmp.SetInt64(1234567890)
310 n1, ok1 := new(Int).SetString(test.in, test.base)
311 n2, ok2 := tmp.SetString(test.in, test.base)
312 expected := NewInt(test.val)
313 if ok1 != test.ok || ok2 != test.ok {
314 t.Errorf("#%d (input '%s') ok incorrect (should be %t)", i, test.in, test.ok)
319 t.Errorf("#%d (input '%s') n1 != nil", i, test.in)
325 t.Errorf("#%d (input '%s') n2 != nil", i, test.in)
330 if ok1 && !isNormalized(n1) {
331 t.Errorf("#%d (input '%s'): %v is not normalized", i, test.in, *n1)
333 if ok2 && !isNormalized(n2) {
334 t.Errorf("#%d (input '%s'): %v is not normalized", i, test.in, *n2)
337 if n1.Cmp(expected) != 0 {
338 t.Errorf("#%d (input '%s') got: %s want: %d", i, test.in, n1, test.val)
340 if n2.Cmp(expected) != 0 {
341 t.Errorf("#%d (input '%s') got: %s want: %d", i, test.in, n2, test.val)
346 var formatTests = []struct {
351 {"<nil>", "%x", "<nil>"},
352 {"<nil>", "%#x", "<nil>"},
353 {"<nil>", "%#y", "%!y(big.Int=<nil>)"},
355 {"10", "%b", "1010"},
362 {"10", "%y", "%!y(big.Int=10)"},
363 {"-10", "%y", "%!y(big.Int=-10)"},
365 {"10", "%#b", "1010"},
366 {"10", "%#o", "012"},
369 {"10", "%#x", "0xa"},
370 {"10", "%#X", "0XA"},
371 {"-10", "%#X", "-0XA"},
372 {"10", "%#y", "%!y(big.Int=10)"},
373 {"-10", "%#y", "%!y(big.Int=-10)"},
375 {"1234", "%d", "1234"},
376 {"1234", "%3d", "1234"},
377 {"1234", "%4d", "1234"},
378 {"-1234", "%d", "-1234"},
379 {"1234", "% 5d", " 1234"},
380 {"1234", "%+5d", "+1234"},
381 {"1234", "%-5d", "1234 "},
382 {"1234", "%x", "4d2"},
383 {"1234", "%X", "4D2"},
384 {"-1234", "%3x", "-4d2"},
385 {"-1234", "%4x", "-4d2"},
386 {"-1234", "%5x", " -4d2"},
387 {"-1234", "%-5x", "-4d2 "},
388 {"1234", "%03d", "1234"},
389 {"1234", "%04d", "1234"},
390 {"1234", "%05d", "01234"},
391 {"1234", "%06d", "001234"},
392 {"-1234", "%06d", "-01234"},
393 {"1234", "%+06d", "+01234"},
394 {"1234", "% 06d", " 01234"},
395 {"1234", "%-6d", "1234 "},
396 {"1234", "%-06d", "1234 "},
397 {"-1234", "%-06d", "-1234 "},
399 {"1234", "%.3d", "1234"},
400 {"1234", "%.4d", "1234"},
401 {"1234", "%.5d", "01234"},
402 {"1234", "%.6d", "001234"},
403 {"-1234", "%.3d", "-1234"},
404 {"-1234", "%.4d", "-1234"},
405 {"-1234", "%.5d", "-01234"},
406 {"-1234", "%.6d", "-001234"},
408 {"1234", "%8.3d", " 1234"},
409 {"1234", "%8.4d", " 1234"},
410 {"1234", "%8.5d", " 01234"},
411 {"1234", "%8.6d", " 001234"},
412 {"-1234", "%8.3d", " -1234"},
413 {"-1234", "%8.4d", " -1234"},
414 {"-1234", "%8.5d", " -01234"},
415 {"-1234", "%8.6d", " -001234"},
417 {"1234", "%+8.3d", " +1234"},
418 {"1234", "%+8.4d", " +1234"},
419 {"1234", "%+8.5d", " +01234"},
420 {"1234", "%+8.6d", " +001234"},
421 {"-1234", "%+8.3d", " -1234"},
422 {"-1234", "%+8.4d", " -1234"},
423 {"-1234", "%+8.5d", " -01234"},
424 {"-1234", "%+8.6d", " -001234"},
426 {"1234", "% 8.3d", " 1234"},
427 {"1234", "% 8.4d", " 1234"},
428 {"1234", "% 8.5d", " 01234"},
429 {"1234", "% 8.6d", " 001234"},
430 {"-1234", "% 8.3d", " -1234"},
431 {"-1234", "% 8.4d", " -1234"},
432 {"-1234", "% 8.5d", " -01234"},
433 {"-1234", "% 8.6d", " -001234"},
435 {"1234", "%.3x", "4d2"},
436 {"1234", "%.4x", "04d2"},
437 {"1234", "%.5x", "004d2"},
438 {"1234", "%.6x", "0004d2"},
439 {"-1234", "%.3x", "-4d2"},
440 {"-1234", "%.4x", "-04d2"},
441 {"-1234", "%.5x", "-004d2"},
442 {"-1234", "%.6x", "-0004d2"},
444 {"1234", "%8.3x", " 4d2"},
445 {"1234", "%8.4x", " 04d2"},
446 {"1234", "%8.5x", " 004d2"},
447 {"1234", "%8.6x", " 0004d2"},
448 {"-1234", "%8.3x", " -4d2"},
449 {"-1234", "%8.4x", " -04d2"},
450 {"-1234", "%8.5x", " -004d2"},
451 {"-1234", "%8.6x", " -0004d2"},
453 {"1234", "%+8.3x", " +4d2"},
454 {"1234", "%+8.4x", " +04d2"},
455 {"1234", "%+8.5x", " +004d2"},
456 {"1234", "%+8.6x", " +0004d2"},
457 {"-1234", "%+8.3x", " -4d2"},
458 {"-1234", "%+8.4x", " -04d2"},
459 {"-1234", "%+8.5x", " -004d2"},
460 {"-1234", "%+8.6x", " -0004d2"},
462 {"1234", "% 8.3x", " 4d2"},
463 {"1234", "% 8.4x", " 04d2"},
464 {"1234", "% 8.5x", " 004d2"},
465 {"1234", "% 8.6x", " 0004d2"},
466 {"1234", "% 8.7x", " 00004d2"},
467 {"1234", "% 8.8x", " 000004d2"},
468 {"-1234", "% 8.3x", " -4d2"},
469 {"-1234", "% 8.4x", " -04d2"},
470 {"-1234", "% 8.5x", " -004d2"},
471 {"-1234", "% 8.6x", " -0004d2"},
472 {"-1234", "% 8.7x", "-00004d2"},
473 {"-1234", "% 8.8x", "-000004d2"},
475 {"1234", "%-8.3d", "1234 "},
476 {"1234", "%-8.4d", "1234 "},
477 {"1234", "%-8.5d", "01234 "},
478 {"1234", "%-8.6d", "001234 "},
479 {"1234", "%-8.7d", "0001234 "},
480 {"1234", "%-8.8d", "00001234"},
481 {"-1234", "%-8.3d", "-1234 "},
482 {"-1234", "%-8.4d", "-1234 "},
483 {"-1234", "%-8.5d", "-01234 "},
484 {"-1234", "%-8.6d", "-001234 "},
485 {"-1234", "%-8.7d", "-0001234"},
486 {"-1234", "%-8.8d", "-00001234"},
488 {"16777215", "%b", "111111111111111111111111"}, // 2**24 - 1
495 func TestFormat(t *testing.T) {
496 for i, test := range formatTests {
498 if test.input != "<nil>" {
500 x, ok = new(Int).SetString(test.input, 0)
502 t.Errorf("#%d failed reading input %s", i, test.input)
505 output := fmt.Sprintf(test.format, x)
506 if output != test.output {
507 t.Errorf("#%d got %q; want %q, {%q, %q, %q}", i, output, test.output, test.input, test.format, test.output)
512 var scanTests = []struct {
518 {"1010", "%b", "10", 0},
519 {"0b1010", "%v", "10", 0},
520 {"12", "%o", "10", 0},
521 {"012", "%v", "10", 0},
522 {"10", "%d", "10", 0},
523 {"10", "%v", "10", 0},
524 {"a", "%x", "10", 0},
525 {"0xa", "%v", "10", 0},
526 {"A", "%X", "10", 0},
527 {"-A", "%X", "-10", 0},
528 {"+0b1011001", "%v", "89", 0},
529 {"0xA", "%v", "10", 0},
530 {"0 ", "%v", "0", 1},
531 {"2+3", "%v", "2", 2},
532 {"0XABC 12", "%v", "2748", 3},
535 func TestScan(t *testing.T) {
537 for i, test := range scanTests {
540 buf.WriteString(test.input)
541 if _, err := fmt.Fscanf(&buf, test.format, x); err != nil {
542 t.Errorf("#%d error: %s", i, err)
544 if x.String() != test.output {
545 t.Errorf("#%d got %s; want %s", i, x.String(), test.output)
547 if buf.Len() != test.remaining {
548 t.Errorf("#%d got %d bytes remaining; want %d", i, buf.Len(), test.remaining)
553 // Examples from the Go Language Spec, section "Arithmetic operators"
554 var divisionSignsTests = []struct {
556 q, r int64 // T-division
557 d, m int64 // Euclidian division
560 {-5, 3, -1, -2, -2, 1},
561 {5, -3, -1, 2, -1, 2},
562 {-5, -3, 1, -2, 2, 1},
567 func TestDivisionSigns(t *testing.T) {
568 for i, test := range divisionSignsTests {
576 q1 := new(Int).Quo(x, y)
577 r1 := new(Int).Rem(x, y)
578 if !isNormalized(q1) {
579 t.Errorf("#%d Quo: %v is not normalized", i, *q1)
581 if !isNormalized(r1) {
582 t.Errorf("#%d Rem: %v is not normalized", i, *r1)
584 if q1.Cmp(q) != 0 || r1.Cmp(r) != 0 {
585 t.Errorf("#%d QuoRem: got (%s, %s), want (%s, %s)", i, q1, r1, q, r)
588 q2, r2 := new(Int).QuoRem(x, y, new(Int))
589 if !isNormalized(q2) {
590 t.Errorf("#%d Quo: %v is not normalized", i, *q2)
592 if !isNormalized(r2) {
593 t.Errorf("#%d Rem: %v is not normalized", i, *r2)
595 if q2.Cmp(q) != 0 || r2.Cmp(r) != 0 {
596 t.Errorf("#%d QuoRem: got (%s, %s), want (%s, %s)", i, q2, r2, q, r)
599 d1 := new(Int).Div(x, y)
600 m1 := new(Int).Mod(x, y)
601 if !isNormalized(d1) {
602 t.Errorf("#%d Div: %v is not normalized", i, *d1)
604 if !isNormalized(m1) {
605 t.Errorf("#%d Mod: %v is not normalized", i, *m1)
607 if d1.Cmp(d) != 0 || m1.Cmp(m) != 0 {
608 t.Errorf("#%d DivMod: got (%s, %s), want (%s, %s)", i, d1, m1, d, m)
611 d2, m2 := new(Int).DivMod(x, y, new(Int))
612 if !isNormalized(d2) {
613 t.Errorf("#%d Div: %v is not normalized", i, *d2)
615 if !isNormalized(m2) {
616 t.Errorf("#%d Mod: %v is not normalized", i, *m2)
618 if d2.Cmp(d) != 0 || m2.Cmp(m) != 0 {
619 t.Errorf("#%d DivMod: got (%s, %s), want (%s, %s)", i, d2, m2, d, m)
624 func checkSetBytes(b []byte) bool {
625 hex1 := hex.EncodeToString(new(Int).SetBytes(b).Bytes())
626 hex2 := hex.EncodeToString(b)
628 for len(hex1) < len(hex2) {
632 for len(hex1) > len(hex2) {
639 func TestSetBytes(t *testing.T) {
640 if err := quick.Check(checkSetBytes, nil); err != nil {
645 func checkBytes(b []byte) bool {
646 b2 := new(Int).SetBytes(b).Bytes()
647 return bytes.Equal(b, b2)
650 func TestBytes(t *testing.T) {
651 if err := quick.Check(checkSetBytes, nil); err != nil {
656 func checkQuo(x, y []byte) bool {
657 u := new(Int).SetBytes(x)
658 v := new(Int).SetBytes(y)
665 q, r := new(Int).QuoRem(u, v, r)
671 uprime := new(Int).Set(q)
672 uprime.Mul(uprime, v)
673 uprime.Add(uprime, r)
675 return uprime.Cmp(u) == 0
678 var quoTests = []struct {
683 "476217953993950760840509444250624797097991362735329973741718102894495832294430498335824897858659711275234906400899559094370964723884706254265559534144986498357",
684 "9353930466774385905609975137998169297361893554149986716853295022578535724979483772383667534691121982974895531435241089241440253066816724367338287092081996",
689 "11510768301994997771168",
690 "1328165573307167369775",
692 "885443715537658812968",
696 func TestQuo(t *testing.T) {
697 if err := quick.Check(checkQuo, nil); err != nil {
701 for i, test := range quoTests {
702 x, _ := new(Int).SetString(test.x, 10)
703 y, _ := new(Int).SetString(test.y, 10)
704 expectedQ, _ := new(Int).SetString(test.q, 10)
705 expectedR, _ := new(Int).SetString(test.r, 10)
708 q, r := new(Int).QuoRem(x, y, r)
710 if q.Cmp(expectedQ) != 0 || r.Cmp(expectedR) != 0 {
711 t.Errorf("#%d got (%s, %s) want (%s, %s)", i, q, r, expectedQ, expectedR)
716 func TestQuoStepD6(t *testing.T) {
717 // See Knuth, Volume 2, section 4.3.1, exercise 21. This code exercises
718 // a code path which only triggers 1 in 10^{-19} cases.
720 u := &Int{false, nat{0, 0, 1 + 1<<(_W-1), _M ^ (1 << (_W - 1))}}
721 v := &Int{false, nat{5, 2 + 1<<(_W-1), 1 << (_W - 1)}}
724 q, r := new(Int).QuoRem(u, v, r)
725 const expectedQ64 = "18446744073709551613"
726 const expectedR64 = "3138550867693340382088035895064302439801311770021610913807"
727 const expectedQ32 = "4294967293"
728 const expectedR32 = "39614081266355540837921718287"
729 if q.String() != expectedQ64 && q.String() != expectedQ32 ||
730 r.String() != expectedR64 && r.String() != expectedR32 {
731 t.Errorf("got (%s, %s) want (%s, %s) or (%s, %s)", q, r, expectedQ64, expectedR64, expectedQ32, expectedR32)
735 var bitLenTests = []struct {
747 {"0x800000000000", 48},
748 {"0x8000000000000000", 64},
749 {"0x80000000000000000000", 80},
750 {"-0x4000000000000000000000", 87},
753 func TestBitLen(t *testing.T) {
754 for i, test := range bitLenTests {
755 x, ok := new(Int).SetString(test.in, 0)
757 t.Errorf("#%d test input invalid: %s", i, test.in)
761 if n := x.BitLen(); n != test.out {
762 t.Errorf("#%d got %d want %d", i, n, test.out)
767 var expTests = []struct {
774 {"-10", "0", "", "1"},
775 {"1234", "-1", "", "1"},
778 {"0", "0", "1", "0"},
779 {"1", "0", "1", "0"},
780 {"-10", "0", "1", "0"},
781 {"1234", "-1", "1", "0"},
784 {"5", "-7", "", "1"},
785 {"-5", "-7", "", "1"},
787 {"-5", "0", "", "1"},
789 {"-5", "1", "", "-5"},
790 {"-2", "3", "2", "0"},
791 {"5", "2", "", "25"},
792 {"1", "65537", "2", "1"},
793 {"0x8000000000000000", "2", "", "0x40000000000000000000000000000000"},
794 {"0x8000000000000000", "2", "6719", "4944"},
795 {"0x8000000000000000", "3", "6719", "5447"},
796 {"0x8000000000000000", "1000", "6719", "1603"},
797 {"0x8000000000000000", "1000000", "6719", "3199"},
798 {"0x8000000000000000", "-1000000", "6719", "1"},
800 "2938462938472983472983659726349017249287491026512746239764525612965293865296239471239874193284792387498274256129746192347",
801 "298472983472983471903246121093472394872319615612417471234712061",
802 "29834729834729834729347290846729561262544958723956495615629569234729836259263598127342374289365912465901365498236492183464",
803 "23537740700184054162508175125554701713153216681790245129157191391322321508055833908509185839069455749219131480588829346291",
807 func TestExp(t *testing.T) {
808 for i, test := range expTests {
809 x, ok1 := new(Int).SetString(test.x, 0)
810 y, ok2 := new(Int).SetString(test.y, 0)
811 out, ok3 := new(Int).SetString(test.out, 0)
816 if len(test.m) == 0 {
819 m, ok4 = new(Int).SetString(test.m, 0)
822 if !ok1 || !ok2 || !ok3 || !ok4 {
823 t.Errorf("#%d: error in input", i)
827 z1 := new(Int).Exp(x, y, m)
828 if !isNormalized(z1) {
829 t.Errorf("#%d: %v is not normalized", i, *z1)
831 if z1.Cmp(out) != 0 {
832 t.Errorf("#%d: got %s want %s", i, z1, out)
836 // the result should be the same as for m == 0;
837 // specifically, there should be no div-zero panic
838 m = &Int{abs: nat{}} // m != nil && len(m.abs) == 0
839 z2 := new(Int).Exp(x, y, m)
841 t.Errorf("#%d: got %s want %s", i, z1, z2)
847 func checkGcd(aBytes, bBytes []byte) bool {
850 a := new(Int).SetBytes(aBytes)
851 b := new(Int).SetBytes(bBytes)
853 d := new(Int).GCD(x, y, a, b)
861 var gcdTests = []struct {
865 {"0", "0", "0", "0", "0"},
866 {"0", "0", "0", "0", "7"},
867 {"0", "0", "0", "11", "0"},
868 {"0", "0", "0", "-77", "35"},
869 {"0", "0", "0", "64515", "-24310"},
870 {"0", "0", "0", "-64515", "-24310"},
872 {"1", "-9", "47", "120", "23"},
873 {"7", "1", "-2", "77", "35"},
874 {"935", "-3", "8", "64515", "24310"},
875 {"935000000000000000", "-3", "8", "64515000000000000000", "24310000000000000000"},
876 {"1", "-221", "22059940471369027483332068679400581064239780177629666810348940098015901108344", "98920366548084643601728869055592650835572950932266967461790948584315647051443", "991"},
878 // test early exit (after one Euclidean iteration) in binaryGCD
879 {"1", "", "", "1", "98920366548084643601728869055592650835572950932266967461790948584315647051443"},
882 func testGcd(t *testing.T, d, x, y, a, b *Int) {
892 D := new(Int).GCD(X, Y, a, b)
894 t.Errorf("GCD(%s, %s): got d = %s, want %s", a, b, D, d)
896 if x != nil && X.Cmp(x) != 0 {
897 t.Errorf("GCD(%s, %s): got x = %s, want %s", a, b, X, x)
899 if y != nil && Y.Cmp(y) != 0 {
900 t.Errorf("GCD(%s, %s): got y = %s, want %s", a, b, Y, y)
903 // binaryGCD requires a > 0 && b > 0
904 if a.Sign() <= 0 || b.Sign() <= 0 {
910 t.Errorf("binaryGcd(%s, %s): got d = %s, want %s", a, b, D, d)
914 func TestGcd(t *testing.T) {
915 for _, test := range gcdTests {
916 d, _ := new(Int).SetString(test.d, 0)
917 x, _ := new(Int).SetString(test.x, 0)
918 y, _ := new(Int).SetString(test.y, 0)
919 a, _ := new(Int).SetString(test.a, 0)
920 b, _ := new(Int).SetString(test.b, 0)
922 testGcd(t, d, nil, nil, a, b)
923 testGcd(t, d, x, nil, a, b)
924 testGcd(t, d, nil, y, a, b)
925 testGcd(t, d, x, y, a, b)
928 quick.Check(checkGcd, nil)
931 var primes = []string{
938 "13756265695458089029",
939 "13496181268022124907",
940 "10953742525620032441",
941 "17908251027575790097",
943 // http://code.google.com/p/go/issues/detail?id=638
944 "18699199384836356663",
946 "98920366548084643601728869055592650835572950932266967461790948584315647051443",
947 "94560208308847015747498523884063394671606671904944666360068158221458669711639",
949 // http://primes.utm.edu/lists/small/small3.html
950 "449417999055441493994709297093108513015373787049558499205492347871729927573118262811508386655998299074566974373711472560655026288668094291699357843464363003144674940345912431129144354948751003607115263071543163",
951 "230975859993204150666423538988557839555560243929065415434980904258310530753006723857139742334640122533598517597674807096648905501653461687601339782814316124971547968912893214002992086353183070342498989426570593",
952 "5521712099665906221540423207019333379125265462121169655563495403888449493493629943498064604536961775110765377745550377067893607246020694972959780839151452457728855382113555867743022746090187341871655890805971735385789993",
953 "203956878356401977405765866929034577280193993314348263094772646453283062722701277632936616063144088173312372882677123879538709400158306567338328279154499698366071906766440037074217117805690872792848149112022286332144876183376326512083574821647933992961249917319836219304274280243803104015000563790123",
956 var composites = []string{
957 "21284175091214687912771199898307297748211672914763848041968395774954376176754",
958 "6084766654921918907427900243509372380954290099172559290432744450051395395951",
959 "84594350493221918389213352992032324280367711247940675652888030554255915464401",
960 "82793403787388584738507275144194252681",
963 func TestProbablyPrime(t *testing.T) {
968 for i, s := range primes {
969 p, _ := new(Int).SetString(s, 10)
970 if !p.ProbablyPrime(nreps) {
971 t.Errorf("#%d prime found to be non-prime (%s)", i, s)
975 for i, s := range composites {
976 c, _ := new(Int).SetString(s, 10)
977 if c.ProbablyPrime(nreps) {
978 t.Errorf("#%d composite found to be prime (%s)", i, s)
986 type intShiftTest struct {
992 var rshTests = []intShiftTest{
1007 {"-100", 100, "-1"},
1008 {"4294967296", 0, "4294967296"},
1009 {"4294967296", 1, "2147483648"},
1010 {"4294967296", 2, "1073741824"},
1011 {"18446744073709551616", 0, "18446744073709551616"},
1012 {"18446744073709551616", 1, "9223372036854775808"},
1013 {"18446744073709551616", 2, "4611686018427387904"},
1014 {"18446744073709551616", 64, "1"},
1015 {"340282366920938463463374607431768211456", 64, "18446744073709551616"},
1016 {"340282366920938463463374607431768211456", 128, "1"},
1019 func TestRsh(t *testing.T) {
1020 for i, test := range rshTests {
1021 in, _ := new(Int).SetString(test.in, 10)
1022 expected, _ := new(Int).SetString(test.out, 10)
1023 out := new(Int).Rsh(in, test.shift)
1025 if !isNormalized(out) {
1026 t.Errorf("#%d: %v is not normalized", i, *out)
1028 if out.Cmp(expected) != 0 {
1029 t.Errorf("#%d: got %s want %s", i, out, expected)
1034 func TestRshSelf(t *testing.T) {
1035 for i, test := range rshTests {
1036 z, _ := new(Int).SetString(test.in, 10)
1037 expected, _ := new(Int).SetString(test.out, 10)
1038 z.Rsh(z, test.shift)
1040 if !isNormalized(z) {
1041 t.Errorf("#%d: %v is not normalized", i, *z)
1043 if z.Cmp(expected) != 0 {
1044 t.Errorf("#%d: got %s want %s", i, z, expected)
1049 var lshTests = []intShiftTest{
1060 {"4294967296", 0, "4294967296"},
1061 {"4294967296", 1, "8589934592"},
1062 {"4294967296", 2, "17179869184"},
1063 {"18446744073709551616", 0, "18446744073709551616"},
1064 {"9223372036854775808", 1, "18446744073709551616"},
1065 {"4611686018427387904", 2, "18446744073709551616"},
1066 {"1", 64, "18446744073709551616"},
1067 {"18446744073709551616", 64, "340282366920938463463374607431768211456"},
1068 {"1", 128, "340282366920938463463374607431768211456"},
1071 func TestLsh(t *testing.T) {
1072 for i, test := range lshTests {
1073 in, _ := new(Int).SetString(test.in, 10)
1074 expected, _ := new(Int).SetString(test.out, 10)
1075 out := new(Int).Lsh(in, test.shift)
1077 if !isNormalized(out) {
1078 t.Errorf("#%d: %v is not normalized", i, *out)
1080 if out.Cmp(expected) != 0 {
1081 t.Errorf("#%d: got %s want %s", i, out, expected)
1086 func TestLshSelf(t *testing.T) {
1087 for i, test := range lshTests {
1088 z, _ := new(Int).SetString(test.in, 10)
1089 expected, _ := new(Int).SetString(test.out, 10)
1090 z.Lsh(z, test.shift)
1092 if !isNormalized(z) {
1093 t.Errorf("#%d: %v is not normalized", i, *z)
1095 if z.Cmp(expected) != 0 {
1096 t.Errorf("#%d: got %s want %s", i, z, expected)
1101 func TestLshRsh(t *testing.T) {
1102 for i, test := range rshTests {
1103 in, _ := new(Int).SetString(test.in, 10)
1104 out := new(Int).Lsh(in, test.shift)
1105 out = out.Rsh(out, test.shift)
1107 if !isNormalized(out) {
1108 t.Errorf("#%d: %v is not normalized", i, *out)
1110 if in.Cmp(out) != 0 {
1111 t.Errorf("#%d: got %s want %s", i, out, in)
1114 for i, test := range lshTests {
1115 in, _ := new(Int).SetString(test.in, 10)
1116 out := new(Int).Lsh(in, test.shift)
1117 out.Rsh(out, test.shift)
1119 if !isNormalized(out) {
1120 t.Errorf("#%d: %v is not normalized", i, *out)
1122 if in.Cmp(out) != 0 {
1123 t.Errorf("#%d: got %s want %s", i, out, in)
1128 var int64Tests = []int64{
1136 9223372036854775807,
1137 -9223372036854775807,
1138 -9223372036854775808,
1141 func TestInt64(t *testing.T) {
1142 for i, testVal := range int64Tests {
1143 in := NewInt(testVal)
1147 t.Errorf("#%d got %d want %d", i, out, testVal)
1152 var uint64Tests = []uint64{
1159 9223372036854775807,
1160 9223372036854775808,
1161 18446744073709551615, // 1<<64 - 1
1164 func TestUint64(t *testing.T) {
1166 for i, testVal := range uint64Tests {
1167 in.SetUint64(testVal)
1171 t.Errorf("#%d got %d want %d", i, out, testVal)
1174 str := fmt.Sprint(testVal)
1175 strOut := in.String()
1177 t.Errorf("#%d.String got %s want %s", i, strOut, str)
1182 var bitwiseTests = []struct {
1184 and, or, xor, andNot string
1186 {"0x00", "0x00", "0x00", "0x00", "0x00", "0x00"},
1187 {"0x00", "0x01", "0x00", "0x01", "0x01", "0x00"},
1188 {"0x01", "0x00", "0x00", "0x01", "0x01", "0x01"},
1189 {"-0x01", "0x00", "0x00", "-0x01", "-0x01", "-0x01"},
1190 {"-0xaf", "-0x50", "-0xf0", "-0x0f", "0xe1", "0x41"},
1191 {"0x00", "-0x01", "0x00", "-0x01", "-0x01", "0x00"},
1192 {"0x01", "0x01", "0x01", "0x01", "0x00", "0x00"},
1193 {"-0x01", "-0x01", "-0x01", "-0x01", "0x00", "0x00"},
1194 {"0x07", "0x08", "0x00", "0x0f", "0x0f", "0x07"},
1195 {"0x05", "0x0f", "0x05", "0x0f", "0x0a", "0x00"},
1196 {"0x013ff6", "0x9a4e", "0x1a46", "0x01bffe", "0x01a5b8", "0x0125b0"},
1197 {"-0x013ff6", "0x9a4e", "0x800a", "-0x0125b2", "-0x01a5bc", "-0x01c000"},
1198 {"-0x013ff6", "-0x9a4e", "-0x01bffe", "-0x1a46", "0x01a5b8", "0x8008"},
1200 "0x1000009dc6e3d9822cba04129bcbe3401",
1201 "0xb9bd7d543685789d57cb918e833af352559021483cdb05cc21fd",
1202 "0x1000001186210100001000009048c2001",
1203 "0xb9bd7d543685789d57cb918e8bfeff7fddb2ebe87dfbbdfe35fd",
1204 "0xb9bd7d543685789d57ca918e8ae69d6fcdb2eae87df2b97215fc",
1205 "0x8c40c2d8822caa04120b8321400",
1208 "0x1000009dc6e3d9822cba04129bcbe3401",
1209 "-0xb9bd7d543685789d57cb918e833af352559021483cdb05cc21fd",
1210 "0x8c40c2d8822caa04120b8321401",
1211 "-0xb9bd7d543685789d57ca918e82229142459020483cd2014001fd",
1212 "-0xb9bd7d543685789d57ca918e8ae69d6fcdb2eae87df2b97215fe",
1213 "0x1000001186210100001000009048c2000",
1216 "-0x1000009dc6e3d9822cba04129bcbe3401",
1217 "-0xb9bd7d543685789d57cb918e833af352559021483cdb05cc21fd",
1218 "-0xb9bd7d543685789d57cb918e8bfeff7fddb2ebe87dfbbdfe35fd",
1219 "-0x1000001186210100001000009048c2001",
1220 "0xb9bd7d543685789d57ca918e8ae69d6fcdb2eae87df2b97215fc",
1221 "0xb9bd7d543685789d57ca918e82229142459020483cd2014001fc",
1225 type bitFun func(z, x, y *Int) *Int
1227 func testBitFun(t *testing.T, msg string, f bitFun, x, y *Int, exp string) {
1228 expected := new(Int)
1229 expected.SetString(exp, 0)
1231 out := f(new(Int), x, y)
1232 if out.Cmp(expected) != 0 {
1233 t.Errorf("%s: got %s want %s", msg, out, expected)
1237 func testBitFunSelf(t *testing.T, msg string, f bitFun, x, y *Int, exp string) {
1240 expected := new(Int)
1241 expected.SetString(exp, 0)
1243 self = f(self, self, y)
1244 if self.Cmp(expected) != 0 {
1245 t.Errorf("%s: got %s want %s", msg, self, expected)
1249 func altBit(x *Int, i int) uint {
1250 z := new(Int).Rsh(x, uint(i))
1251 z = z.And(z, NewInt(1))
1252 if z.Cmp(new(Int)) != 0 {
1258 func altSetBit(z *Int, x *Int, i int, b uint) *Int {
1260 m := one.Lsh(one, uint(i))
1265 return z.AndNot(x, m)
1267 panic("set bit is not 0 or 1")
1270 func testBitset(t *testing.T, x *Int) {
1272 z := new(Int).Set(x)
1273 z1 := new(Int).Set(x)
1274 for i := 0; i < n+10; i++ {
1276 old1 := altBit(z1, i)
1278 t.Errorf("bitset: inconsistent value for Bit(%s, %d), got %v want %v", z1, i, old, old1)
1280 z := new(Int).SetBit(z, i, 1)
1281 z1 := altSetBit(new(Int), z1, i, 1)
1283 t.Errorf("bitset: bit %d of %s got 0 want 1", i, x)
1286 t.Errorf("bitset: inconsistent value after SetBit 1, got %s want %s", z, z1)
1289 altSetBit(z1, z1, i, 0)
1291 t.Errorf("bitset: bit %d of %s got 1 want 0", i, x)
1294 t.Errorf("bitset: inconsistent value after SetBit 0, got %s want %s", z, z1)
1296 altSetBit(z1, z1, i, old)
1299 t.Errorf("bitset: inconsistent value after SetBit old, got %s want %s", z, z1)
1303 t.Errorf("bitset: got %s want %s", z, x)
1307 var bitsetTests = []struct {
1318 {"0x2000000000000000000000000000", 108, 0},
1319 {"0x2000000000000000000000000000", 109, 1},
1320 {"0x2000000000000000000000000000", 110, 0},
1321 {"-0x2000000000000000000000000001", 108, 1},
1322 {"-0x2000000000000000000000000001", 109, 0},
1323 {"-0x2000000000000000000000000001", 110, 1},
1326 func TestBitSet(t *testing.T) {
1327 for _, test := range bitwiseTests {
1329 x.SetString(test.x, 0)
1332 x.SetString(test.y, 0)
1335 for i, test := range bitsetTests {
1337 x.SetString(test.x, 0)
1340 t.Errorf("#%d got %v want %v", i, b, test.b)
1344 z.SetBit(NewInt(0), 2, 1)
1345 if z.Cmp(NewInt(4)) != 0 {
1346 t.Errorf("destination leaked into result; got %s want 4", z)
1350 func BenchmarkBitset(b *testing.B) {
1355 for i := b.N - 1; i >= 0; i-- {
1356 z.SetBit(z, i&512, 1)
1360 func BenchmarkBitsetNeg(b *testing.B) {
1365 for i := b.N - 1; i >= 0; i-- {
1366 z.SetBit(z, i&512, 0)
1370 func BenchmarkBitsetOrig(b *testing.B) {
1372 altSetBit(z, z, 512, 1)
1375 for i := b.N - 1; i >= 0; i-- {
1376 altSetBit(z, z, i&512, 1)
1380 func BenchmarkBitsetNegOrig(b *testing.B) {
1382 altSetBit(z, z, 512, 0)
1385 for i := b.N - 1; i >= 0; i-- {
1386 altSetBit(z, z, i&512, 0)
1390 func TestBitwise(t *testing.T) {
1393 for _, test := range bitwiseTests {
1394 x.SetString(test.x, 0)
1395 y.SetString(test.y, 0)
1397 testBitFun(t, "and", (*Int).And, x, y, test.and)
1398 testBitFunSelf(t, "and", (*Int).And, x, y, test.and)
1399 testBitFun(t, "andNot", (*Int).AndNot, x, y, test.andNot)
1400 testBitFunSelf(t, "andNot", (*Int).AndNot, x, y, test.andNot)
1401 testBitFun(t, "or", (*Int).Or, x, y, test.or)
1402 testBitFunSelf(t, "or", (*Int).Or, x, y, test.or)
1403 testBitFun(t, "xor", (*Int).Xor, x, y, test.xor)
1404 testBitFunSelf(t, "xor", (*Int).Xor, x, y, test.xor)
1408 var notTests = []struct {
1416 {"-81910", "81909"},
1418 "298472983472983471903246121093472394872319615612417471234712061",
1419 "-298472983472983471903246121093472394872319615612417471234712062",
1423 func TestNot(t *testing.T) {
1426 expected := new(Int)
1427 for i, test := range notTests {
1428 in.SetString(test.in, 10)
1429 expected.SetString(test.out, 10)
1431 if out.Cmp(expected) != 0 {
1432 t.Errorf("#%d: got %s want %s", i, out, expected)
1435 if out.Cmp(in) != 0 {
1436 t.Errorf("#%d: got %s want %s", i, out, in)
1441 var modInverseTests = []struct {
1447 {"239487239847", "2410312426921032588552076022197566074856950548502459942654116941958108831682612228890093858261341614673227141477904012196503648957050582631942730706805009223062734745341073406696246014589361659774041027169249453200378729434170325843778659198143763193776859869524088940195577346119843545301547043747207749969763750084308926339295559968882457872412993810129130294592999947926365264059284647209730384947211681434464714438488520940127459844288859336526896320919633919"},
1450 func TestModInverse(t *testing.T) {
1451 var element, prime Int
1453 for i, test := range modInverseTests {
1454 (&element).SetString(test.element, 10)
1455 (&prime).SetString(test.prime, 10)
1456 inverse := new(Int).ModInverse(&element, &prime)
1457 inverse.Mul(inverse, &element)
1458 inverse.Mod(inverse, &prime)
1459 if inverse.Cmp(one) != 0 {
1460 t.Errorf("#%d: failed (e·e^(-1)=%s)", i, inverse)
1465 var encodingTests = []string{
1466 "-539345864568634858364538753846587364875430589374589",
1477 "298472983472983471903246121093472394872319615612417471234712061",
1480 func TestIntGobEncoding(t *testing.T) {
1481 var medium bytes.Buffer
1482 enc := gob.NewEncoder(&medium)
1483 dec := gob.NewDecoder(&medium)
1484 for _, test := range encodingTests {
1485 medium.Reset() // empty buffer for each test case (in case of failures)
1487 tx.SetString(test, 10)
1488 if err := enc.Encode(&tx); err != nil {
1489 t.Errorf("encoding of %s failed: %s", &tx, err)
1492 if err := dec.Decode(&rx); err != nil {
1493 t.Errorf("decoding of %s failed: %s", &tx, err)
1495 if rx.Cmp(&tx) != 0 {
1496 t.Errorf("transmission of %s failed: got %s want %s", &tx, &rx, &tx)
1501 // Sending a nil Int pointer (inside a slice) on a round trip through gob should yield a zero.
1502 // TODO: top-level nils.
1503 func TestGobEncodingNilIntInSlice(t *testing.T) {
1504 buf := new(bytes.Buffer)
1505 enc := gob.NewEncoder(buf)
1506 dec := gob.NewDecoder(buf)
1508 var in = make([]*Int, 1)
1509 err := enc.Encode(&in)
1511 t.Errorf("gob encode failed: %q", err)
1514 err = dec.Decode(&out)
1516 t.Fatalf("gob decode failed: %q", err)
1519 t.Fatalf("wrong len; want 1 got %d", len(out))
1522 if out[0].Cmp(&zero) != 0 {
1523 t.Errorf("transmission of (*Int)(nill) failed: got %s want 0", out)
1527 func TestIntJSONEncoding(t *testing.T) {
1528 for _, test := range encodingTests {
1530 tx.SetString(test, 10)
1531 b, err := json.Marshal(&tx)
1533 t.Errorf("marshaling of %s failed: %s", &tx, err)
1536 if err := json.Unmarshal(b, &rx); err != nil {
1537 t.Errorf("unmarshaling of %s failed: %s", &tx, err)
1539 if rx.Cmp(&tx) != 0 {
1540 t.Errorf("JSON encoding of %s failed: got %s want %s", &tx, &rx, &tx)
1545 var intVals = []string{
1546 "-141592653589793238462643383279502884197169399375105820974944592307816406286",
1547 "-1415926535897932384626433832795028841971",
1553 "1415926535897932384626433832795028841971",
1554 "141592653589793238462643383279502884197169399375105820974944592307816406286",
1557 func TestIntJSONEncodingTextMarshaller(t *testing.T) {
1558 for _, num := range intVals {
1560 tx.SetString(num, 0)
1561 b, err := json.Marshal(&tx)
1563 t.Errorf("marshaling of %s failed: %s", &tx, err)
1567 if err := json.Unmarshal(b, &rx); err != nil {
1568 t.Errorf("unmarshaling of %s failed: %s", &tx, err)
1571 if rx.Cmp(&tx) != 0 {
1572 t.Errorf("JSON encoding of %s failed: got %s want %s", &tx, &rx, &tx)
1577 func TestIntXMLEncodingTextMarshaller(t *testing.T) {
1578 for _, num := range intVals {
1580 tx.SetString(num, 0)
1581 b, err := xml.Marshal(&tx)
1583 t.Errorf("marshaling of %s failed: %s", &tx, err)
1587 if err := xml.Unmarshal(b, &rx); err != nil {
1588 t.Errorf("unmarshaling of %s failed: %s", &tx, err)
1591 if rx.Cmp(&tx) != 0 {
1592 t.Errorf("XML encoding of %s failed: got %s want %s", &tx, &rx, &tx)
1597 func TestIssue2607(t *testing.T) {
1598 // This code sequence used to hang.
1600 n.Rand(rand.New(rand.NewSource(9)), n)