我的Go+语言初体验——整型有理数数据类型
Posted Python小白进阶
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了我的Go+语言初体验——整型有理数数据类型相关的知识,希望对你有一定的参考价值。
我的Go+语言初体验——(6)整型有理数数据类型
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 bigint
println 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 int
println 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 rational
println "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 = 306r
println "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/100r
println "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 = 30141738682531947
bint1 + 160 = 36893488147419103392
bint2 - 160 = 36893488147419103072
bint3 * 306 = 2822351843277561397248
bint3 / 3014 = 3060176521849627
bint1 + 160/1r = 36893488147419103392
bint2 - 160/5r = 36893488147419103200
bint3 * 305/306r = 9193230298172243860
bint3 / 5/100r = 18446744073709551
bint4 * 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 = 306
println "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) = 733900
println 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 = 36
println "bint4 + y = ", bint1+y //invalid operation
4. 总结
-
Go+ 语言使用后缀 ‘r’ 表示有理数,支持整型、分数型、浮点型三种有理数数据类型(Rational number)。
-
在整型有理数变量声明时,可以同时对变量赋值;如果对整型有理数变量只声明而没有赋值,其初始值不是 0,而是 “”。
-
整型有理数的基本运算如加减乘除,其计算方法和规则与通常的整数运算相同,按照先乘除、后加减的顺序进行运算。
-
整型有理数变量可以与整型有理数类型的常数、分数形式的有理数类型的常数和整型常数进行运算,不能与浮点数类型的常数进行运算。
-
整型有理数变量可以与整型变量进行运算,运算结果为整型有理数。不允许对整型有理数与浮点型变量进行运算。
【本节完】
版权声明:
原创作品,转载必须标注原文链接:(https://blog.csdn.net/youcans/article/details/121755262)
Copyright 2021 youcans, XUPT
Crated:2021-12-06
欢迎关注『我的Go+语言初体验』系列,持续更新中…
我的Go+语言初体验——(1)超详细安装教程
我的Go+语言初体验——(2) IDE 详细安装教程
我的Go+语言初体验——(3)Go+ 数据类型
我的Go+语言初体验——(4)零基础学习 Go+ 爬虫
我的Go+语言初体验——(5)Go+ 基本语法之 Switch
我的Go+语言初体验——(6)整型有理数数据类型
以上是关于我的Go+语言初体验——整型有理数数据类型的主要内容,如果未能解决你的问题,请参考以下文章