Haskell 在天真的整数分解中比 Python 慢？

Posted 2023-03-15

【中文标题】Haskell 在天真的整数分解中比 Python 慢？

【英文标题】：Haskell slower than Python in naïve integer factorization?

【发布时间】：2017-03-30 02:33:54

【问题描述】：

我正在上一门数学课程，我们必须做一些整数分解作为解决问题的中间步骤。我决定编写一个 Python 程序来为我做这件事（我们没有测试我们的分解能力，所以这完全是光明正大的）。程序如下：

#!/usr/bin/env python3

import math
import sys

# Return a list representing the prime factorization of n. The factorization is
#   found using trial division (highly inefficient).
def factorize(n):

    def factorize_helper(n, min_poss_factor):
        if n <= 1:
            return []
        prime_factors = []
        smallest_prime_factor = -1
        for i in range(min_poss_factor, math.ceil(math.sqrt(n)) + 1):
            if n % i == 0:
                smallest_prime_factor = i
                break
        if smallest_prime_factor != -1:
            return [smallest_prime_factor] \
                   + factorize_helper(n // smallest_prime_factor,
                                      smallest_prime_factor)
        else:
            return [n]

    if n < 0:
        print("Usage: " + sys.argv[0] + " n   # where n >= 0")
        return []
    elif n == 0 or n == 1:
        return [n]
    else:
        return factorize_helper(n, 2)

if __name__ == "__main__":
    factorization = factorize(int(sys.argv[1]))
    if len(factorization) > 0:
        print(factorization)

我也一直在自学一些 Haskell，所以我决定尝试用 Haskell 重写程序。该程序如下：

import System.Environment

-- Return a list containing all factors of n at least x.
factorize' :: (Integral a) => a -> a -> [a]
factorize' n x = smallestFactor
                 : (if smallestFactor == n
                    then []
                    else factorize' (n `quot` smallestFactor) smallestFactor)
    where
        smallestFactor = getSmallestFactor n x
        getSmallestFactor :: (Integral a) => a -> a -> a
        getSmallestFactor n x
            | n `rem` x == 0                          = x
            | x > (ceiling . sqrt . fromIntegral $ n) = n
            | otherwise                               = getSmallestFactor n (x+1)

-- Return a list representing the prime factorization of n.
factorize :: (Integral a) => a -> [a]
factorize n = factorize' n 2

main = do
    argv <- getArgs
    let n = read (argv !! 0) :: Int
    let factorization = factorize n
    putStrLn $ show (factorization)
    return ()

（注意：这需要64位环境。在32位上，导入Data.Int并使用Int64作为read (argv !! 0)上的类型注释）

写完这篇文章后，我决定比较两者的性能，发现有更好的算法，但两个程序使用基本相同的算法。例如，我会执行以下操作：

$ ghc --make -O2 factorize.hs
$ /usr/bin/time -f "%Uu %Ss %E" ./factorize 89273487253497
[3,723721,41117819]
0.18u 0.00s 0:00.23

然后，为 Python 程序计时：

$ /usr/bin/time -f "%Uu %Ss %E" ./factorize.py 89273487253497
[3, 723721, 41117819]
0.09u 0.00s 0:00.09

自然，每次我运行一个程序时，时间都会略有不同，但它们总是在这个范围内，Python 程序比编译的 Haskell 程序快几倍。在我看来，Haskell 版本应该能够运行得更快，我希望你能告诉我如何改进它。

我已经看到了一些优化 Haskell 程序的技巧，如对 this question 的回答，但似乎无法让我的程序运行得更快。循环比递归快得多吗？ Haskell 的 I/O 是不是特别慢？我在实际实现算法时犯了错误吗？理想情况下，我想要一个优化的 Haskell 版本，仍然相对容易阅读

【问题讨论】：

这与性能无关，但您不应该使用read 来处理用户输入。导入Text.Read 并使用readMaybe。这将使您能够正确处理错误。

FWIW，如果命令式地表达 Python 代码会好很多。 Aka. this code. 如果 Haskell 使用大整数（如 Python），PyPy 的速度是 Cactus 的 3 倍，如果 Haskell 使用固定宽度的整数，速度是合理的 85%。

请注意，像这样的总程序运行时间

@dfeuer -- 我并不太担心这里的错误处理，但请记住这一点。谢谢！ @Veedrac——你的 Python 程序比我的要干净得多。我以前没有用过yield，但它看起来真的很方便。 @leftaroundabout - 我知道这样的小测试通常并不可靠，但我之前没有听说过这个“热身”时间的想法。这真的很有趣；谢谢。

@jdw1996，是的，Haskell 运行时系统在开始运行用户代码之前需要花费大量时间来启动自身。它当然必须设置一些数据结构来管理垃圾收集，我想它可能会加载许多库，我相信它为标准输入/输出/错误分配 Haskell 句柄，并且它可能还有其他“管理”工作。

【参考方案1】：

如果您只计算一次 limit = ceiling . sqrt . fromIntegral $ n，而不是每次迭代一次，那么我发现 Haskell 版本更快：

limit = ceiling . sqrt . fromIntegral $ n
smallestFactor = getSmallestFactor x

getSmallestFactor x
    | n `rem` x == 0 = x
    | x > limit      = n
    | otherwise      = getSmallestFactor (x+1)

使用这个版本，我明白了：

$ time ./factorizePy.py 89273487253497
[3, 723721, 41117819]

real    0m0.236s
user    0m0.171s
sys     0m0.062s

$ time ./factorizeHs  89273487253497
[3,723721,41117819]

real    0m0.190s
user    0m0.000s
sys     0m0.031s

【参考方案2】：

除了 Cactus 提出的关键点之外，这里还有一些重构和严格注释的空间，以避免产生不必要的 thunk。特别注意factorize 是惰性的：

factorize' undefined undefined = undefined : undefined

这并不是必需的，它会强制 GHC 分配几个 thunk。其他地方的额外懒惰也是如此。我希望你会得到这样的更好的性能：

-# LANGUAGE BangPatterns #-

factorize' :: Integral a => a -> a -> [a]
factorize' n x
  | smallestFactor == n = [smallestFactor]
  | otherwise = smallestFactor : factorize' (n `quot` smallestFactor) smallestFactor
  where
    smallestFactor = getSmallestFactor n (ceiling . sqrt . fromIntegral $ n) x
    getSmallestFactor n !limit x
       | n `rem` x == 0 = x
       | x > limit = n
       | otherwise = getSmallestFactor n limit (x+1)

-- Return a list representing the prime factorization of n.
factorize :: Integral a => a -> [a]
factorize n = factorize' n 2

我让getSmallestFactor 将n 和limit 作为参数。这可以防止getSmallestFactor 被分配为堆上的闭包。我不确定这是否值得额外的争论。两种方法都可以试试。