Golang big.NewInt类(方法)实例源码

func TestCRLCreation(t *testing.T) {
	block, _ := pem.Decode([]byte(pemPrivateKey))
	priv, _ := ParsePKCS1PrivateKey(block.Bytes)
	block, _ = pem.Decode([]byte(pemCertificate))
	cert, _ := ParseCertificate(block.Bytes)

	now := time.SecondsToUTC(1000)
	expiry := time.SecondsToUTC(10000)

	revokedCerts := []pkix.RevokedCertificate{
		{
			SerialNumber:   big.NewInt(1),
			RevocationTime: now,
		},
		{
			SerialNumber:   big.NewInt(42),
			RevocationTime: now,
		},
	}

	crlBytes, err := cert.CreateCRL(rand.Reader, priv, revokedCerts, now, expiry)
	if err != nil {
		t.Errorf("error creating CRL: %s", err)
	}

	_, err = ParseDERCRL(crlBytes)
	if err != nil {
		t.Errorf("error reparsing CRL: %s", err)
	}
}

func spiral_side_len(iter int64) *big.Int {
	//The big package is incredibly awkward, so in case you can't tell,
	// side_len = iter*2 - 1
	n := big.NewInt(0)
	n = n.Add(n.Mul(big.NewInt(iter), big.NewInt(2)), big.NewInt(-1))
	return n
}

func main() {
	ss := new(s_a)
	ss.a = 24
	ss.b = "45"
	ss.b = ss.b + fmt.Sprint(ss.a)
	ss.test()
	n, err := fmt.Print("hello")
	n = n + 1
	fmt.Print(err)
	ss.a, err = strconv.Atoi(ss.b)
	fmt.Print(ss)
	iTest(ss)

	f, err := os.Open("c:\\my.txt", os.O_RDONLY, 0)
	if err != nil {
		return
	}
	defer f.Close()
	var s string
	//  n1, err := fmt.Fscanln(f,"%s",s)
	fr := bufio.NewReader(f)
	s, err = fr.ReadString('\n')
	fmt.Println(s)
	log.Println("log message")

	summa := big.NewInt(0)
	summa.SetString("123454567891234545678912345456789", 0)
	summa2 := big.NewInt(0)
	summa2.SetString("7", 0)
	summa3 := big.NewInt(0)
	summa3.Exp(summa, summa2, nil)
	fmt.Println(summa3)
	_, _ = 4*5, "test"
	_ = "Test"
}

func fibo(n *big.Int) *big.Int {
	s := n.String()
	if r, ok := fiboCache[s]; ok {
		return r
	}

	i0 := big.NewInt(0)
	if n.Cmp(i0) <= 0 {
		return i0
	}
	if n.Cmp(big.NewInt(2)) <= 0 {
		return big.NewInt(1)
	}

	n1 := big.NewInt(-1)
	n1.Add(n1, n)
	n1 = fibo(n1)

	n2 := big.NewInt(-2)
	n2.Add(n2, n)
	n2 = fibo(n2)

	i0.Add(n1, n2)
	fiboCache[s] = i0
	return i0
}

func readRSAKey(x PrivateKey) (*rsa.PrivateKey, os.Error) {
	var k rsa.PrivateKey
	var Ns, Ds, Ps, Qs string
	_, e := fmt.Sscanf(string(x), "N = %s\nE = %d\nD = %s\nP = %s\nQ = %s\n", &Ns, &k.E, &Ds, &Ps, &Qs)
	if e != nil {
		return nil, os.NewError("Couldn't read file: " + e.String())
	}
	var ok = true
	k.N, ok = big.NewInt(0).SetString(Ns, 0)
	if !ok {
		return nil, os.NewError("Unable to read k.N: " + Ns)
	}
	k.D, ok = big.NewInt(0).SetString(Ds, 0)
	if !ok {
		return nil, os.NewError("Unable to read k.D: " + Ds)
	}
	k.P, ok = big.NewInt(0).SetString(Ps, 0)
	if !ok {
		return nil, os.NewError("Unable to read k.P: " + Ps)
	}
	k.Q, ok = big.NewInt(0).SetString(Qs, 0)
	if !ok {
		return nil, os.NewError("Unable to read k.Q: " + Qs)
	}
	return &k, nil
}

func (h *Hash) l2(m []byte, length, iter int) []byte {
	tmpt := h.kdf(192, 128*(iter+1))
	t := tmpt[16*iter : 16*(iter+1)]
	for i := 0; i < 16; i += 4 {
		t[i] &= 31
	}
	k := newInt(t)
	y := big.NewInt(1)

	n := len(m) / 16
	if n != 0 {
		for i := 0; i < n; i++ {
			mi := newInt(m[16*i : 16*(i+1)])
			y.Mod(y.Add(y.Mul(y, k), mi), p127)
		}
	} else {
		y = k
	}

	y.Add(y, new(big.Int).Lsh(big.NewInt(int64(length%l1keylen)), 64))
	y.Mod(y, p127)

	Y := make([]byte, 16)
	copy(Y[16-len(y.Bytes()):], y.Bytes())
	return Y
}

func bitwise_arithmetic_shift_left(x, y Obj) Obj {
	xfx := (uintptr(unsafe.Pointer(x)) & fixnum_mask) == fixnum_tag
	yfx := (uintptr(unsafe.Pointer(y)) & fixnum_mask) == fixnum_tag
	if !yfx {
		panic("bad shift amount")
	}
	amount := uint(uintptr(unsafe.Pointer(y)) >> fixnum_shift)
	if xfx && amount < 32-fixnum_shift {
		i := int64(int(uintptr(unsafe.Pointer(x)) >> fixnum_shift))
		r := i << amount
		if r >= int64(fixnum_min) && r <= int64(fixnum_max) {
			return Obj(unsafe.Pointer(uintptr((r << fixnum_shift) | fixnum_tag)))
		} else {
			return wrap(big.NewInt(r))
		}
	} else if xfx {
		x = wrap(big.NewInt(int64(fixnum_to_int(x))))
	} else if (uintptr(unsafe.Pointer(x)) & heap_mask) != heap_tag {
		panic("bad type")
	}

	switch vx := (*x).(type) {
	case *big.Int:
		var z *big.Int = big.NewInt(0)
		return wrap(z.Lsh(vx, amount))
	}
	panic("bad type")
}

func bitwise_and(x, y Obj) Obj {
	xfx := (uintptr(unsafe.Pointer(x)) & fixnum_mask) == fixnum_tag
	yfx := (uintptr(unsafe.Pointer(y)) & fixnum_mask) == fixnum_tag
	if xfx && yfx {
		i1 := uintptr(unsafe.Pointer(x))
		i2 := uintptr(unsafe.Pointer(y))
		return Obj(unsafe.Pointer(uintptr(i1 & i2)))
	}

	if (!xfx && (uintptr(unsafe.Pointer(x))&heap_mask) != heap_tag) ||
		(!yfx && (uintptr(unsafe.Pointer(y))&heap_mask) != heap_tag) {
		panic("bad type")
	}

	if xfx {
		return bitwise_and(y, x)
	}

	switch vx := (*x).(type) {
	case *big.Int:
		var z *big.Int = big.NewInt(0)
		if yfx {
			vy := big.NewInt(int64(fixnum_to_int(y)))
			return wrap(z.And(vx, vy))
		}
		switch vy := (*y).(type) {
		case *big.Int:
			return wrap(z.And(vx, vy))
		default:
			panic("bad type")
		}
	}
	panic("bad type")
}

// doubleJacobian takes a point in Jacobian coordinates, (x, y, z), and
// returns its double, also in Jacobian form.
func (BitCurve *BitCurve) doubleJacobian(x, y, z *big.Int) (*big.Int, *big.Int, *big.Int) {
	// See http://hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html#doubling-dbl-2009-l

	a := new(big.Int).Mul(x, x) //X1²
	b := new(big.Int).Mul(y, y) //Y1²
	c := new(big.Int).Mul(b, b) //B²

	d := new(big.Int).Add(x, b) //X1+B
	d.Mul(d, d)                 //(X1+B)²
	d.Sub(d, a)                 //(X1+B)²-A
	d.Sub(d, c)                 //(X1+B)²-A-C
	d.Mul(d, big.NewInt(2))     //2*((X1+B)²-A-C)

	e := new(big.Int).Mul(big.NewInt(3), a) //3*A
	f := new(big.Int).Mul(e, e)             //E²

	x3 := new(big.Int).Mul(big.NewInt(2), d) //2*D
	x3.Sub(f, x3)                            //F-2*D
	x3.Mod(x3, BitCurve.P)

	y3 := new(big.Int).Sub(d, x3)                  //D-X3
	y3.Mul(e, y3)                                  //E*(D-X3)
	y3.Sub(y3, new(big.Int).Mul(big.NewInt(8), c)) //E*(D-X3)-8*C
	y3.Mod(y3, BitCurve.P)

	z3 := new(big.Int).Mul(y, z) //Y1*Z1
	z3.Mul(big.NewInt(2), z3)    //3*Y1*Z1
	z3.Mod(z3, BitCurve.P)

	return x3, y3, z3
}

func RabinMiller(p *big.Int) bool {
	pdec := new(big.Int).Sub(p, big.NewInt(1)) // =  p - 1
	big2 := big.NewInt(2)

	for i := 0; i < 20; i++ {
		x := RandNumSmaller(p)
		stg := new(big.Int).Exp(x, pdec, p) // = x^(p-1) mod p
		if stg.Cmp(big1) != 0 {
			return false
		}

		// test na Carmichaelova cisla (kontrola zda x^[(p-1)/2] je +1 nebo -1)
		p2 := new(big.Int).Rsh(p, 1) // = (p - 1)/2
		for {
			stg.Exp(x, p2, p)
			if stg.Cmp(pdec) == 0 {
				break
			}
			if stg.Cmp(big1) != 0 {
				return false
			}
			_, res := p2.Div(p2, big2)
			if res.Cmp(big1) == 0 {
				break
			}
		}
	}
	return true
}

func factorial(num int) (ret *big.Int) {
	ret = big.NewInt(1)
	for i := num; i > 0; i-- {
		ret = ret.Mul(ret, big.NewInt(int64(i)))
	}
	return
}

func main() {
	flag.Parse()
	m := int64(*nrows)

	//Setup  profiling
	if *cpuprofile != "" {
		f, err := os.Create(*cpuprofile)
		if err != nil {
			log.Fatal(err)
		}
		pprof.StartCPUProfile(f)
		defer pprof.StopCPUProfile()
	}

	if *memprofile != "" {
		f, err := os.Create(*memprofile)
		if err != nil {
			log.Fatal(err)
		}
		pprof.WriteHeapProfile(f)
		f.Close()
		return
	}

	prev := make([]*big.Int, 1)
	one := big.NewInt(int64(1))
	prev[0] = one
	x := big.NewInt(int64(0))

	for row := int64(1); row < m; row++ {
		curr := make([]*big.Int, 1, row+1)
		curr[0] = one

		mid := int64(row/2) + 1
		var right int64
		if math.Fmod(float64(row), 2.0) == 0 {
			right = mid - 1
		} else {
			right = mid
		}

		for j := int64(1); j < mid; j++ {
			x = x.Add(prev[j-1], prev[j])
			curr = append(curr, x)
			x = big.NewInt(int64(0))
		}

		// Take a slice of the first half of the row, reverse it, and
		// append to the current row.
		s := make([]*big.Int, right)
		r := curr[0:right]
		copy(s, r)
		rev := reverse(s)
		curr = append(curr, rev...)
		//fmt.Println(curr)

		prev = curr[:]
	}
}

func (b Base58) Base582Big() *big.Int {
	answer := new(big.Int)
	for i := 0; i < len(b); i++ {
		answer.Mul(answer, big.NewInt(58))                              //multiply current value by 58
		answer.Add(answer, big.NewInt(int64(revalp[string(b[i:i+1])]))) //add value of the current letter
	}
	return answer
}

func main() {
	for x := 0; x < 100000; x++ {
		a := big.NewInt(1)
		for i := 200; i < 221; i++ {
			a.Mul(big.NewInt(int64(i+x)), a)
		}
	}
}

func Factorial(val *big.Int) *big.Int {
	result := big.NewInt(int64(1))

	for mult := big.NewInt(int64(1)); mult.Cmp(val) != 1; mult = mult.Add(mult, big.NewInt(int64(1))) {
		result = result.Mul(result, mult)
	}
	return result
}

func prod(n int) *big.Int {
	prod := big.NewInt(1)
	i, inc := big.NewInt(1), big.NewInt(1)
	for ; n > 0; n-- {
		prod.Mul(prod, i)
		i.Add(i, inc)
	}
	return prod
}

func TestRatSub(t *testing.T) {
	fmt.Println("Testing RatSub")
	x := big.NewRat(0, 1).Sub(big.NewRat(1, 3), big.NewRat(1, 2))
	fmt.Print("x ")
	fmt.Println(x)
	if (x.Num().Cmp(big.NewInt(-1)) != 0) || (x.Denom().Cmp(big.NewInt(6)) != 0) {
		t.Error("Num and Denom don't match")
	}
}

func make_fibonacci() func() *big.Int {
	last, next := big.NewInt(1), big.NewInt(1)
	return func() *big.Int {
		tmp := new(big.Int).Set(last)
		last.Set(next)
		next.Add(tmp, next)
		return tmp
	}
}

func bigfact(n *big.Int) *big.Int {
	one := big.NewInt(1)
	if one.Cmp(n) == 0 {
		return n
	}
	o := big.NewInt(0).Set(n)
	p := big.NewInt(0).Set(n)
	return o.Mul(o, bigfact(p.Sub(p, one)))
}

func fact(n int) *big.Int {
	if n <= 1 {
		return big.NewInt(1)
	}

	r := big.NewInt(int64(n))

	return r.Mul(r, fact(n-1))
}