Informatique pour tous Résolution numérique d’une équation différentielle

RÉSOLUTION NUMÉRIQUE D’UNE

ÉQUATION DIFFÉRENTIELLE
Informatique pour tous Résolution numérique d’une équation différentielle

I-Équation différentielle du premier ordre

RÉSOLUTION NUMÉRIQUE D’UNE

ÉQUATION DIFFÉRENTIELLE
I-Équation différentielle du premier ordre
Informatique pour tous Résolution numérique d’une équation différentielle

I-Équation différentielle du premier ordre

1) Méthode d’Euler

RÉSOLUTION NUMÉRIQUE D’UNE

ÉQUATION DIFFÉRENTIELLE
I-Équation différentielle du premier ordre
1) Méthode d’Euler
 Informatique pour tous Résolution numérique d’une équation différentielle

I-Équation différentielle du premier ordre

1) Méthode d’Euler

Rappel de l’algorithme d’Euler :

def euler(f, t0, tf, y0, h):

t = t0
y = y0
liste_t = [t]
liste_y = [y]
liste_v = [f(t, y)]
while t <= tf :
y = y + h * f(t, y)
liste_y.append(y)
t = t + h
liste_t.append(t)
liste_v.append(f(t , y))
return [Link]([liste_t, liste_y, liste_v])

Travail demandé : Documenter chaque

ligne du programme de manière
compréhensible pour un lecteur connaissant la
mathématique sous-jacente et le langage Python
mais ne connaissant pas l’algorithme. (Rappel :
commentaire = touche #)
 Informatique pour tous Résolution numérique d’une équation différentielle

I-Équation différentielle du premier ordre

1) Méthode d’Euler

Rappel de l’algorithme d’Euler :

def euler(f, t0, tf, y0, h):

t = t0
y = y0
liste_t = [t]
liste_y = [y]
liste_v = [f(t, y)]
while t <= tf :
y = y + h * f(t, y)
liste_y.append(y)
t = t + h
liste_t.append(t)
liste_v.append(f(t , y))
return [Link]([liste_t, liste_y, liste_v])

Travail demandé : On considère l'unique solution u de l’équation différentielle y’ = −y/ττ qui

vaut 1 en t = 0.
Expliciter la solution analytique.
Superposer sur un même graphique, la courbe représentative de la solution analytique avec
celle d'une de la solution numérique obtenue par la méthode d’Euler.
Faire varier h et observer la précision du résultat numérique.
Informatique pour tous Résolution numérique d’une équation différentielle

I-Équation différentielle du premier ordre

1) Méthode d’Euler
2) Fonction odeint

RÉSOLUTION NUMÉRIQUE D’UNE

ÉQUATION DIFFÉRENTIELLE
I-Équation différentielle du premier ordre
1) Méthode d’Euler
2) Fonction odeint
Informatique pour tous Résolution numérique d’une équation différentielle

I-Équation différentielle du premier ordre

1) Méthode d’Euler
2) Fonction odeint

La fonction odeint() est importée de la librairie [Link]

Pour résoudre l’équation y’(t) = f (y(t) , t) sur l’intervalle [t0, tf], l’instruction est : odeint(f,
odeint(f,
liste_y0 liste_t) où :
liste_y0, liste_t)
¤ f est une fonction ayant pour paramètre (dans l’ordre) liste_y et liste_t qui sont des
[Link] (liste-y est crée par odeint, liste_t est défini par l’utilisateur);
¤ liste_t est un [Link] défini préalablement et contenant les bornes t0 et tf ;
¤ liste_y0 est un [Link] contenant les conditions initiales [y0 (y0’,…)] correspondant à
la première valeur de liste_t .
liste-y retourné par la fonction odeint est un [Link] de nombre de lignes égal à
¤ l’objet liste-
liste_t et de nombre de colonnes égal à len(liste_y0) contenant la liste des valeurs du vecteur y
(y’,…) pour chaque valeur t du tableau liste_t.

Travail demandé : Rajouter au graphe obtenu précédemment la solution calculée avec odeint.
Informatique pour tous Résolution numérique d’une équation différentielle

I-Équation différentielle du premier ordre

1) Méthode d’Euler
2) Fonction odeint

Voici par exemple le graphe obtenue pour τ = 1, y0 = 1, t0 = 0, tf = 5 et le même nombre de points de

calcul pour les deux méthodes numériques.
Informatique pour tous Résolution numérique d’une équation différentielle

I-Équation différentielle du premier ordre

1) Méthode d’Euler
2) Fonction odeint

Travail demandé : Effectuer la même étude (résolution analytique, méthode d’Euler, fonction odeint)
pour les équations :

y ' = y2
y (0) = 1
t ∈ [ 0, 0.8]
proposition de solution

y ' = 3 y cos ( t )
y (1) = 10
t ∈ [ 0, 10]
500 pts
Informatique pour tous Résolution numérique d’une équation différentielle

I-Équation différentielle du premier ordre II-Au-delà

1) Méthode d’Euler
2) Fonction odeint

RÉSOLUTION NUMÉRIQUE D’UNE

ÉQUATION DIFFÉRENTIELLE
I-Équation différentielle du premier ordre
1) Méthode d’Euler
2) Fonction odeint
II-Au-delà
Informatique pour tous Résolution numérique d’une équation différentielle

I-Équation différentielle du premier ordre II-Au-delà

1) Méthode d’Euler 1) Ordre supérieur à 1
2) Fonction odeint

RÉSOLUTION NUMÉRIQUE D’UNE

ÉQUATION DIFFÉRENTIELLE
I-Équation différentielle du premier ordre
1) Méthode d’Euler
2) Fonction odeint
II-Au-delà
1) Équation différentielle d’un ordre supérieur à 1
Informatique pour tous Résolution numérique d’une équation différentielle

I-Équation différentielle du premier ordre II-Au-delà

1) Méthode d’Euler 1) Ordre supérieur à 1
2) Fonction odeint

Une équation différentielle d’ordre supérieur à un contient d’autres dérivées qu’une dérivée
première, par exemple une équation du deuxième ordre peut s ’écrire y’’ = f(t, y, y’) .
Mais elle se ramène au schéma du premier ordre en considérant le vecteur Y = [y(t) , y’(t)].
Il est alors tel que Y’ = F(t , Y) avec F définie par :
Y → F(t , Y) = [y’(t) , f(t, y, y’) ]

Exemples :

équation différentielle fonction F

y ''+ y = 0 F (t,Y ) = [ y ' , − y]

d 2θ ( t )  d θ (t ) 
+ k sin ( θ ( t ) ) = 0 F (t, Y ) =  , − k sin ( θ ( t ) ) 
dt 2  dt 
d 2 x (t ) dx ( t ) 2  dx ( t ) h dx ( t ) ω0 2 
m 2
+ h + ω 0 x (t ) = 0 F (t, Y ) =  ,− − x ( t )
dt dt  dt m dt m 
 Informatique pour tous Résolution numérique d’une équation différentielle

I-Équation différentielle du premier ordre II-Au-delà

1) Méthode d’Euler 1) Ordre supérieur à 1
2) Fonction odeint

Travail demandé : Pour mettre en place les méthodes, on cherche à résoudre l’équation z’’(t) = g
sur l’intervalle [0, 2] à l’aide de la méthode d’Euler et de la fonction odeint.
Étudier de près les programmes suivants avant de les transcrire sur la machine pour obtenir un
résultat voisin de celui-ci :

proposition de solution
 Informatique pour tous Résolution numérique d’une équation différentielle

I-Équation différentielle du premier ordre II-Au-delà

1) Méthode d’Euler 1) Ordre supérieur à 1
2) Fonction odeint

A priori, l’algorithme d’Euler fonctionne toujours mais Y est un [Link] ainsi que F(t, Y)

def euler(F, t0, tf, CI_tab, h):

y_tab = [Link]([CI_tab[0],CI_tab[1]]) #y_tab est le tableau [y(t), v(t)]
t = t0
liste_y = [y_tab] # liste_y est la liste des [y(t), v(t)]
liste_t = [t] # liste_t est la liste des instants t
while t + h <= b:
y_tab = y_tab + h * F(t, y_tab) # pour que l’opération * marche
comme il faut, y_tab doit être un [Link]
liste_y.append(list(y_tab)) # mais pour la suite, il vaut mieux que
liste_y soit une liste de listes plutôt que de [Link]
t += h
liste_t.append(t)
return liste_t, [Link](liste_y) # par contre, pour le slicing , il vaut
mieux renvoyer un [Link] qu’une liste !

Exemple : équation z’’(t) = g sur l’intervalle [0, 2]

 Informatique pour tous Résolution numérique d’une équation différentielle

I-Équation différentielle du premier ordre II-Au-delà

1) Méthode d’Euler 1) Ordre supérieur à 1
2) Fonction odeint
Utilisation de odeint
import numpy as np
from [Link] import odeint

def f_ode(syst, t): # la fonction qui retourne le vecteur syst=[y’,y’’]

g = -9.81
v = syst[1]
return [v, g]

# conditions initiales
CI_tableau = [Link](2)
CI_tableau[0] = 10
CI_tableau[1] = 0.

# Paramètres d'intégration
debut = 0
fin = 2.
nb_points = 100
liste_t = [Link](debut,fin,nb_points)
# résolution du système
sol_ode = odeint(equadiff, syst_CI, t_vec)
#récupération des valeurs de y
y_ode = sol_ode[:, 0]
Informatique pour tous Résolution numérique d’une équation différentielle

I-Équation différentielle du premier ordre II-Au-delà

1) Méthode d’Euler 1) Ordre supérieur à 1
2) Fonction odeint

Travail demandé : Étude d’un oscillateur de pulsation ω0.

d 2 x (t ) ω0 dx ( t )
¤ Oscillations libres amorties : résoudre l’équation 2
+ + ω0 2 x ( t ) = 0 à l’aide de la méthode
dt Q dt

d’Euler et de la fonction odeint sur l’intervalle [0, 10] avec les valeurs numériques suivantes :
ω0 = 2*pi ; Q = 10 ; x0=1 ; v0=0

¤ Oscillations forcées : étudier la solution complète en changeant la pulsation ω de l’excitateur (on

pourra n’utiliser que la fonction odeint) . Tracer le portrait de phase.
d 2θ ( t )
¤ Oscillations libres d’un pendule pesant : + ω0 2 sin ( θ ( t ) ) = 0 sur l’intervalle [0, 3] pour θ0= π et
dt 2
θ0’ non nul.
Informatique pour tous Résolution numérique d’une équation différentielle

I-Équation différentielle du premier ordre II-Au-delà

1) Méthode d’Euler 1) Ordre supérieur à 1
2) Fonction odeint

Pour faire envie, le livre d’images à feuilleter :

proposition de solution
Informatique pour tous Résolution numérique d’une équation différentielle

I-Équation différentielle du premier ordre II-Au-delà

1) Méthode d’Euler 1) Ordre supérieur à 1
2) Fonction odeint

Pour faire envie, le livre d’images à feuilleter :

proposition de solution
Informatique pour tous Résolution numérique d’une équation différentielle

I-Équation différentielle du premier ordre II-Au-delà

1) Méthode d’Euler 1) Ordre supérieur à 1
2) Fonction odeint

Pour faire envie, le livre d’images à feuilleter :

proposition de solution
Informatique pour tous Résolution numérique d’une équation différentielle

I-Équation différentielle du premier ordre II-Au-delà

1) Méthode d’Euler 1) Ordre supérieur à 1
2) Fonction odeint

Pour faire envie, le livre d’images à feuilleter :

proposition de solution
Informatique pour tous Résolution numérique d’une équation différentielle

I-Équation différentielle du premier ordre II-Au-delà

1) Méthode d’Euler 1) Ordre supérieur à 1
2) Fonction odeint

Pour faire envie, le livre d’images à feuilleter :

d 2 x (t )   x  2 ω0  dx ( t )
+   −  + ω0 2 x ( t ) = 0
dt 2  a  Q dt
 

proposition de solution
Informatique pour tous Résolution numérique d’une équation différentielle

I-Équation différentielle du premier ordre II-Au-delà

1) Méthode d’Euler 1) Ordre supérieur à 1
2) Fonction odeint 2) Système d’équations différentielles

RÉSOLUTION NUMÉRIQUE D’UNE

ÉQUATION DIFFÉRENTIELLE
I-Équation différentielle du premier ordre
1) Méthode d’Euler
2) Fonction odeint
II-Au-delà
1) Équation différentielle d’un ordre supérieur à 1
2) Système d’équations différentielles
Informatique pour tous Résolution numérique d’une équation différentielle

I-Équation différentielle du premier ordre II-Au-delà

1) Méthode d’Euler 1) Ordre supérieur à 1
2) Fonction odeint 2) Système d’équations différentielles

Quand différentes populations

(issues d’espèces différentes)
interagissent, la dynamique de
chacune est affectée par les effectifs
des autres. Elles forment une
cascade de populations en
interaction qui constitue une
communauté, appelée « chaîne
trophique ».
Les relations possibles entre
espèces d’une même chaîne
trophique se classent en trois
catégories principales : la relation proie-prédateur, la relation de symbiose mutualiste et la relation de
compétition.
Le plus célèbre des modèles de dynamique de deux populations en interaction est celui de Lotka-
Volterra. Il fut proposé indépendamment par Alfred James Lotka (mathématicien et statisticien américain)
en 1925 et Vito Volterra (mathématicien et physicien italien) en 1926. Dans ce modèle, les prédateurs
prospèrent lorsque les proies sont nombreuses, mais finissent par épuiser leurs ressources et commencent à
décliner. Lorsque la population de prédateurs a suffisamment diminué, les proies se reproduisent et leur
population augmente à nouveau.
Ainsi, les variations cycliques des populations de lièvres des neiges et de lynx suivies au Canada
depuis 1825 ont été modélisées à l’aide du modèle de Lotka-Volterra.
Informatique pour tous Résolution numérique d’une équation différentielle

I-Équation différentielle du premier ordre II-Au-delà

1) Méthode d’Euler 1) Ordre supérieur à 1
2) Fonction odeint 2) Système d’équations différentielles

On note x(t) l'effectif des proies et y(t) celui des prédateurs en fonction du temps.

Les proies sont supposées avoir une source illimitée de nourriture et se reproduire exponentiellement
si elles ne sont soumises à aucune prédation ; cette croissance est donc représentée par le terme
 dx 
  = a x (t )
 dt CROISSANCE
(a est constant, indépendant du nombre de prédateurs) .

Le taux de prédation des proies est supposé proportionnel aux rencontres entre les prédateurs et les
proies ; il est décrit par le terme −p x(t) y(t) (p est une constante).
Le taux de croissance de la population des proies est similaire au taux de prédation ; cependant, une
constante différente est utilisée car la vitesse à laquelle la population des prédateurs augmente n'est pas
nécessairement égale à celle à laquelle ils consomment les proies. Ce terme s’écrit q x(t) y(t) .
Le taux de disparition naturelle des proies est proportionnel à leur population selon
 dy 
  = − b x (t )
 dt MORTALITE

Finalement, x(t) et y(t) vérifient le système d’équations :

 dx
 dt = a x ( t ) − px ( t ) y ( t )

 dy = − b x ( t ) + qx ( t ) y ( t )
 dt
 Informatique pour tous Résolution numérique d’une équation différentielle

I-Équation différentielle du premier ordre II-Au-delà

1) Méthode d’Euler 1) Ordre supérieur à 1
2) Fonction odeint

Travail demandé : Résoudre le système d’équations de Volterra avec la fonction odeint (on pourra
vérifier que la méthode d’Euler n’est pas adaptée ici). Représenter les courbes x(t) et y(t) puis le
diagramme de phase y(x) dans le cas a = 2 , p = 1, b = 1.1 et q = 1.

proposition de solution
Informatique pour tous Résolution numérique d’une équation différentielle
Informatique pour tous Représentations graphiques

I-Méthode de Newton II-Plotons un peu III-Escargot IV-Bouquet final

 Informatique pour tous Résolution numérique d’une équation différentielle

I-Équation différentielle du premier ordre II-Au-delà

1) Méthode d’Euler 1) Ordre supérieur à 1
2) Fonction odeint
import numpy as np #résolution
# Exemples
from [Link] import odeint sol_ode = odeint(f_ode,CI_1(),t) # Résolution
def f_ana(t) :
numérique de l'équation différentielle avec odeint
y0 = CI_1()
def euler(f, a, b, h) : sol_euler = euler(f_euler, debut, fin,(fin-debut)/nb_points)
return y0/(1 - y0*(t))
y = CI_1()[0] return
t=a
liste_y=[y] # Récupération des listes des abscisses ou ordonnées
liste_t=[t] y_ana=[f_ana(x) for x in t]
def f_euler(t,y):
liste_v = [f(t, y)] y_ode = sol_ode[:, 0]
return y**2
while t+h <= b: y_euler = sol_euler[1]
y += h * f(t, y) t_euler = sol_euler[0]
liste_y.append(y) def f_ode(syst, t):
t += h # Graphiques des solutions
return [syst[0]**2]
liste_t.append(t) import [Link] as pl
liste_v.append(f(t, y))
return [Link]([liste_t,liste_y, liste_v]) [Link](t, y_ana, '-b', lw=1.5, label=u"Sol. analytique")
#renvoie le tableau des valeurs # Solution analytique
[Link](t, y_ode, 'o', ms=6, mfc='w',
# Paramètres des calculs mec='b',label=u"[Link]") # Solution numérique
debut = 0 [Link](t_euler, y_euler, 'o', ms=6, mfc='w',
fin = 0.8 mec='red',label=u"[Link]")
nb_points = 50
t = [Link](debut,fin,nb_points) [Link](r"$t $", fontsize=16) # Label de l'axe des
abscisses
# Conditions initiales [Link](r"$y/y_{0}$", fontsize=16) # Label de l'axe des
def CI_1(): ordonnées
y0 = 1 [Link]()
return [Link]([y0]) [Link]()
 Informatique pour tous Résolution numérique d’une équation différentielle

I-Équation différentielle du premier ordre II-Au-delà

1) Méthode d’Euler 1) Ordre supérieur à 1
2) Fonction odeint

import numpy as np def f_ode(syst, t):

from [Link] import odeint g = 9.81 # Graphiques des solutions
v = syst[1] import [Link] as pl
def euler(F, a, b,CI_tab, h): return [v, -g]
[Link](liste_t, y_ode,label=u"[Link]") #
y_tab = [Link]([CI_tab[0],CI_tab[1]]) # conditions initiales Solution numérique
#y_tab est le tableau [y(t), v(t)] CI_tableau = [Link](2) [Link](t_euler, y_euler, 'o', ms=4, mfc='w',
t=a CI_tableau[0] = 10 mec='red',label=u"[Link]")
liste_y = [y_tab] # la liste des valeurs de CI_tableau[1] = 0.
y renvoyées [Link](r"$t $", fontsize=16) # Label de l'axe
liste_t = [a] # Paramètres d'intégration des abscisses
while t+h <= b: debut = 0 [Link](r"$z$", fontsize=16) # Label de l'axe
y_tab = y_tab + h * F(t, y_tab) fin = 2. des ordonnées
liste_y.append(list(y_tab)) nb_points = 100
t += h liste_t = [Link](debut,fin,nb_points) [Link]() # Appel de la légende
liste_t.append(t) [Link]()
return liste_t, [Link](liste_y) # résolution du système
sol_ode = odeint(f_ode, CI_tableau,
# la fonction qui retourne le vecteur liste_t)
Y=[y’,y’’] sol_euler = euler(f_euler, debut,fin,
CI_tableau,(abs(debut-fin))/nb_points)
def f_euler(t,syst):
g = 9.81 #récupération des résultats
v = syst[1] y_ode = sol_ode[:, 0]
return [Link]([v, -g]) v_ode = sol_ode[:, 1]
y_euler = sol_euler[1][:,0]
t_euler = sol_euler[0]
 Informatique pour tous Résolution numérique d’une équation différentielle

I-Équation différentielle du premier ordre II-Au-delà

1) Méthode d’Euler 1) Ordre supérieur à 1
2) Fonction odeint

import numpy as np # Paramètres d'intégration et résolution # Graphiques des solutions

from [Link] import odeint debut= 0 import [Link] as pl
fin=30 [Link](r"$osillateur \ harmonique\
# les constantes globales nb_points = 40000 amorti $",fontsize=16)
omega0 = 2*[Link] liste_t = [Link](debut,fin,nb_points) [Link](1,2,1)
Q = 10 sol_ode = odeint(f_ode,CI_tableau,liste_t) [Link](liste_t, y_ode) # Solution
numérique odeint
[Link](r"$t $") # Label de l'axe des
def f_ode(syst, t):
#récupération des résultats abscisses
x = syst[0] # Variable1 x
y_ode = sol_ode[:, 0] [Link](r"$x$") # Label de l'axe des
v = syst[1] # Variable2 v
v_ode = sol_ode[:, 1] ordonnées
dxdt = v # Equation différentielle 1
dvdt = -omega0/Q*v-omega0**2*x # Equation différentielle 2
[Link](1,2,2)
return [dxdt,dvdt] # Dérivées des variables
[Link](y_ode, v_ode) # Solution
# conditions initiales numérique
[Link](r"$x $") # Label de l'axe des
CI_tableau = [Link](2)
abscisses
CI_tableau[0] = 1
[Link](r"$x'$") # Label de l'axe des
CI_tableau[1] = 0.
ordonnées

[Link]() # Appel de la légende

[Link]()
 Informatique pour tous Résolution numérique d’une équation différentielle

I-Équation différentielle du premier ordre II-Au-delà

1) Méthode d’Euler 1) Ordre supérieur à 1
2) Fonction odeint
import [Link] as pl prefixe =r'$\omega =\omega _0‘
import numpy as np omegastr_liste =[prefixe + "/3$",]
from [Link] import odeint omegastr_liste.append(prefixe + "/2$",)
omegastr_liste.append(prefixe +"$",)
# les constantes globales omegastr_liste.append(prefixe + "\cdot2$",)
omega0 = 2*[Link] omegastr_liste.append(prefixe + "\cdot3$",)
omega = [Link](2)*[Link] [Link](r"$osillateur \ harmonique\ (puls\ \omega _0)\ forc\'e \ (puls\ \omega) $",fontsize=16)
Q = 10

def f_ode(syst, t,omega): for omega in omega_tup :

x = syst[0] # Variable1 x sol_ode = odeint(f_ode,CI_tableau,liste_t,(omega,))
v = syst[1] # Variable2 v #récupération des résultats
dxdt = v # Equation différentielle 1 y_ode = sol_ode[:, 0]
dvdt = 2*[Link](omega*t) -omega0/Q*v-omega0**2*x # Equation différentielle 2 v_ode = sol_ode[:, 1]
return [dxdt,dvdt] # Dérivées des variables
# Graphiques des solutions
# conditions initiales omegastr=omegastr_liste[omega_liste.index(omega)]
CI_tableau = [Link](2) [Link](liste_t, y_ode,label=omegastr) # Solution
CI_tableau[0] = 1 numérique
CI_tableau[1] = 0. [Link](r"$t $", fontsize=16) # Label de l'axe
des abscisses
# Paramètres d'intégration et résolution [Link](r"$x$", fontsize=16) # Label de l'axe
debut= 0 des ordonnées
fin= 30 #fin de la boucle sur les omega
nb_points = 40000 [Link]() # Appel de la légende
liste_t = [Link](debut,fin,nb_points) [Link]()
omega_tup =(omega0/3,omega0/2,omega0,2*omega0,3*omega0)
 Informatique pour tous Résolution numérique d’une équation différentielle

I-Équation différentielle du premier ordre II-Au-delà

1) Méthode d’Euler 1) Ordre supérieur à 1
2) Fonction odeint
import [Link] as pl #récupération des résultats
import numpy as np y_ode = sol_ode[:, 0]
from [Link] import odeint v_ode = sol_ode[:, 1]
liste_t_fin = liste_t[-1000:]
# les constantes globales y_ode_fin = y_ode[-2000:]
omega0 = 2*[Link] v_ode_fin = v_ode[-2000:]
omega = [Link](2)*[Link]
Q = 10 # Graphiques des solutions
[Link](r"$osillateur \ harmonique\ forc\'e$",fontsize=16)
def f_ode(syst, t):
x = syst[0] # Variable1 x [Link](1,2,1) # sous-dessin 1
v = syst[1] # Variable2 v [Link](liste_t, y_ode) # Solution numérique
dxdt = v # Equation différentielle 1 [Link](r"$t $") # Label de l'axe des abscisses
dvdt = 2*[Link](omega0*t) -omega0/Q*v-omega0**2*x [Link](r"$x$") # Label de l'axe des ordonnées
# Equation différentielle 2 [Link](r"$x = f(t)$")
return [dxdt,dvdt] # Dérivées des variables
[Link](1,2,2) # sous-dessin 2
# conditions initiales [Link](y_ode, v_ode) # Solution numérique
CI_tableau = [Link](2) [Link](y_ode_fin, v_ode_fin,color = "red",label=r"$traj\
CI_tableau[0] = 1 finale$",linewidth= 2) # Solution numérique
CI_tableau[1] = 0. [Link](r"$x $") # Label de l'axe des abscisses
[Link](r"$dx/dt$") # Label de l'axe des ordonnées
# Paramètres d'intégration et résolution [Link]() # Appel de la légende
debut= 0 [Link](r"$portrait\ de\ phase$")
fin= 30
nb_points = 40000 [Link]()
liste_t = [Link](debut,fin,nb_points)
sol_ode = odeint(f_ode,CI_tableau,liste_t)
 Informatique pour tous Résolution numérique d’une équation différentielle

I-Équation différentielle du premier ordre II-Au-delà

1) Méthode d’Euler 1) Ordre supérieur à 1
2) Fonction odeint

import numpy as np
from [Link] import odeint [Link](r"$pendule pesant $",fontsize=16)
import [Link] as pl [Link](r"$\theta_0\ = \pi/4\ et\ \theta'_0\ non\ nul$« )

# les constantes globales

omega0 = 2*[Link] for i in [Link](1,11.6,10) :
Q =10 CI_tableau[1]=i
def f_ode(syst, t): sol_ode = odeint(f_ode,CI_tableau,liste_t)
x = syst[0] # Variable1 x #récupération des résultats
v = syst[1] # Variable2 v y_ode = sol_ode[:, 0]
dxdt = v # Equation différentielle 1 v_ode = sol_ode[:, 1]
dvdt = -omega0**2*[Link](x) # Equation différentielle 2 y_ode_debut = y_ode[:100]
return [dxdt,dvdt] # Dérivées des variables v_ode_debut = v_ode[:100]

# conditions initiales # Graphiques des solutions

CI_tableau = [Link](2) #[Link](3,2,Q_liste.index(Q)+1)
CI_tableau[0] = [Link]/4
CI_tableau[1] = 11.7 [Link](y_ode[0], v_ode[0],"ro")
[Link](y_ode, v_ode) # Solution numérique
# Paramètres d'intégration et résolution [Link](y_ode_debut, v_ode_debut,color="red") # Solution numérique
debut= 0 [Link](r"$\theta $", fontsize=16) # Label de l'axe des abscisses
fin=3 [Link](r"$\theta'$", fontsize=16) ) # Label de l'axe des ordonnées
nb_points = 4000
liste_t = [Link](debut,fin,nb_points) [Link]()
 Informatique pour tous Résolution numérique d’une équation différentielle

I-Équation différentielle du premier ordre II-Au-delà

1) Méthode d’Euler 1) Ordre supérieur à 1
2) Fonction odeint

import numpy as np
Q_liste=( 0.1,1,6,10,20,30)
from [Link] import odeint
[Link](r"$osillateur \ Van\ der\ Pol $",fontsize=16)
import [Link] as pl
for Q in Q_liste :
# les constantes globales
sol_ode = odeint(f_ode,CI_tableau,liste_t)
omega0 = 2*[Link]
#récupération des résultats
Q =10
y_ode = sol_ode[:, 0]
v_ode = sol_ode[:, 1]
def f_ode(syst, t) :
y_ode_debut = y_ode[:100]
x = syst[0] # Variable1 x
v_ode_debut = v_ode[:100]
v = syst[1] # Variable2 v
dxdt = v # Equation différentielle 1
# Graphiques des solutions
dvdt = -(x**2-omega0/Q)*v-omega0**2*x # Equation
[Link](3,2,Q_liste.index(Q)+1)
différentielle 2
[Link](y_ode[0], v_ode[0],"ro")
return [dxdt,dvdt] # Dérivées des variables
[Link](y_ode, v_ode) # Solution numérique
[Link](y_ode_debut, v_ode_debut,color="red") # Solution numérique
# conditions initiales
e = Q/omega0
CI_tableau = [Link](2)
x=([Link](y_ode) + [Link](y_ode))/2
CI_tableau[0] = 1
y=[Link](v_ode)
CI_tableau[1] = 0.
[Link](x+1,y,r"$\omega _0/Q =$"+"{0:.3f}.".format(e)) # Appel de la
légende
# Paramètres d'intégration et résolution
[Link]()
debut= 0
fin=300
nb_points = 40000
liste_t = [Link](debut,fin,nb_points)
 Informatique pour tous Résolution numérique d’une équation différentielle

I-Équation différentielle du premier ordre II-Au-delà

1) Méthode d’Euler 1) Ordre supérieur à 1
2) Fonction odeint

import numpy as np def t() :

from [Link] import odeint debut = 0
import [Link] as pl fin = 10
nb_points = 1000
def Volterra(syst,t) : return [Link](debut, fin, nb_points
(a,b,p,q) = param()
x = syst[0] soluce = odeint(Volterra,CI(),t())
y = syst[1]
der_x = x*(a - p*y) [Link](r"$Mod\`ele\ de\ Lotka-Volterra$",fontsize=16)
der_y = y*(-b + q*x) [Link](1,2,1)
return [der_x,der_y] [Link](t(),soluce)
[Link](["proie","predateurs"],"upper left")
def param() : [Link](r'$t$')
a=2
p=1 [Link](1,2,2)
b = 1.1 x_list = soluce[:,0]
q=1 y_list = soluce[:,1]
return (a,b,p,q) [Link](x_list,y_list)
[Link](r'$proies$')
def CI() : [Link](r'$predateurs$')
syst_CI = [Link](2) [Link]()
syst_CI[0] = 2
syst_CI[1] = 1
return syst_CI