为什么大量分解的速度更快 [英] Why does division become faster with very large numbers
问题描述
我想看看除法运算的常数,所以我运行了这段代码
导入时间
def di(n):
n / 101
i = 10
而我< 1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000:
start = time.clock()
di(i)
end = time.clock()
print( On + str(i)+ + str(end-start))
i * = 10000
这是我得到的输出
在10 5.98714047756e-06
p>
在100000 4.7041818038e-06
在1000000000 2.56591734753e-06
上10000000000000 2.99357023878e-06
上100000000000000000 2.99357023878e-06
上1000000000000000000000 2.99357023879e-06
上10000000000000000000000000 2.99357023878e-06
上100000000000000000000000000000 3.42122313003e-06
在1000000000000000000000000000000000000000 3.42122313003e-06
在10000000000000000000000000000000000000000000 3.84887602128e-06
在1000000000000000000000000000000000000000000000000000 3.84887602128e-06
在10000000000000000000000000000000000000000000 3.84887602128e-06
在10000000000000000000000000000000000000000000000000000000 1 .71061156501e-06
上100000000000000000000000000000000000000000000000000000000000000000 1.71061156502e-06
上1000000000000000000000000000000000000000000000000000000000 1.71061156501e-06
上10000000000000000000000000000000000000000000000000000000000000000000 2.13826445628e-06
上100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000b 2.13826445628e-06
在10000000000000000000000000000000000000000000000000000000000000000000000000000000000000 2.13826445628e-06
在100000000000000000000000000000000000000000000000000000000000000000000000000000000000 2.13826445626e-06
在1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 2.13826445626e-06
为什么后来的除法通常会比前两个术语中最小的时间更快?
解决方案
为什么相对于前两个术语中最小的时间,该除法通常会在以后变得更快吗?
,实际上。如果我将
di
替换为:def di(n):
for i在范围(10000000)中:n / 101
然后我得到了(Python 3.5,我假设您正在使用):
在10 0.546889
在100000 0.545004
在1000000000 0.5454929999999998
在10000000000000上0.5519709999999998
在100000000000000000 1.330797
在1000000000000000000000 1.31053
在10000000000000000000000000 1.3393129999999998
在100000000000000000000000000000 1.3524339999999997
在1000000000000000000000000000000000 1.3817269999999997
在1000000000000000000000000 $ b在100000000000000000000000000000000000000000000 1.3358929999999987
在1000000000000000000000000000000000000000000000 1.3773859999999996
在10000000000000000000000000000000000000000000000000000000 1.3326890000000002
在100000000000000000000000000000000000000000000000000000000000000 3000 1.3704769999999993
在100000000000000000000 0000000000000000000000000000000000000 1.3235019999999995
在10000000000000000000000000000000000000000000000000000000000000 1.357647
在100000000000000000000000000000000000000000000000000000000000000000 1.3341190000000012
在1000000000000000000000000000000000000000000000000000000000000000000000 1.326544000000002
在10000000000000000000000000000000000000000000000000000000000000000000000000 1.3671139999999973
在100000000000000000000000000000000000000000000000000000000000000000000000000000 1.3630120000000012
在1000000000000000000000000000000000000000000000000000000000000000000000000000000000 1.3600200000000022
在10000000000000000000000000000000000000000000000000000000000000000000000000000000000000 1.3189189999999975
在100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 1.3503469999999993
您可以看到,大约有两次:较小的数字,较大的一个数字。在Python 3.5中,
/
进行浮点除法,因此无论数字大小如何,它实际上应该花费相同的时间。
但是,从小到大都有差距。使用以下函数保留语义的Python 2.7也会发生相同的结果:
def di(n):
用于我在xrange(10000000)中:n / 101.0
在同一台机器上,我得到:
在10 0.617427
在100000 0.61805
在1000000000 0.6366
在10000000000000 0.620919
在100000000000000000 0.616695
上1000000000000000000000 0.927353
上10000000000000000000000000 1.007156
上100000000000000000000000000000 0.98597
上1000000000000000000000000000000000 0.99258
上10000000000000000000000000000000000000000000 0.966753
上10000000000000000000000000000000000000000 0.992684
上0.991711
上10000000000000000000000000000000000000000000000000 0.994703
上100000000000000000000000000000000000000000000000000000000000 0.978877
上1000000000000000000000000000000000000000000000000000000000000000000000 0.982035
上10000000000000000 000000000000000000000000000000000000000000000 0.973266
在100000000000000000000000000000000000000000000000000000000000000000 0.977911
在1000000000000000000000000000000000000000000000000000000000000000000000 0.996857
在10000000000000000000000000000000000000000000000000000000000000000000000000 0.972555
在100000000000000000000000000000000000000000000000000000000000000000000000000000 0.985676
在1000000000000000000000000000000000000000000000000000000000000000000000000000000000 0.987412
在10000000000000000000000000000000000000000000000000000000000000000000000000000000000000 0.997207
在100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 0.970129
这与将整数转换为浮点数有关(具体细节待定)数。当整数超过某个点时,速度会变慢,并且当超过该点时,除法运算会花费更长的时间。
I wanted to see how constant the division operation is, so I ran this code
import time def di(n): n/101 i = 10 while i < 1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000: start = time.clock() di(i) end = time.clock() print("On " + str(i) + " " + str(end-start)) i *= 10000
And this was the output I got
On 10 5.98714047756e-06 On 100000 4.7041818038e-06 On 1000000000 2.56591734753e-06 On 10000000000000 2.99357023878e-06 On 100000000000000000 2.99357023878e-06 On 1000000000000000000000 2.99357023879e-06 On 10000000000000000000000000 2.99357023878e-06 On 100000000000000000000000000000 3.42122313003e-06 On 1000000000000000000000000000000000 3.42122313003e-06 On 10000000000000000000000000000000000000 3.84887602128e-06 On 100000000000000000000000000000000000000000 3.42122313003e-06 On 1000000000000000000000000000000000000000000000 3.84887602128e-06 On 10000000000000000000000000000000000000000000000000 1.71061156501e-06 On 100000000000000000000000000000000000000000000000000000 1.71061156502e-06 On 1000000000000000000000000000000000000000000000000000000000 1.71061156501e-06 On 10000000000000000000000000000000000000000000000000000000000000 2.13826445628e-06 On 100000000000000000000000000000000000000000000000000000000000000000 1.71061156502e-06 On 1000000000000000000000000000000000000000000000000000000000000000000000 2.13826445628e-06 On 10000000000000000000000000000000000000000000000000000000000000000000000000 2.13826445628e-06 On 100000000000000000000000000000000000000000000000000000000000000000000000000000 2.13826445626e-06 On 1000000000000000000000000000000000000000000000000000000000000000000000000000000000 2.13826445626e-06
Why does the division generally get faster later on as opposed to the time of the first two terms which are the smallest?
解决方案Why does the division generally get faster later on as opposed to the time of the first two terms which are the smallest?
It doesn't, actually. If I replace
di
with:def di(n): for i in range(10000000): n / 101
Then I get (Python 3.5, which I presume you are using):
On 10 0.546889 On 100000 0.545004 On 1000000000 0.5454929999999998 On 10000000000000 0.5519709999999998 On 100000000000000000 1.330797 On 1000000000000000000000 1.31053 On 10000000000000000000000000 1.3393129999999998 On 100000000000000000000000000000 1.3524339999999997 On 1000000000000000000000000000000000 1.3817269999999997 On 10000000000000000000000000000000000000 1.3412670000000002 On 100000000000000000000000000000000000000000 1.3358929999999987 On 1000000000000000000000000000000000000000000000 1.3773859999999996 On 10000000000000000000000000000000000000000000000000 1.3326890000000002 On 100000000000000000000000000000000000000000000000000000 1.3704769999999993 On 1000000000000000000000000000000000000000000000000000000000 1.3235019999999995 On 10000000000000000000000000000000000000000000000000000000000000 1.357647 On 100000000000000000000000000000000000000000000000000000000000000000 1.3341190000000012 On 1000000000000000000000000000000000000000000000000000000000000000000000 1.326544000000002 On 10000000000000000000000000000000000000000000000000000000000000000000000000 1.3671139999999973 On 100000000000000000000000000000000000000000000000000000000000000000000000000000 1.3630120000000012 On 1000000000000000000000000000000000000000000000000000000000000000000000000000000000 1.3600200000000022 On 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000 1.3189189999999975 On 100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 1.3503469999999993
As you can see, there are roughly two times: one for smaller numbers, and one for larger numbers. In Python 3.5,
/
does floating point division, so it should actually take about the same amount of time regardless of the size of the numbers.However, there is that gap from small to large. The same result happens with Python 2.7 using the following function to preserve semantics:
def di(n): for i in xrange(10000000): n / 101.0
On the same machine, I get:
On 10 0.617427 On 100000 0.61805 On 1000000000 0.6366 On 10000000000000 0.620919 On 100000000000000000 0.616695 On 1000000000000000000000 0.927353 On 10000000000000000000000000 1.007156 On 100000000000000000000000000000 0.98597 On 1000000000000000000000000000000000 0.99258 On 10000000000000000000000000000000000000 0.966753 On 100000000000000000000000000000000000000000 0.992684 On 1000000000000000000000000000000000000000000000 0.991711 On 10000000000000000000000000000000000000000000000000 0.994703 On 100000000000000000000000000000000000000000000000000000 0.978877 On 1000000000000000000000000000000000000000000000000000000000 0.982035 On 10000000000000000000000000000000000000000000000000000000000000 0.973266 On 100000000000000000000000000000000000000000000000000000000000000000 0.977911 On 1000000000000000000000000000000000000000000000000000000000000000000000 0.996857 On 10000000000000000000000000000000000000000000000000000000000000000000000000 0.972555 On 100000000000000000000000000000000000000000000000000000000000000000000000000000 0.985676 On 1000000000000000000000000000000000000000000000000000000000000000000000000000000000 0.987412 On 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000 0.997207 On 100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 0.970129
This has something to do (exact specifics to be determined) with converting the integer to a floating point number. This is slower with integers beyond a certain point, and when that point is crossed, the division starts taking longer.
这篇关于为什么大量分解的速度更快的文章就介绍到这了,希望我们推荐的答案对大家有所帮助,也希望大家多多支持IT屋!