M1Math ´e matiques

M1 Math´ematiques

Programmation - Octave

etienne.birmele@parisdescartes.fr

Automne 2017

Universit´ e Paris Descartes

TP1 - Introduction et prise en main d’ Octave

Octave est un logiciel libre de calcul num´ erique, qui a son propre langage de programmation et un environnement interactif. On peut ex´ ecuter une commande soit en la tapant directement en ligne de commande dans la fenˆ etre graphique d’Octave soit en ex´ ecutant un script qui est une suite de commandes qui se trouvent dans un fichier dont l’extension est ” .m”. Une documentation en ligne est disponible sur le site www.gnu.org/software/octave/, ou ` a l’aide de la commande help.

Cette introduction a pour objectif de vous apprendre ou rappeler l’utilisation ´ el´ e- mentaire d’Octave. Une partie de ce document est tutorielle et peut ˆ etre ex´ ecut´ ee enti` erement en ligne de commande, mais d` es qu’il faudra construire des programmes plus complexes on aura recourt ` a des scripts et fonctions afin de gagner en efficacit´ e.

Pendant la partie tutorielle, vous ˆ etes encourag´ es ` a taper les commandes et ` a en com- prendre le r´ esultat. Faire suivre une commande par un ”;” avant de taper [ENTREE]

fait que le r´ esultat du calcul n’est pas visualis´ e. Si vous voulez voir le r´ esultat il ne faut pas mettre de ”;”. De plus le caract` ere % introduit un commentaire, tout ce qui le suit sur la ligne est ignor´ e.

3+4; % Vous n ' ^ etes pas oblig´ es de taper les commentaires.

3+4

1.1 Les bases

Dans Octave, toutes les variables sont des matrices dont les entr´ ees sont des r´ eels (repr´ esent´ es par un type ”double”) ou des complexes (x + iy, o` u x et y sont r´ eels). On dit qu’une matrice est de taille m × n si elle a m lignes et n colonnes. Un vecteur colonne est une matrice qui a une seule colonne (de taille n × 1) et un vecteur ligne est une matrice qui a une seule ligne (de taille 1 × n).

1.2 G´ en´ erer une matrice

Il y a divers moyens de g´ en´ erer une matrice ou un vecteur

— zeros(m,n) : G´ en` ere une matrice de taille m × n pleine de z´ eros.

— ones(m,n) : Cette fois-ci la matrice est pleine de 1.

— eye(m,n) : Matrice identit´ e de taille m.

— linspace(x,y,n) : Vecteur de n valeurs r´ eguli` erement espac´ ees entre x et y.

Par exemple

linspace(1.3,15.8,5)

— a :b :c : G´ en` ere un vecteur ligne commen¸ cant ` a a et incr´ ement´ e de b tant que

l’on est encore plus petit ou ´ egal ` a c. Si on tape a : c l’incr´ ement par d´ efaut

est 1. Essayez par exemple

1.3. Op´erations sur les matrices

0:3:6 0:3:7 1:6 0:0.1:1 0:-0.1:1 1:-0.1:0

— rand(m,n) : matrice de taille m × n remplie de nombres al´ eatoires tir´ es selon la loi uniforme sur [ 0, 1 ] . Si on veut plutˆ ot qu’ils suivent une loi gaussienne centr´ ee r´ eduite, on ´ ecrira randn(m,n) (cf aide de la fonction rand).

— Entrer directement les valeurs entre crochets : [1 2 3] % vecteur ligne 1 2 3

[1;2; 3] % vecteur colonne

[1 2; 3 4] % Une matrice 2 par 2

[1 2; 3] % UNE ERREUR (voir concat´ enation plus bas)

— Indices et sous-matrices.

Les indices en Scilab commencent ` a 1 : h(1) est le premier ´ el´ ement du vecteur h. A(2,1) est l’´ el´ ement situ´ e ` a la ligne 2 colonne 1 de la matrice A. Si A est une matrice de taille m × n, la matrice

B = A(i:j,k:l)

est la sous-matrice de A correspondant aux lignes i ` a j et aux colonnes k ` a l.

On extrait la i-i` eme ligne (resp. colonne) de A par la commande A(i,:) (resp. A(:,i))

Essayez par exemple h=0:9;

h(1:3)

sum(h(1:10)) % somme de tous les ´ el´ ements de h

sum(h(1:length(h))) % length(h) renvoie la longueur d ' un vecteur sum(h(1:2:length(h))) % h(1)+h(3)+h(5)+...

h(length(h):-1:1) % renvoie le vecteur h ` a l'envers

h(2:4)=ones(1,3) % remplace certaines entr´ ees de h par des 1

1.3 Op´ erations sur les matrices

— A+B : Renvoie la somme des deux matrices qui doivent ˆ etre de mˆ eme taille.

Exception : Si A ou B est un scalaire (une matrice de taille 1 × 1), il est ajout´ e ` a toutes les entr´ ees de l’autre matrices. L’op´ eration ”-” fonctionne de la mˆ eme mani` ere pour la soustraction

ones(2,2)+ones(2,2)

[1 2; 3 4]+1 % on ajoute 1 ` a toutes les entr´ ees.

— A*B : Renvoie la multiplication des matrices A et B qui doivent avoir des tailles respectives de m × n et n × l. Le r´ esultat est de taille m × l. Notez que si m = l = 1 alors cette op´ eration est un produit scalaire entre le vecteur ligne A et le vecteur colonne B. Il y a la mˆ eme exception que ci-dessus.

[1 2; 3 4]*[-2 1; 1.5 -0.5]

[1 2; 3 4]*[1 0; 0 1]

[1:20]*[1:20] ' % A ' est la matrice transpos´ ee (et conjugu´ ee) de A

(1:3) ' *(1:3)

— A.*B : Multiplication point par point. A et B doivent avoir la mˆ eme taille.

Comparez

[1 2; 3 4]*[-2 1; 1.5 -0.5]

[1 2; 3 4].*[-2 1; 1.5 -0.5]

— Fonctions unaires : Scilab dispose d’un grand nombre de fonctions usuelles pr´ ed´ efinies telles que : sin, cos, exp, tan, log . . . . Les appliquer ` a une matrice signifie appliquer la fonction ` a chaque ´ el´ ement de la matrice

exp((0:10)) % fonction exponentielle appliqu´ ee au vecteur $(0,1\dots,10)$.

— sum(v) : Renvoie la somme des ´ el´ ements de v.

sum(ones(1,10)) sum(ones(10,1)) sum(ones(2,3))

sum((1:10).*(1:10)) % somme des carr´ es des entiers de 1 ` a 10

— [A B] : Si A et B sont deux matrices avec le mˆ eme nombre de lignes, renvoie la concat´ enation horizontale des deux.

[ ones(2,6) zeros(2,4) ones(2,5)] % matrice ` a deux lignes identiques 6x1,4x0,5x1

— [A ;B] : A et B ont le mˆ eme nombre de colonnes, renvoie la concat´ enation verticale

— A( :) : Quelque soit la forme de A, renvoie un vecteur colonne qui est la conca- t´ enation verticale des colonnes de A. Utile pour s’assurer que deux vecteurs ont la mˆ eme forme (colonne)

A=[1 2; 3 4];

A(:)

— x.ˆ A : ´ el` eve le scalaire x ` a la puissance chacune des entr´ ees de A (-1/2).^(0:10) % les puissances de -1/2 de 0 ` a 10

— Constantes Scilab contient plusieurs constantes, comme le nombre complexe i, que l’on appelle avec la commande i, ou le nombre π, avec la commande pi.

exp(2*i*pi*0.123*(0:10)) % Onde de Fourier sur Z de fr´ equence 0.123, entre 0 et10 real(exp(2*i*pi*0.123*(0:10))) % Partie r´ eelle de l'onde

plot(real(exp(2*i*pi*0.123*(0:10)))) % affichage graphique Exercices

1. On consid` ere les vecteurs de R

suivants

~ u =



 1 2 3



 , ~ v =





− 5 2 1



 et ~ w =





− 1

− 3 7



 .

(a) Cr´ eer des tableaux correspondants ` a ces vecteurs.

(b) Calculer ~ u + ~ v, ~ u + 3 ~ v − 5 w, ~

~ w.

(c) En utilisant les commandes appropri´ ees, calculer k~ u k

, k ~ v k

, k~ w k

et le cosinus de l’angle form´ e par les vecteurs ~ u et ~ v.

2. On consid` ere les matrices suivantes : A =

2 3 6 5

et B =





2 3 4 7 6 5 2 8 7



 .

1.4. Scripts et fonctions

(a) Cr´ eer des tableaux correspondants ` a A et B.

(b) En utilisant les commandes appropri´ ees, calculer leurs d´ eterminants, in- verses et valeurs propres et vecteurs propres associ´ es

.

3. Pour n ∈ _N , n ≥ 2 , cr´ eer le tableau correspondant ` a la matrice tridiagonale d’ordre n d´ efinie par

A

=















2 − 1

− 1 2 − 1 . .. ... ...

− 1 2 − 1

− 1 2













 .

4. Octave (comme R) est beaucoup plus efficace lorsqu’il travaille sur des matrices que lorsqu’il ex´ ecute des boucles. On propose de se servir de la fonction timer() pour l’observer en ex´ ecutant les instructions suivantes :

n = 400;

t1=cputime();

for j=1:n, for i=1:n, a(i,j) = cos(i)*cos(j); end; end;

t2 =cputime(); clear a;

t2-t1 Puis

t3=cputime();

a=zeros(n,n);

a = cos(1:n)'*sin(1:n);

t4 =cputime();

t4-t3

1.4 Scripts et fonctions

Un programme est une suite d’instructions. Ces instructions peuvent ˆ etre plac´ ees dans un fichier (que l’on appelle un script) ` a l’aide d’un ´ editeur de texte : l’´ editeur associ´ e scipad ou un autre. Si le script s’appelle monscript.m, on l’ex´ ecute avec la commande

source monscript.m ou

run monscript.m

Une fonction Octave d´ efinie par l’utilisateur est un fichier de script sp´ ecial qui commence par une ligne du type

function [out]=mafonction(a,b,c)

La variable ”out” sera celle qui contiendra le r´ esultat de ”mafonction”. a,b et c sont les param` etres de la fonction. Voici un exemple complet de fonction

1. On consultera l’aide en ligne de la commande

function out=mafonction(a,b,c)

tmp=a+b; %tmp est une variable locale qui disparaitra ` a la fin de la fonction

out=tmp*c; % la valeur de out ` a la fin de l ' execution est la r´ eponse de "mafonction"

Avant de pouvoir utiliser cette fonction en ligne de commande, chargez la en tapant :

source mafonction.sci

Les fonctions peuvent aussi faire partie d’un script. Attention, si le script com- mence par

function

, Octave consid` ere que la fichier contient une unique fonction.

Exercices - Ecriture de fonctions

1. ´ Ecrire une fonction nomm´ ee polaire, prenant comme arguments d’entr´ ee les coordon´ ees cart´ esiennes ( x, y ) d’un point de R

et renvoyant en sortie les coor- donn´ ees polaires ( r, θ ) de ce point

.

2. Ecrire une fonction nomm´ ee profil qui associe ` a toute matrice A ` a m lignes et n colonnes son profil, c’est-` a-dire la suite d’entiers { φ ( i )}

avec φ une application de { 1, . . . , m } dans N telle que

φ ( i ) =

( inf

j ∈ { _{1, . . . ,} n } | a

6= ₀ si la i

ligne de A est non nulle,

n + i sinon.

3. Suite de Fibonacci

(a) ´ Ecrire une boucle calculant les valeurs des vingt premiers termes de la suite de Fibonacci d´ efinie par

u

= 0, u

= 1 et u

= u

+ u

, ∀ k ∈ _N, et conservant ces valeurs dans un vecteur.

(b) ´ Ecrire une boucle calculant les termes successifs de la suite de Fibonacci dont la valeur est inf´ erieure ou ´ egale ` a 50000 et afficher le dernier de ces termes.

(c) ´ Ecrire enfin une fonction fibonacci(n) calculant de mani` ere it´ erative le n

terme de la suite de Fibonacci, sans toutefois conserver les valeurs de tous les termes de la suite.

2. On rappelle que, en vertu du th´ eor` eme de Pythagore, on a

=

+

et que, pour obtenir l’angle

dans l’intervalle [

[ , on utilise les formules suivantes :

θ

=



















arctan ^y_x

si

>

et

≥

+

si

>

et

<

+

si

<

π2

si

=

et

>

3π

2

si

=

et

<

1.4. Scripts et fonctions

4. Suites adajacentes

On d´ efinit deux suites ( u

)

et ( v

)

par u

= 1, v

= 2, u

= ^u

(k)

+ v

2 , v

= ^p u

v

, ∀ n ∈ _N.

On admet que ces suites sont adjacentes, de limite

√ 27 π .

(a) ´ Ecrire un programme lisant

un entier n et affichant l’approximation du nombre π obtenue ` a partir de la valeur de v

.

(b) ´ Ecrire un programme lisant un r´ eel ε strictement positif et affichant l’ap- proximation du nombre π obtenue ` a partir de la valeur de v

, premier terme de la suite ( v

)

` a satisfaire la condition

u

− v

u

+ v

≤ ε,

avec ε un r´ eel strictement positif fix´ e

5. Calcul d’une valeur approch´ ee de π par la m´ ethode de Monte-Carlo

Pour obtenir une valeur approch´ ee du nombre π par la m´ ethode de Monte- Carlo, on tire au hasard

, dans un carr´ e de cˆ ot´ e de longueur ´ egale ` a 2, des points de coordonn´ ees ( x, y ) et l’on v´ erifie s’ils appartiennent ou non au disque de rayon 1 et de centre le centre du carr´ e. Ces points pouvant ˆ etre tir´ es avec la mˆ eme probabilit´ e dans l’ensemble du carr´ e, le rapport entre le nombre de points tir´ es dans le disque et le nombre de points tir´ es au total tend, lorsque le nombre de tirages tend vers l’infini, vers le rapport des surfaces du cercle et du carr´ e, soit

, en vertu de la loi des grands nombres.

(a) Au moyen de la commande rand, qui g´ en` ere une suite de nombres r´ eels jouant le rˆ ole d’une r´ ealisation d’une suite de variables al´ eatoires conti- nues, ind´ ependantes et identiquement distribu´ ees selon la loi uniforme sur l’intervalle [ <sub>0, 1</sub> ] , ´ ecrire une fonction prenant comme argument le nombre de tirages ` a r´ ealiser et renvoyant la valeur approch´ ee de π obtenue par la m´ ethode de Monte-Carlo d´ ecrite ci-dessus (pour simplifier, on pourra se restreindre au quart de carr´ e contenu dans l’orthant positif de R

).

(b) Donner un ordre du nombre de tirages n´ ecessaires pour obtenir plus de deux d´ ecimales exactes de π. Que dire de l’efficacit´ e de cette m´ ethode ? 6. Programmation r´ ecursive

En informatique, une fonction dite r´ ecursive lorsqu’elle s’appelle elle-mˆ eme. En pratique, une telle fonction aura toujours au moins une instruction condition- nelle, afin que, dans certains cas au moins, il n’y ait pas d’appel r´ ecursif (sans

3. Utiliser par exemple la fonction

pour demander ` a l’utilisateur de fournir une r´ eponse.

4. On appelle m´ ethode de Monte-Carlo toute m´ ethode visant ` a calculer une approximation nu- m´ erique par utilisation d’un proc´ ed´ e al´ eatoire. Le nom de ce type de m´ ethode, qui fait allusion aux jeux de hasard pratiqu´ es dans le c´ el` ebre casino d’un des quartiers de la cit´ e- ´ Etat de la principaut´ e de Monaco, a ´ et´ e invent´ e en 1947 par Nicholas Metropolis et publi´ e pour la premi` ere fois en 1949 dans un article co-´ ecrit avec Stanislas Ulam.

5. C’est-` a-dire selon une loi de probabilit´ e uniforme.

quoi la fonction s’appellerait ind´ efiniment jusqu’` a la saturation de la pile, pro- voquant une interruption du programme). Le concept de fonction r´ ecursive est g´ en´ eralement oppos´ e ` a celui de fonction it´ erative, qui s’ex´ ecute sans s’invoquer ou s’appeler explicitement.

Bien que cette forme de programmation aboutisse ` a des programmes concis et proches des formulations math´ ematiques qui en sont ` a l’origine, il peut parfois ˆ

etre mal indiqu´ e ou mˆ eme catastrophique d’employer la r´ ecursivit´ e (toute fonc- tion r´ ecursive pouvant ˆ etre remplac´ ee par une fonction it´ erative), comme on le v´ erifiera ` a la troisi` eme question du pr´ esent exercice.

(a) ´ Ecrire une fonction r´ ecursive rfactorielle(n) calculant n!.

(b) ´ Ecrire, en utilisant la fonction mod donnant le reste de la division eucli- dienne de deux entiers, une fonction r´ ecursive PGCD(a,b) renvoyant le plus grand commun diviseur

des entiers naturels a et b calcul´ e par l’algorithme d’Euclide

.

(c) ´ Ecrire une fonction r´ ecursive rfibonacci(n) calculant le n

terme de la suite de Fibonacci et comparer son temps d’ex´ ecution avec celui de la fonction fibonacci(n) de l’exercice 3.

1.5 Repr´ esentation graphique

La commande plot2d(x,y)

o` u x et y sont deux vecteurs de mˆ eme dimension, produit le graphe de la ligne bris´ ee obtenue en reliant chaque point de coordonn´ ee ( x ( i ) , y ( i )) au point suivant de coordonn´ ee ( x ( i + 1 ) , y ( i + 1 )) . Les vecteurs x et y doivent donc avoir au moins deux composantes. Lorsque le vecteur x est omis, il est pris par d´ efaut ´ egal ` a ( 1 : n ) o` u n est la dimension du vecteur y. Pour tracer le graphe de la fonction sinus sur [ 0, 2π ] avec 100 points, on utilisera la commande :

x=linspace(0,2*pi,100);

plot(x,sin(x))

Une autre solution est d’utiliser la commande fplot

fplot(@sin ,[0,2*pi])

On peut aussi utiliser le menu Zoom pour zoomer sur une partie du graphe.

Par d´ efaut, les fonctions plot et fplot effacent la fenˆ etre graphique pr´ ec´ edente, effa¸cant la courbe pr´ ec´ edente. On peut supoerposer des courbes en utilisant les com- mandes hold on et hold off. Si, ` a la suite des commandes pr´ ec´ edentes, on fait :

6. C’est-` a-dire le plus grand entier naturel qui divise simultan´ ement ces deux entiers.

7. Cet algorithme est bas´ e sur la propri´ et´ e suivante :

≥

donc de faire des divisions euclidiennes successives jusqu’` a trouver un reste nul. Le dernier reste non

nul est le PGCD.

1.6. Format d’affichage

hold on

t=linspace(0,4*pi,100);

plot(t,0.5*cos(t));

hold off

on obtiendra le graphe des deux fonctions sinus et cosinus, dans une ´ echelle commune (l’axe des x allant de 0 ` a 4π apr` es le deuxi` eme trac´ e).

Exercices - repr´ esentations graphiques

1. Tracer une repr´ esentation graphique de la fonction f ( x ) = exp (− x ) sin ( 4 x )

´

echantillonn´ ee sur 101 valeurs ´ equidistantes sur l’intervalle [ 0, 2 π ] .

2. En utilisant le zoom, d´ eterminer une valeur approch´ ee du maximum de f sur [ 0, 2 π ] . Comment affiner le trac´ e pour pr´ eciser ce maximum ?

3. Tracer sur une mˆ eme figure une repr´ esentation graphique des fonctions x 7→

x

et x 7→ x

sin ( x ) exp (− x ) sur l’intervalle [− 1, 1 ] , en utilisant des couleurs diff´ erentes pour chacune d’entre elles.

1.6 Format d’affichage

Scilab utilise par d´ efaut le format de repr´ esentation double pr´ ecision de la norme IEEE 754 pour les calculs arithm´ etiques et toute variable est a priori stock´ ee dans ce format.

On peut afficher des (tableaux de) valeurs num´ eriques ou chaˆınes de caract` eres en tapant simplement le nom des variables correspondantes ou en utilisant la commande disp, cette derni` ere r´ ealisant l’affichage sans ´ ecrire le nom de la variable concern´ ee.

Il existe diff´ erents formats d’affichage pr´ ed´ efinis, s´ electionnables grˆ ace ` a la com- mande format.

1. Tester ces formatsen ex´ ecutant la suite d’instructions suivantes : x=pi^5;

disp(x) % affichage avec la notation par d´ efaut format long % notation longue

disp(x)

format long e % notation longue au format scientifique disp(x)

Ces changements de format ne modifient pas la pr´ ecision des calculs de Scilab, seule- ment la visualisation des r´ esultats. L’affichage est variable et s’adapte au nombre ` a repr´ esenter.

Il est aussi possible de contrˆ oler tr` es pr´ ecisement la mise en forme d’un affichage

avec la commande printf, qui permet de sp´ ecifier explicitement le format via une

chaˆıne de caract` eres. Dans cette derni` ere, le format voulu pour chaque variable d´ e-

bute par le signe %, suivi de la longueur minimale du champ (c’est-` a-dire le nombre

minimal de caract` eres utilis´ es pour l’affichage) et d’un caract` ere de conversion (une

lettre) indiquant que la valeur ` a afficher est un unique caract` ere (%c), une chaˆıne de

caract` eres (%s), un entier sign´ e en base 10 (%d ou %i) ou encore un r´ eel en notation ` a

s´ eparateur fixe (%f), en notation scientifique (%e) ou compacte (%g). Dans les derniers

cas, on peut pr´ eciser le nombre maximal de caract` eres utilis´ es (pour %s), le nombre

de chiffres situ´ es ` a droite du s´ eparateur (pour %f ou %e) ou bien le nombre de chiffres

significatifs (pour %g), par un point suivi d’un chiffre. Indiquons que plusieurs autres op´ erateurs optionnels existent (’, -, + ou le caract` ere espace), ainsi que des caract` eres d’´ echappement, tels que \n pour un saut de ligne, \t pour une tabulation horizon- tale, etc... Le tableau de variables ` a afficher donn´ e en argument de la commande doit contenir au moins autant d’´ el´ ements qu’il y en a de pr´ evu dans la chaˆıne de caract` ere donnant le format.

Tester les possibilit´ es offertes par mprintf en ex´ ecutant les commandes suivantes : printf('%c\n','abcdefghijklmnopqrstuvwxyz')

printf('%s\n','abcdefghijklmnopqrstuvwxyz')

printf( ' %.13s\n ' , ' abcdefghijklmnopqrstuvwxyz ' )

TP2 - Alg`ebre lin´eaire

Exercice 2.1 ((proc´ ed´ e d’orthonormalisation de Gram–Schmidt)). On rappelle que, par- tant d’une famille B = { x

, . . . , x

} de vecteurs lin´ eairement ind´ ependants de R

, avec m et n des entiers tels que 2 ≤ m ≤ n, le proc´ ed´ e d’orthonormalisation de Gram–Schmidt permet de construire une famille B

= { q

, . . . , q

} de vecteurs or- thonormaux donn´ es par

q

= ^x

k x

k ^, q

= ^{q e}

k q _e

k ^{, avec q e}

= x

−

k−1 i

∑

( x

, q

) q

, k = 2, . . . , m.

Le pseudo-code pour cet algorithme peut ˆ etre ´ ecrit sous la forme : Gram-Schmidt

for k = 1 to m do s = 0

for i = 1 to k − 1 do s = s + < x

, q

> q

s = x

− s

if k s k 6= 0 then q

= s/ k s k else

q

= 0

1. ´ Ecrire une fonction nomm´ ee gramschmidt, prenant comme param` etre d’entr´ ee une matrice ayant pour colonnes les m vecteurs de la famille B et retournant en sortie une matrice ayant pour colonnes les m vecteurs de la famille B

, obtenue en appliquant ` a B le proc´ ed´ e d’orthonormalisation de Gram–Schmidt.

2. On pose ε = 10

. Tester la fonction gramschmidt avec la famille

B =



 



 









 1 ε 0 0







 ,







 1 0 ε 0







 ,







 1 0 0 ε











 



 

 ,

puis v´ erifier si les vecteurs obtenus sont bien orthogonaux deux ` a deux. Que constate-t-on ?

3. Pour pallier les d´ efauts d’orthogonalit´ e des vecteurs de la famille B

obser- v´ es (qui sont dˆ us aux erreurs d’arrondi en arithm´ etique ` a virgule flottante), il faut utiliser une version plus stable de la m´ ethode, appel´ ee proc´ ed´ e de Gram–

Schmidt modifi´ e. On proc` ede alors de la mani` ere suivante. A la premi` ere ´ etape, on calcule

q

= ^x

k x

k ^,

et on remplace chaque x

par x

− ( q

, x

) q

pour i > 1. Ensuite, une fois qu’on a calcul´ e les k − 1 vecteurs q

, . . . q

, on pose q

=

xkk

et on remplace chaque x

par x

− ( q

, x

) q

pour tout i > k.

Impl´ ementer, en modifiant la fonction d´ ej` a existante, cette variante pour obtenir une nouvelle fonction qu’on nommera modgramschmidt. Effectuer alors l’ortho- normalisation de la famille B donn´ ee dans la question pr´ ec´ edente. Qu’observe t’on ?

Exercice 2.2 ((R´ esolution de syst` emes lin´ eaires carr´ es)). Dans cet exercice, on consid` ere le syst` eme lin´ eaire Ax = b, o` u A ∈ M

( _R ) matrice inversible, et b ∈ _R

.

1. Formules de Cramer On rappelle que si A est une matrice inversible de colonnes a

, la solution du syst` eme lin´ eaire Ax = b est donn´ ee par

x

= ^det ( a

, . . . , a

, b, a

, . . . , a

)

det ( A ) ^.

(a) ´ Ecrire une fonction [d]=determinant(A), qui prend en entr´ ee une matrice carr´ ee et renvoie son d´ eterminant calcul´ e de fa¸ con r´ ecursive. Comparer ` a la vitesse d’ex´ ecution de la fonction det() de Scilab.

(b) ´ Ecrire une fonction [x]=cramer(A,b), qui r´ esout le syst` eme Ax=b par la m´ ethode de Cramer. Cette solution est-elle efficace ?

2. D´ ecomposition LU

(a) Impl´ ementer la d´ ecomposition LU de A en utilisant l’algorithme ci- dessous. Pour la fonction [L,U]=decomposition_lu(A), utiliser les op´ e- rations par blocs de matrices afin de diminuer le nombre de boucles ` a une.

Note : on suppose que la matrice A ne contient pas de z´ eros sur la diago- nale !

Factorisation LU : U = O

, L = I

for i = ₁ to n − ₁ do for j = i + 1 to n do

l

= a

/a

for j = i to n do

u

= a

for j = i + 1 to n do for k = i + 1 to n do

a

= a

− l

· u

u

= a

Fin

(b) ´ Ecrire, en utilisant la fonction [L,U]=decomposition_lu(A), une fonction [d]=mon_det(A),

(c) Comparer exp´ erimentalement, ` a l’aide de la fonction timer(), ou

tic()/toc(), la rapidit´ e des fonctions determinant() et mon_det().

(d) ´ Ecrire, en utilisant la fonction [L,U]=decomposition_lu(A), une fonction [x]=lu_linsolve(A,b), qui r´ esout le syst` eme Ax = b ` a l’aide de la d´ e- composition A = L ∗ U et de la r´ esolution de deux syst` emes triangulaires.

3. Influence du pivot

On consid` ere l’exemple suivant A = ε 1

1 1

et le vecteur b =

1 + ε 2

, avec ε ∈ _R

.

(a) Quelle est la solution du syst` eme lin´ eaire Ax = b ?

(b) Pour ε = 10

, r´ esoudre le syst` eme en utilisant [L,U]=decomposition_lu(A) et [x]=lu_linsolve(A,b) sans pivot, et avec pivot.

Utiliser format(``v'',23) pour afficher toutes les d´ ecimales.

(c) Mˆ eme question pour ε = 10

, que constatez vous ? 4. Pivot partiel de Gauss

(a) On consid` ere les matrices A=matrix([1:9],3,3) et P =





1 0 0 0 0 1 0 1 0



.

Calculer AP et PA. Que constatez vous ? Que vaut P

, P

, det ( P ) ? (b) G´ en´ eralisons. On ´ ecrit I

= [ e

e

· · · e

] o` u e

est le j

vecteur colonne de

la base canonique et l’on construit P en ´ echangeant la i

et la j

colonne de I

.

Montrer que le produit AP ´ echange les i

et j

colonnes de A.

En d´ eduire que P = P

= P

, det ( P ) = ± 1

et que le produit PA ´ echange les i

et j

lignes de A.

Ecrire une fonction ´ function [P]=perm_mat(n,i,j), qui d´ etermine la matrice P ∈ M

( n ) qui ´ echange les i

et j

lignes, resp. colonnes.

(c) Soit A ∈ M

( n ) . ´ Ecrire une fonction function [P]=pivot_part(A)

qui d´ etermine la matrice de permutation P telle que PA ne n´ ecessite

plus de pivot partiel de Gauss, c-` a-d : |( PA )

| ≥ max

|( PA )

| ,

j = 1, . . . , n − 1.

TP3 - R´esolution d’´equations non-lin´eaires

Dans ce TP, on souhaite utiliser sur des exemples diff´ erentes m´ ethodes d’approxi- mation d’un z´ ero d’une fonction. Il est ` a noter qu’Octave dispose de la fonction fsolve pour cela mais le but du TP est d’explorer les m´ ethodes sous-jacentes sans utiliser cette fonction.

Exercice 3.1 ((m´ ethodes de dichotomie et de Newton–Raphson, d’apr` es A. Quarteroni)). 1.

On consid` ere tout d’abord la fonction g ( x ) =

− _sin ( x ) +

−

√3

2

sur l’inter- valle

−

, π

, en observant qu’elle y poss` ede deux z´ eros.

a. D´ efinir la fonction y = g ( x ) dans Octave.

b. Tracer le graphe de la fonction g sur

−

, π

avec les commandes x=linspace(-%pi/2,%pi,100);

plot2d(x,g(x));

Expliquer pourquoi la m´ ethode de dichotomie ne peut ˆ etre utilis´ ee que pour approcher l’un des deux z´ eros de g, que l’on notera ξ dans la suite.

c. Ecrire une fonction [zero,iter,res,inc]=dichotomie(f,a,b,tol,nmax) impl´ ementant la m´ ethode de dichotomie pour l’approximation d’un z´ ero d’une fonction f donn´ ee, compris dans un intervalle [ a, b ] tel que f ( a ) f ( b ) <

0. Les autres param` etres d’entr´ ee tol et nmax de la fonction dichotomie sont respectivement la tol´ erance pour le crit` ere d’arrˆ et de la m´ ethode et le nombre maximum d’it´ erations ` a effectuer. Les param` etres de sortie zero, iter, res ´ etant pour leur part l’approximation du z´ ero obtenue, le nombre d’it´ erations n´ ecessaire au calcul de cette approximation, la valeur de la fonc- tion f en ce point. Le param` etre de sortie inc est un vecteur contenant la suite des valeurs absolues des diff´ erences entre deux approximations succes- sives (dite suite des incr´ ements). Si on note x

l’approximation du z´ ero ` a la k

it´ eration de la dichotomie, inc ( k ) doit donc contenir la valeur de l’incr´ ement | x

− x

| .

d. Utiliser la fonction dichotomie sur la fonction g de la question a) pour calculer une approximation de ξ avec une tol´ erance ´ egale ` a 10

pour le crit` ere d’arrˆ et ` a partir du choix d’un intervalle [ a, b ] convenable.

Remarque Pour utiliser la fonction f comme argument d’une autre fonction g, il faut utiliser une function handle, c` ad appeler g ( @ f ) .

e. Au moyen de la commande semilogy((1:iter),inc), tracer le graphe de

la suite des incr´ ements | x

− x

| (en fonction de k) avec une ´ echelle

semilogarithmique et d´ eterminer la loi selon laquelle ces quantit´ es tendent

vers 0 quand k tend vers l’infini.

f. On souhaite maintenant utiliser la m´ ethode de Newton pour approcher les z´ eros d’une fonction f . On rappelle qu’on part d’un point x

dans l’ensemble de d´ efinition de la fonction et qu’on construit la suite :

x

= x

− ^f ( x

)

f

( x

) ^{. (3.1)}

Le point x

est en fait l’intersection de la droite y = f ( x

) + f

( x

)( x − x

) avec l’axe des abcisses. Pour appliquer la m´ ethode de Newton dans Scilab ` a une fonction f donn´ ee, il faudra non seulement d´ efinir f dans Scilab (comme on l’a fait pour g dans la question a.), mais ´ egalement d´ efinir dans Octave la fonction d f qui correspond ` a la d´ eriv´ ee de f .

Ecrire une fonction [zero, iter,res,inc]=newton(f,df,x0,tol,nmax) qui impl´ emente la m´ ethode de Newton–Raphson pour l’approximation d’un z´ ero d’une fonction d´ erivable f donn´ ee. Les param` etres d’entr´ ee df, x0, tol et nmax repr´ esentent respectivement le nom de la fonction correspondant ` a la fonction f

, l’initialisation de la m´ ethode, la tol´ erance pour le crit` ere d’arrˆ et de la m´ ethode et le nombre maximum d’it´ erations ` a effectuer. En sortie, les param` etres sont identiques ` a ceux de la fonction dichotomie.

g. Calculer la d´ eriv´ ee g

de la fonction g d´ efinie en a., et d´ efinir une fonction y = dg ( x ) dans Scilab qui correspond ` a cette d´ eriv´ ee. Calculer des approxi- mations des deux z´ eros ξ et ζ de la fonction g avec la m´ ethode de Newton–

Raphson, en prenant une tol´ erance ´ egale ` a 10

pour le crit` ere d’arrˆ et et comme initialisation le point π pour ξ et −

pour ζ. Comparer les nombres d’it´ erations effectu´ ees pour obtenir une approximation de chacun des z´ eros.

Pourquoi sont-ils tr` es diff´ erents ? Comparer ´ egalement les graphes des suites des incr´ ements obtenus avec la commande plot2d("nl",inc).

h. On cherche ` a r´ eduire le nombre d’it´ erations n´ ecessaires ` a l’obtention d’une approximation du z´ ero n´ egatif ζ de la fonction g. La m´ ethode de Newton–

Raphson modifi´ ee, bas´ ee sur la modification suivante de la relation de r´ ecur- rence de la m´ ethode de Newton–Raphson

x

= x

− 2 f ( x

) f

( x

) ^,

a une convergence quadratique si f

( ζ ) = 0. Impl´ ementer cette m´ ethode dans une fonction modnewton. Appliquer la sur la fonction g et observer combien d’it´ erations sont n´ ecessaires pour qu’elle fournisse une approximation de ζ avec une tol´ erance ´ egale ` a 10

pour le crit` ere d’arrˆ et.

2. On consid` ere ` a pr´ esent la fonction g ( x ) = x + e

cos ( x ) , dont on veut approcher les z´ eros par la m´ ethode de Newton–Raphson.

(a) D´ efinir une premi` ere fonction Octave pour g, puis une seconde pour sa d´ eriv´ ee g

.

(b) Utiliser la fonction newton pour essayer d’approcher d’un z´ ero de g en

prenant x

= 0 pour initialisation et une tol´ erance ´ egale ` a 10

pour le

crit` ere d’arrˆ et.

(c) Tracer le graphe de g sur l’intervalle [− 1, 1 ] et tenter de donner une ex- plication qualitative du fait la m´ ethode de Newton–Raphson ne converge pas avec l’initialisation pr´ ec´ edente.

(d) Appliquer la m´ ethode de dichotomie ` a la fonction g sur l’intervalle [− 1, 1 ] pour la recherche d’un z´ ero de g.

3. Renommer et modifier la fonction dichotomie pour obtenir, sur le mˆ eme mo- d` ele, une fonction regulafalsi impl´ ementant la m´ ethode de la fausse posi- tion

. De la mˆ eme mani` ere, ´ ecrire une fonction qui impl´ emente la m´ ethode de la s´ ecante

` a partir de la fonction newton.

Exercice 3.2 ((calcul de √

2)). Dans cet exercice, on cherche ` a calculer une approxi- mation de √

2 de diverses fa¸ cons.

1. On peut tout d’abord obtenir une valeur approch´ ee de √

2 en cherchant la racine positive du polynˆ ome f ( x ) = x

− 2. Pour cela, appliquer successivement ` a f les m´ ethodes de dichotomie, de la fausse position, de Newton–Raphson et de la s´ ecante sur l’intervalle [ 1, 2 ] et d´ eterminer celles qui convergent.

2. On peut ´ egalement se servir de m´ ethodes de point fixe, d´ efinies ` a partir des applications suivantes

g

( _x ) = ₂ + _x − x

, g

( _x ) = ²

x et g

( _x ) = ^x + ₂ x + 1 , consid´ er´ ees sur l’intervalle [ 1, 2 ] .

(a) Parmi les trois fonctions ci-dessus, lesquelles conduisent ` a une m´ ethode de point fixe convergente ?

(b) V´ erifier ces affirmations en calculant les 20 premiers termes des suites d´ efinies par les relations de r´ ecurrence

x

= ¹

2 , x

= g

( x

) , k ∈ _N, i ∈ { 1, 2, 3 } .

Exercice 3.3 ((bassins de convergence de la m´ ethode de Newton–Raphson)). On s’in- t´ eresse ` a la recherche des solutions complexes de l’´ equation z

= 1 par la m´ ethode de Newton–Raphson. On consid` ere pour cela la fonction d’une variable complexe

f ( z ) = z

− 1, qui s’annule en chaque point z du plan complexe tel que z

= 1.

1. D´ efinir deux fonctions Octave f et df renvoyant respectivement les valeurs de f et de f

en un point quelconque de C .

1. On rappelle que, pour cette m´ ethode, l’approximation du z´ ero ` a l’it´ eration

est donn´ ee par l’abscisse de l’intersection de la droite passant par les points (

(

)) et (

(

)) avec l’axe des abscisses, c’est-` a-dire

x^(k)

=

−

(k)

−

f

(

) −

(

)

(

)

2. On rappelle que la m´ ethode de la s´ ecante peut ˆ etre obtenue ` a partir de la m´ ethode de Newton–

Raphson en rempla¸ cant la quantit´ e

apparaissant dans la relation de r´ ecurrence par le quotient

(

)

(

)

x^(k)−x^(k)−1

. L’initialisation de cette m´ ethode n´ ecessite donc deux points distincts,

et

, si possible proches du z´ ero recherch´ e.

2. Pour tout entier n ≥ 2, on d´ efinit une grille de pas h =

couvrant le carr´ e [− 1.5, 1.5 ] × [− 1.5i, 1.5i ] . ´ Ecrire un programme r´ esolvant, pour une valeur don- n´ ee de n, l’´ equation f ( z ) = 0 avec une tol´ erance ´ egale ` a 10

par la m´ ethode de Newton–Raphson

initialis´ ee successivement en chaque point de la grille z

= − 1, 5 ( 1 + i ) + ( i + ji ) h, 0 ≤ i, j ≤ n. Pour chaque couple ( i, j ) , stocker dans le tableau ` a deux dimensions nrac le num´ ero k (k = 1, 2 ou 3) de la racine cubique complexe de l’unit´ e e

vers laquelle la m´ ethode aura converg´ ee ` a par- tir de z

(en posant k = 4 lorsque la m´ ethode n’a pas converg´ e apr` es nmax=100 it´ erations) et dans le tableau niter le nombre d’it´ erations n´ ecessaires pour at- teindre la convergence (en stockant le nombre maximal d’it´ erations autoris´ ees nmax en l’absence de convergence).

3. Afficher une repr´ esentation de chacun des tableaux nrac et niter obtenus pour n = 100 (on pourra utiliser la fonction imagesc).

4. Refaire des trac´ es pour des pas de grille plus petits (i.e., de plus grandes valeurs de n). Que dire des fronti` eres des trois bassins de convergence de la m´ ethode ?

3. On pourra pour cela utiliser la fonction

´ ecrite ` a l’exercice