骏马金龙

网名骏马金龙,钟情于IT世界里的各种原理和实现机制,强迫症重症患者。爱研究、爱翻译、爱分享。特借此一亩三分田记录自己成长点滴!!!
我本问道人,道心不坚,必将与道无缘!

Ruby中的数值

数值类型

Ruby中所有数值都是Numeric类的子类对象,数值都是不可变对象

数值类型的继承关系如下:

Integer是整数,Float是浮点数类型,Rational是分数。

对于整数,要么是Fixnum,要么是Bignum:Fixnum是比较小整数的类型(31个二进制位),Bignum是较大整数的类型。实际上,Ruby中的整数可以变得任意大。但是浮点数不会任意大,浮点数位数达到一点程度后会溢出到正、负无穷

Fixnum和Bignum之间在需要的时候会自动转换:当一个初始为Bignum类型的变量值变小后,会自动转换成Fixnum类型;同理,Fixnum的变量也会在它变得足够大时转换成Bignum类型。

对于分数,只需要在某个数后面加上一个后缀字母r,就会自动转换为分数形式。例如0.3r等价于分数(3/10)2r等价于2/1r等价于分数形式(2/1)。在Kernel模块中有一个Rational方法,可以用来将各种类型转换成分数形式。

关于算术操作的类型转换

当算术运算的两个操作数中,有一个是Float类型,那么整数类型将转换成Float类型进行运算,运算结果也都是Float类型

>> 2 * 2.5
=> 5.0

>> 1.0 + 2
=> 3.0

>> 5.0/2.5
=> 2.0

>> 5.0/2
=> 2.5

对于整数除法,即两个数都是整数的除法,那么除法得到的结果将是截断后的整数。对于结果为负数的整数除法,将取比它精确结果更小的整数。也就是说,Ruby中的整数除法采取的是地板除法(floor)所以,(-a)/b等价于a/(-b),但是可能不等价于-(a/b)

>> 5/2
=> 2

>> -3/2    # (-a)/b
=> -2
>> 3/-2    # a/(-b)
=> -2
>> -(3/2)  # -(a/b)
=> -1

浮点数是不精确的,所以不要在浮点数参与运算的时候对浮点数做等值比较。非要比较,可以通过减法运算,跟一个足够小的值做大小比较,但也别小过头了。例如,(0.4-0.1)和0.3做等值比较:

>> (0.4 - 0.1) == 0.3
=> false

>> 0.4 - 0.1
=> 0.30000000000000004

>> ( 0.4 - 0.1 ) - 0.3 < 0.00001  # 这是正确的浮点数参与运算的等值比较方式
=> true
>> ( 0.4 - 0.1 ) - 0.3 < 0.0000000000000000000001
=> false

可以使用Rational分数来比较:

>> (0.4r-0.1r) == 0.3r     #=> true

>> 0.4r                    #=> (2/5)
>> 0.1r                    #=> (1/10)
>> 0.4r-0.1r               #=> (3/10)
>> 0.3r                    #=> (3/10)

也可以使用BigDecimal类来进行运算,它采用的是十进制表示法来表示浮点数,而Float采用的是二进制表示法表示。只不过BigDecimal的运算速度要比正常的浮点数速度慢上很多个数量级,当然,对于普通的财务运算等领域也足够了,只是在进行科学运算的时候,BigDecimal就不够了。另外,BigDecimal不是内置类,只是一个标准库,需要先导入。

require "bigdecimal"
(BigDecimal("0.4") - BigDecimal("0.1")) == BigDecimal("0.3")  #=> true

以下是几种浮点数运算等值比较的效率高低(比较100W次):

# 直接使用浮点数比较,比较是不精确的
$ time ruby -e '1000000.times {|x| (0.4-0.1) == 0.3 }'

real    0m0.147s
user    0m0.063s
sys     0m0.078s

# 直接使用浮点数做不等值比较,比较是精确的
# (多次测试,速度比上面要慢一点点,多了次运算)
$ time ruby -e '1000000.times {|x| (0.4-0.1) - 0.3 < 0.00001 }'

real    0m0.158s
user    0m0.094s
sys     0m0.063s

# 使用分数字面量,比较是精确的
$ time ruby -e '1000000.times {|x| (0.4r-0.1r) == 0.3r }'

real    0m0.248s
user    0m0.188s
sys     0m0.094s

# 使用Kernel中的Rational()
$ time ruby -e '1000000.times {|x| (Rational("0.4") - Rational("0.1")) == Rational("0.3") }'

real    0m0.630s
user    0m0.563s
sys     0m0.063s

# 使用bigdecimal
$ time ruby -r"bigdecimal" -e '1000000.times do |x| 
                (BigDecimal("0.4") - BigDecimal("0.1")) == BigDecimal("0.3") 
            end'

real    0m1.079s
user    0m0.953s
sys     0m0.125s

可见,使用分数字面量或浮点数不等值比较的效率是比较可取的,而使用Kernel.Rational()或BigDecimal()的效率相比之下都比较差。

对于Ruby中的取模%运算,也是支持浮点数的。

>> 1.5 % 0.4
=> 0.29999999999999993

指数运算时,采取的是Fortran里的优先级模式,和Perl是一样的:从右向左计算。例如3 ** 4 ** 2等价于3 ** (4 ** 2),即其值为3 ** 16

>> 3 ** 4 ** 2
=> 43046721
>> 3 ** 16
=> 43046721

指数运算的指数支持浮点数、负数,只是指数涉及到整数除法运算时需要注意,因为对于整数除法,Ruby默认采用的是floor除法:

x ** 4
x ** -1      # 即x分之1
x ** (1/3.0) # 即x的立方根
x ** (1/4)   # 1/4=0,等价于x ** 0,即结果为1
x**(1.0/4.0) # 即x的四次方根

虽然,数值是不可变对象,但是对于整数来说,它支持索引查找各个二进制位上的值,只是不允许修改。

>> printf "%b\n", 12345
11000000111001    # 这是十进制12345对应的二进制数

>> x[0]
=> 1
>> x[1]
=> 0
>> x[4]
=> 1
>> x[5]
=> 1
>> x[6]
=> 0
>> x[11]
=> 0
>> x[12]
=> 1

所以,要判断一个数是否为偶数,就非常容易了:

x[0] == 0  # 偶数返回true,奇数返回false
posted @ 2019-05-03 16:45 骏马金龙 阅读(...) 评论(...) 编辑 收藏