[PYTHON] Ich habe eine Animation geschrieben, bei der das lineare System mit tödlich schmutzigem Code schrumpft

Was machst du

Mein Junior an der Universität sagte, dass ich das Bild der Kontraktion des linearen Systems nicht bekommen könne, und entschied mich daher für eine Animation, die die Eigenvektoren des zweidimensionalen linearen Systems verschmilzt. Die zu lösende Gleichung ist äußerst einfach und hat die folgende Form.

\frac{d}{dt}\Bigl(\begin{matrix}
x\\
y
\end{matrix} \Bigl)=
\Bigl(\begin{matrix}
-1 & -1\\
0 & -1-\epsilon
\end{matrix}\Bigl)\Bigl(\begin{matrix}x\\
y\end{matrix}\Bigl)

Die Kontraktion wird im Voraus gelöst, indem die Störung $ \ epsilon $ nur in die $ (2,2) $ -Komponente der $ 2 \ times 2 $ -Matrix eingefügt wird. Dann wird die for-Anweisung gedreht, um $ \ epsilon $ allmählich zu ändern, und jeder Schritt wird aus mehreren Anfangsbedingungen in scipy odeint integriert. In der folgenden Stichprobe werden stabile Knoten zurückgezogen. Wenn Sie die for-Anweisung etwas weiter drehen, können Sie sehen, dass sich der Ursprung zum Sattel ändert, und je nachdem, wie Sie die Störung eingegeben haben, sollten Sie auch den Übergang zwischen dem Knoten und der Spirale sehen.

Code tatsächlich geschrieben

Da es sich um einen anti-intelligenten Code handelt, habe ich mir Sorgen gemacht, ob ich ihn einen halben Tag lang veröffentlichen soll, aber ich werde ihn in der Hoffnung veröffentlichen, dass jemand aussagekräftige Kommentare abgibt. In der for-Anweisung wird der Störungsparameter $ e (= \ epsilon) $ für jeden Schritt entsprechend der Anzahl der Schritte berechnet und die Differentialgleichung basierend darauf gelöst.

Linear_degenerate.ipynb

%matplotlib nbagg
import matplotlib.pyplot as plt
import numpy as np
from scipy.integrate import odeint
from numpy import sin, cos, pi
import matplotlib.animation as animation
# degeneration of linear system
def func(v, t, e):
    return [ -v[0] - v[1], -(1+e)*v[1] ] #  2-D linear system

#def func(v,t):
#    return [ -v[1] -0.5*v[0]*(v[0]**2+v[1]**2), v[0] -0.5*v[1]*(v[0]**2 + v[1]**2)]

# time length and unit step    
dt = 0.1
T = np.arange(0.0, 20, dt)
v0 = [[17,7], [17,17], [7,17], [-17,-7], [-17,-17], [-7,-17],[-7,17], [7,-17]]

# make animation
fig = plt.figure()

ims = []

for k in range(200):
    e = (150-k)/50
    #each initial state
    space = []
    for v, color in zip(v0, 'rbgrbgkk'):
        u = odeint(func, v, T, args=(e,))
        space += plt.plot(u[:,0], u[:,1], color)

    ims.append(space)
    
    
    '''u0 = odeint(func, v0[0], T, args=(e,))
    space0 = plt.plot(u0[:,0], u0[:,1], 'r')
    u1 = odeint(func, v0[1], T, args=(e,))
    space1 = plt.plot(u1[:,0], u1[:,1], 'b')
    u2 = odeint(func, v0[2], T, args=(e,))
    space2 = plt.plot(u2[:,0], u2[:,1], 'g')
    u3 = odeint(func, v0[3], T, args=(e,))
    space3 = plt.plot(u3[:,0], u3[:,1], 'r')
    u4 = odeint(func, v0[4], T, args=(e,))
    space4 = plt.plot(u4[:,0], u4[:,1], 'b')
    u5 = odeint(func, v0[5], T, args=(e,))
    space5 = plt.plot(u5[:,0], u5[:,1], 'g')
    u6 = odeint(func, v0[6], T, args=(e,))
    space6 = plt.plot(u6[:,0], u6[:,1], 'k')
    u7 = odeint(func, v0[7], T, args=(e,))
    space7 = plt.plot(u7[:,0], u7[:,1], 'k')

    ims.append(space0+space1+space2+space3+space4+space5+space6+space7)
    '''
plt.xlim(-17 ,17) 
plt.ylim(-17 ,17)
plt.xlabel('x')
plt.ylabel('y')
plt.grid()
ani = animation.ArtistAnimation(fig, ims, interval=27, blit=True, repeat=True)

plt.show()

Ausführungsbeispiel

Sie können sehen, dass die eindeutige Richtung, die unabhängig von $ x $ erster Ordnung war, allmählich in $ x $ zusammenfällt.

Problem

Der obige Code ist voller Probleme ~~ 1: Die gleiche Operation wird in der for-Anweisung ~~ viele Male ausgeführt ~~ 2: Ich wollte es automatisieren, habe aber nicht darüber nachgedacht, wie ich die Farbe entsprechend dem Anfangswert ändern kann ~~ 3: Ich habe die Handlung in der spezifischen Richtung vergessen, obwohl ich die Kontraktion beobachte Und so weiter (dann können Sie es selbst reparieren).

Ich werde später etwas tun, wenn ich intelligenteren Code schreiben kann ~~. Dank der freundlichen Person, die mich unterrichtet hat, wurden die Probleme 1 und 2 gelöst. Danke nochmal. In Bezug auf den Teil des Problems, der gelöst wurde, habe ich beschlossen, den schmutzigen Code, den ich im Kommentar geschrieben habe, wegzulassen. Ich dachte, es wäre schön, wenn ich ein bisschen mehr Platz für die Anfangsbedingungen finden könnte, aber da die leicht zu erkennenden Orte je nach System unterschiedlich sind, frage ich mich, ob ich es doch von Hand bekommen muss.