Haskell：地图长度。组比显式递归慢得多吗？

Question

考虑这个简单的整数分解算法n：让d'成为最后找到的n的约数。最初，设置 d'=1。找到 n 的最小约数 d>d'，并找到最大值 e 使得 de除 n。将 de 附加到答案并在 n/de[=66 上重复该过程=]。最后，当 n 变为 1 时停止。为简单起见，让我们忽略数学优化，例如在 sqrt n 处停止等

我用两种方式实现了它。第一个生成除法“尝试”列表，然后按除数对成功的进行分组。例如，对于 n=20，我们首先生成 [(2,20),(2,10),(2,5),(3,5),(4,5),(5,5),(5,1)]，然后使用 group 和其他库函数将其转换为所需的 [(2,2),(5,1)]。

第二个实现是显式递归，沿途跟踪指数 e，附加 de一旦达到最大值 e，就会找到答案，继续寻找“下一个”d，依此类推。

问题 1：为什么第一个实现运行比第二个慢得多，尽管有以下内容：

两种实现都执行算法的核心步骤div，次数大致相同。
惰性求值（和融合？）的效果是从一开始就不必具体化上面说明的长列表。正如您在下面的代码中看到的，我正在谈论的列表 divTrials n 由一系列高阶函数转换。在那，我认为 map (\xs-> (head xs,length xs)) ... group 部分应该告诉编译器列表只是中间的：

{-# OPTIONS_GHC -O2 #-}
module GroupCheck where
import Data.List
import Data.Maybe

implement1 :: Integral t=> t -> [(t,Int)]                    -- IMPLEMENTATION 1
implement1  = map (\xs-> (head xs,length xs)).factorGroups where
  tryDiv (d,n)
    | n `mod` d == 0 = (d,n `div` d)
    | n == 1 = (1,1) -- hack
    | otherwise = (d+1,n)
  divTrials n = takeWhile (/=(1,1)) $ (2,n): map tryDiv (divTrials n)
  factorGroups = filter (not.null).map tail.group.map fst.divTrials

implement2 :: Show t => Integral t => t -> [(t,Int)]         -- IMPLEMENTATION 2
implement2 num = keep2 $ tail $ go (1,0,1,num) where
  range d n = [d+1..n]
  nextd d n = fromMaybe n $ find ((0==).(n`mod`)) (range d n)
  update (d,e,de,n)
    | n `mod` d == 0 = update (d,e+1,de*d,n`div`d)
    | otherwise      = (d,e,de,n)
  go (d,e,de,1) = [(d,e,de,1)]
  go (d,e,de,n) = (d,e,de,n) : go (update (nextd d n,0,1,n))
  keep2 = map (\(d,e,_,_)->(d,e))

main :: IO ()
main = do
  let n = 293872
  let ans1 = implement1 n 
  let ans2 = implement2 n
  print ans1
  print ans2

分析告诉我们 tryDiv 和 divTrials 一起占用了整个执行时间的 >99%：

> stack ghc -- -main-is GroupCheck.main -prof -fprof-auto -rtsopts GroupCheck 
> ./GroupCheck +RTS -p >/dev/null && cat GroupCheck.prof


           GroupCheck +RTS -p -RTS

        total time  =       18.34 secs   (18338 ticks @ 1000 us, 1 processor)
        total alloc = 17,561,404,568 bytes  (excludes profiling overheads)

COST CENTRE          MODULE     SRC                          %time %alloc

implement1.divTrials GroupCheck GroupCheck.hs:12:3-69         52.6   69.2
implement1.tryDiv    GroupCheck GroupCheck.hs:(8,3)-(11,25)   47.2   30.8

问题 1.5: 所以..这些函数有什么不好的？还有，

问题 2： 在更一般的情况下，必须聚合来自非递减序列的相同元素的连续块，我们是否应该采用庞大的 implement2 方式，如果我们想要速度？（同样，忽略特定领域的优化。）

还是我完全错过了一些明显的东西？谢谢！

Answer 1

只是为了建立一个基线，我运行你的程序在一个稍大的起始数字上（所以 time 没有打印出 0.00s）。我选择 n = 2938722345623 没有特别的原因。这是开始调整之前的时间安排：

ans1: 无异于无限（我写完这整个答案还是运行，一共约26分钟）
ans2：2.78s

首先要尝试调整这一行：

divTrials n = takeWhile (/=(1,1)) $ (2,n): map tryDiv (divTrials n)

这看起来是一个很自然的定义，但事实证明 GHC 从不记忆函数调用。因此，如果您想创建一个根据自身递归定义的列表，则不得在递归中进行函数调用。方法如下：

divTrials n = xs where xs = takeWhile (/=(1,1)) $ (2,n): map tryDiv xs

正是这一变化使时间缩短到 7.85 秒。仍然相差约 3 倍，但好多了。

不太明显的问题在于：

factorGroups = filter (not.null).map tail.group.map fst.divTrials

如此早地放置 group 会破坏融合，导致该中间列表实际上被具体化。这意味着分配和释放大量的 cons 单元和元组。这是一个具有相同精神的实现，但在 group:

之前做了更多工作

  tryDiv d n
    | n `mod` d == 0 = d : tryDiv d (n `div` d)
    | n == 1 = []
    | otherwise = tryDiv (d+1) n
  factorGroups = group . tryDiv 2

有了这个，我们下降到 2.65s -- 比 ans2 稍微快一点，虽然我只对每个测试进行了一次测试，所以它很可能只是测量噪声。

Haskell：地图长度。组比显式递归慢得多吗？

Haskell: map length . group is way slower than explicit recursion?

performance

grouping

haskell

lazy-evaluation

prime-factoring