Question

感谢您抽出宝贵的时间阅读并（希望）回答了我的问题！我最近对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

Answer 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中。

Answer 2

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

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

PIπ计算加载系统

2 个答案: