我的Go+语言初体验——（6）整型有理数数据类型

“我的Go+语言初体验” | 征文活动进行中…

Go+ 语言使用后缀 ‘r’ 表示有理数，支持整型、分数型、浮点型三种有理数数据类型（Rational number）。
在整型有理数变量声明时，可以同时对变量赋值；如果对整型有理数变量只声明而没有赋值，其初始值不是 0，而是 <nil>。
整型有理数的基本运算如加减乘除与通常的整数运算相同，按照先乘除、后加减的顺序进行运算。
整型有理数变量可以与整型有理数类型的常数、分数形式的有理数类型的常数和整型常数进行运算，不能与浮点数类型的常数进行运算。
整型有理数变量可以与整型变量进行运算，运算结果为整型有理数。不允许对整型有理数与浮点型变量进行运算。

1. 有理数数据类型

在数学上，数字分为实数和复数，实数分为有理数和无理数。有理数是整数和分数的集合，整数可以表示为分母为 1 的分数，因此可以用分数来表示任意的有理数。

在计算机语言中，数据类型是数据的一种属性，类型系统提供了各种数据类型的定义、实现和使用方法。大多数编程语言支持数字的数据类型有：无符号整数、有符号整数、浮点数和复数类型，有些类型还可以进一步分为不同的位数，如 8位、16位、32位和64位。但是，现有计算机语言中，几乎都没有提供有理数数据类型，一些计算机语言允许用户定义有理数数据结构。

Go+ 语言除了这些常用的数字类型之外，还支持有理数（Rational number）数据类型。

Go+ 语言中使用后缀 ‘r’ 表示有理数，支持整型、分数型、浮点型三种有理数数据类型：

**bigint：整型有理数。**支持 64位以上的大整数，例如 “1r<<65” 的值等于 2 的 65 次幂，“1r<<65 - 100” 的值等于 2 的 65 次幂减去 100 的结果。

**bigrat：分数型有理数。**支持分数形式表示的有理数，例如 “4/5r” 的值等于分数 4/5。

bigfloat：浮点型有理数0支持浮点数形式表示的有理数。

2. 整型有理数的变量声明与赋值

2.1 变量声明与赋值

Go+ 语言使用 var 关键字声明变量，整型有理数的变量声明方法如下：

var varname bigint // 声明变量 varname 为 bigint 类型

【例程 1】变量声明

// Example 1: declaration and assignment of bigint type variables
import "reflect"
var bint1 bigint = 1r << 100
var bint2 bigintprintln reflect.TypeOf(bint1), ", bint1 =: ", bint1
println reflect.TypeOf(bint2), ", bint2 =: ", bint2/* Running results：
builtin.Gop_bigint , bint1 =:  1267650600228229401496703205376
builtin.Gop_bigint , bint2 =:  <nil>
*/

程序说明：

（1）在整型有理数变量 bint1 声明时，可以同时对变量 bint1 赋值。“1r << 100” 的值等于 2 的 100 次幂。
（2）对整型有理数变量 bint2 只声明而没有赋值，其初始值不是 0，而是 “<nil>”。

2.2 不指定变量类型

Go+ 语言允许不通过 var 声明变量，在不指定变量类型而直接对变量进行初始化并赋值，编译器将自动推导变量类型。但需要注意的是，如果初始化的数值没有后缀 ‘r’，系统将优先将其识别为整型变量 int。

【例程 2】变量初始化时不指定类型

// Example 2: variable initialization without specified type
import "reflect"
bint3 := 306
bint4 := 306r
bint5 := 9223372036854775807
bint6 := 9223372036854775808r
//bint6 := 9223372036854775808 // constant 9223372036854775808 overflows intprintln reflect.TypeOf(bint3), ", bint3 =: ", bint3
println reflect.TypeOf(bint4), ", bint4 =: ", bint4
println reflect.TypeOf(bint5), ", bint5 =: ", bint5
println reflect.TypeOf(bint6), ", bint6 =: ", bint6/* Running results：
int , bint3 =:  306
builtin.Gop_bigint , bint4 =:  306
int , bint5 =:  9223372036854775807
builtin.Gop_bigint , bint6 =:  9223372036854775808
*/

程序说明：

（1）Go+ 语言中的整型变量 int64 的取值范围是：-9223372036854775808 ~ 9223372036854775807。在此范围内的整数，带有后缀 ‘r’ 则被识别为整型有理数变量，不带后缀 ‘r’ 则被识别为整型变量 int。
（2）在初始化变量时，如果赋值的数值不带后缀 ‘r’，编译器识别变量为整型变量 int，如 bint3, bint5。
（3）在初始化变量时，如果赋值的数值带有后缀 ‘r’，识别变量为整型有理数变量 bigint，如 bint4, bint6。
（4）但是，超出 int64 取值范围的大整数（如：9223372036854775808），如果不带后缀 ‘r’ 就会报错。

2.3 用表达式对变量赋值

【例程 3】使用表达式对整型有理数变量赋值

// Example 3: assigning values to variables using expressions
// bigint type, is allowed to define large integers bigger than int64
var bint7 bigint = 1r << 65      // the value is equal to the 65th power of 2
var bint8 bigint = 1r<<65 - 100  // expression is allowed in definition
var bint9 bigint = -3r<<36 + 200 // define a negative integer rational
var bint10 bigint = 0            // 0 is allowed as a integer rationalprintln "bint7 = 1r << 65: ", bint7
println "bint8 = 1r<<65 - 100: ", bint8
println "bint9 = -3r<<36 + 200: ", bint9
println "bint10 = 0: ", bint10/* Running results：
bint7 = 1r << 65:  36893488147419103232
bint8 = 1r<<65 - 100:  36893488147419103132
bint9 = -3r<<36 + 200:  -206158430008
bint10 = 0:  0
*/

程序说明：

（1）可以用表达式对整型有理数变量进行赋值，表达式可以混合使用带有后缀 ‘r’ 的整型有理数常数和不带后缀 ‘r’ 的整型常数。
（2）“1r<<65” 的值等于 2 的 65 次幂，“1r<<65 - 100” 的值等于 2 的 65 次幂减去 100 的结果，"-3r<<36 + 200" 的值等于 2 的 65 次幂乘以 -3后加 200 的结果。
（3）正整数、负整数和零都可以被赋值给整型有理数变量。

3. 整型有理数的运算

3.1 整型有理数的基本运算

整型有理数的基本运算，如加减乘除，其计算方法和规则与通常的整数运算相同。

【例程 4】整型有理数的基本运算

// Example 4: Basic operations of integer rational numbers
var bint1 bigint = 1r << 65
var bint2 bigint = 1r<<36 + 100
var bint3 bigint = 9223372036854775808r
var bint4 bigint = 306rprintln "bint1 + bint2 = ", bint1+bint2
println "bint1 - bint2 = ", bint1-bint2
println "bint1 * bint2 = ", bint1*bint2
println "bint1 / bint2 = ", bint1/bint2// The operation rule is multiplication and division before addition and subtraction.
println "bint1 + bint2 / bint3 = ", bint1+bint2/bint3
println "(bint1 + bint2) / bint3 = ", (bint1+bint2)/bint3
println "bint1 + (bint2 / bint3) = ", bint1+(bint2/bint3)/* Running results：
bint1 + bint2 =  36893488216138580068
bint1 - bint2 =  36893488078699626396
bint1 * bint2 =  2535301204145807617735316733952
bint1 / bint2 =  536870911
bint1 + bint2 / bint3 =  36893488147419103232
(bint1 + bint2) / bint3 =  4
bint1 + (bint2 / bint3) =  36893488147419103232
*/

程序说明：

（1）整型有理数的基本运算，如加减乘除，其计算方法和规则与通常的整数运算相同。
（2）整型有理数的基本运算，按照先乘除、后加减的顺序进行运算。
（3）整型有理数表达式的运算结果如果不是整数，则对运算结果自动取整。

3.2 整型有理数与常数的运算

整型有理数变量可以与整型有理数类型的常数进行加减乘除运算，也可以与整型常数进行运算。

【例程 5】整型有理数与整型常数的运算

// Example 5: Basic operations with constants of integer (rational) type
var bint1 bigint = 1r << 65
var bint2 bigint = 1r<<36 + 100
var bint3 bigint = 9223372036854775808r
var bint4 bigint = 306r// The operations with constants of integer rational type
println "bint1 + 1r<<60 = ", bint1+1r<<60
println "bint2 - 1r<<36 = ", bint2-1r<<36
println "bint3 * 306r = ", bint3*306r
println "bint3 / 306r = ", bint3/306r// The operations with constants of integer  type
println "bint1 + 160 = ", bint1+160
println "bint2 - 160 = ", bint1-160
println "bint3 * 306 = ", bint3*306
println "bint3 / 3014 = ", bint3/3014// The operations with constants of rational number in fractional form
println "bint1 + 160/1r = ", bint1+160/1r
println "bint2 - 160/5r = ", bint1-160/5r
println "bint3 * 305/306r = ", bint3*305/306r
println "bint3 / 5/100r = ", bint3/5/100rprintln "bint4 * 0 = ", bint4*0
println "bint4 / 0 = ", bint4/0 // panic: division by zero/* Running results：
bint1 + 1r<<60 =  38046409652025950208
bint2 - 1r<<36 =  100
bint3 * 306r =  2822351843277561397248
bint3 / 306r =  30141738682531947bint1 + 160 =  36893488147419103392
bint2 - 160 =  36893488147419103072
bint3 * 306 =  2822351843277561397248
bint3 / 3014 =  3060176521849627bint1 + 160/1r =  36893488147419103392
bint2 - 160/5r =  36893488147419103200
bint3 * 305/306r =  9193230298172243860
bint3 / 5/100r =  18446744073709551bint4 * 0 =  0
panic: division by zero
*/

程序说明：

（1）整型有理数变量可以与整型有理数类型的常数进行加减乘除运算，也可以与整型常数进行运算。
（2）整型有理数变量可以与分数型有理数类型的常数进行运算，运算结果转换为整型有理数。
（3）整型有理数变量运算，被 0 除时将发生错误，系统提示为：“panic: division by zero”。

一般地，整型有理数不能与浮点数类型的常数进行加减乘除运算。

【例程 6】整型有理数与浮点数的运算

// Example 6: Basic operations with constants of float type
var bint1 bigint = 1r << 65// The operations with constants of float  type
println "bint1 + 160.0 = ", bint1+160.0
println "bint1 - 160.0 = ", bint1-160.0
println "bint1 * 306.0 = ", bint1*306.0
println "bint1 / 3014.0 = ", bint1/3014.0//println "bint1 + 160.5 = ", bint1+160.5   // invalid operation
//println "bint1 - 160.5 = ", bint1-160.5   // invalid operation
//println "bint1 * 306.5 = ", bint1*306.5   // invalid operation
//println "bint1 / 3014.5 = ", bint1/3014.5 // // invalid operation/* Running results：
bint1 + 160.0 =  36893488147419103392
bint1 - 160.0 =  36893488147419103072
bint1 * 306.0 =  11289407373110245588992
bint1 / 3014.0 =  12240706087398508
*/

程序说明：

（1）在第一组加减乘除运算中，算式中浮点数常数的数值都是整数，可以转换为整型常数，因此运算可以执行，运算结果也是正确的。

（2）在第二组加减乘除运算中，算式中浮点数常数的数值不是整数，不能自动转换为整型常数，这些运算都不能执行，系统提示为 “无效操作”：

invalid operation: mismatched types github.com/goplus/gop/builtin.Gop_bigint and untyped float

这表明，**Go+ 语言中不允许对整型自然数与浮点型常数进行运算。**虽然第一组运算可以进行，但我们也应该避免对整型自然数与浮点型常数进行运算。

3.3 整型有理数与变量的运算

Go+ 语言中整型有理数变量可以与整型变量进行运算，运算结果为整型有理数。不允许对整型有理数与浮点型变量进行运算。

【例程 7】整型有理数与整型变量的运算

// Example 7: Basic operations with integer variables
import "reflect"
var bint1 bigint = 1r << 36
var x int = 306println "bint1 + x*5 = ", bint1+x*5     // bint1 + x*5 =  68719478266
println "bint1 - x/2 = ", bint1-x/2     // bint1 - x/2 =  68719476583
println "bint1 * x = ", bint1*x         // bint1 * x =  21028159881216
println "bint1 / x = ", bint1/x         // bint1 / x =  224573453
println "bint1 / (x*x) = ", bint1/(x*x) // bint1 / (x*x) =  733900println reflect.TypeOf(bint1+x*5)   // builtin.Gop_bigint
println reflect.TypeOf(bint1/(x*x)) // builtin.Gop_bigint

【例程 8】整型有理数与浮点数的运算

// Example 8: Basic operations with float variables
var bint1 bigint = 1r << 36
var y float64 = 36println "bint4 + y = ", bint1+y  //invalid operation

4. 总结

Go+ 语言使用后缀 ‘r’ 表示有理数，支持整型、分数型、浮点型三种有理数数据类型（Rational number）。
在整型有理数变量声明时，可以同时对变量赋值；如果对整型有理数变量只声明而没有赋值，其初始值不是 0，而是 “”。
整型有理数的基本运算如加减乘除，其计算方法和规则与通常的整数运算相同，按照先乘除、后加减的顺序进行运算。
整型有理数变量可以与整型有理数类型的常数、分数形式的有理数类型的常数和整型常数进行运算，不能与浮点数类型的常数进行运算。
整型有理数变量可以与整型变量进行运算，运算结果为整型有理数。不允许对整型有理数与浮点型变量进行运算。

【本节完】

原创作品，转载必须标注原文链接：(https://blog.csdn.net/youcans/article/details/121755262)

Crated：2021-12-06

欢迎关注『我的Go+语言初体验』系列，持续更新中…

我的Go+语言初体验——（1）超详细安装教程
我的Go+语言初体验——（2） IDE 详细安装教程
我的Go+语言初体验——（3）Go+ 数据类型
我的Go+语言初体验——（4）零基础学习 Go+ 爬虫
我的Go+语言初体验——（5）Go+ 基本语法之 Switch
我的Go+语言初体验——（6）整型有理数数据类型

“我的Go+语言初体验” | 征文活动进行中…