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

Posted Python小白进阶

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了我的Go+语言初体验——整型有理数数据类型相关的知识,希望对你有一定的参考价值。

我的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 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+语言初体验” | 征文活动进行中…

以上是关于我的Go+语言初体验——整型有理数数据类型的主要内容,如果未能解决你的问题,请参考以下文章

我的Go+语言初体验——GoPlus基础语法学习

我的Go+语言初体验——GoPlus基础语法学习

我的Go+语言初体验——GoPlus基础语法学习

我的Go+语言初体验——GoPlus基础语法学习

我的Go+语言初体验——Go+ 语言数据类型

我的Go+语言初体验——用Go+写个爬虫并进行数据处理