Ingénierie numérique Fichier

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
1/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 (x0 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 xn et xn+1 est déduite du schéma ci-dessous (à partir de l’équation de la tangente en un
point d’abscisse xn).
Le critère d’arrêt peut porter sur la valeur de |f(xn)| ou/et sur |xn+1 – xn| ou/et sur le nombre d’itérations.
Perfectionnements :
- vérifier à chaque étape que xn 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
2/4
Méthode d’Euler
Ingénierie numérique
Intégration d’une équation différentielle d’ordre 1
Problème de Cauchy
Recherche de la fonction y(t) telle que :
 y ′( t ) = f ( t , y ( t ) )
.

 y ( t 0 ) = y0
y de classe C1 sur [t0, tf ].
La 1ère condition exprime que y’ est une fonction connue de t et y.
La 2nde 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 ti
et les valeurs yi correspondants (h = tn+1 – tn est le pas de discrétisation, les autres paramètres sont définis ci-dessus).
Algorithme : la relation de récurrence entre yn et yn+1 est déduite du schéma ci-dessous (à partir de l’équation de la tangente en un
point d’abscisse tn).
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)
plt.show()
(liste1 = abscisses et liste2 = ordonnées)
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
3/4
Intégration d’une équation différentielle d’ordre 2 – Pendule simple (d’après concours)
2
En l’absence de frottements, l’équation du pendule simple est : θɺɺ = −ω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 =
τ
où N est un entier.
N
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 ) .
(1)
θ ( kh + h) = θ ( kh ) + h θɺ(kh)
Le système discrétisé s’écrit sous la forme : 
.
(2)
θɺ( kh + h) = θɺ( kh ) + h θɺɺ( 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
θɺɺ = − aθɺ − ω sin(θ ) .
0
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.
PCSI – IPT G. Monod
Ingenierie_numerique.docx
4/4