L03-02. number类型

一. number类型

　　1. Lua5.3 版本开始， Lua 语言为数值格式提供了两种选择 :integer( 整型 )和float(双精度浮点型 )[float不代表单精度类型 ] 

 

　　2. 默认当成双精度浮点类型来运算的。也就是说number会底层当做double类型来处理，精度是16~17位

 

　　3. 十进制

　　　　① 十进制表示方式

--十进制表示
local a = 2         --输出结果: 2
local b = 2.1       --输出结果: 2.1

　　　　 ② 十进制科学计数法表示方式(科学记数法的结果是一个浮点数)

 

--[[
    科学计数法规则:
        1. 数字后面加e或者E字符然后跟数值(数值不能省略) 表示科学计数法
        2. 数值的正数表示小数点后移,数值的负数表示小数点往前移
--]]

print(4.57e0)           --输出结果: 4.57
print(0.3e12)           --输出结果: 300000000000.0
print(0.3e+12)          --输出结果: 300000000000.0(与上面的表达式一样)
print(5.26E+20)         --输出结果: 526E+020(数值过大无法转换,但也能表示十进制数)

 

　　4. 十六进制

　　　　① 以0x开头的十六进制常量, 不仅支持十六进制的整型、还支持十六进制的浮点数

--十六进制表示方式输出的结果是十进制
local e = 0xa2548   --输出结果: 9544
local f = 0x2.5     --输出结果: 2.3125
local g = 0xa.5     --输出结果: 10.3125

　　　　② 十六进制还可以由p或P开头的指数部分组成

 

--十六进制科学计数法表示输出结果是十进制
--p表示什么不必深究
local h = 0x2.ap3   --输出结果: 21.0
--通过string.format()的%a参数可以对上面的这种格式进行格式化的输出,格式化的意思是: 有格式
--虽然这种格式很难阅读，但是这种格式可以保留所有浮点数的精度，并且比十进制的转换速度更快
print(string.format("%a", 419))       --0x1.a3p+8
print(string.format("%a", 0.5))       --0x1p-1 
print(0x1.a3p+8)    --输出结果: 419

　　5. 十六进制与十进制互转

--十六进制转十进制--一字节
print(0x01)       --输出结果: 1
print(0xFF)       --输出结果: 255
--二字节
print(0xFF01)     --输出结果: 65281
print(0xFFFF)     --输出结果: 65535
--四字节
print(0xA0AA0A)   --输出结果: 10529290
print(0xFFFFFF)   --输出结果: 16777215


--十进制转十六进制
local function dec(decnum)
local num = tonumber(decnum)
　　if not num then return nil end
　　if not math.type(num) == "integer" then return nil end
　　local hex,dis,rem = "",num
　　repeat
　　　　dis, rem = math.modf(dis/16), math.fmod(dis,16)
　　　　rem = rem > 9 and string.char(rem+55) or rem
　　　　hex = rem .. hex
　　until dis == 0
　　return "0x" .. hex
end
print(dec(65535))

　　5. math.type(参数),　判断是否为int或者float

--[[
    math.type判断是否是int或者float
    语法: 
        math.type(参数)
    功能: 
        判断是否是int或者float
    参数: 
        参数: 数值,不是数值返回nil
    返回值:
        字符串型, "integer", "float"
--]]

print(math.type(1))         --输出结果: intger
print(math.type(-1.5))      --输出结果: float

 

二. 算数运算符

　　1. Lua支持的算术运算

　　　 ① 加（+）、减（-）、乘（*）、除（/）

　　　　② 取负数（-）

　　　　③ 取整除法和floor除法（//）

　　　　④ 取余（%）

　　　　⑤ 指数运算(e和p)

　　　　⑥ 幂运算（^）

　　 2. 整型值和浮点型值之间的算术运算

　　　   ① 在对一个字符串进行算术操作时，Lua会尝试将这个字符串转换为一个数字来进行算数操作(结果是浮点数)

　　      ② 当两个操作数的类型不同时，运算之前会先将整型值转换为浮点型值

print(13 + 15)        --结果是整数型
print(13.0 + 15)      --结果是浮点数型
print(13 + 15.0)      --结果是浮点数型
print(13.0 + 15.0)    --结果是浮点数型
print(1 * 2)          --结果是整数型
print(1 * 2.0)        --结果是浮点数型

　　　　③ / 的注意事项:   由于两个整数相处并不一定是整数，因此当两个数进行相除时，interger都会转换为浮点数（即使两个操作数都是整数液转换,并且除法运算的结果也是浮点数

　　　　④ // 和 math.floor注意事项: 向左取整    // 向左取整时如果两个数组有浮点数则结果是浮点数  math.floor向左取整则不会出现浮点数

 

print(2.5 // 1)             --输出结果: 2.0
print(-2.5 // 1)            --输出结果: -3.0

print(math.floor(2.5))      --输出结果: 2
print(math.floor(-2.5))     --输出结果: -3

　　　　⑤ 取负数运算(如果两个操作数都是整型值则返回整型；否则返回浮点数)

print(-(-1))        --输出结果: 1 
print(-(1))         --输出结果: -1 
print(-(3 * 6.0))   --输出结果: -18.0

　　　　⑥ 取余运算(如果两个操作数都是整型值则返回整型；否则返回浮点数)

local a = 11
local b = 2
print( a % b == a - ((a // b) * b) )    --输出结果: true

--取余运算可以对数值保留n位小数(一般不用这种方式)
x = math.pi
print(x - x % 0.1)                --保留1位小数

print(x - x % 0.01)               --保留2位小数

　　　　⑦ 幂运算: 幂运算的操作数和结果也永远是浮点类型, 使用x^0.5来计算x的平方根，使用x^(1/3)来计算x的立方根

 

三. 关系运算符

　　1. Lua支持的关系运算符如下

　　　　 ①大于（>）、小于（<）

　　　　②大于等于（>=）、小于等于（<=）

　　　　③相等（==）

　　　　④不相等（~=）

　　2. Lua关系运算的结果都是boolean类型

　　3. ==、~=说明：这两个运算符可以应用于任意两个值，当这两个值的类型不同时，Lua语言认为它们是不相等的；否则，会根据它们的类型再对两者进行比较

　　4. Lua通过引用比较tables、userdata、functions。也就是说两者表示同一个对象时相等

 

print(1 == 2)       --输出结果: false
print(1 == 1)       --输出结果: true
 
-- 类型不同, 直接返回false, 根本不进行比较
print(1 == "1")     --输出结果: false
print("1" == "1")   --输出结果: true
print("1" == "2")   --输出结果: false

--布尔值与nil比较
print(false ~= nil)    -- true

--数组比较
a = { 1, 2 }
b = { 1, 2 }
c = a
print(a == b) --false
print(a == c) --true

　　5. 比较数值时永远忽略数值的子类型，数值究竟是以整型还是浮点型表示并无区别，只与算术值有关（尽管如此，比较具有相同子类型的数值时效率更高）

print(1.0 == 1)     --输出结果: true
print(1 == 1)       --输出结果: true
print(1.1 == 1)     --输出结果: false

　　6. > < >= <=

--字符串比较(必须两边都是字符串否则会报错)
print("a">"b")  --false
--"12"和"2"比较时，按照字母顺序比较的时候，首先是字符"1"和字符"2"进行比较，1大于2为false，则忽略后面的比较操作,直接返回false
print("12" > "2") --false

--比较大小的错误示范
print(true > 1) --报错,类型不同
print("1" > 1) --报错,类型不同

 

四. math数学库

　　1. Lua语言提供了标准数学库math，由一组标准的数学函数组成，包括：
　　　　 ① 三角函数（sin、cos、tan、asin等）：所有三角函数都以弧度为单位，并通过函数deg和rad进行角度和弧度的转换
　　　　② 指数函数
　　　　③ 取整函数
　　　　④ 最大函数max、最小函数min
　　　　⑤ 用于生成伪随机的伪随机函数（random）
　　　　⑥ 常量pi
　　　　⑦ 常量huge（最大可表示数值，大多数平台上代表inf）

　　2. 三角函数
　　　　math.acos (x)
　　　　返回 x 的反余弦值（用弧度表示）。

　　　　math.asin (x)
　　　　返回 x 的反正弦值（用弧度表示）。

　　　　math.atan (y [, x])
　　　　返回 y/x 的反正切值（用弧度表示）。 它会使用两个参数的符号来找到结果落在哪个象限中。 （即使 x 为零时，也可以正确的处理。）
　　　　默认的 x 是 1 ， 因此调用 math.atan(y) 将返回 y 的反正切值。

　　　　math.cos (x)
　　　　返回 x 的余弦（假定参数是弧度）。

　　　　math.deg (x)
　　　　将角 x 从弧度转换为角度。

　　　　math.rad (x)
　　　　将角 x 从角度转换为弧度。

　　　　math.sin (x)
　　　　返回 x 的正弦值（假定参数是弧度）。

　　　　math.tan (x)
　　　　返回 x 的正切值（假定参数是弧度）。

　　3. 自然对数
　　　　math.exp (x)
　　　　返回 ex 的值 （e 为自然对数的底）。

　　　　math.log (x [, base])
　　　　返回以指定底的 x 的对数。 默认的 base 是 e （因此此函数返回 x 的自然对数）。

　　4. 取整函数

　　　   math.floor(number)：向左取整

　　　　math.ceil(number)：向右取整

　　　　math.modf(number)：除了返回取整后的值之外，还会返回小数部分作为第二个结果

print(math.floor("3.3"))      --输出结果: 3
print(math.floor(-3.3))     --输出结果: -4
 
print(math.ceil(3.3))       --输出结果: 4
print(math.ceil(-3.3))      --输出结果: -3
 
print(math.modf(3.3))       --输出结果: 3   0.3
print(math.modf(-3.3))      --输出结果: -3  -0.3
 
print(math.floor(2^10))     --输出结果: 1024

--使用向左取整函数判断数值是否是整数(其它的取整函数也可以)
local function isinteger(num)
    if not tonumber(num) then return false end
    return math.floor(num) == num 
end

--将数值进行四舍五入(+0.5向左取整就促成了四舍五入,同理向右取整就是-0.5)
local a = 1244.66
print(math.floor(a + 0.5))

--当参数是一个很大的整数时，简单的加法会导致精度丢失，考虑下面的代码进行四舍五入
print(string.format("%d",math.floor(a + 0.5)))

--以上情况数值过大会出现错误,需要用到以下写法对整数单独处理
function round(x)
    local f = math.floor(x)
    if x == f then return f
    else return math.floor(x + 0.5)
    end
end

　　5. 取余函数 和 % 取模运算

　　　　① math.fmod(number)(向0取整)  和 % (向左取整) 的区别:　a与b两个整数做求模或求余操作。那么第一步是先求整数商c，即a / b的值，第二步是计算模或余数：a - c * b。求模与求余的区别在于怎么处理a / b的值。

--取模
print(-2 % 3)  　　　　　　　　--输出结果: 1
--以上代码相当于 ("//"向左取整)
print(-2 - (-2 // 3) * 3)

--取余
print(math.fmod(-2,3))　　　　--输出结果: -2
--以上代码相当于 (math.modf()向0取整)
--向0取整的意思是取距离0最近的整数 例如: -2.9  取得就是-2   2.9 取得就是2
print(-2 - (math.modf(-2 / 3) * 3))

　　6. 取绝对值函数

 　　　　① math.abs(number)

--取绝对值
print(math.abs(15))         --输出结果: 15
print(math.abs("26"))       --输出结果: 26.0
print(math.abs(-25))        --输出结果: 25
print(math.abs("-15"))      --输出结果: 15.0

--利用绝对值判断某个数值是否在某个数值的区间
local a = 50
local b = 60

if math.abs(b-a) <= 10 then
    print("a在b的区间")
else
    print("a不在b的区间")
end

　　7. 返回列表中最大最小的值函数

　　　　① math.max (x, ···) : 返回可变长参数(list)中最大的值

　　　　② math.min (x, ...) : : 返回可变长参数(list)中最小的值

--返回数组中最大的值
local t = {5,992,41214,24574,441,21214545,52454}
print(math.max(table.unpack(t)))        --输出结果: 21214545

 

　　8. Lua常量

　　　　 math.huge
　　　　浮点数 HUGE_VAL， 这个数比任何数字值都大。

　　　　math.pi
　　　　π 的值。

　　　　math.maxinteger
　　　　最大值的整数。

　　　　math.mininteger
　　　　最小值的整数。

　　9. 取绝对值比较整数数值函数(以<符号为准)

　　　　① math.ult (m, n): 如果整数 m 和 n 以无符号整数形式比较， m 在 n 之下，返回布尔真否则返回假。

print( math.ult (1, 2) )        --1 < 2 输出结果: true
print( math.ult (2, 2) )        --2 = 2 输出结果: false
print( math.ult (3, 2) )        --3 > 2 输出结果: false

　　10. 平方根函数

　　　　①math.sqrt (x) : 返回 x 的平方根。 （你也可以使用乘方 x^0.5 来计算这个值。）

　　11. 判断数值是否是整数

　　　　① math.tointeger(x): 如果 x 可以转换为一个整数， 返回该整数。 否则返回 nil。

　　　　 ② math.type (x) : 如果 x 是整数，返回 "integer"， 如果它是浮点数，返回 "float"， 如果 x 不是数字，返回 nil。

　　12. 随机数

--取随机数
--初始化随机种子
math.randomseed(os.time())
--3种调用方式
math.random()        --返回一个在[0,1)范围内的均匀分布的伪随机实数
math.random(6)       --返回一个在[1, n]范围内的伪随机整数
math.random(10, 50)  --返回在[m, n]范围内的伪随机整数

 

 

　　13. 数值的取值范围

　　　　① 标准Lua使用64个比特位来存储整型值，其最大值为: math.maxinteger获取的值

　　　   ② math.maxinteger和math.mininteger常量分别定义了整型值的最大值和最小值

　　　   ③ 当数值很大或者很小发生溢出时，就会发生回环。回环的意思就是结果只能在maxinteger和mininteger之间

--最大数和最小数常量
print(math.maxinteger)
print(math.mininteger)

--最大数+1回轮后跟最小数常量会相等
print(math.maxinteger + 1 == math.mininteger)   --输出结果: true
--最小数-1回轮后跟最大数常量会相等
print(math.mininteger - 1 == math.maxinteger)   --输出结果: true

--步骤: -最小数为正数然而这个正数超过了它最大数进行了回轮所以等于它自身,所以相等
print(-math.mininteger == math.mininteger)      --输出结果: true
--步骤: 负数 除以 负数 相当于 负数 乘以 负数 
print(math.mininteger // -1 == math.mininteger) --输出结果: true

　　　　④ 浮点数超出范围会得到一个整数的近似值

 

--超出了范围得到一个近似值
print( math.maxinteger + 2.0 == math.maxinteger + 1.0 ) --输出结果: true
--整数超过最大值或小于最小值会发生回环
print(999999999999999999999999999)
--小数超过最大值或小于最小值会得到与整数相近的数值(使用科学计数法表示)
print(9999999999999999999999999999999999999999999999999999999999999.00)