避免在python中硬编码大量耦合的ode

Question

首先，我很抱歉，如果标题不完全合适，我很难找到一个合适的标题（这可能也会影响我对已经提出的问题的搜索效率：/）。在

问题如下。虽然用Scipy在python中解决耦合的ODE相对容易，但我仍然必须以形式显式地写下我的ODE。例如一个形式的耦合颂歌

d/dt（c_0）=a（c_0）+b（c_1）和d/dt（c_1）=c（c_0）

我会设置类似于：

import numpy as np
from scipy.integrate import ode

a=1
b=2
c=3
val=[]

def dC_dt(t, C):
    return [a*C[0]+b*C[1],
            c*C[0]]

c0, t0 = [1.0,0.0], 0
r = ode(dC_dt).set_integrator('zvode', method='bdf',with_jacobian=False)
r.set_initial_value(c0, t0)
t1 = 0.001
dt = 0.000005
while r.successful() and r.t < t1:
    r.integrate(r.t+dt)
val.append(r.y)

然而，现在我已经耦合了粗略形式的颂歌

d/dt（c{m，n}）=a（c{m，n}）+b（c{m+1，n-1}）+k（c{m-1，n+1}）

当c{0,0}=1时，必须包含m^2+n^2-mn小于最大值的订单。 对于一个小的max，我所做的是使用字典来使用一个带有两个索引的符号，并将其映射到一个1D列表中

^{pr2}$

然后我为每个订单输入了颂歌

def dC_dt(t,C):
    return[a*C[dict_in['0,0']]+b*C[dict_in['1,-1']]...

现在我基本上要对大约100个耦合方程，我不想硬编码，所以我想找出一种方法，然而，我还没有找到一种方法来解决系数中有两个指数，以及仅包含m^2+n^2-mn小于最大值的阶的情况。 由于我要赶在最后期限前完成任务，我想是时候向更聪明的人寻求帮助了。在

谢谢你读我的问题！在

Answer 1

我也有类似的问题。如果你填写了字典，你可以在循环中多次重新声明函数。这是一个愚蠢的例子，它是如何运作的：

dict_in={'0,0':0,'-1,0':2}

for elem in dict_in:
    def dC_dt(t,C):
        #return[a*C[dict_in['0,0']]+b*C[dict_in['1,-1']]
        return dict_in[elem]

    t, C = 0, 0
    print(dC_dt(t,C))
    #r = ode(dC_dt).set_integrator('zvode', method='bdf',with_jacobian=False)

如果需要一起使用更多函数，可以使用匿名函数并将它们存储在内存中。另一个例子：

^{pr2}$

你也可以使用列表或生成器。例如，您可以在一个txt文件上写下该值，然后每次使用readline函数读取该值。在

正如下面的评论所指出的，如果你使用lamda函数，你应该注意参考文献。另请参见https://docs.python.org/3/faq/programming.html#why-do-lambdas-defined-in-a-loop-with-different-values-all-return-the-same-result