Comparer aussi aux valeurs approchées obtenues à l’aide de la fonctionquaddécrite dans le document Python-AN.pdf

Lycée Berthollet MP/MP* 2021-22

TP sur les algorithmes numériques

Le but de ces exercices est la révision des algorithmes d’analyse numérique au programme de première année. Chacun pourra donc choisir l’ordre le plus approprié pour leur résolution, en fonction de l’état de ses connaissances. Ces algorithmes seront systématiquement comparés à ceux des bibliothèquesnumpy/scipy, en utilisant au besoin les outils graphiques de la bibliothèquematplotlib.pyplot. Pour la syntaxe concer- nant les objets et fonctions de ces bibliothèques, on renvoie au document d’aide utilisé à l’oral du concours Centrale/Supélec, qui est par exemple accessible sur le site de la classe :

http://mathemouton.free.fr/Info/Cours/Python-total-Centrale.pdf Exercice 1 Calcul approché d’intégrales

1. Après un dessin sur papier, coder deux fonctionsrectangles(f,a,b,n)ettrapezes(f,a,b,n) qui prennent en arguments une fonction Pythonfreprésentant une fonction réelle f, a etbreprésentant deux réelsa<betnreprésentant un entiern, et retournent les valeurs approchées de^R_a^bf obtenues respective- ment par les méthodes des rectangles et des trapèzes, avec une subdivision régulière de l’intervalle[a,b]en nsous-intervalles.

2. Comparer à l’aide d’une représentation graphique les deux méthodes (en prenant différentes valeurs de n) sur une fonction dont on sait calculer explicitement l’intégrale.

Comparer aussi aux valeurs approchées obtenues à l’aide de la fonctionquaddécrite dans le document Python-AN.pdf.

Exercice 2 Résolution approchée d’une équation f(x) =0 1. Dichotomie

1. Programmer une fonction dicho(f,a,b,eps) qui prenne en argument une fonction Python f re- présentant une fonction réelle f continue sur un intervalle I, deux flottantsa etb représentant des valeursa<bdansI telles que f(a)f(b)≤0 et un flottanteps représentant une erreurε, et trouve une valeur approchée àεprès d’un zéro de f appartenant à l’intervalle[a,b].

2. À des fins de tests et comparaison, programmer aussi une fonctiondichoIter(f,a,b,n)qui effec- tuenétapes de l’algorithme précédent et retourne le point milieu du dernier intervalle obtenu.

2. Méthode de Newton

On considère une fonctionf qu’on suppose deux fois dérivable, de dérivée strictement positive et de dérivée seconde positive sur un intervalle[a,b], avec f(a)<0 et f(b)>0. La méthode de Newton consiste à partir d’un pointu₀ de l’intervalle, prendre l’abcisseu₁ du point d’intersection de la tangente au graphe de f en (u₀,f(u₀))avec l’axe des abcisses, et recommencer...

1. Faire un dessin sur papier qui représente les itérations de la méthode de Newton en partant du pointb et donner la formule permettant de définir la suite réelle correspondante. Pourquoi cette suite est-elle bien définie ? Que se passe-t-il si on part du pointa? Ou d’un point d’image négative, mais “proche”

de la racine ? Et si f⁰⁰≤0 ? Et si f⁰<0 et f⁰⁰ ≤0 ?

2. On suppose dans un premier temps qu’on dispose de la formule de la dérivée de la fonction f. On peut donc coder deux fonctions Python, l’une pour f et l’autre pour f⁰. Programmer alors une fonctionnewton(f,df,u0,eps)qui prenne en arguments les deux fonctions Python représentant f et f⁰, un flottantu0représentant le point de départ etepsreprésentant un réelε>0, et qui retourne une valeurztelle que|f(z)|<ε.

3. À des fins de tests et comparaison, programmer aussi une fonction newtonIter(f,df,u0,n) qui effectuenétapes de l’algorithme précédent et retourne le dernier point obtenu.

4. Que proposez-vous lorsqu’on n’a pas de formule explicite pour la dérivée de la fonction ?

3. Comparer à l’aide d’une représentation graphique les deux méthodes (en prenant différentes valeurs de n), sur des exemples pour lesquels on sait calculer explicitement la racine.

Comparer aussi aux valeurs approchées obtenues à l’aide de la fonctionfsolvedécrite dans le document Python-AN.pdf.

Exercice 3 Méthode d’Euler

On considère ici une équation différentielle (E): ϕ⁰(t) = F(ϕ(t),t). Par exemple, si l’équation est ϕ⁰(t) =t²ϕ(t), la fonctionF est alors définie parF(x,t) =t²x.

On veut résoudre numériquement(E)sur un intervalle [a,b]avec la condition initialeϕ(a) =x₀. Pour cela, on découpe l’intervalle enn parts égales en posant, pourk∈[[0,n]],t_k =a+^k_n(b−a). On approche ensuite successivement les réels ϕ(t_k) par des valeurs x_k de la manière suivante. Pour k∈[[0,n−1]], on évaluex_k+1à partir dex_k ainsi : on prend la solutionϕ_kde(E)qui passe parx_k au tempst_k, on l’approche par la fonction affine dont le graphe est la tangente au graphe de cette solution au point(t_k,x_k)(qui a donc comme penteϕ⁰_k(t_k) =F(ϕ_k(t_k),t_k) =F(x_k,t_k)) et on prend pourx_k+1l’ordonnée du point de cette tangente qui a comme abcisset_k+1.

1. Faire un dessin de la construction dex_k+1à partir dex_k. 2. En déduire une expression dex_k+1en fonction dex_k.

3. Coder une fonction euler(F,x0,T) qui prenne en argument une fonction Python F(x,t) codant la fonction F, x0 représentant la condition initiale et un tableau T contenant les points de la subdivision (t₀,t₁, . . . ,t_n)de l’intervalle[a,b], et retourne un tableau contenant les valeurs approchées(x₀,x₁, . . . ,x_n).

4. En prenant une équation différentielle qu’on sait explicitement résoudre, faire afficher sur un même graphique les solutions approchées obtenues pour différentes valeurs denainsi que la solution “exacte”.

Faire aussi afficher sur ce graphique la solution obtenue à l’aide de la fonctionodeintdécrite dans le documentPython-AN.pdf.

Exercice 4 Algorithme du pivot

Le but de cet exercice est de programmer la résolution numérique d’un système linéaire denéquations àninconnues dont on suppose qu’il est de Cramer : il y a donc une unique solution et le système étant de rang maximal, on est assuré qu’on pourra trouver à chaque étape un pivot non nul dans la colonne que l’on est en train de traiter.

Les données du système sont supposées être stockées dans un matrice (dite augmentée) à n lignes et n+1 colonnes, contenant le second membre en dernière colonne. On utilise ici un tableau de type numpy.ndarray, dont les éléments sont de type float, pour représenter cette matrice. Le termematrice désignera donc ici un tel tableau.

La fonction principale lancera une copie de la matrice passée en paramètre, de telle sorte que les fonc- tions auxilliaires puissent modifier la matrice du système au fur et à mesure de l’algorithme sans que la matrice initiale soit modifiée.

1. Écrire une fonctionafficheMat(a)prenant en paramètre une matriceaet l’affichant de manière lisible par un humain (cette fonction ne retourne rien).

2. Écrire une fonction echangeLignes(a,i,k)prenant en paramètres une matricea et deux indices de lignesietk, et échangeant les deux lignes de la matriceasur place(elle modifie donc l’objet pointé para et ne retourne rien). Tester cette fonction à l’aide de la fonction précédenteafficheMat.

3. Écrire une fonctionlignePivotMax(a,j)prenant en paramètre une matriceaet un indice de colonne jet retournant l’indice de lignelignesupérieur ou égal àjtel quea[ligne][j]soit maximal en valeur absolue.

4. Écrire une fonctionmetUnZero(a,i,j)prenant en paramètres une matricea, un indice de ligneiet un indice de colonnej, et faisant apparaître un zéro dansa[i][j]par une opération élémentaire sur les lignes consistant à soustraire à la ligneiun certain multiple de la lignej.

2

5. Écrire une fonction descentePivot(a) prenant en paramètre une matricea et effectuant la descente de l’algorithme du pivot. À la fin de l’exécution, la matriceaest triangulaire supérieure.

6. Écrire une fonctionremonteePivot(a)prenant en paramètre une matrice (triangulaire)aet effectuant la remontée de l’algorithme du pivot. À la fin de l’exécution, la matriceaest diagonale.

7. Écrire une fonction resolPivot(a) prenant en paramètre une matrice (diagonale) a et effectuant la résolution de l’algorithme du pivot. Cette fonction ne modifie pasamais retourne dans une liste le vecteur solution du système.

8. Écrire la fonction principale pivot(a) qui résout le système associé à la matrice paramètrea : cette fonction doit afficher la matrice initiale, la matrice à la fin de la descente, la matrice à la fin de la remontée et le vecteur solution. Pour cette question seulement, on travaille directement sur la matrice a passée en paramètre, qui sera donc modifiée.

9. Tester votre algorithme sur un exemple en comparant votre résultat avec celui obtenu avec numpy :

# Avec numpy --- import numpy.linalg as alg

A = np.array([[ 1, 2, 5], [ 3, 4, 6], [-1,-2,-3]]) print(A)

Ainv = alg.inv(A) print(Ainv)

b = np.array([8,9,1]) btransp = b.T

print(btransp)

x=np.dot(Ainv,btransp) print(x)

# Avec les fonctions implementees ici --- Ab = np.array([[ 1, 2, 5, 8],

[ 3, 4, 6, 9], [-1,-2,-3, 1]],

dtype=float) pivot(Ab)

10. Modifier la fonction principale pivot(a) pour qu’elle ne modifie plus la matrice la matrice a, en utilisant l’appel a.copy(). Remarquer que cela ne fonctionnerait pas si on représentait les matrices par des listes de listes (plutôt qu’un tableaunumpy) car alors la copie serait superficielle et la matrice originale serait modifiée lors de l’exécution de la fonctionpivot.

11. Lors de l’exécution des opérations élémentaires sur les lignes dans votre fonction metUnZero, il est probable qu’il y ait des calculs inutiles (on sait déjà qu’il y aura des zéros à des endroits précis). Modifier cette fonction pour qu’elle fasse le moins d’opérations possibles, à la descente comme à la montée.

12. Calculer alors le nombre d’opérations et d’affectations effectuées lors de l’appel dedescentePivot, puis en déduire l’ordre de grandeur de la complexité de la fonctionpivot.

13. En pratique il arrive fréquemment qu’on doive résoudre des systèmes tridiagonaux, i.e.tels que les seuls coefficients non nuls soient sur la diagonale, immédiatement au dessus et immédiatement au dessous.

Comment optimiser la fonctionmetUnZerodans ce cas ? Construire des fonctions avec le suffixeTridiag

3

permettant d’appliquer l’algorithme du pivot dans ce cas et le tester en le comparant avec le résultat de numpy sur l’exemple suivant :

# Avec numpy --- def tridiag(a,b,c):

return np.diag(a,-1) + np.diag(b,0) + np.diag(c,1) A = tridiag([1,1,1,1],[2,2,2,2,2],[3,3,3,3])

print(A)

Ainv = alg.inv(A) print(Ainv)

b = np.mat([9,8,7,6,5]) btransp = b.T

print(btransp)

x=np.dot(Ainv,btransp) print(x)

# Avec les fonctions implementees ici --- a = np.array([[ 2, 3, 0, 0, 0, 9],

[ 1, 2, 3, 0, 0, 8], [ 0, 1, 2, 3, 0, 7], [ 0, 0, 1, 2, 3, 6], [ 0, 0, 0, 1, 2, 5]],

dtype=float) pivotTridiag(a)

14. Montrer que la complexité de la fonctionpivotTridiagest linéaire.

4