blocks|key|3211452|text|10%5E12是一个整数，它强制fromIntegral的值是一个整数，这意味着difffibonaccimap被分配了一个四舍五入的值，所以如果时间小于半秒，它就是0。(不管怎样，这是我的猜测。我没有时间去研究它。)|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3211453|entityMap^0|0|5|E|C|12|G|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|O|8|@]|D|@]|E|$]]]|G|$]]

<code>10^12</code> is an integer, which forces the value of <code>fromIntegral</code> to be an integer, which means <code>difffibonaccimap</code> is assigned a rounded value, so it's 0 if the time is less than half a second. (That's my guess, anyway. I don't have time to look into it.)

blocks|key|3211471|text|哈斯克尔很懒。您在行中请求的计算|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3211472|let+fibonaccimap+=+map+fib+listaVintesete|code-block|syntax|javascript|3211473|直到你以某种方式使用了fibonaccimap的值，它才会真正发生。因此，为了测量所用的时间，您需要引入一些强制程序执行实际计算的东西。|offset|length|style|CODE|3211474|ETA:我最初建议打印最后一个元素来强制求值。正如TomMD指出的，这远远不够好--我强烈建议阅读他在这里的回复，以获得处理这段特定代码的实际有效方法。|3211475|entityMap^0|0|0|B|C|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Haskell is lazy. The computation you request in the line

<pre><code>let fibonaccimap = map fib listaVintesete
</code></pre>

doesn't actually happen until you somehow use the value of <code>fibonaccimap</code>. Thus to measure the time used, you'll need to introduce something that will force the program to perform the actual computation.

ETA: I originally suggested printing the last element to force evaluation. As TomMD points out, this is nowhere near good enough -- I strongly recommend reading his response here for an actually working way to deal with this particular piece of code.

blocks|key|1049540|text|我怀疑你是lazy+evaluation的“受害者”。不会强制在两次计时调用之间对fibonaccimap求值，因此不会计算它。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1049541|编辑我怀疑你是在尝试对你的代码进行基准测试，在这种情况下，应该指出的是，better+ways+to+do+this更可靠。|style|BOLD|1049542|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Lazy_evaluation|1|http://www.serpentine.com/blog/2009/09/29/criterion-a-new-benchmarking-library-for-haskell/|2|http://donsbot.wordpress.com/2010/02/23/modern-benchmarking-in-haskell/^0|5|F|0|0|0|2|10|B|1|1F|7|2|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@$A|U|B|V|1|W]]|C|$]]|$1|D|3|E|5|6|7|X|8|@$A|Y|B|Z|F|G]]|9|@$A|10|B|11|1|12]|$A|13|B|14|1|15]]|C|$]]|$1|H|3|-4|5|6|7|16|8|@]|9|@]|C|$]]]|I|$J|$5|K|L|M|C|$N|O]]|P|$5|K|L|M|C|$N|Q]]|R|$5|K|L|M|C|$N|S]]]]

I suspect you are a "victim" of <a href="http://en.wikipedia.org/wiki/Lazy_evaluation" rel="nofollow">lazy evaluation</a>. Nothing forces the evaluation of fibonaccimap between the timing calls, so it's not computed.

Edit
I suspect you're trying to benchmark your code, and in that case it should be pointed out that there are <a href="http://www.serpentine.com/blog/2009/09/29/criterion-a-new-benchmarking-library-for-haskell/" rel="nofollow">better ways</a> to <a href="http://donsbot.wordpress.com/2010/02/23/modern-benchmarking-in-haskell/" rel="nofollow">do this</a> more reliably.

blocks|key|4679281|text|正如其他人所说，这是由于懒惰的评估造成的。要强制求值，您应该使用deepseq包和BangPatterns|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4679282|{-#+LANGUAGE+BangPatterns+#-}
import+Control.DeepSeq
import+Text.Printf
import+System.CPUTime

main+::+IO+()
main+=+do
+iniciofibonaccimap+<-+getCPUTime
+let+!fibonaccimap+=+rnf+$+map+fib+listaVintesete
+fimfibonaccimap+<-+getCPUTime
+let+difffibonaccimap+=+(fromIntegral+(fimfibonaccimap+-+iniciofibonaccimap))+/+(10%5E12)
+printf+"Computation+time+fibonaccimap:+%250.3f+sec\n"+(difffibonaccimap+::+Double)
...|code-block|syntax|javascript|4679283|在上面的代码中，您应该注意三件事：|4679284|4679285|It编译(对上面定义的函数的...取模)。当你发布代码提问时，请确保它运行(低，你应该包括导入)|ordered-list-item|4679286|+rnf+|4679287|deepseq的使用。这将强制对列表中的每个元素进行求值。|4679288|+!fibonaccimap上的bang模式，意思是“立即执行此操作，不要等待”。这迫使列表被评估为弱头部范式(whnf，基本上只是第一个构造函数(:))。否则，rnf函数本身将保持为unevaluated.|4679289|4679290|结果是：|4679291|$+ghc+--make+ds.hs
$+./ds
Computation+time+fibonaccimap:+6.603+sec|4679292|如果您打算进行基准测试，还应该使用优化(-O2)和Criterion包，而不是getCPUTime。|4679293|entityMap|0|LINK|mutability|MUTABLE|url|http://hackage.haskell.org/package/deepseq|1|http://hackage.haskell.org/package/criterion^0|15|C|W|7|0|0|0|0|0|E|3|0|1|3|0|0|7|0|1|D|21|3|29|3|0|0|0|0|K|3|13|A|P|9|1|0^^$0|@$1|2|3|4|5|6|7|1D|8|@$9|1E|A|1F|B|C]]|D|@$9|1G|A|1H|1|1I]]|E|$]]|$1|F|3|G|5|H|7|1J|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1K|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|1L|8|@]|D|@]|E|$]]|$1|N|3|O|5|P|7|1M|8|@$9|1N|A|1O|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|P|7|1P|8|@$9|1Q|A|1R|B|C]]|D|@]|E|$]]|$1|S|3|T|5|6|7|1S|8|@$9|1T|A|1U|B|C]]|D|@]|E|$]]|$1|U|3|V|5|P|7|1V|8|@$9|1W|A|1X|B|C]|$9|1Y|A|1Z|B|C]|$9|20|A|21|B|C]]|D|@]|E|$]]|$1|W|3|-4|5|6|7|22|8|@]|D|@]|E|$]]|$1|X|3|Y|5|6|7|23|8|@]|D|@]|E|$]]|$1|Z|3|10|5|H|7|24|8|@]|D|@]|E|$I|J]]|$1|11|3|12|5|6|7|25|8|@$9|26|A|27|B|C]|$9|28|A|29|B|C]]|D|@$9|2A|A|2B|1|2C]]|E|$]]|$1|13|3|-4|5|6|7|2D|8|@]|D|@]|E|$]]]|14|$15|$5|16|17|18|E|$19|1A]]|1B|$5|16|17|18|E|$19|1C]]]]

As others have said, this is due to lazy evaluation. To force evaluation you should use the <a href="http://hackage.haskell.org/package/deepseq" rel="noreferrer">deepseq</a> package and <code>BangPatterns</code>:

<pre><code>{-# LANGUAGE BangPatterns #-}
import Control.DeepSeq
import Text.Printf
import System.CPUTime

main :: IO ()
main = do
 iniciofibonaccimap &lt;- getCPUTime
 let !fibonaccimap = rnf $ map fib listaVintesete
 fimfibonaccimap &lt;- getCPUTime
 let difffibonaccimap = (fromIntegral (fimfibonaccimap - iniciofibonaccimap)) / (10^12)
 printf "Computation time fibonaccimap: %0.3f sec\n" (difffibonaccimap :: Double)
...
</code></pre>

In the above code you should notice three things:

<ol>
<li>It compiles (modulo the <code>...</code> of functions you defined above). When you post code for questions please make sure it runs (iow, you should include imports)</li>
<li>The use of <code>rnf</code> from <code>deepseq</code>. This forces the evaluation of each element in the list.</li>
<li>The bang pattern on <code>!fibonaccimap</code>, meaning "do this now, don't wait". This forces the list to be evaluated to weak-head normal form (whnf, basically just the first constructor <code>(:)</code>). Without this the <code>rnf</code> function would itself remain unevaluated.</li>
</ol>

Resulting in:

<pre><code>$ ghc --make ds.hs
$ ./ds
Computation time fibonaccimap: 6.603 sec
</code></pre>

If you're intending to do benchmarking you should also use optimization (<code>-O2</code>) and the <a href="http://hackage.haskell.org/package/criterion" rel="noreferrer">Criterion</a> package instead of <code>getCPUTime</code>.

blocks|key|895937|text|正如其他答案所说，懒惰的评估实际上已经咬了你一口。具体地说，'let‘不会强制表达式求值，它只是限定变量的作用域。计算实际上不会发生，直到某个东西需要它的值，而这可能只有在实际的IO操作需要它的值时才会发生。因此，您需要将打印语句放在getCPUTime求值之间。当然，这也会得到print使用的CPU时间，但print的大部分时间都在等待IO。(终端速度很慢。)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|895938|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Lazy evaluation has in fact bitten you, as the other answers have said. Specifically, 'let' doesn't force the evaluation of an expression, it just scopes a variable. The computation won't actually happen until its value is demanded by something, which probably won't happen until an actual IO action needs its value. So you need to put your print statement between your getCPUTime evaluations. Of course, this will also get the CPU time used by print in there, but most of print's time is waiting on IO. (Terminals are slow.)

I have:

<pre><code>main :: IO ()
main = do
 iniciofibonaccimap &lt;- getCPUTime
 let fibonaccimap = map fib listaVintesete
 fimfibonaccimap &lt;- getCPUTime
 let difffibonaccimap = (fromIntegral (fimfibonaccimap - iniciofibonaccimap)) / (10^12)
 printf "Computation time fibonaccimap: %0.3f sec\n" (difffibonaccimap :: Double)

listaVintesete :: [Integer]
listaVintesete = replicate 100 27

fib :: Integer -&gt; Integer
fib 0 = 0
fib 1 = 1
fib n = fib (n-1) + fib (n-2)
</code></pre>

But

<pre><code>*Main&gt; main
Computation time fibonaccimap: 0.000 sec
</code></pre>

I do not understand why this happens.
Help-me thanks.

Haskell: can't use getCPUTime

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我有：main :: IO ()main = do iniciofibonaccimap <- getCPUTime let fibonaccimap = map fib listaVintesete fimfibonaccimap <- getCPUTime let difffibon...

问哈斯克尔:不能使用getCPUTime
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问哈斯克尔:不能使用getCPUTimeEN