Ingénierie numérique Fichier

PCSI – IPT G. Monod Ingenierie_numerique.docx 1/4
Ingénierie numérique Intégration numérique
But : écrire les fonctions rectangles(f,a,b,n) et trapezes(f,a,b,n) réalisant l’intégration numérique d’une fonction f(x)
entre les points a et b (n est le nombre de rectangles ou de trapèzes).
Algorithmes : ils sont basés sur les schémas ci-dessous.
Vérification :
from scipy.integrate import quad # Taper ?quad dans le shell pour l'aide .
Rappel : fonctions lambda
Il est possible de définir une fonction « à la volée » en utilisant la syntaxe suivante : lambda x:2*x (pour définir une fonction
anonyme qui à x associe 2x).
Exemple 1 : rectangles(lambda x:2*x,0,1,10) (entré directement dans le shell).
Exemple 2 : fct=eval(input('Fonction : ')) (dans le fichier) et on entre dans le shell : lambda x:2*x .
Méthode des rectangles
Méthode des trapèzes

PCSI – IPT G. Monod Ingenierie_numerique.docx 2/4
Ingénierie numérique Méthode de Newton
But : écrire une fonction Newton(f,der,f,a,b,x0) permettant de rechercher le zéro d’une fonction f dérivable sur un intervalle
donné [a,b] (on cherche la valeur α telle que f( α ) = 0) en utilisant la méthode de Newton (x
0
est la valeur de départ dans
l’intervalle et der est la dérivée de f(x) fournie explicitement).
Algorithme : la relation de récurrence entre x
n
et x
n+1
est déduite du schéma ci-dessous (à partir de l’équation de la tangente en un
point d’abscisse x
n
).
Le critère d’arrêt peut porter sur la valeur de |f(x
n
)| ou/et sur |x
n+1
– x
n
| ou/et sur le nombre d’itérations.
Perfectionnements :
- vérifier à chaque étape que x
n
est bien dans l’intervalle ;
- que la dérivée ne s’annule pas (attention, du fait de la représentation des flottants sur un nombre fini de bits, un test de la
forme if f’(x) == 0; n’a pas de sens).
Vérification :
import scipy.optimize as sp # Taper ?sp.newton, ?sp.fsolve, ?sp.root dans le shell pour l'aide
Tester les commandes suivantes :
sp.newton(fct,x,der)
sp.newton(fct,x)
sp.fsolve(fct,x)
sp.root(fct,x).x
Méthode de Newton

PCSI – IPT G. Monod Ingenierie_numerique.docx 3/4
Ingénierie numérique Méthode d’Euler
Intégration d’une équation différentielle d’ordre 1
Problème de Cauchy
Recherche de la fonction y(t) telle que :
( )
0 0
( ) , ( )
( )
y t f t y t
y t y
′=
=
. y de classe C
1
sur [t
0
, t
f
].
La 1
ère
condition exprime que y’ est une fonction connue de t et y.
La 2
nde
condition est une condition initiale.
But : écrire une fonction Euler(f,t0,y0,tf,h) retournant deux listes Lt et Ly contenant respectivement les valeurs des instants t
i
et les valeurs y
i
correspondants (h = t
n+1
– t
n
est le pas de discrétisation, les autres paramètres sont définis ci-dessus).
Algorithme : la relation de récurrence entre y
n
et y
n+1
est déduite du schéma ci-dessous (à partir de l’équation de la tangente en un
point d’abscisse t
n
).
Vérification :
from scipy.integrate import odeint # Taper ?odeint dans le shell pour l'aide
y = odeint(f,[y0,t0],t) où t est une liste de valeurs (cf. ci-dessous rappels numpy).
Rappel : tracés avec matplotlib
import matplotlib.pyplot as plt
plt.plot(liste1, liste2) (liste1 = abscisses et liste2 = ordonnées)
plt.show()
Rappel : construction de listes de valeurs (flottants) avec numpy
import numpy as np
np.arange(debut,fin,pas) ou np.linspace(debut,fin,nombre) (voir l’aide).
Voir aussi np.zeros(n) et np.ones(n).
Méthode d’Euler

PCSI – IPT G. Monod Ingenierie_numerique.docx 4/4
Intégration d’une équation différentielle d’ordre 2 – Pendule simple (d’après concours)
En l’absence de frottements, l’équation du pendule simple est :
2
0
sin( )
θ ω θ
= −
ɺɺ
où θ est l’angle entre la verticale et le fil du pendule.
On simule le système sur l’intervalle de temps [0, τ ].
Schéma numérique
Le temps est discrétisé avec un pas
h
N
τ
=
où N est un entier.
On construit alors un tableau à deux indices de taille (2, N+1) : les cases d’indices [0, k] contiennent les valeurs θ (kh) et celles
d’indices [1, k] contiennent les valeurs
( )
kh
θ
ɺ
.
Le système discrétisé s’écrit sous la forme :
( ) ( ) h (kh) (1)
( ) ( ) h ( ) (2)
kh h kh
kh h kh kh
θ θ θ
θ θ θ
+ = +
+ = +
ɺ
ɺ ɺ ɺɺ
.
Dans l’équation (2), la dérivée seconde est donnée par l’équation physique du mouvement.
Objectifs
1/ Comparer (graphiquement) les solutions des équations linéarisées et non linéarisées du pendule simple.
Écrire deux fonctions :
- penduleExact(N, tau, theta0, thetaPoint0, omega0) retournant le tableau des θ (kh) ;
- penduleLinearise(N, tau, theta0, thetaPoint0, omega0) (solution lorsque l’approximation sin( )
θ θ
≈
est effectuée).
2/ Observer l’influence des frottements.
Modifier ces fonctions pour tenir compte d’un moment résistant proportionnel à la vitesse angulaire :
2
0
sin( )
a
θ θ ω θ
= − −
ɺɺ ɺ
.
On pourra prendre 2000 points (à ajuster) sur 20 secondes, θ
0
= 1 rad, ω
0
= 1 rad/s et a = 0.1 s
-1
.
Rappel numpy
Initialisation d’un tableau à deux indices de N+1 valeurs : zeros((2,N+1)) .
Vérification
scipy.integrate (cf. odeint).
La syntaxe est de la forme odeint(systeme, conditionsInitiales, t) où :
- systeme(theta, t) est une fonction de la variable theta =
[ , ]
θ θ
ɺ
(tableau à deux indices défini comme ci-dessus) et du
temps retournant la dérivée de theta, c'est-à-dire
[ , ]
θ θ
ɺ ɺɺ
ou encore, dans notre exemple,
[theta[1], -a*theta[1] -w0**2*np.sin(theta[0])] ;
- conditionsInitiales est de la forme [theta0, thetaPoint0] ;
- t = linspace(debut, fin, nbrePoints) (cf. aide).
odeint renvoie un tableau de tableaux de la forme […
[ , ]
θ θ
ɺ
…] correspondant aux différents instants.