PIπ计算加载系统

时间:2018-12-01 10:37:25

标签: python math pi

感谢您抽出宝贵的时间阅读并(希望)回答了我的问题!我最近对Pi感兴趣(π不是可食用的类型,我已经喜欢那些了!),并且对这样一个数字的计算很感兴趣,我可以流利地键入中度高级的python,并且是高级Linux用户,因此我进行了设置老式计算机的“集群”。经过一番挖掘后,我发现了一个计算pi的python程序,我对其进行了编辑并将其输出到文件中,然后在其中一台计算机上运行了它,并且效果惊人,目前它在pi上大约有200万位数(与世界纪录22.7万亿!)并且正在使用100%的内核和94%的ram,我唯一的问题是我无法取消该过程或必须重新开始,我正在尝试了解算法,因此我可以加载函数中的代码。加载功能应打开文件,并从那里继续计算pi。我可以稍微了解一下该算法,并且已经发现它使用已经计算出的pi数字来计算出这些数字(这说明了速度衰减),因此可以加载预先计算的数据。代码如下:

import sys


def calcPi():
    q, r, t, k, n, l = 1, 0, 1, 1, 3, 3
    while True:
        if 4*q+r-t < n*t:
            yield n
            nr = 10*(r-n*t)
            n  = ((10*(3*q+r))//t)-10*n
            q  *= 10
            r  = nr
        else:
            nr = (2*q+r)*l
            nn = (q*(7*k)+2+(r*l))//(t*l)
            q  *= k
            t  *= l
            l  += 2
            k += 1
            n  = nn
            r  = nr

pi_digits = calcPi()
i = 0
for d in pi_digits:
    sys.stdout =open("piDigits.txt", "a")
    sys.stdout.write(str(d))
    i += 1
    if i == 50:
        print("")
        i = 0

如果有人可以帮助我找到一种方法来加载pi的预先计算的数字并从那里继续进行计算,或者向我解释算法/代码,我将不胜感激! 提前致谢。 -Leo Cornelius

2 个答案:

答案 0 :(得分:1)

您需要的是转储并还原calcPi生成器的整个状态。幸运的是,所有状态都在第一行中明确指定。这是一个原型,向您展示这个想法:

import sys
import os.path


def calcPi(state=None):
    if state is None:
        q, r, t, k, n, l = 1, 0, 1, 1, 3, 3
        skip_first = False
    else:
        q, r, t, k, n, l = state
        skip_first = True
    while True:
        if 4 * q + r - t < n * t:
            # have to skip the first yield in the "restore state" scenario because
            # this is the same we returned the last time from this state
            if not skip_first:
                state = q, r, t, k, n, l
                yield n, state
            else:
                skip_first = False
            nr = 10 * (r - n * t)
            n = ((10 * (3 * q + r)) // t) - 10 * n
            q *= 10
            r = nr
        else:
            nr = (2 * q + r) * l
            nn = (q * (7 * k) + 2 + (r * l)) // (t * l)
            q *= k
            t *= l
            l += 2
            k += 1
            n = nn
            r = nr


initial_state = None
total_digit_cnt = 0
buf_digit_cnt = 0
state_file_name = "piState.txt"
if os.path.isfile(state_file_name):
    with open(state_file_name, "r+") as stateF:
        lines = stateF.readlines()
        if len(lines) > 0:
            last_line = lines[-1]
            # truncate the old state and save only the few last last lines
            stateF.seek(0)
            stateF.truncate(0)
            stateF.write(lines[-3])
            stateF.write(lines[-2])
            stateF.write(last_line)
            initial_state = map(long, last_line.replace('(', '').replace(')', '').split(','))
            total_digit_cnt = initial_state[-1]
            initial_state = initial_state[:-1]

if initial_state is not None:
    print str((total_digit_cnt, initial_state))

pi_digits = calcPi(initial_state)
buf = ""
state_cnt = 0
with open("piDigits.txt", "a") as outF:
    with open(state_file_name, "a+") as stateF:
        for digit, state in pi_digits:
            buf += str(digit)
            buf_digit_cnt += 1
            total_digit_cnt += 1

            if buf_digit_cnt == 500:
                print "Start dumping state %d" % state_cnt
                buf_digit_cnt = 0
                outF.write(buf)
                buf = ""
                outF.write("\n")
                outF.flush()
                # as states take much more space, clear old states
                state_cnt += 1
                if state_cnt % 50 == 0:
                    stateF.seek(0)
                    stateF.truncate(0)
                stateF.write(str((state, total_digit_cnt)) + "\n")
                stateF.flush()
                print "End dumping state %d" % state_cnt

这个想法是不仅要返回下一位数字,还要从生成器返回整个状态,并定期将其转储到另一个文件中。这只是一个原型。在处理数百万位数字的真实代码中,您可能希望按自上次转储以来经过的时间而不是按计数来转储状态,因为计算每个下一位数字可能会越来越慢。但是,这使恢复代码难以跟踪更多细节(例如,最后一行实际写了多少位?),因此我没有将其放入PoC中。

答案 1 :(得分:0)

您使用的代码中包含一个生成器。这是一个带有“ yield”语句的函数。这些操作是在被调用时产生一个值,然后等待直到通常在循环中再次调用它们,然后计算下一个值,然后产生该值。因为您要在无限循环中计算一个无限数,所以程序将一直运行直到杀死它,然后您将失去状态。因此,您需要一种保持状态的方法。

我建议您实现一个迭代器来替换生成器。迭代器就像一个生成器,但是它不是一个函数,而是一个对象。因此它具有状态。也就是说,您可以将所有这些变量(nr,nn,q等)的当前值存储为“实例”变量。然后,当您要终止时,可以使用“ pickle”库保留类的当前状态。然后,要继续执行脚本中遗留的脚本,请加载pickle文件以完全重建程序终止前的状态来重建对象。