Python 已知常微分方程的李雅普诺夫谱-3

我想用本文中描述的标准方法，数值计算的李雅普诺夫谱

基本上需要积分洛伦兹系统和切向向量，我用龙格-库塔方法。由洛伦兹系统的雅可比矩阵给出了切向矢量的演化方程。在每次迭代之后，需要对向量应用Gram-Schmidt方案并存储其长度。然后通过存储长度的平均值给出三个李雅普诺夫指数

我用python版本3.7.4实现了上面解释的方案，但没有得到正确的结果

我认为错误在于Rk4方法用于der向量，但我找不到任何错误…用于轨迹x、y、z的Rk4方法正确地工作，如图所示，并且实现的Gram-Schmidt方案也正确地实现

我希望有人能看看我的短代码，也许能找到我的错误

编辑：更新代码

from numpy import array, arange, zeros, dot, log
import matplotlib.pyplot as plt
from numpy.linalg import norm

# Evolution equation of tracjectories and tangential vectors
def f(r):
    x = r[0]
    y = r[1]
    z = r[2]

    fx = sigma * (y - x)
    fy = x * (rho - z) - y
    fz = x * y - beta * z

    return array([fx,fy,fz], float)

def jacobian(r):
    M = zeros([3,3])
    M[0,:] = [- sigma, sigma, 0]
    M[1,:] = [rho - r[2], -1, - r[0] ]
    M[2,:] = [r[1], r[0], -beta]

    return M

def g(d, r):
    dx = d[0]
    dy = d[1]
    dz = d[2]

    M = jacobian(r)

    dfx = dot(M, dx)
    dfy = dot(M, dy)
    dfz = dot(M, dz)

    return array([dfx, dfy, dfz], float)

# Initial conditions
d = array([[1,0,0], [0,1,0], [0,0,1]], float)
r = array([19.0, 20.0, 50.0], float)
sigma, rho, beta = 10, 45.92, 4.0 

T  = 10**5                         # time steps 
dt = 0.01                          # time increment
Teq = 10**4                        # Transient time

l1, l2, l3 = 0, 0, 0               # Lengths

xpoints, ypoints, zpoints  = [], [], []

# Transient
for t in range(Teq):
    # RK4 - Method 
    k1  = dt * f(r)                 
    k11 = dt * g(d, r)

    k2  = dt * f(r + 0.5 * k1)
    k22 = dt * g(d + 0.5 * k11, r + 0.5 * k1)

    k3  = dt * f(r + 0.5 * k2)
    k33 = dt * g(d + 0.5 * k22, r + 0.5 * k2)

    k4  = dt * f(r + k3)
    k44 = dt * g(d + k33, r + k3)

    r  += (k1  + 2 * k2  + 2 * k3  + k4)  / 6
    d  += (k11 + 2 * k22 + 2 * k33 + k44) / 6

    # Gram-Schmidt-Scheme
    orth_1 = d[0]                    
    d[0] = orth_1 / norm(orth_1)

    orth_2 = d[1] - dot(d[1], d[0]) * d[0]
    d[1] = orth_2 / norm(orth_2)

    orth_3 = d[2] - (dot(d[2], d[1]) * d[1]) - (dot(d[2], d[0]) * d[0]) 
    d[2] = orth_3 / norm(orth_3)

for t in range(T):
    k1  = dt * f(r)                 
    k11 = dt * g(d, r)

    k2  = dt * f(r + 0.5 * k1)
    k22 = dt * g(d + 0.5 * k11, r + 0.5 * k1)

    k3  = dt * f(r + 0.5 * k2)
    k33 = dt * g(d + 0.5 * k22, r + 0.5 * k2)

    k4  = dt * f(r + k3)
    k44 = dt * g(d + k33, r + k3)

    r  += (k1  + 2 * k2  + 2 * k3  + k4)  / 6
    d  += (k11 + 2 * k22 + 2 * k33 + k44) / 6

    orth_1 = d[0]                    # Gram-Schmidt-Scheme
    l1 += log(norm(orth_1))
    d[0] = orth_1 / norm(orth_1)

    orth_2 = d[1] - dot(d[1], d[0]) * d[0]
    l2 += log(norm(orth_2))
    d[1] = orth_2 / norm(orth_2)

    orth_3 = d[2] - (dot(d[2], d[1]) * d[1]) - (dot(d[2], d[0]) * d[0]) 
    l3 += log(norm(orth_3))
    d[2] = orth_3 / norm(orth_3)

# Correct Solution (2.16, 0.0, -32.4)

lya1 = l1 / (dt * T)
lya2 = l2 / (dt * T)  - lya1
lya3 = l3 / (dt * T) -  lya1 - lya2 

lya1, lya2, lya3

# my solution T = 10^5 : (1.3540301507934012, -0.0021967491623752448, -16.351653561383387) 

以上代码根据Lutz建议进行更新。 结果看起来好多了，但仍然不是100%准确

正确的解决方案2.16，0.0，-32.4

我的解决方案1.3540301507934012，-0.0021967491623752448，-16.351653561383387

正确的解决方案来自。在第290-291页，他描述了他的方法，这与我在本文开头提到的论文（第81页）中的方法完全相同

---

所以我的代码中肯定有另一个错误

您需要将点和雅可比矩阵系统作为前向耦合系统进行求解。在原始源代码中，所有内容都在组合系统的一个RK4调用中更新

例如，在第二阶段中，您将混合这些操作，以获得一个组合的第二阶段

k2=dt*fr+0.5*k1 M=jacobianr+0.5*k1 k22=dt*gd+0.5*k11，r+0.5*k1 您还可以在g函数中委托M的计算，因为这是唯一需要它的地方，并且您可以增加变量范围中的局部性

注意，我将d的更新从k1改为k11，这应该是数值结果中错误的主要来源

关于最新代码版本2/28/2021的附加说明：

正如在评论中所说的，代码看起来会按照算法的数学规定执行。有两种误读会阻止代码返回接近参考的结果：

本文中的参数是sigma=16。 本文使用的不是自然对数，而是二元对数，即震级演变为2^L_it。所以你必须把计算出的指数除以log2。 使用中导出的方法，我得到了指数

[2.1531855610566595, -0.00847304754613621, -32.441308372177566]

---

这与参考文献2.16,0.0，-32.4非常接近。

我更新了我以前的帖子。如果你能看一下，我将不胜感激。你的预期产量是多少？你得到了多少？看看[mvve]。我更新的帖子中现在包含了所需的输出。代码现在看起来在技术上是正确的。关于结果差异的任何问题现在都已脱离主题，属于scicomp.SE或math.SE。通过将RK4步骤设置为函数，甚至将整个迭代设置为函数，可以使代码更加紧凑，而不考虑初始迭代的计算l[1,2,3]值。