big.Int

已于 2023-05-31 15:38:10 修改
阅读量1.4k 收藏
点赞数
分类专栏： Go 文章标签： golang big.Int
于 2023-05-31 15:36:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tcattime/article/details/130970251
版权

big.Int是Go超大整型数据的结构。它可以进行超大收据的运算和比较等操作。

初始化

通过整型字面量或int64创建

big.NewInt函数可以基于一个int64整型数据或整型字面量创建一个big.Int实例：

package main

import "math/big"

func main() {
	var (
		num int = 6
	)
	number1 := big.NewInt(int64(num))
	
	number2 := big.NewInt(6)
}

通过字符串创建

big.Int实例的SetString方法可以通过字符串来创建一个big.Int实例。该方法返回两个数据，一个big.Int实例，和一个bool值用来表示成功还是失败。

package main

import (
	"fmt"
	"math/big"
)

func main() {
	number, ok := new(big.Int).SetString("123000001230011", 10)
	if !ok {
		fmt.Println("create big.Int failed")
		return
	}
	fmt.Println(number)
	// 123000001230011
}

SetString允许指定数字的进制。创建的结果仍然是十进制的大整型数据：

package main

import (
	"fmt"
	"math/big"
)

func main() {
	number, ok := new(big.Int).SetString("110000011010101010101", 2)
	if !ok {
		fmt.Println("create big.Int failed")
		return
	}
	fmt.Println(number)
	// 1586517
}

运算

加

使用Add方法进行加法运算。需要注意的是Add方法返回一个big.Int实例，但通过地址不难看出，返回的实例与第一个加数相同。

package main

import (
	"fmt"
	"math/big"
)

func main() {
	number1 := big.NewInt(123)
	number2 := big.NewInt(456)
	result := number1.Add(number1, number2)
	fmt.Println(result, number1, number2)
	// 579 579 456
	println(result, number1, number2)
	// 0x140000b0000 0x140000b0000 0x140000b0020
}

减

Sub方法进行减法运算，并与加法参数和返回值相似：

package main

import (
	"fmt"
	"math/big"
)

func main() {
	number1 := big.NewInt(123)
	number2 := big.NewInt(456)
	result := number1.Sub(number1, number2)
	fmt.Println(result, number1, number2)
	// -333 -333 456
	println(result, number1, number2)
	// 0x14000132000 0x14000132000 0x14000132020
}

乘

Mul用于乘法运算：

package main

import (
	"fmt"
	"math/big"
)

func main() {
	number1 := big.NewInt(123)
	number2 := big.NewInt(456)
	result := number1.Mul(number1, number2)
	fmt.Println(result, number1, number2)
	// 56088 56088 456
	println(result, number1, number2)
	// 0x14000132000 0x14000132000 0x14000132020
}

除

Quo用于除法运算：

package main

import (
	"fmt"
	"math/big"
)

func main() {
	number1 := big.NewInt(400)
	number2 := big.NewInt(100)
	result := number1.Quo(number1, number2)
	fmt.Println(result, number1, number2)
	// 4 4 100
	println(result, number1, number2)
	// 0x14000132000 0x14000132000 0x14000132020
}

如果除数为0，那么panic: division by zero被抛出：

package main

import (
	"fmt"
	"math/big"
)

func main() {
	defer func() {
		err := recover()
		if err != nil {
			fmt.Println(err)
			// division by zero
		}
	}()
	
	number1 := big.NewInt(7)
	number2 := big.NewInt(0)
	result := number1.Quo(number1, number2)
	fmt.Println(result, number1, number2)
	println(result, number1, number2)
}

求余

Rem用于求余运算：

package main

import (
	"fmt"
	"math/big"
)

func main() {
	number1 := big.NewInt(7)
	number2 := big.NewInt(3)
	result := number1.Rem(number1, number2)
	fmt.Println(result, number1, number2)
	// 1 1 3
	println(result, number1, number2)
	// 0x14000132000 0x14000132000 0x14000132020
}

如果除数为0，那么panic: division by zero被抛出：

package main

import (
	"fmt"
	"math/big"
)

func main() {
	defer func() {
		err := recover()
		if err != nil {
			fmt.Println(err)
			// division by zero
		}
	}()

	number1 := big.NewInt(7)
	number2 := big.NewInt(0)
	result := number1.Rem(number1, number2)
	fmt.Println(result, number1, number2)
	// 1 1 3
	println(result, number1, number2)
	// 0x14000132000 0x14000132000 0x14000132020
}

绝对值

Abs方法获取big.Int实例的绝对值，返回的值仍然是一个big.Int实例：

package main

import (
	"fmt"
	"math/big"
)

func main() {
	number := big.NewInt(-7)
	result := number.Abs(number)
	fmt.Println(result, number)
	// 7 7
	println(result, number)
	// 0x14000132000 0x14000132000
}

比较

Cmp方法用于比较两个big.Int实例的数值大小，CmpAbs方法用于比较两个big.Int实例数值绝对值大小。

  • 若number1 > number2，Cmp/CmpAbs方法返回1
  • 若number1 = number2，Cmp/CmpAbs方法返回0
  • 若number1 < number2，Cmp/CmpAbs方法返回-1
package main

import (
	"fmt"
	"math/big"
)

func main() {
	number1 := big.NewInt(200)
	number2 := big.NewInt(500)
	number3 := big.NewInt(200)

	result := number1.Cmp(number2)
	fmt.Println(result)
	// -1

	result = number2.Cmp(number3)
	fmt.Println(result)
	// 1

	result = number1.Cmp(number3)
	fmt.Println(result)
	// 0

	number4 := big.NewInt(-200)
	result = number4.CmpAbs(number1)
	fmt.Println(result)
	// 0
}

移位

Lsh方法进行位左移运算，Rsh方法进行位右移运算。

package main

import (
	"fmt"
	"math/big"
)

func main() {
	number1 := big.NewInt(4)
	// same as 4 << 1
	result := number1.Lsh(number1, 1)
	fmt.Println(result, number1) // 8 8
	println(result, number1)     // 0x14000132000 0x14000132000

	number2 := big.NewInt(-4)
	// same as -4 >> 1
	result = number2.Rsh(number2, 1)
	fmt.Println(result, number2) // -2 -2
	println(result, number2)     // 0x14000128020 0x14000128020
}

与

And方法进行与运算：

package main

import (
	"fmt"
	"math/big"
)

func main() {
	number1 := big.NewInt(9)
	number2 := big.NewInt(3)

	// Same as 9 & 3
	result := number1.And(number1, number2)
	fmt.Println(result, number1, number2) // 1 1 3
	println(result, number1, number2)     // 0x14000132000 0x14000132000 0x14000132020
}

或

Or方法进行或运算：

package main

import (
	"fmt"
	"math/big"
)

func main() {
	number1 := big.NewInt(5)
	number2 := big.NewInt(3)

	// Same as 5 | 3
	result := number1.Or(number1, number2)
	fmt.Println(result, number1, number2) // 7 7 3
	println(result, number1, number2)     // 0x14000132000 0x14000132000 0x14000132020
}

亦或

Xor方法进行亦或运算：

package main

import (
	"fmt"
	"math/big"
)

func main() {
	number1 := big.NewInt(5)
	number2 := big.NewInt(3)

	// Same as 5 ^ 3
	result := number1.Xor(number1, number2)
	fmt.Println(result, number1, number2) // 6 6 3
	println(result, number1, number2)     // 0x14000132000 0x14000132000 0x14000132020
}

非

Not方法进行非运算：

package main

import (
	"fmt"
	"math/big"
)

func main() {
	number := big.NewInt(7)
	result := number.Not(number)
	fmt.Println(result, number) // -8, -8
	println(result, number)     // 0x14000132000 0x14000132000
}

按位清除

c = a &^ b

b转换为二进制后，值为1的位置对应c的位置为0，c中剩余比特值与a对应位置的比特值相等。

例如 0110 &^ 1011 = 0100

在big.Int实例中，提供了AndNot方法来执行按位清除运算：

package main

import (
	"fmt"
	"math/big"
)

func main() {
	number1 := big.NewInt(5)
	number2 := big.NewInt(11)

	// Same as 5 &^ 11
	result := number1.AndNot(number1, number2)
	fmt.Println(result, number1, number2) // 4 4 11
	println(result, number1, number2)     // 0x14000132000 0x14000132000 0x14000132020
}

开方

Sqrt方法提供了开方运算，并返回结果的绝对值。其返回值也是一个big.Int实例：

package main

import (
   "fmt"
   "math/big"
)

func main() {
   number := big.NewInt(9)
   result := number.Sqrt(number)
   fmt.Println(result, number) // 3 3
   println(result, number)     // 0x14000128000 0x14000128000
}

如果被开方的结果不能用一个整数来表示，那么Sqrt方法返回一个最接近该值的整数。因此在涉及高精度计算时，不建议采用Sqrt方法。

package main

import (
   "fmt"
   "math/big"
)

func main() {
   number := big.NewInt(7)
   result := number.Sqrt(number)
   fmt.Println(result, number) // 2 2
   println(result, number)     // 0x14000128000 0x14000128000
}

如果被开方的数字是个负数，那么panic会被抛出：

package main

import (
   "fmt"
   "math/big"
)

func main() {
   number := big.NewInt(-9)  // panic: square root of negative number
   result := number.Sqrt(number)
   fmt.Println(result, number)
   println(result, number)
}

类型转换

big.Int提供了一些类型转换的API，可供使用者将big.Int实例转换成期望的结果。

string

可使用String方法或fmt包中的格式化函数将big.Int转换成字符串：

package main

import (
	"fmt"
	"math/big"
)

func main() {
	number := big.NewInt(531)

	numberString := number.String()
	fmt.Println(numberString)
	// 531

	numberString = fmt.Sprint(number)
	fmt.Println(numberString)
	// 531
}

int64

Int64方法将big.Int实例转换为int64整数。

package main

import (
	"fmt"
	"math/big"
)

func main() {
	number := big.NewInt(531)

	number64 := number.Int64()
	fmt.Println(number64)
	// 531
}

如果big.Int表示的数据超出int64的最大范围（-9223372036854775808 ~ 9223372036854775807），转换的结果是不准确的。

package main

import (
	"fmt"
	"math/big"
)

func main() {
	number, ok := new(big.Int).SetString("9223372036854775809", 10)
	if !ok {
		fmt.Println("create big.Int failed")
		return
	}

	number64 := number.Int64()
	fmt.Println(number64)
	// -9223372036854775807
}

为了避免这种情况的发生，我们可以使用IsInt64方法判断big.Int实例是否可以正确转换成int64：

package main

import (
	"fmt"
	"math/big"
)

func main() {
	number, ok := new(big.Int).SetString("9223372036854775809", 10)
	if !ok {
		fmt.Println("create big.Int failed")
		return
	}

	if !number.IsInt64() {
		fmt.Println("can not be represented as an int64")
		return
	}
	
	// ...
}

uint64

big.Int提供了Uint64和IsUint64方法，用来将big.Int实例转换为uint64类型和判断是否可以转换。其用法与Int64和IsInt64类似，这里不再赘述。

[]byte

使用Bytes方法将big.Int实例的绝对值转换为[]byte：

package main

import (
	"fmt"
	"math/big"
)

func main() {
	number1 := big.NewInt(512)
	fmt.Println(number1.Bytes())
	// [2 0]

	number2 := big.NewInt(-512)
	fmt.Println(number2.Bytes())
	// [2 0]
}

其它

获取比特数

BitLen方法返回一个int数值表示big.Int实例绝对值的比特长度：

package main

import (
	"fmt"
	"math/big"
)

func main() {
	number := big.NewInt(8)
	fmt.Println(number.BitLen()) // 4
}
TCatTime
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Go 语言 big.Int
关于代码的那些事
09-27 1万+
简介 math/big 作为 Go 语言提供的进行大数操作的官方库，在以太坊 Ethereum 项目中作为 currency 的类型表示得到了广泛的使用，这篇文章主要介绍该库的使用。 官方包解析 在官方的 math/big 包中，Int 类型定义如下： // An Int represents a signed multi-precision integer. // The zero v...
Big-Int-P.rar_Big!
09-20
我有一个简单的问题:给出两个大整数a,b,你的工作就是求其中a+b的和
golang--基本数据类型,big.Int类型,类型转换
weixin_42248522的博客
07-30 9313
nil 是 interface、function、pointer、map、slice 和 channel 类型变量的默认初始值 不可以用"=="比较类型： slice（切片）、map（key-value集合）、func（函数） map的比较可以使用reflect.DeepEqual() m1 := map[string]string{"one": "a", "two": "b"} m2 := map[string]string{"two": "b", "one": "a"} // 1.map类型
Golang 的大数运算 big.Int 一次赋值引发的血案
Jung_zhang的专栏
09-08 5577
结论先行 在进行 big.Int 类型的简单相互赋值过程中发生了浅拷贝，big.Int 类型数据存储的实体 []uint 并未发生变更，导致出现数据紊乱。 问题引入 在Golang中，标准库提供了big包用来进行大数运算。为了研究它的用法，我编写了下边这个小程序来验证它的特性。程序的逻辑很简单，初始化两个大数变量 a = 1 和 b = 2，然后使用中间变量法对 a 和 b 进行交换，交换完毕后再...
Go语言的big包实现大整数运算
海岛Blog
07-29 2万+
程序虽然写出来了，但是不知道如何用一个大数（例如100位的大数）去初始化一个大数变量，比较遗憾！ Go语言程序： // bigint project main.go package main import ( "fmt" "math" "math/big" ) func main() { // Here are some calculations with bigInts:
go语言big.int类型
qq_30505673的博客
11-20 3447
go语言中内置了big类型的数据，其包含很多常用的方法，比如比较两个大数是否相等，cmp,如果是-1表示前面的数字比较小，0表示相等，1表示前面的数字比较大。 newInt可以对数据进行初始化， 可以轻松从其他的类型的数据得到big类型的数据。 big在椭圆曲线加密中经常会用到。 ...
Big_Int_Calculation.zip_Big!_big in_big int_大数运算
09-21
大数运算的库，速度比较快，可供大家学习使用。
add-two-big-int-numbers.zip_Big!
09-20
该程序的功能主要是实现两个大整数（150位以内）的加法。
Big Int.cpp
11-30
C++大整数应用只包含加法和减法
Mul-of-big-Int.rar_Big!_分治 大整数
09-22
引用分治法实现两个位数相同的大整数的乘法运算
Golang和Ethereum中的big.Int
我不是大牛
05-30 3994
big.Int是golang提供的数据类型，用来处理比较大的整型数，当然它也可以处理诸如64bit，32bit的常用整数。 # /go-1.x/src/math/big/int.go package big type Int struct { neg bool // sign, whether negaive abs nat // absolute va...
GoLang之”奇怪用法“实践总结
热门推荐
delphiwcdj的专栏
11-23 3万+
2013-11-23 wcdj 0 摘要 本文通过对A Tour of Go的实践，总结Go语言的基础用法。 1 Go语言”奇怪用法“有哪些？ 1，go的变量声明顺序是：”先写变量名，再写类型名“，此与C/C++的语法孰优孰劣，可见下文解释： article on Go's declaration syntax 2，go是通过package来组织的（与pytho
go(Golang) big.Int 类型比较
lying_byr的博客
07-03 9386
在进行以太币转账之前，需要比较big.Int格式的余额bigWeiBalance和转账金额bigWeiValue。遇到一个很傻的问题就是big.Int 没有 "<"">"的比较。 比较方法如下： enough := bigWeiBalance.Cmp(bigWeiValue) 原来，big.Int 类自带cmp方法 返回 1：前面的big.Int 实例大于cmp方法big.I...
将int，bigint整型数值可逆转换字符串
weixin_30485799的博客
04-08 601
将 Int 和 BigInt 类型数值转换为字符串的可逆方法，可用于缩短网址或记录的ID转换等。 如： 9223372036854775807 => aZl8N0y58M7 class Convert { /** * 默认密钥字符串 * @var string */ const KEY = '012345678...
go big.int 转float_go 变量传递和切片
weixin_30271235的博客
12-27 432
接触go已经快两年了, 老是想把学过的东西写下来, 但是一直没能行动, 今天算开个头吧. 基础数据类型在golang里有int(int、 int8、 int16、 int32、 int64、 uint、 uint8、 uint16、 uint32、 uint64)、 float(float32、 float64)、 struct、 array、 slice、 map、 interface{}等。 ...
Go *big.Int类型比大小
太阳上的雨天
10-13 559
在进行TRX转账之前，需要比余额和转账金额的大小. aBalance 余额 tBlance转账金额 同为big.Int类型。aBalance < tBlance 返回 -1。aBalance > tBlance 返回 1。aBalance = tBlance 返回 0。使用big.Int.Cmp函数。
big.int除以小数
最新发布
05-17
在大多数编程语言中，整数（如big.int）无法直接除以小数。如果您想要执行这样的操作，需要将大整数转换为浮点数，然后进行除法运算。 例如，在Python中，您可以使用以下代码将大整数除以小数： ``` from decimal import Decimal big_int = 1000000000000000000000 small_float = 0.1 result = Decimal(big_int) / Decimal(str(small_float)) print(result) ``` 在这个例子中，我们将大整数 `big_int` 转换为 `Decimal` 类型，然后将小数 `small_float` 转换为字符串，并使用 `Decimal` 构造函数创建一个 `Decimal` 类型的对象。然后，我们可以使用 `/` 运算符来执行除法运算，得到一个 `Decimal` 类型的结果。 请注意，由于浮点数精度的限制，对于非常大的整数，将其转换为浮点数可能会导致精度丢失。因此，如果需要高精度的运算，建议使用专门的高精度数学库。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值