用Python递归求解数学方程

我想解决一个方程，我应该解决它递归，我上传了公式的图片（对不起！我不知道如何写数学公式在这里！） 我用Python编写了如下代码：

import math
alambda = 1.0
rho = 0.8
c = 1.0
b = rho * c / alambda
P0 = (1 - (alambda*b))
P1 = (1-(alambda*b))*(math.exp(alambda*b) - 1)

def a(n):
    a_n = math.exp(-alambda*b) * ((alambda*b)**n) / math.factorial(n)
    return a_n

def P(n):
    P(n) = (P0+P1)*a(n) + sigma(n)

def sigma(n):
    j = 2
    result = 0
    while j <= n+1:
        result = result + P(j)*a(n+1-j)
        j += 1
    return result

导入数学
alambda=1.0
rho=0.8
c=1.0
b=rho*c/alambda
P0=（1-（alambda*b））
P1=（1-（alambda*b））*（math.exp（alambda*b）-1）
def a（n）：
a_n=math.exp（-alambda*b）*（（alambda*b）**n）/math.factorial（n）
归还
def P（n）：
P（n）=（P0+P1）*a（n）+σ（n）
定义西格玛（n）：
j=2
结果=0
而j您可以通过这种方式修复：

import math
alambda = 1.0
rho = 0.8
c = 1.0
b = rho * c / alambda


def a(n):
  # you might want to cache a as well
  a_n = math.exp(-alambda*b) * ((alambda*b)**n) / math.factorial(n)
  return a_n


PCache={0:(1 - (alambda*b)),1:(1-(alambda*b))*(math.exp(alambda*b) - 1)}

def P(n):
 if n in PCache:
   return PCache[n]
 ret= (P(0)+P(1))*a(n) + sigma(n)
 PCache[n]=ret
 return ret

def sigma(n):
  # caching this seems smart as well
  j = 2
  result = 0
  while j <= n+1:
    result = result + P(j)*a(n+1-j)
    j += 1
  return result

void displayP(n):
  P(n) # fill cache :-)
  for x in range(n):
    print ("%u -> %d\n" % (x,PCache[x]))

导入数学
alambda=1.0
rho=0.8
c=1.0
b=rho*c/alambda
def a（n）：
#您可能还需要缓存一个
a_n=math.exp（-alambda*b）*（（alambda*b）**n）/math.factorial（n）
归还
PCache={0:（1-（alambda*b）），1:（1-（alambda*b））*（math.exp（alambda*b）-1}
def P（n）：
如果PCache中有n：
返回PCache[n]
ret=（P（0）+P（1））*a（n）+sigma（n）
PCache[n]=ret
回程网
定义西格玛（n）：
#缓存这似乎也很聪明
j=2
结果=0
当j时，需要重新组织公式，这样就不必计算p（3）来计算p（2）。这很容易做到，将求和的最后一项P（n+1）a（0）带到方程的左侧，然后除以a（0）。然后你有一个关于P（n+1）的公式，其中m需要一个初始值。否则，该序列将无限遍历。基本上，告诉我P（0）和P（1）的值。我会说你最好的选择是把你的“P-s”作为一个列表，你的函数会添加到其中
p（n）=pvals[n]
依赖于
p（n-1）=pvals[n-1]
。不是字面上的递归，而是使用递归逻辑。@MalikBrahimi，没错。初始值写在第6行和第7行。@Schilcote，好吧，你的代码解决方案是什么？天哪！你让我觉得有点困难，我不是专业的Python用户。所以我不知道cache和void也是一样的。你的P函数会被多次调用，使用相同的参数（一个整数）。不是每次都重新计算，而是将结果放在查找表中并提供预计算的结果。这将在性能方面为此类问题获得数量级（CPU与RAM之间的折衷）
import math
a_lambda = 1.0
rho = 0.8
c = 1.0
b = rho * c / a_lambda
p0 = (1 - (a_lambda*b))
p1 = (1-(a_lambda*b))*(math.exp(a_lambda*b) - 1)
p_dict = {0: p0, 1: p1}

def a(n):
    return math.exp(-a_lambda*b) * ((a_lambda*b)**n) / math.factorial(n)

def get_nth_p(n, p_dict):
    # return pre-calculated value if p(n) is already known
    if n in p_dict:
        return p_dict[n]

    # Calculate p(n) using modified formula
    p_n = ((get_nth_p(n-1, p_dict)
            - (get_nth_p(0, p_dict) + get_nth_p(1, p_dict)) * a(n - 1)
            - sum(get_nth_p(j, p_dict) * a(n + 1 - j) for j in xrange(2, n)))
          / a(0))

    # Save computed value into the dict
    p_dict[n] = p_n
    return p_n

get_nth_p(6, p_dict)
print p_dict

import math

# Customary to distinguish variables that are unchanging by making them ALLCAP
A_LAMBDA = 1.0
RHO = 0.8
C = 1.0
B = RHO * C / A_LAMBDA
P0 = (1 - (A_LAMBDA*B))
P1 = (1-(A_LAMBDA*B))*(math.exp(A_LAMBDA*B) - 1)

p_value_cache = {0: P0, 1: P1}

def a(n):
    return math.exp(-A_LAMBDA*B) * ((A_LAMBDA*B)**n) / math.factorial(n)

def p(n, p_dict=p_value_cache):
    # return pre-calculated value if p(n) is already known
    if n in p_dict:
        return p_dict[n]

    # Calculate p(n) using modified formula
    p_n = ((p(n-1)
            - (p(0) + p(1)) * a(n - 1)
            - sum(p(j) * a(n + 1 - j) for j in xrange(2, n)))
          / a(0))

    # Save computed value into the dict
    p_dict[n] = p_n
    return p_n

p(6)
print p_value_cache