【问题标题】:decimals not working with factorials in roblox lua小数不适用于roblox lua中的阶乘
【发布时间】:2021-05-11 01:23:19
【问题描述】:

你想达到什么目标? 我想做一个阶乘函数

有什么问题? 除非它们是整数,否则我找不到任何解决阶乘的方法

到目前为止,您尝试了哪些解决方案? 我看过 roblox devforum 和 youtube 和 google 和 discord,但我真的找不到任何方法让小数与阶乘一起正常工作

我唯一知道的是你可以使用伽马函数来解决十进制阶乘,但我正在寻找,但我不知道如何将它实现到 luau 中,所以我真的很挣扎 我什至使用了斯特林的近似值,但这并不是 100% 正确的,因为我需要一些东西来完全符合实际的答案

local function SolveFactorial(FN)
    if string.match(FN, "^-") then
        local T = 1
        FN *= -1
        for i = FN, 1, -1 do
            T = T * i
        end
        T *= -1
        return T
    else
        local T = 1
        for i = FN, 1, -1 do
            T = T * i
        end
        return T
    end
end

这是一个正常的阶乘函数,适用于除 0 以外的所有整数

local function SF(FN)
    if string.match(FN, "^-") then
        FN *= -1
        local N = math.sqrt(2*math.pi*FN)*math.pow((FN/math.exp(1)), FN)
        N *= -1
        return N
    else
        local N = math.sqrt(2*math.pi*FN)*math.pow((FN/math.exp(1)), FN)
        return N
    end
end

这是斯特林的近似值,正如我之前所说,它不是 100% 准确的

这是我目前拥有的两个功能,我不知道此时我应该做什么来修复它 有没有办法使用 gamma 函数,或者有比我在 atm 做的更简单的方法吗

注意这是roblox lua!!!

任何帮助都会真正节省大量时间,谢谢你,nici

【问题讨论】:

    标签: lua roblox


    【解决方案1】:

    您的问题标题有点误导,并不是小数不起作用。正是斯特林近似为您的目的提供了不准确的数字。

    如果您需要 gamma 函数,Rosetta Code 上有一个非常易于使用的实现。我做了一些小的调整并在此处转录:

    local function gammafunc(z)
        local gamma = 0.577215664901
        local coeff = -0.65587807152056
        local quad = -0.042002635033944
        local qui = 0.16653861138228
        local set = -0.042197734555571
    
        function recigamma(rz)
          return rz + gamma * rz^2 + coeff * rz^3 + quad * rz^4 + qui * rz^5 + set * rz^6
        end
         
        if z == 1 then
            return 1
        elseif math.abs(z) <= 0.5 then
            return 1 / recigamma(z)
        else
            return (z - 1) * gammafunc(z - 1)
        end
    end
    

    为了让它正确返回正确的阶乘值,您需要将 z 偏移 1。

    for n = 0.0, 10, 0.2 do
        local f1 = factorial(n)
        local f2 = stirlingApprox(n)
        local f3 = gammafunc(n + 1)
        print(n, f1, f2, f3)
    end
    ---[[ Returns...
     n             n!            Stirling          Gamma
    0.0           1.0000         -0.0000          1.0000
    0.2                           0.6652          0.9182
    0.4                           0.7366          0.8872
    0.6                           0.7843          0.8934
    0.8                           0.8427          0.9314
    1.0           1.0000          0.9221          1.0000
    1.2                           1.0293          1.1018
    1.4                           1.1714          1.2421
    1.6                           1.3579          1.4295
    1.8                           1.6014          1.6765
    2.0           2.0000          1.9190          2.0000
    2.2                           2.3344          2.4240
    2.4                           2.8800          2.9811
    2.6                           3.6003          3.7167
    2.8                           4.5571          4.6942
    3.0           6.0000          5.8362          6.0000
    3.2                           7.5579          7.7567
    3.4                           9.8914         10.1358
    3.6                          13.0759         13.3803
    3.8                          17.4518         17.8378
    4.0          24.0000         23.5062         24.0000
    4.2                          31.9393         32.5781
    4.4                          43.7635         44.5977
    4.6                          60.4506         61.5492
    4.8                          84.1502         85.6217
    5.0         120.0000        118.0192        120.0000
    5.2                         166.7162        169.4060
    5.4                         237.1499        240.8277
    5.6                         339.6157        344.6753
    5.8                         489.5289        496.6057
    6.0         720.0000        710.0782        720.0000
    6.2                        1036.3071       1050.3173
    6.4                        1521.4128       1541.2974
    6.6                        2246.5097       2274.8568
    6.8                        3335.8193       3376.9185
    7.0        5040.0000       4980.3958       5040.0000
    7.2                        7475.3217       7562.2846
    7.4                       11278.2406      11405.6005
    7.6                       17101.8057      17288.9114
    7.8                       26060.2260      26339.9645
    8.0       40320.0000      39902.3955      40320.0000
    8.2                       61384.0725      62010.7339
    8.4                       94864.1090      95807.0442
    8.6                      147262.8822     148684.6384
    8.8                      229608.1738     231791.6880
    9.0      362880.0000     359536.8728     362880.0000
    9.2                      565356.8075     570498.7521
    9.4                      892663.0429     900586.2158
    9.6                     1415149.6282    1427372.5285
    9.8                     2252332.9545    2271558.5427
    10.0     3628800.0000   3598695.6187    3628800.0000]]
    

    请记住,此实现运行与传统阶乘函数具有相同的堆栈溢出风险,因为它需要递归计算值。您使用的斯特林近似值明显更快,并且在某些情况下可能已经足够了。

    【讨论】:

    • 非常感谢,也很抱歉我在标题上有点误导?
    猜你喜欢
    • 1970-01-01
    • 1970-01-01
    • 1970-01-01
    • 2021-04-16
    • 2022-11-14
    • 1970-01-01
    • 1970-01-01
    • 2014-03-24
    • 1970-01-01
    相关资源
    最近更新 更多