Question

所以我正在研究一种懒惰生成素数的方法，我想出了这三个定义，它们都以相同的方式工作 - 只需检查每个新的整数在所有前面的素数中有一个因素：

primes1 :: [Integer]
primes1 = mkPrimes id [2..]
  where mkPrimes f (x:xs) = 
          if f (const True) x 
          then 
            let g h y = y `mod` x > 0 && h y in
            x : mkPrimes (f . g) xs
          else
            mkPrimes f xs

primes2 :: [Integer]
primes2 = mkPrimes id (const True) [2..]
  where mkPrimes f f_ (x:xs) = 
          if f_ x 
          then 
            let g h y = y `mod` x > 0 && h y in
            x : mkPrimes (f . g) ( f $ g $ const True) xs
          else
            mkPrimes f f_ xs

primes3 :: [Integer]
primes3 = mkPrimes [] [2..]
  where mkPrimes ps (x:xs) = 
          if all (\p -> x `mod` p > 0) ps
          then 
            x : mkPrimes (ps ++ [x]) xs
          else
            mkPrimes ps xs

所以在我看来primes2应该比primes1快一点，因为它避免重新计算每个整数f_ = f (const True)（我认为需要按照数字的顺序工作）我们到目前为止找到的素数），只有当我们遇到新的素数时才更新它。

仅仅从不科学的测试（在ghci中运行take 1000）看来primes3运行得更快比primes2。

我应该从中吸取教训，并假设我可以将一个函数表示为一个操作在一个数组上，我应该以后一种方式实现它以提高效率，或者有什么东西还在这儿吗？

Answer 1

f需要的第二个参数是什么？在我看来，这两种替代方案都更具可读性，并且不会对性能产生重大影响......

...
            let g y = f y && y `mod` x > 0 in
            x : mkPrimes g xs
...

import Control.Arrow  -- instance Monad (-> r)
import Control.Monad  -- liftM2
(.&&.) = liftM2 (&&)
...
            let g y = y `mod` x > 0 in
            x : mkPrimes (f .&&. g) xs
...

无论如何，回到这个问题。有时使用函数作为数据结构是某个任务的最佳表示，有时不是。在编码简易性方面“最佳”和在性能方面“最佳”并不总是相同的。 “作为数据结构的功能”技术对runtime compilation至关重要，但随着该页面发出警告，

运行时编译有时可以为您带来显着的效率提升，但通常可以以增加的压力和降低的工作效率为代价赢得几乎任何东西。

在您的情况下，构建每个f :: Integer -> ... -> Bool的开销可能远高于构建每个ps :: [Integer]的开销，而在调用f ... x与{{all ... ps时几乎没有差异1}}。

要从无限的主筛中挤出循环，摆脱对mod的调用！整数乘法，除法和模数比整数加法和减法慢得多。在我的机器上，这个实现在计算前1000个素数时速度快40％（GHC 6.10.3 -O2）。

import qualified Data.Map as M
primes' :: [Integer]
primes' = mkPrimes 2 M.empty
  where
    mkPrimes n m = case (M.null m, M.findMin m) of
        (False, (n', skips)) | n == n' ->
            mkPrimes (succ n) (addSkips n (M.deleteMin m) skips)
        _ -> n : mkPrimes (succ n) (addSkip n m n)
    addSkip n m s = M.alter (Just . maybe [s] (s:)) (n+s) m
    addSkips = foldl' . addSkip

在行动中（使用一些JSON-ish语法），

   mkPrimes 2 {}
=> 2 : mkPrimes 3 {4: [2]}
=> 2 : 3 : mkPrimes 4 {4: [2], 6: [3]}
=> 2 : 3 : mkPrimes 5 {6: [2, 3]}
=> 2 : 3 : 5 : mkPrimes 6 {6: [2, 3], 10: [5]}
=> 2 : 3 : 5 : mkPrimes 7 {8: [2], 9: [3], 10: [5]}
=> 2 : 3 : 5 : 7 : mkPrimes 8 {8: [2], 9: [3], 10: [5], 14: [7]}
=> 2 : 3 : 5 : 7 : mkPrimes 9 {9: [3], 10: [2, 5], 14: [7]}
=> 2 : 3 : 5 : 7 : mkPrimes 10 {10: [2, 5], 12: [3], 14: [7]}
=> 2 : 3 : 5 : 7 : mkPrimes 11 {12: [2, 3], 14: [7], 15: [5]}
...

地图会跟踪未来的倍数，只使用其他内容。

Answer 2

请注意，将primes3更改为ps++[x]可以提高(x:ps)的效率。运行(++)在其左参数的长度上是线性的，但在右参数的长度上是常量。

Haskell风格/效率

2 个答案: