Tp 4 analyse numérique: Programmation des méthodes numériques matlab

Ce document pédagogique a été conçu pour accompagner les étudiants universitaires dans leur apprentissage du logiciel MATLAB. Il offre une introduction complète aux fonctionnalités essentielles de ce puissant outil de calcul scientifique.

Le contenu couvre les notions suivantes :

Les généralités et opérations numériques de base ;
La manipulation des matrices et des vecteurs ;
La création de fonctions graphiques en 2D et 3D ;
Les éléments de programmation (scripts, boucles, tests) ;
De nombreux exercices et aides pour travaux pratiques.

Télécharger PDF

Généralités

Qu'est-ce que Matlab ?

Matlab est un logiciel de calcul scientifique offrant diverses fonctionnalités :

Fonctions mathématiques usuelles
Calcul matriciel
Recherche des racines d’un polynôme
Résolution d'équations différentielles
Intégration numérique
Etc.

Il peut être doté de nombreuses extensions, appelées boîtes à outils (par exemple : statistique, Simulink).

Deux Manières d'Utiliser Matlab

En entrant des instructions à la suite du prompteur `>>`, le logiciel se comporte comme une très bonne calculatrice graphique.
En créant des scripts (ou m-files) ou des fonctions (extension .m), on crée des « programmes » sauvegardables.

Aide

Pour tout problème de syntaxe, utilisez l’aide en ligne avec la commande `help`.

Opérations Numériques en Ligne

Cette section vise à se familiariser avec le logiciel en utilisant les opérateurs mathématiques de base. Le calcul sur les nombres complexes est également abordé.

Premières Commandes

Voici quelques exemples à essayer (cherchez le résultat avant l'exécution et commentez-le) :

>> 3*4

On peut taper plusieurs commandes Matlab sur une même ligne en les séparant par une virgule :

>> 5*6, 2^5

>> 3+5*2^5

Les opérateurs arithmétiques respectent la priorité habituelle (comme sur une calculatrice).

>> 3+5*2^5/5

Pour rappeler des commandes précédentes, deux possibilités s'offrent à vous :

Utiliser les touches du clavier ↑ ou ↓ pour afficher les commandes précédentes dans l’ordre chronologique.
Taper les premiers caractères de la commande puis utiliser les touches ↑ ou ↓.

Après avoir choisi la commande à rappeler, il est toujours possible de la modifier en se déplaçant avec les touches ← et → et en effectuant la correction.

Une ligne d'instruction terminée par un point-virgule (`;`) est exécutée immédiatement, mais son résultat n'est pas affiché.

Il est important de bien comprendre le sens du signe `=` : il ne signifie pas une identité entre les deux termes, mais que le résultat de l'expression de droite est assigné à la variable de gauche, qui prend alors une nouvelle valeur.

À titre d'exemple, `x = x + 1` n'a de sens qu'en langage de programmation : le résultat de la somme du « contenu » de la variable `x` et de `1` est recopié dans la même variable `x`.

La dernière réponse est appelée `ans`, à défaut de lui avoir donné un nom. On peut l'utiliser ainsi :

Calculs sur les Nombres Complexes

Dans Matlab, `i` (ou `j`) désigne le nombre imaginaire pur de partie imaginaire égale à `1`. Si la variable `i` a été utilisée entre-temps à un autre usage (comme un indice de boucle par exemple), vous pouvez la réinitialiser par `i = sqrt(-1)`.

La commande `whos` fournit des informations sur la taille, le nombre d'éléments et le nombre d'octets occupés par les variables. Matlab travaille toujours sur des données en double précision (soit 8 octets).

Matrices

Le « Mat » de Matlab ne signifie pas « Mathématique » mais « Matrice ». En effet, il considère tout nombre réel comme une matrice `1x1`. Pour Matlab, tout est tableau.

Syntaxe de Création d'une Matrice

Pour définir une matrice `A`, la syntaxe est : `A = [a11 a12; a21 a22]`, où :

Les éléments d’une ligne sont séparés par des blancs ou des virgules.
Les éléments d’une colonne sont séparés par un point-virgule (`;`) ou un retour chariot.
Le tout est mis entre crochets (`[]`).

L'appel aux éléments de la matrice est le suivant : `A(lignes, colonnes)`.

Opérations sur les Matrices

Il est possible de réaliser des opérations terme à terme sur les matrices, qui sont alors assimilées à des tableaux.

Les opérateurs `+` et `-` travaillent déjà terme à terme. Pour les autres opérateurs (`*`, `/`, `\`, et `^`), il est nécessaire de les précéder d'un point (`.`) pour préciser que les opérations se font terme à terme. Par exemple, `A .* B` effectue une multiplication élément par élément.

Remarque :

Notez quelques symboles importants : `pi`, `i` (pour un nombre complexe) et `eps` (`2.2e-16`, la précision maximale des calculs). Il faut également noter que ces symboles peuvent voir leur contenu modifié. Leur sens donné plus haut est celui fixé au lancement de Matlab. Si, après une modification, on veut revenir à la valeur prédéfinie, il faut taper `clear nom_de_la_variable`.

Fonctions Graphiques

Matlab offre des possibilités de résultats graphiques esthétiques. Travaillant sous Windows, les graphiques peuvent être recopiés dans d'autres applications (comme Word).

Fonctions 2D

>> x=-10:.1:10;
>> plot(x.^2) % chaque élément du tableau x à la puissance 2 et non produit matriciel
>> figure % créer une nouvelle fenêtre graphique. permet de stocker plusieurs graphes en une même session
>> plot(x,x.^2)

Les styles de tracé sont définis par des symboles pour la couleur et le marqueur :

Symbole pour la couleur
Symbole pour le marqueur

Fonctions 3D

On utilise la commande `plot3`. Elle possède la même syntaxe que `plot` avec le paramètre `z` (altitude) en plus :

>> t=0:pi/50:20*pi;
>> plot3(sin(t),cos(t),t);

Pour voir les figures, utilisez le menu `Windows`.

Exercices

Courbe de Gauss

Tracer la courbe correspondant à la fonction [Fonction manquante dans le texte original] pour `0 ≤ x ≤ 10`. (On commencera par créer un tableau de valeurs pour `x` avec un pas de `0.01`).

Dosage Colorimétrique du Manganèse dans un Acier

Objectif :

Tracer la courbe d’absorbance `A = f(lambda)` à partir de résultats expérimentaux.
Exploiter cette courbe pour obtenir des résultats par interpolation.

Créer les tableaux `lambda` et `A`.
Tracer `A = f(lambda)` (afficher les points expérimentaux uniquement).
Tracer la courbe par interpolation avec un pas de `1 nm`. Pour cela, utiliser la commande `spline` (voir l'aide : `help spline`) pour l’interpolation et `hold on` pour afficher les deux courbes sur le même graphique.
Déterminer `A` pour `lambda` quelconque (à l’aide de `spline`).
Trouver le maximum (fonction `max`).

Aide pour TP

Le Script AIDE_TP1

% Le script aide_TP1 en mode "démonstration" permet de se
% familiariser avec les commandes simples de Matlab.
% On fait défiler la suite du contenu de cette aide en appuyant
% sur n'importe quelle touche.
% Les commentaires écrits après un "%" ne sont pas interprétés.
% Les premières lignes de commentaires sont disponibles par "help aide_TP1"
help aide_TP1 % on affiche les premières lignes de commentaires ci-dessus
echo on % mode démonstration avec affichage des instructions
pause
format compact % affichage des résultats sans sauts de ligne

disp(' '), disp(' '), disp('Variables :'), disp(' ')
a=1
2+a
b=3*ans % le dernier résultat est appelé "ans" pour "answer"
1+2^5/4, 3e6,... % "," sépare sur une ligne et "..." empêche la rupture de ligne
i^2, pi, exp(i*pi) % i et j représentent (sauf si redéfinis) la même racine de -1
a=1;b=a+1;c='0*a'; % ";" permet de ne pas afficher le résultat:
a=a,b,2*c % la chaîne de 3 caractères "c" est une matrice 1x3
x=(1>=0);y=(0~=0);
x,y % vrai=1 et faux=0
pause
disp(' '), disp(' '), disp('Affichage :'), disp(' ')

format long,1/3 % format avec (au maximum) 15 chiffres
format short e,1/3 % format avec 5 chiffres en notation scientifique
format,1/3 % format courant (5 décimales, non compact)
format compact

1+eps==1,1+eps/2==1 % epsilon machine=eps=2^(-52)
2^(-1074) % plus petit nombre realmin flottant > 0
2^(1023)*(2-2^(-52)) % plus grand nombre realmax flottant
10^1000,ans/ans % infini:Inf, not_a_number : NaN
pause
disp(' '), disp(' '), disp('Matrices et vecteurs :'), disp(' ')

A=[1 2;2 3] % cette matrice s'écrit aussi [1,2;2,3]
A(2,2)=1;A
B=rand(2,3) % matrice 2x3 aléatoire
u=2:4 % ":" permet de construire des suites arithmétiques
2:0.5:4 % nombres de 2 à 4 par pas de 0.5
v=[2 3 4]' % vecteur = adjoint d'une matrice ligne

prod(1:20) % factorielle 20
p=poly([0,-2]) % coefficients en décroissant du polynôme p de racines 0 et -2
roots(p) % récupération des racines de p dans C
a0=p(length(p)) % coefficient "constant" de p
z=polyval(p,2); % évaluation de p(2)
fprintf('\np(2)=%g\n\n',z) % affichage du résultat avec saut de ligne par "\n"
pause
disp(' '), disp(' '), disp('Tests et boucles :'), disp(' ')

clear x;for k=1:5x(k)=k^2;end;x' % les vecteurs 1:n sont d'accès très rapide
k=0;while k^3<0;k=k+1;end;k % utiliser plutôt si possible "for"
n = input('nombre entier à tester ?\n'); % dialogue
if rem(n,2)==0,r='pair';else r='impair';end;
fprintf('\n%g est %s\n\n',n,r)
pause
disp(' '), disp(' '), disp('Graphes :'), disp(' ')

figure(1),clf % on prépare la fenêtre 1 (inutile si pas "hold on")
x=[-.5:0.001:0.5]'; % représentation de l'axe des abscisses par une suite de points
y=x.*sin(x);
plot(x,y,'r'), axis equal % graphe de x->x*sin(1/x) sur [-1/2,1/2] en rouge ("red")
title('y=x*sin(x)'), xlabel('x'), ylabel('y'), grid % légende et grille
v=axis;line([v(1),v(2)],[0,0]) % on trace l'axe des abscisses
pause
disp(' '), disp(' '), disp('Équations différentielles :'), disp(' ')

figure(2),clf % on prépare la fenêtre 2
[t1,Y1] =ode45('secondmembre_y',[0 1],[1]); % y'=y sur [0,1] avec y(0)=1
[t2,Y2] =ode45('secondmembre_y',[0 -1],[1]); % y'=y sur [-1,0] avec y(0)=1
plot([t2 t1],[Y2 Y1]); % on trace la solution de y'=y sur [-1,1] avec y(0)=1
title('solution de y''=y et y(0)=1')

clear all
% on efface de la mémoire les variables affectées
echo off

Le Script AIDE_TP2

% Le script aide_TP2 permet de se familiariser avec
% les commandes simples de Matlab concernant les matrices.
help aide_TP2,format short,format compact,echo on
pause
disp(' '), disp(' '), disp('Matrice adjointe, produit :'), disp(' ')

clear i,u=[0 i 2] % variante: "u=[0,i,2]"
u', u.' % matrice adjointe et transposée
3*u,u/2,u'*u,u*u'
pause
disp(' '), disp(' '), disp('Id, diagonale, zeros et uns :'), disp(' ')

A=[1 2;3 4] % variante: 1ère ligne avec "A=[1 2" et 2ème avec "3 4]"
eye(size(A)),eye(2,3) % la matrice identité "I" se lit, comme "eye" en anglais
diag(A),diag([1 4]) % extraction de diagonale et construction de matrice
% diagonale
zeros(2,3),ones(3,2)
pause
disp(' '), disp(' '), disp('Taille, norme, parties réelle et imaginaire :'), disp(' ')

u=[0 i 2],size(u,1),size(u,2),length(u) % "1"="ligne","2"="colonne"
norm(u,1),norm(u,2),norm(u,'inf'),norm(u)
A=[1 2;3 4],size(A),size(A,1),size(A,2)
norm(A,1),norm(A,2),norm(A,'inf'),norm(A,'fro')
z=1+2*i
norm(z), abs(z), real(z), imag(z), conj(z)
pause
disp(' '), disp(' '), disp('Déterminant, valeurs propres :'), disp(' ')

A=[1 2;3 4],det(A)
norm(A,2),sqrt(max(eig(A'*A)))
norm(A,2)==sqrt(max(eig(A'*A))) % il ne faut pas croire le résultat de ce test
p=poly([1,1]),C=compan(p) % une matrice de pol.car. proportionnel à p
eig(C), poly(C) % valeurs propres et polynôme caractéristique

disp(' '), disp(' '), disp('Matrice par blocs :'), disp(' ')
A=[1 2;3 4]
[A,[7 8]'],[A;[7 8]] % variantes: "[A[7 8]']" et "[A;7 8]"
pause
disp(' '), disp(' '), disp('Puissance :'), disp(' ')

A=[1 2;3 4]
inv(A), eye(size(A))/A % cf."help slash"
B=A^2
B^0.5,ans^2 % une racine carrée de B autre que A
pause
disp(' '), disp(' '), disp('Opérations terme à terme :'), disp(' ')

A=[1 2;3 4]
A+1
A.^2
sqrt(A) % matrice A.^0.5 des racines carrées des coefficients
exp(A) % par contre, l'exponentielle de la matrice A est "expm(A)"
A.*A
A./A
1./A % à ne pas confondre avec l'inverse de A
pause
disp(' '), disp(' '), disp('Extraction de sous-matrices :'), disp(' ')

A=[1 2;3 4]
A(1,2),A(1,1),A(1,[2,1]) % des coefficients de A
A(1,:),A(:),A(:,[2,1])
% ":" donne tous les éléments
A(1,end),A(:,end-1) % "end" donne le dernier élément
pause
disp(' '), disp(' '), disp('Matrices creuses :'), disp(' ')

S=sparse([1 2 3],[2 4 1],[1,2,3]) % indices i,indices j,puis valeurs
T=full(S), sparse(T)
U=T(1:2,2:4)
D1=diag(ones(2,1),-1),D2=diag(ones(2,1),1)

clear all
echo off

FAQ

Qu'est-ce que Matlab et comment peut-on l'utiliser ?

Matlab est un logiciel de calcul scientifique permettant d'effectuer diverses opérations mathématiques, du calcul matriciel à la résolution d'équations différentielles. Il peut être utilisé de deux manières principales : en mode interactif pour des commandes ponctuelles, agissant comme une calculatrice graphique avancée, ou en créant des scripts (.m-files) et des fonctions pour des programmes sauvegardables.

Comment effectuer des calculs matriciels de base dans Matlab ?

Dans Matlab, tout nombre est considéré comme une matrice. Vous pouvez créer une matrice en utilisant des crochets, en séparant les éléments d'une ligne par des espaces ou des virgules, et les colonnes par des points-virgules. Les opérations élément par élément sur les matrices (multiplication, division, puissance) nécessitent de précéder l'opérateur d'un point (par exemple, `A .* B`).

Quels sont les symboles importants dans Matlab et comment réinitialiser leur valeur par défaut ?

Des symboles importants incluent `pi` pour la constante π, `i` (ou `j`) pour le nombre imaginaire, et `eps` pour l'epsilon machine (précision maximale des calculs). Ces symboles peuvent être redéfinis par l'utilisateur. Pour revenir à leur valeur par défaut, vous pouvez utiliser la commande `clear nom_de_la_variable` (par exemple, `clear i`).