go语言浮点数的题 golang浮点数计算

GO语言(十五):泛型入门(下)-

在本节中,您将添加通用函数调用的修改版本,进行小的更改以简化调用代码。您将删除在这种情况下不需要的类型参数。

成都创新互联公司于2013年创立,先为襄阳等服务建站,襄阳等地企业,进行企业商务咨询服务。为襄阳企业网站制作PC+手机+微官网三网同步一站式服务解决您的所有建站问题。

当 Go 编译器可以推断您要使用的类型时,您可以在调用代码中省略类型参数。编译器从函数参数的类型推断类型参数。

请注意,这并不总是可能的。例如,如果您需要调用没有参数的泛型函数,则需要在函数调用中包含类型参数。

在 main.go 中,在您已有的代码下方,粘贴以下代码。

在此代码中:

(1)调用泛型函数,省略类型参数。

从包含 main.go 的目录中的命令行,运行代码。

接下来,您将通过将整数和浮点数的并集捕获到您可以重用的类型约束(例如从其他代码中)来进一步简化函数。

正如您将在本节中看到的,约束接口也可以引用特定类型。

1、编写代码

在此代码中:

b.在您已有的函数下方,粘贴以下通用 SumNumbers函数。

在此代码中:

c.在 main.go 中,在您已有的代码下方,粘贴以下代码。

在此代码中:

(1)调用SumNumbers打印每个map的总和。

与上一节一样,在调用泛型函数时省略了类型参数(方括号中的类型名称)。Go 编译器可以从其他参数推断类型参数。

从包含 main.go 的目录中的命令行,运行代码。

做得很好!您刚刚学习了 Go 中的泛型。

关于浮点数形式的计算题

1.

111011.01

规格化=

1.1101101

*

2^5

阶码的原码=000101

阶码的补码=000101

尾码的原码=0001101101

符号位为1

所以结果为1

000101

0001101101

2

350

二进制=

101011110

规格化=1.0101111

*

2^8

阶码的原码=001000

阶码的补码=001000

尾码的原码=0000101111

符号位为0

所以结果为0

001000

0000101111

go的uint64转换成java的哪种类型

Golang 和java/c不同,Go在不同类型的变量之间赋值时需要显式转换。也就是说Golang中数据类型不能自动转换。

基本语法

表达式T(v))将值v 转换为类型T

T∶就是数据类型,比如int32,int64,float32等等

v∶ 就是需要转换的变量

var i int = 100

var b float64 = float64(i)

var c int64 = int64(b)

fmt.Printf("b=%f,c=%d",b,c)

b=100.000000,c=100

登录后复制

细节说明

1)Go中,数据类型的转换可以是从表示范围小-表示范围大,也可以范围大一范围小

2) 被转换的是变量存储的数据(即值),变量本身的数据类型并没有变化!

3) 在转换中,比如将 int64 转成int8,编译时不会报错,只是转换的结果是按溢出处理,和

我们希望的结果不一样。(在转换的时候需要注意范围)

var a int64 = 10000000

var b int8 = int8(a)

fmt.Printf("%d",b)

-128

登录后复制

可以看到在转换的时候,一定要保证转换大数据要是对方可以接受的范围。

n1类型是int32,那么➕20整个就是int32类型,可是n2是int64,这样就会编译错误。

题二n4是12 + 127溢出超过了范围,运行的时候按照溢出处理。n3是直接编译不通过,128已经超过了int8类型的范围

基本数据类型和string的转换

字符串格式化

Go语言用于控制文本输出常用的标准库是fmt

fmt中主要用于输出的函数有:

Print: 输出到控制台,不接受任何格式化操作

Println: 输出到控制台并换行

Printf : 只可以打印出格式化的字符串。只可以直接输出字符串类型的变量(不可以输出别的类型)

Sprintf:格式化并返回一个字符串而不带任何输出

Fprintf:来格式化并输出到 io.Writers 而不是 os.Stdout

整数类型

格 式 描 述

%b 整型以二进制方式显示

%o 整型以八进制方式显示

%d 整型以十进制方式显示

%x 整型以十六进制方式显示

%X 整型以十六进制、字母大写方式显示

%c 相应Unicode码点所表示的字符

%U Unicode 字符, Unicode格式:123,等同于 "U+007B"

浮点数

格 式 描 述

%e 科学计数法,例如 -1234.456e+78

%E 科学计数法,例如 -1234.456E+78

%f 有小数点而无指数,例如 123.456

%g 根据情况选择 %e 或 %f 以产生更紧凑的(无末尾的0)输出

%G 根据情况选择 %E 或 %f 以产生更紧凑的(无末尾的0)输出

布尔

格 式 描 述

%t true 或 false

字符串

格 式 描 述

%s 字符串或切片的无解译字节

%q 双引号围绕的字符串,由Go语法安全地转义

%x 十六进制,小写字母,每字节两个字符

%X 十六进制,大写字母,每字节两个字符

指针

格 式 描 述

%p 十六进制表示,前缀 0x

var num1 int64 = 99

var num2 float64 = 23.99

var b bool = true

var mychar byte = 'h'

str1 := fmt.Sprintf("%d",num1)

str2 := fmt.Sprintf("%f",num2)

bool1 := fmt.Sprintf("%t",b)

mychar1 := fmt.Sprintf("%c",mychar)

fmt.Printf("%T,%T,%T,str1=%v,str2=%v,bool1=%v,mychar1=%v",str1,bool1,str2,str1,str2,bool1,mychar1)

string,string,string,string,str1=99,str2=23.990000,bool1=true,mychar1=h

登录后复制

使用strconv包 基本类型 - string类型

num1 := 99

str1 := strconv.FormatInt(int64(num1),10)

fmt.Printf("%T,%v",str1,str1)

num2 := 99.99

str2 := strconv.FormatFloat(num2,'f',10,64)

fmt.Printf("%T,%v\n",str2,str2)

登录后复制

strconv包提供了字符串与简单数据类型之间的类型转换功能,可以将简单类型转换为字符串,也可以将字符串转换为其它简单类型

string和int转换

int转string的方法是: Itoa()

str := strconv.Itoa(100)

fmt.Printf("type %v, value: %s\n", reflect.TypeOf(str), str)

登录后复制

2.string转int的方法是:

i, err := strconv.Atoi("100")

fmt.Printf("type %v, value: %d, err: %v\n", reflect.TypeOf(i), i, err)

登录后复制

并不是所有string都能转化为int, 所以可能会报错:

i, err := strconv.Atoi("100x")

fmt.Printf("type %v, value: %d, err: %v\n", reflect.TypeOf(i), i, err)

登录后复制

使用strconv包 string转其他类型

strconv包提供的Parse类函数用于将字符串转化为给定类型的值:ParseBool()、ParseFloat()、ParseInt()、ParseUint() 由于字符串转换为其它类型可能会失败,所以这些函数都有两个返回值,第一个返回值保存转换后的值,第二个返回值判断是否转换成功。

1.转bool

b, err := strconv.ParseBool("true")

fmt.Println(b, err)

登录后复制

2.转float

f1, err := strconv.ParseFloat("3.1", 32)

fmt.Println(f1, err)

f2, err := strconv.ParseFloat("3.1", 64)

fmt.Println(f2, err)

登录后复制

由于浮点数的小数部分 并不是所有小数都能在计算机中精确的表示, 这就造成了浮点数精度问题, 比如下面

var n float64 = 0

for i := 0; i 1000; i++ {

n += .01

}

fmt.Println(n)

关于浮点数精度问题: c计算机不都是0101吗,你有想过计算机是怎么表示的小数吗, 简单理解就是:

将其整数部分与小树部分分开, 比如5.25

对于整数部分 5 ,我们使用"不断除以2取余数"的方法,得到 101

对于小数部分 .25 ,我们使用"不断乘以2取整数"的方法,得到 .01

听说有一个包可以解决这个问题: github.com/shopspring/decimal

3.转int

func ParseInt(s string, base int, bitSize int) (i int64, err error)

base: 进制,有效值为0、2-36。当base=0的时候,表示根据string的前缀来判断以什么进制去解析:0x开头的以16进制的方式去解析,0开头的以8进制方式去解析,其它的以10进制方式解析

bitSize: 多少位,有效值为0、8、16、32、64。当bitSize=0的时候,表示转换为int或uint类型。例如bitSize=8表示转换后的值的类型为int8或uint8

fmt.Println(bInt8(-1)) // 0000 0001(原码) - 1111 1110(反码) - 1111 1111

// Parse 二进制字符串

i, err := strconv.ParseInt("11111111", 2, 16)

fmt.Println(i, err)

// Parse 十进制字符串

i, err = strconv.ParseInt("255", 10, 16)

fmt.Println(i, err)

// Parse 十六进制字符串

i, err = strconv.ParseInt("4E2D", 16, 16)

fmt.Println(i, err)

4.转uint

func ParseUint(s string, base int, bitSize int) (uint64, error)

用法和转int一样, 只是转换后的数据类型是uint64

u, err := strconv.ParseUint("11111111", 2, 16)

fmt.Println(u, err)

u, err = strconv.ParseUint("255", 10, 16)

fmt.Println(u, err)

u, err = strconv.ParseUint("4E2D", 16, 16)

fmt.Println(u, err)

其他类型转string

将给定类型格式化为string类型:FormatBool()、FormatFloat()、FormatInt()、FormatUint()。

fmt.Println(strconv.FormatBool(true))

// 问题又来了

fmt.Println(strconv.FormatInt(255, 2))

fmt.Println(strconv.FormatInt(255, 10))

fmt.Println(strconv.FormatInt(255, 16))

fmt.Println(strconv.FormatUint(255, 2))

fmt.Println(strconv.FormatUint(255, 10))

fmt.Println(strconv.FormatUint(255, 16))

fmt.Println(strconv.FormatFloat(3.1415, 'E', -1, 64))

func FormatFloat(f float64, fmt byte, prec, bitSize int) string

bitSize表示f的来源类型(32:float32、64:float64),会据此进行舍入。

fmt表示格式:'f'(-ddd.dddd)、'b'(-ddddp±ddd,指数为二进制)、'e'(-d.dddde±dd,十进制指数)、'E'(-d.ddddE±dd,十进制指数)、'g'(指数很大时用'e'格式,否则'f'格式)、'G'(指数很大时用'E'格式,否则'f'格式)。

prec控制精度(排除指数部分):对'f'、'e'、'E',它表示小数点后的数字个数;对'g'、'G',它控制总的数字个数。如果prec 为-1,则代表使用最少数量的、但又必需的数字来表示f。

Go number

Go中数值类型可细分为整数、浮点数、复数三种,每种都具有不同的大小范围和正负支持。

整型分为两大类

Go提供了有符号和无符号的整数类型,同时提供四种大小不同的整数类型。

取值范围

等价类型

特殊整型

int 和 uint 分别对应特定CPU平台的字长(机器字大小),大小范围在 32bit 或 64bit 之间变化,实际开发中由于编译器和硬件不同而不同。

进制转换

转换函数

使用注意

字节长度

Golang提供了两种精度的浮点数分别为 float32 和 float64 ,它们的算术规范由IEEE754浮点数国际标准定义,IEEE754浮点数标准被现代CPU支持。

float32 类型的浮点数可提供约6个十进制数的精度, float64 类型的浮点数可提供约15个十进制数的精度。通常会优先选择使用 float64 ,因为 float32 累计计算误差会比较容易扩散。

计算机中复数(complex)由两个浮点数表示,一个表示实部(real)一个表示虚部(imag)。

Go语言中复数的值由三部分组成 RE + IMi ,分别是实数部分 RE 、虚数部分 IM 、虚数单位 i , RE 和 IM 均为 float 。

Go语言提供两种类型的复数,分别是 complex64 即32位实数和虚数, complex128 即64位实数和虚数, complex128 为复数的默认类型。

复数声明

z 表示复数的变量名, complex128 表示复数类型, complex() 内置函数用于为复数赋值。 x 和 y 分别表示构成该复数的两个 float64 类型的值, x 为实部, y 为虚部。

简写形式

对于 z 值可通过内置函数 real(z) 获取该复数的实部,使用 imag(z) 获取虚部。


网站标题:go语言浮点数的题 golang浮点数计算
文章转载:http://pwwzsj.com/article/hjsccc.html