Cours à compléter : Chapitre 4 : Analyse numérique

Cours à compléter : Chapitre 4 : Analyse numérique

1 Le type array du module numpy

Nous utiliserons les tableaux array (aussi appelés vecteurs) du module numpy, qui sont des structures de données différentes des listes. Ils sont en effet statiques (leur taille est fixée lors de leur création) et homogènes (ils sont constitués d’éléments de même type), contrairement aux listes Python. Par contre, on peut leur appliquer directement des fonctions vectorielles, par exemple 2*T multiplie par 2 tous les éléments du tableau T (à comparer avec une liste !). On importe numpyde la manière suivante :

import numpy as np

Cette notation signifie que l’on renomme le modulenp, dès que l’on fera appel à une fonction issue de cette bibliothèque on la fera précéder du préfixenp.

Commandes de base sur les tableaux (on en fera d’autres plus tard quand on abordera les matrices):

1. np.zeros(n) : crée un vecteur nul de taille n (unidimensionnel), par défaut c’est un vecteur de flottants mais on peut changer le type en ajoutant dtype = ....

Remarque : la commande np.zeros(n, dtype = bool) renvoie un vecteur rempli de False.

2. np.array(L): crée un vecteur à partir d’une liste. Si c’est une liste de listes, cela créera une matrice.

2 Tracés de courbes

On utilise le sous-modulepyplot du modulematplotlib, on l’importe avec la commande:

import matplotlib.pyplot as plt

On doit aussi importer le module numpy pour créer des tableaux (ce module contient aussi les fonctions mathématiques classiques) :

import numpy as np

Il nous faut d’abord créer un intervalle de représentation, on le fait avec la commande np.linspace. Par exemple, pour tracer la fonction f(x) = exp(−x²/2) sur l’intervalle [0,10], on écrira:

X=np.linspace(0,10,100) Y=np.exp(-X**2/2)

plt.plot(X,Y) plt.show()

On peut ajouter en options (entre apostrophes) la couleur (r pour rouge, b pour bleu, g pour vert, ypour jaune, kpour noir), le style du tracé (– pour des pointillés,-. pour alterner pointillés et points...), et ajouter des marques (o pour des ronds, x pour des croix, vpour des

3 Résoudre f (x) = 0

Dans cette partie, on considère une fonction f continue sur un intervalle [a, b] telle que f(a) et f(b) soient de signes opposés (on peut supposerf(a)>0 et f(b)<0). Le théorème des valeurs intermédiaires nous assure alors l’existence d’un c ∈ [a, b] tel quef(c) = 0. Les méthodes qui suivent permettent de déterminer une approximation d’une solution (pas forcément unique).

3.1 Méthode de dichotomie

Le principe est le suivant : on regarde le signe de f^a+b₂ . S’il est positif, on sait qu’il existe une solution sur^ha+b₂ , bⁱdonc on recommence sur cet intervalle, sinon on se place sur l’intervalle ha,^a+b₂ ⁱ. Pour que l’algorithme s’arrête, on considère un ǫ >0 et on s’arrête quand l’intervalle a une longueur < ǫ. On retourne alors la valeur du point milieu.

Exercice: Écrire une fonction dicho(f,a,b,eps)renvoyant un intervalle de taille < eps inclus dans [a, b] et contenant un zéro de f. Montrer la correction de l’algorithme. Au bout de n étapes, quelle est la précision obtenue ? Quelle est la complexité de l’algorithme ?

Notons l’existence de la méthode bisectdans le modulescipy.optimizede Python.

3.2 Méthode de Newton

Sif est dérivable, le principe de la méthode de Newton est le suivant: on part d’un pointx₀, et on trace la tangente à la courbe de f au pointx0. Sif^′(x0)6= 0, cette tangente coupe l’axe des abscisses enx₁ =x₀−_f^f(x_′(x⁰⁾

0). On poursuit alors, on a une suite (xn) qui sous certaines conditions converge (vite) vers une solution α à l’équationf(x) = 0.

Pour le code Python, on pourra utiliser la méthodederivativedu modulescipy.miscpour calculer de manière approchée la dérivée de f au pointx (la syntaxe est derivative(f,x).

Exercice: Faire un dessin de la situation. Donner l’équation de la tangente à la courbe de f au point d’abscisse x. En déduire une expression dex_n+1 en fonction de xn (où (xn) est la suite définie précédemment par la méthode de Newton). Écrire la fonctionnewton(f,x0,n)calculant x_n.

Le théorème suivant donne des conditions suffisantes pour que la méthode fonctionne:

Théorème: Soit f : [a, b]→Rde classe C². On suppose qu’il existeα∈]a, b[ tel quef(α) = 0 et f^′(α) 6= 0. Alors pour x₀ ∈]a, b[ suffisamment proche de α, la suite (xn) précédente est bien définie et converge quadratiquement vers α, c’est-à-dire il existe une constante M >0 telle que:

|x_n+1−α|6M|xn−α|².

Idée de preuve: On applique deux fois l’égalité des accroissements finis.

Exercice: Si on veut avoir une précision ǫ, combien d’étapes au minimum sont nécessaires ? Comparer avec la dichotomie.

Remarques: On dispose d’une méthode newton dans le module scipy.optimize qui réalise la méthode de Newton. Si f n’est plus dérivable (ou que l’on veut s’affranchir du calcul de la dérivée), on peut remplacer la tangente par la corde reliant les points de la courbe def d’abscisses x_n−1 etx_n(méthode de la sécante). La méthode est un peu plus lente que la méthode de Newton mais meilleure que la dichotomie (elle est d’ordre φoù φest le nombre d’or).

4 Calculs d’intégrales

Cadre : Soit f : [a, b]→Rune fonction continue, on cherche à estimer ^R_a^bf(x)dx.

Méthode des rectangles

La méthode des rectangles est la plus simple qui soit : on approche l’aire sous la courbe d’une fonction continue sur un intervalle [a, b] par l’aire d’un rectangle dont la hauteur vaut f(ξ) où ξ ∈[a, b] et de longueur b−a. En général on prend ξ =a (méthode des rectangles à gauche), ξ = b (méthode des rectangles à droite) ou le point milieu ^a+b₂ (méthode des rectangles point milieu).

On peut ensuite affiner cette méthode en divisant l’intervalle [a, b] en n sous-intervalles de même longueur h (appelée le pas) a = x0 < x1 < · · · < b = xn, et on applique la méthode à chaque subdivision (on appelle cela une méthode composée). Voir dessin au tableau illustrant la méthode des rectangles à gauche.

Exercices:

1. Faire un dessin illustrant la méthode composée des rectangles point milieu.

2. Exprimer le pas h en fonction de a,betn.

3. Établir dans les 3 cas (gauche, droite, point milieu) la formule donnant la somme des aires des rectangles obtenus en fonction deh et des valeurs de f en des points particuliers.

4. Écrire une fonction en Pythonrectangle_gauche(f,a,b,n)prenant en entrée la fonction f, les bornesa etb et le nombre nde sous-intervalles à considérer et renvoyant la valeur approchée obtenue par la méthode (composée) des rectangles à gauche. En particulier, il faudra définir le pas h et les pointsxi de la subdivision. Donner sa complexité.

5. Faire de même pour les rectangles à droite et point milieu.

Cette méthode est connue en mathématiques sous le nom de sommes de Riemann, et on montre qu’effectivement quandntend vers l’infini, la valeur approchée tend vers la valeur exacte de l’intégrale.

Intéressons-nous à l’ordre de ces méthodes:

Définition: On dit qu’une méthode de calcul approché d’intégrale est d’ordre n si elle donne la valeur exacte de l’intégrale pour tout polynôme de degré n.

Exercice: Donner l’ordre des méthodes ci-dessus.

Remarque: Si on a plus d’hypothèses surf (de classe C¹ ou C² par exemple), on peut établir une majoration de l’erreur commise à l’aide du théorème des accroissements finis par exemple (voir cours de maths).

Exercice facultatif: On suppose que f est de classe C¹. Montrer à l’aide du théorème des accroissements finis que la méthode des rectangles à gauche donne une erreur de l’ordre de ¹_n. Méthode des trapèzes

La méthode est la même que précédemment sauf qu’au lieu d’approcher l’aire sous la courbe par l’aire d’un rectangle, on l’approche par l’aire du trapèze joignant les points (a, f(a)) et (b, f(b)).

Voir dessin au tableau.

Exercices:

1. Rappeler la formule donnant l’aire d’un trapèze rectangle.

2. Donner l’aire obtenue par la méthode composée des trapèzes sur une subdivisiona=x₀ <

x₁<· · ·< x_n=bde pash.

3. Écrire la fonction Python correspondante methode_trapezes(f,a,b,n). Donner sa com- plexité.

4. Montrer que la méthode des trapèzes peut s’obtenir facilement à partir de celle des rect- angles à gauche et d’un terme correctif à expliciter.

5. Donner l’ordre de cette méthode, comparer avec les précédentes.

Méthodes d’ordre supérieur et méthodes intégrées à Python

Nous avons vu que l’on pouvait approcher l’intégrale def par l’intégrale de fonctions constantes par morceaux (rectangles) ou affines par morceaux (trapèzes). On peut aussi considérer des fonctions polynomiales par morceaux de degré supérieur (en interpolant certains points parti- culiers par interpolation de Lagrange), on obtient les méthodes de Newton-Côtes. En degré 2 (fonctions quadratiques par morceaux), c’est la méthode de Simpson (qui est d’ordre 3) (voir TP facultatif la semaine prochaine).

Signalons enfin la méthodequadintégrée au modulescipy.integratede Python, qui donne aussi une approximation de l’erreur. La syntaxe estquad(f,a,b)oùf est la fonction eta,bles bornes.

5 Résolution d’équations différentielles

On suppose avoir importé les bibliothèques habituelles:

import numpy as np

import matplotlib.pyplot as plt

Équations d’ordre 1

Cadre: On veut trouver une solution approchée au problème de Cauchy:

( x^′(t) =F(x(t), t) x(t₀) =x₀

oùx:I →R avec I intervalle de R,F :U →Roù U ouvert de R² et (x₀, t₀)∈U. Méthode d’Euler

Sur un segment [a, b] ⊂ I avec t₀ = a, on construit une solution approchée de la manière suivante: on commence par subdiviser [a, b] en n sous-intervalles de longueur h = ^b−_n^a (appelé le pas de la subdivision), on appelle t₀ = a, t₁, . . . , tn = b les extrémités de ces sous-segments, puis on construit la solution x en posant d’abord x(t0) = x₀ (condition initiale). L’idée est alors la même que pour la méthode de Newton : on remplace x par une fonction plus simple (et que l’on sait mieux approcher), à savoir sa tangente au point x₀ (cela revient aussi à faire un développement limité à l’ordre 1). En effet on sait par l’équation différentielle que cette tangente a pour coefficient directeur F(x0, t₀). Le point x₁ (approchant x(t1)) est alors défini comme l’ordonnée du point d’abscisset₁ =t₀+hsitué sur cette tangente. On poursuit de même en calculant le coefficient directeurF(x₁, t₁) de la tangente suivante, ce qui nous donnex₂, etc...

Exercices:

1. Rappeler le développement limité à l’ordre 1 de x(t₀+h). En déduire que:

x₁ =x₀+h.F(x₀, t₀).

2. Donner la formule générale exprimantx_i+1 en fonction dex_i. 3. Appliquer la méthode au problème de Cauchy:

( x^′(t) =x(t) x(0) = 1

sur l’intervalle [0,10] avec un pas de 1. Comparer avec la solution exacte.

4. Programmer la méthode d’Euler en Python. La fonction euler(T,x0,F)prend en entrée la fonction F, la condition initiale x₀ et le vecteur T des temps t₀, . . . , t_n (sous forme de tableau numpy), et renvoie le vecteur contenant les x₀, . . . , x_n.

Remarque: On peut démontrer mathématiquement que si la fonctionFest suffisamment régulière (par exemple C¹) la méthode d’Euler converge vers la solution réelle de l’équation différentielle (qui existe et est unique dans ce cas) quand le pash tend vers 0. On peut aussi définir "l’erreur commise" et montrer qu’elle est de l’ordre de O(h).

Systèmes d’équations différentielles

La méthode d’Euler s’adapte aussi aux systèmes d’équations différentielles, qui se ramènent à une seule équation différentielle mais à valeurs vectorielles. En effet la relation de récurrence:

X_i+1 =X_i+h.F(Xi, t_i)

garde tout son sens siX_i est un vecteur et non plus un réel. En Python, le code précédent a un sens si X est un tableau numpy (rappelons l’intérêt des tableaux numpy : faire des opérations vectorielles!)

Exemple/exercice : système proie/prédateur de Lotka-Volterra: Il s’agit d’un modèle permettant de simuler l’évolution de deux populations, l’une étant les "proies" et l’autre les "prédateurs".

Considérons le système suivant:











x^′(t) =x(t)(1−y(t)) y^′(t) =y(t)(x(t)− ¹₂) x(0) = ¹₂, y(0) = ¹₂

Dans ce système,x(t) représente la proportion de "proies" ety(t) celle des prédateurs. Dans l’équation donnant x^′(t) on observe deux termes : le terme x(t) indiquant un taux de repro- duction des proies, et le terme −x(t)y(t) indiquant une mortalité car les proies se font manger par les prédateurs. De même, dans l’équation donnant y^′(t), le terme y(t)x(t) indique un taux de reproduction proportionné au nombre de proies mangées (s’il y a moins de proies, moins de reproduction !) et le terme −¹₂y(t) correspond à un taux de décès naturel. Les conditions initiales sont des taux de ¹₂ pour chaque espèce.

Exercices:

1. En posant X(t) = x(t) y(t)

!

, écrire le système sous la formeX^′(t) =G(X, t) où G est une fonction à déterminer. On appelle ce procédé la "vectorialisation".

2. (TP) Programmer en Python la fonction G(X,t) correspondante. Le paramètre X ainsi que le résultat seront des tableaux numpy.

3. (TP) Appliquer la méthode d’Euler à ce problème en prenant a = 0, b= 10 et n= 100.

On pourra construire une liste de tableaux numpy que l’on convertira ensuite en matrice.

Tracer sur un même dessin l’évolution de x et y en fonction de t, et sur un autre dessin l’évolution dey en fonction dex. Sachant que l’on peut montrer mathématiquement que les solutions du système de Lotka-Volterra sont périodiques, qu’en déduit-on sur la qualité de la méthode d’Euler ?

Équations d’ordre supérieur

La vectorialisation permet aussi de résoudre les équations différentielles (à valeurs réelles ou vec- torielles) d’ordre supérieur à 1. Elles peuvent en effet toujours être mises sous forme d’équations d’ordre 1 en prenant un vecteur comme inconnue.

Exercice: On considère l’équation du pendule: θ^′′(t) =−sin(θ(t)) avec condition initiale θ(0) = 0, θ^′(0) = 1. En posant X(t) = θ(t)

θ^′(t)

!

, se ramener à une équation vectorielle d’ordre 1 enX.

(TP) La résoudre numériquement à l’aide de la méthode d’Euler (on prendra a = 0, b = 10, n= 100). Tracer les courbes deθ(t) en fonction detainsi queθ^′(t) en fonction deθ(t) (portrait de phase).

Méthode intégrée à Python

Python dispose d’une méthodeodeintdans le modulescipy.integratequi résout de manière approchée les équations différentielles ordinaires de la forme X^′ =F(X, t) (y compris à valeurs vectorielles). La commande est de la forme odeint(F,X0,T)et prend en paramètre la fonction F, la condition initiale X₀ et l’échelle de tempsT.

Bonus : Lien avec les calculs d’intégrales On remarque le problème de Cauchy

( x^′(t) =F(x(t), t) x(t0) =x₀

)

est équivalent à la formulation sous forme intégrale:

x^′(t) =x₀+^{Z t}

t0

F(x(t), t)

(essayer de le montrer en utilisant le théorème fondamental de l’analyse !).

Dès lors, résoudre l’équation différentielle revient à trouver un moyen de calculer l’intégrale Rt

t0F(x(t), t) (tout en ignorant la valeur dex...), et nous avons justement vu des méthodes pour cela dans une partie précédente !

Exercice: Appliquer la méthode des rectangles à gauche pour calculer l’intégrale, que retrouve-t- on? Essayer ensuite avec les rectangles à droite, quel problème apparaît? Comment y remédier?

Remarque (pour votre culture): On peut en fait essayer avec toutes les méthodes vues précédem- ment, on obtient les méthodes dites de Runge-Kutta (RK), la méthode d’Euler étant la première (RK1). La plus utilisée est la méthode RK4 qui repose sur la méthode de Simpson (voir TP facultatif sur les calculs d’intégrales).

6 Matrices et pivot de Gauss

Nous utiliserons les tableauxarraydu modulenumpy, rappelons qu’ils sont statiques (leur taille est fixée lors de leur création) et homogènes (ils sont constitués d’éléments de même type), contrairement aux listes Python. On importenumpy de la manière suivante :

import numpy as np

On appellera matrice un tableau numpy à 2 dimensions. Commandes à connaître sur les vecteurs/matrices:

1. np.zeros(n): crée un vecteur nul de taillen(unidimensionnel), par défaut c’est un vecteur de flottants mais on peut changer le type en ajoutantdtype = .... De même pour créer une matrice de zéros : np.zeros((n,m))(attention, deux paires de parenthèses) oùn, m sont respectivement le nombre de lignes et de colonnes.

Remarque : la commande np.zeros(n, dtype = bool) renvoie un vecteur rempli de False.

2. np.array(L) : crée un vecteur à partir d’une liste. Si c’est une liste de listes, cela créera une matrice.

3. M[i,j]ou M[i][j] pour accéder (ou modifier avec =) au coefficient de coordonnées (i, j) (ipour la ligne,j pour la colonne) de la matrice M.

4. Si M est une matrice, len(M) renvoie son nombre de lignes ! Pour avoir le nombre de colonnes on peut regarder la taille d’une liste, par exemple len(M[0]).

5. Il y a aussi la commande M.shape (sans parenthèses) qui renvoie directement le couple (n, m) (nombre de lignes, nombre de colonnes).

6. Si M est une matrice, M[i] est un vecteur représentant la i-ème ligne de M. On peut aussi accéder à laj-ième colonne avec M[:,j].

7. Rappel : on peut faire des combinaisons linéaires de vecteurs ou de matrices, aussi la commande M1 + 2*M2, où M₁ etM₂ sont des matrices, est tout à faire valide et renvoie bien ce que vous pensez.

8. Autres commandes qui peuvent être utiles (non obligatoires de les retenir mais à savoir recoder si on vous le demande) : np.identity(n)pour créer la matrice identité de taille n,np.diag(L)pour créer une matrice diagonale contenant les éléments de la listeL. Pour faire le produit de 2 matrices M₁ etM₂ : np.dot(M1,M2).

Cadre : soit A une matrice carrée inversible de taille n×n et b un vecteur colonne de taille n, on cherche à résoudre le système linéaire Ax=bd’inconnue x (vecteur colonne de taille n), qui possède une unique solution par inversibilité de A. Nous utiliserons la méthode du pivot de Gauss vue en maths.

Opérations élémentaires

Les opérations élémentaires sur les matrices que nous utiliserons sont:

• La transvection L_i ←L_i+t.L_j.

• La dilatation L_i←t.L_i.

• L’échange de deux lignes L_i etL_j.

Exercice: (Ré)écrire les fonctions Python réalisant les opérations élémentaires (elles étaient dans le TP sur les vecteurs et matrices !) et donner leurs complexités. Les fonctions modifieront

Triangularisation

Pour résoudre le système linéaireAx=bà l’aide du pivot de Gauss, la première étape consiste à transformer la matriceApar des opérations élémentaires en matrice triangulaireT. En effectuant les mêmes opérations sur b, on obtient alors un système triangulaireT x=v équivalent.

Pour cela, on choisit d’abord un pivot. Mathématiquement, n’importe quel pivot non nul convient, mais informatiquement, il vaut mieux prendre un pivot de valeur absolue maximale dans une colonne donnée pour minimiser les erreurs d’arrondis et éviter de diviser par un élément très petit qui aurait dû être nul mais ne l’est pas en pratique (rappel : on ne teste jamais si un flottant est nul en Python !) Après avoir échangé les lignes correspondantes, on se sert de ce pivot pour annuler tous les coefficients en-dessous, à l’aide des transvections:

Lj ← Lj−aji

aii

.Li.

On passe ensuite à la colonne suivante.

Exercices:

1. Écrire une fonction pivot_partiel(A,j) renvoyant l’indice de l’élément de plus grande valeur absolue sur la colonnej de la matriceA en ne considérant que les éléments sous la diagonale.

2. En déduire une fonction triangularisation(A,b) réalisant la triangularisation du sys- tème Ax=b et renvoyant la matrice T et le vecteur v correspondant au niveau système équivalent T x = v. On utilisera la commande copy() pour réaliser des copies, on ne modifiera pas les entrées.

3. Quelle est la complexité dans le pire des cas de la fonction triangularisation? Remontée

Une fois que l’on a notre système triangulaireT X =B^′, il est facile de le résoudre par remontée.

On trouve d’abord xn−1, puis xn−2 etc à l’aide de la formule:

xi = 1 tii



b^′_i−

n−1

X

k=i+1

tikxk



.

Exercices:

1. Écrire une fonctionremontee(T,v)prenant en entrée la matrice triangulaireT et le vecteur v précédents et qui renvoie le vecteur x solution du systèmeT x=v.

2. En déduire une fonction gauss(A,b) qui résout le système linéaire Ax=b.

3. Quelle est la complexité de la fonctionremontee? En déduire le coût total de la méthode du pivot de Gauss. Sachant qu’un ordinateur de bureau peut réaliser environ 10¹⁰ opéra- tions sur les flottants par seconde, combien de temps faut-il pour résoudre un système de taille 10⁴ ? Et 10⁶ ? Commenter.

Remarque: On dispose dans le sous-modulelinalgdu module numpyd’une fonction solvequi résout les systèmes linéaires.