Summary

“由于这一功能,斯图尔特的间接费用远大于赖因的间接费用。

Details

作为一种缩微镜,这实际上对两种语言在适当使用中的表现都说了很多。 和你一样,你也想重新制定方案,以利用沙尔和鲁比的长处,但这确实表明目前沙捞越的弱点之一。 速度差异的根源在于职能称为间接费用。 我进行了几次测试,以说明情况。 详见下文。 关于“灰色”试验,我于2000年使用了两种浓缩参数。

Interpreter: Python 2.6.6
Program type: gcd using function call
Total CPU time: 29.336 seconds

Interpreter: Python 2.6.6
Program type: gcd using inline code
Total CPU time: 13.194 seconds

Interpreter: Python 2.6.6
Program type: gcd using inline code, with dummy function call
Total CPU  time: 30.672 seconds

这告诉我们,它不是由造成大部分时间差异的加权职能进行的计算,而是发挥职能本身的作用。 甲型六氯环己烷

Interpreter: Python 3.1.3rc1
Program type: gcd using function call
Total CPU time: 30.920 seconds

Interpreter: Python 3.1.3rc1
Program type: gcd using inline code
Total CPU time: 15.185 seconds

Interpreter: Python 3.1.3rc1
Program type: gcd using inline code, with dummy function call
Total CPU time: 33.739 seconds

同样,实际计算并不是最大的贡献者,而是职能本身所决定的。 在鲁比拉,职能电话管理费用要小得多。 (说明:我不得不使用比照方案版本的较小参数(200),因为鲁宾·鲁宾确实放慢了实时业绩。 但是,这不影响万国邮联的绩效。

Interpreter: ruby 1.9.2p0 (2010-08-18 revision 29036) [i486-linux]
Program type: gcd using function call
Total CPU time: 21.66 seconds

Interpreter: ruby 1.9.2p0 (2010-08-18 revision 29036) [i486-linux]
Program type: gcd using inline code
Total CPU time: 21.31 seconds

Interpreter: ruby 1.8.7 (2010-08-16 patchlevel 302) [i486-linux]
Program type: gcd using function call
Total CPU time: 27.00 seconds

Interpreter: ruby 1.8.7 (2010-08-16 patchlevel 302) [i486-linux]
Program type: gcd using inline code
Total CPU time: 24.83 seconds

通知表明Ruby 1.8 和1.9 两者都不会因“gcd”功能称呼而遭受很大损失,这种功能称为“在线”形式,其程度大致相同。 鲁比·1.9似乎稍有改善,职能呼吁和在线版本之间差别较小。

因此,对问题的答复是:“由于职能要求波什的间接费用远远大于鲁比。

Code

# iter_gcd -- Python 2.x version, with gcd function call
#             Python 3.x version uses range instead of xrange
from sys import argv,stderr

def gcd(m, n):
    if n > m:
        m, n = n, m
    while n != 0:
        rem = m % n
        m = n
        n = rem
    return m

def main(a1, a2):
    comp = 0
    for j in xrange(a1, 1, -1):
        for i in xrange(1, a2):
            comp += gcd(i,j)
    print(comp)

if __name__ ==  __main__ :
    if len(argv) != 3:
        stderr.write( usage: {0:s} num1 num2
 .format(argv[0]))
        exit(1)
    else:
        main(int(argv[1]), int(argv[2]))

# iter_gcd -- Python 2.x version, inline calculation
#             Python 3.x version uses range instead of xrange
from sys import argv,stderr

def main(a1, a2):
    comp = 0
    for j in xrange(a1, 1, -1):
        for i in xrange(1, a2):
            if i < j:
                m, n = j, i
            else:
                m, n = i, j
            while n != 0:
                rem = m % n
                m = n
                n = rem
            comp += m
    print(comp)

if __name__ ==  __main__ :
    if len(argv) != 3:
        stderr.write( usage: {0:s} num1 num2
 .format(argv[0]))
        exit(1)
    else:
        main(int(argv[1]), int(argv[2]))

# iter_gcd -- Python 2.x version, inline calculation, dummy function call
#             Python 3.x version uses range instead of xrange
from sys import argv,stderr

def dummyfunc(n, m):
    a = n + m

def main(a1, a2):
    comp = 0
    for j in xrange(a1, 1, -1):
        for i in xrange(1, a2):
            if i < j:
                m, n = j, i
            else:
                m, n = i, j
            while n != 0:
                rem = m % n
                m = n
                n = rem
            comp += m
            dummyfunc(i, j)
    print(comp)

if __name__ ==  __main__ :
    if len(argv) != 3:
        stderr.write( usage: {0:s} num1 num2
 .format(argv[0]))
        exit(1)
    else:
        main(int(argv[1]), int(argv[2]))

# iter_gcd -- Ruby version, with gcd function call

def gcd(m, n)
    if n > m
        m, n = n, m
    end
    while n != 0
        rem = m % n
        m = n
        n = rem
    end
    return m
end

def main(a1, a2)
    comp = 0
    a1.downto 2 do
        |j|
        1.upto a2-1 do
            |i|
            comp += gcd(i,j)
        end
    end
    puts comp
end

 if __FILE__ == $0
    if ARGV.length != 2
        $stderr.puts( usage: %s num1 num2  % $0)
        exit(1)
    else
        main(ARGV[0].to_i, ARGV[1].to_i)
    end
end

# iter_gcd -- Ruby version, with inline gcd

def main(a1, a2)
    comp = 0
    a1.downto 2 do |j|
        1.upto a2-1 do |i|
            m, n = i, j
            if n > m
                m, n = n, m
            end
            while n != 0
                rem = m % n
                m = n
                n = rem
            end
            comp += m
        end
    end
    puts comp
end

 if __FILE__ == $0
    if ARGV.length != 2
        $stderr.puts( usage: %s num1 num2  % $0)
        exit(1)
    else
        main(ARGV[0].to_i, ARGV[1].to_i)
    end
end

Test runs

最后,为了比较数字而用于Palileo和Ruby的指挥系统是:pythonX.X -m cProfile iter_gcdX.py 2000,用于“Zal”和rubyX.X.rprofile iter_gcdX.rb 200。 出现差异的原因是,Ruby的简介员增加了很多间接费用。 成果仍然有效,因为我对职能呼吁和在线编码之间的区别进行对比,而不是将沙尔和鲁比之间的区别进行比较。