[PYTHON] J'ai écrit une animation que le système linéaire rétrécit avec du code sale mortel

Que fais tu

Mon junior à l'université a dit que je ne pouvais pas obtenir l'image de la contraction du système linéaire, alors j'ai décidé de faire une animation qui fusionne les vecteurs propres du système linéaire bidimensionnel. L'équation à résoudre est extrêmement simple et a la forme suivante.

\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)

La contraction est résolue à l'avance en mettant la perturbation $ \ epsilon $ uniquement dans la composante $ (2,2) $ de la matrice $ 2 \ times 2 $. Ensuite, l'instruction for est tournée pour changer progressivement $ \ epsilon $, et chaque étape est intégrée avec scipy odeint à partir de plusieurs conditions initiales. Dans l'exemple ci-dessous, les nœuds stables sont rétractés. Si vous tournez un peu plus l'instruction for, vous pouvez voir que l'origine change pour la selle, et selon la façon dont vous insérez la perturbation, vous devriez également voir la transition entre le nœud et la spirale.

Code réellement écrit

Puisqu'il s'agit d'un code anti-intelligent, je me demandais s'il fallait le publier pendant une demi-journée, mais je le publierai dans l'espoir que quelqu'un fera des commentaires significatifs. Dans l'instruction for, le paramètre de perturbation $ e (= \ epsilon) $ est calculé pour chaque étape en fonction du nombre d'étapes, et l'équation différentielle est résolue sur cette base.

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()

Exemple d'exécution

Vous pouvez voir que la direction unique, qui était indépendante du premier ordre de $ x $, se réduit progressivement en $ x $.

problème

Le code ci-dessus est plein de problèmes ~~ 1: La même opération est effectuée plusieurs fois dans l'instruction for ~~ ~~ 2: Je voulais l'automatiser, mais je ne pensais pas à la façon de changer la couleur en fonction de la valeur initiale ~~ 3: J'ai oublié l'intrigue dans la direction spécifique même si je regarde la contraction Et ainsi de suite (alors vous pouvez le réparer vous-même).

Je ferai quelque chose plus tard si je peux écrire un code plus intelligent ~~. Grâce à la gentille personne qui m'a appris ~~, les problèmes 1 et 2 ont été résolus. Merci encore. En ce qui concerne la partie du problème qui a été résolue, j'ai décidé de laisser le code sale que j'avais écrit dans le commentaire. J'ai pensé que ce serait bien si je pouvais imaginer un peu plus l'emplacement des conditions initiales, mais comme l'emplacement facile à voir diffère selon le système, je me demande si je dois le récupérer à la main après tout.