哪种方法最有效地将数字四舍五入并截断（在四舍五入后删除小数位）？
例如，如果小数大于0.5（即0.6、0.7等），我想要先将其四舍五入再截断（情况1）。否则，我想要直接截断（情况2）。
for example:
232.98266601563 => after rounding and truncate = 233 (case 1)
232.49445450000 => after rounding and truncate = 232 (case 2)
232.50000000000 => after rounding and truncate = 232 (case 2)
Lua中没有内置的math.round()函数，但是可以使用以下方法： print(math.floor(a+0.5))。
a 应该是什么？ - averwhya 是你想要四舍五入的值。 - Nifim1.49999999999999988 + 0.5，结果很好。同样适用于 2.49999999999999977 + 0.5。 - Roland Illig一个有用的技巧，用于将十进制数值四舍五入到小数位而不是整数位，是将数值传递到格式化的ASCII文本中，并使用%f格式字符串来指定所需的舍入方式。例如：
mils = tonumber(string.format("%.3f", exact))
将exact中的任意值四舍五入为0.001的倍数。
使用math.floor（）或math.ceil（）之前和之后进行比例缩放可以得到类似的结果，但是根据您对边缘情况处理的期望获取正确的细节可能会很棘手。虽然string.format（）也存在此问题，但已经投入了大量工作使其产生“预期”的结果。
将值四舍五入为除十的幂以外的倍数仍需要进行缩放，并且仍具有所有棘手的边缘情况。一种简单表达且具有稳定行为的方法是编写：
function round(exact, quantum)
local quant,frac = math.modf(exact/quantum)
return quantum * (quant + (frac > 0.5 and 1 or 0))
end
您可以微调 frac 的确切条件（可能还包括exact的符号）来获得您想要的边缘情况。
string.format() 根据使用的 Lua 版本而有所不同。请参见我的关于 LuaJIT 的问题，它更喜欢向上舍入，而大多数其他情况下会向下舍入，当面对“精确”的一半时。 - Caleb(exact + quantum*0.5) // quantum * quantum呢？ - AF7要支持负数，可以使用以下代码：
function round(x)
return x>=0 and math.floor(x+0.5) or math.ceil(x-0.5)
end
local function round(num)
return num + (2^52 + 2^51) - (2^52 + 2^51)
end
注意，括号中的数字是在编译时计算的，不影响运行时。
例如，当FPU设置为四舍五入到最近偶数时，该单元测试将打印“所有测试都通过”：
local function testnum(num, expected)
if round(num) ~= expected then
error(("Failure rounding %.17g, expected %.17g, actual %.17g")
:format(num+0, expected+0, round(num)+0))
end
end
local function test(num, expected)
testnum(num, expected)
testnum(-num, -expected)
end
test(0, 0)
test(0.2, 0)
test(0.4, 0)
-- Most rounding algorithms you find on the net, including Ola M's answer,
-- fail this one:
test(0.49999999999999994, 0)
-- Ties are rounded to the nearest even number, rather than always up:
test(0.5, 0)
test(0.5000000000000001, 1)
test(1.4999999999999998, 1)
test(1.5, 2)
test(2.5, 2)
test(3.5, 4)
test(2^51-0.5, 2^51)
test(2^51-0.75, 2^51-1)
test(2^51-1.25, 2^51-1)
test(2^51-1.5, 2^51-2)
print("All tests passed")
这里有另一种算法(当然不够高效)，它可以对所有数字执行相同的FPU舍入：
local function round(num)
local ofs = 2^52
if math.abs(num) > ofs then
return num
end
return num < 0 and num - ofs + ofs or num + ofs - ofs
end
2^52 + 2^51 吗？我尝试了 2^53 - 2，在你的测试用例中同样有效。当然，我可以自己计算，这肯定是值得的，但也许你可以在这里与更广泛的受众分享一些棘手的细节和边缘情况。 - Roland Illig以下代码可将数字四舍五入至任意位数（如果未定义，则为0）：
function round(x, n)
n = math.pow(10, n or 0)
x = x * n
if x >= 0 then x = math.floor(x + 0.5) else x = math.ceil(x - 0.5) end
return x / n
end
x=32.90625和n=4，则大多数Luas将给出32.9062，但LuaJIT将给出23.0963。请参见我的问题以了解如何避免此问题。 - Calebn或0没有涵盖定义数字数目的情况（使用函数中第二个参数...并通过arg[2]进行引用可以实现这一点），更不用说可能会出现除以0的情况。我也可以提到少见的-0发生情况，但你明白我的意思：只要正确处理异常情况，方法就是好的。 - Yin Cognyto对于不良的四舍五入（截断结尾）：
function round(number)
return number - (number % 1)
end
如果你愿意的话，你可以扩展这个内容以便更好地概括。
function round(number)
if (number - (number % 0.1)) - (number - (number % 1)) < 0.5 then
number = number - (number % 1)
else
number = (number - (number % 1)) + 1
end
return number
end
print(round(3.1))
print(round(math.pi))
print(round(42))
print(round(4.5))
print(round(4.6))
3, 3, 42, 5, 5
我喜欢RBerteig上面的回答：mils = tonumber(string.format("%.3f", exact))。将其扩展为函数调用并添加了精度值。
function round(number, precision)
local fmtStr = string.format('%%0.%sf',precision)
number = string.format(fmtStr,number)
return number
end
string.format() 根据使用的 Lua 版本而有所不同。请参见我的关于 LuaJIT 的问题，它更喜欢向上舍入，而大多数其他情况下会向下舍入，当面对“精确”的一半时。 - Caleb如果不存在math.round
function math.round(x, n)
return tonumber(string.format("%." .. n .. "f", x))
end
这里有一个灵活的函数，可以将数字四舍五入到不同的位数。我已经测试过它适用于负数、大数、小数以及各种边缘情况，它非常实用可靠:
function Round(num, dp)
--[[
round a number to so-many decimal of places, which can be negative,
e.g. -1 places rounds to 10's,
examples
173.2562 rounded to 0 dps is 173.0
173.2562 rounded to 2 dps is 173.26
173.2562 rounded to -1 dps is 170.0
]]--
local mult = 10^(dp or 0)
return math.floor(num * mult + 0.5)/mult
end
对于保留给定小数位数（也可以是负数）的四舍五入，我建议采用以下解决方案，它结合了已经提供的答案，特别是Pedro Gimeno提供的启发式答案。我测试了一些我感兴趣的边角情况，但不能保证这使得该函数100％可靠：
function round(number, decimals)
local scale = 10^decimals
local c = 2^52 + 2^51
return ((number * scale + c ) - c) / scale
end
这些案例说明了"四舍五入到最近的偶数"属性（这应该是大多数机器的默认设置）：
assert(round(0.5, 0) == 0)
assert(round(-0.5, 0) == 0)
assert(round(1.5, 0) == 2)
assert(round(-1.5, 0) == -2)
assert(round(0.05, 1) == 0)
assert(round(-0.05, 1) == 0)
assert(round(0.15, 1) == 0.2)
assert(round(-0.15, 1) == -0.2)
我知道我的回答没有处理实际问题的第三种情况，但为了符合IEEE-754标准，我的方法是有意义的。因此，我期望结果取决于FPU中设置的当前舍入模式，其中FE_TONEAREST是默认值。这就是为什么在设置FE_TOWARDZERO之后（无论您如何在Lua中设置），此解决方案似乎极有可能返回与问题所要求的完全相同的结果。