Présentation de Matlab - Département d`informatique et de

Présentation de Matlab - Département d`informatique et de
Présentation de Matlab
1. Introduction - Historique
2. Démarrage de MATLAB
3. Génération de graphique avec MATLAB
Systèmes d'équations linéaires
1.
2.
3.
4.
Matrices et Vecteurs dans MATLAB
Équations et systèmes linéaires dans MATLAB
Méthode directe (Méthode du pivot)
Méthodes itératives
4.1. Méthode de Jacobi
4.2. Méthode de Gauss-Seidel
Polynômes et interpolation polynomiale Résolution des équations non linéaires
1. Opérations sur les polynômes dans MATLAB
1.1. Multiplication des polynômes
1.2. Division des polynômes
2. Manipulation de fonctions polynomiales dans MATLAB
2.1. Évaluation d’un polynôme
2.2. Interpolation au sens des moindres carrés
3. Interpolation linéaire et non linéaire
4. Interpolation de Lagrange
5. Résolution d’équations et de Systèmes d’équations non Linéaire
5.1. Résolution d’équations non Linéaires
5.2. Résolution de Systèmes d’équations non Linéaires
Intégration numérique des fonctions
1. Introduction
2. Méthodes d’intégrations numériques
2.1. Méthode des trapèzes
2.2. Méthode de Simpson
3. Fonctions MATLAB utilisées pour l'intégration numérique
Résolution numérique des équations différentielles et des équations aux dérivées partielles
1.
2.
3.
4.
Introduction
Équations différentielles du premier ordre
Équations différentielles du second ordre
Méthode de Runge-Kutta
4.1. Méthode de Runge-Kutta du second ordre
4.2. Méthode de Runge-Kutta à l'ordre 4
5. Méthode Matricielle avec des "Conditions aux Limites"
6. Conversion de coordonnées
6.1. Coordonnées polaires
6.2. Coordonnées cylindriques
6.3. Coordonnées sphériques
7. Problèmes en Coordonnées Cylindriques
8. Discrétisation de l'équation de la Conduction en régime instationnaire
Présentation de Matlab
1. Introduction - Historique
MATLAB est une abréviation de Matrix LABoratory. Écrit à l’origine, en Fortran, par C. Moler,
MATLAB était destiné à faciliter l’accès au logiciel matriciel développé dans les projets
LINPACK et EISPACK. La version actuelle, écrite en C par the MathWorks Inc., existe en
version professionnelle et en version étudiant. Sa disponibilité est assurée sur plusieurs platesformes : Sun, Bull, HP, IBM, compatibles PC (DOS, Unix ou Windows), Macintoch, iMac et
plusieurs machines parallèles.
MATLAB est un environnement puissant, complet et facile à utiliser destiné au calcul
scientifique. Il apporte aux ingénieurs, chercheurs et à tout scientifique un système interactif
intégrant calcul numérique et visualisation. C'est un environnement performant, ouvert et
programmable qui permet de remarquables gains de productivité et de créativité.
MATLAB est un environnement complet, ouvert et extensible pour le calcul et la visualisation. Il
dispose de plusieurs centaines (voire milliers, selon les versions et les modules optionnels autour
du noyeau Matlab) de fonctions mathématiques, scientifiques et techniques. L'approche
matricielle de MATLAB permet de traiter les données sans aucune limitation de taille et de
réaliser des calculs numériques et symboliques de façon fiable et rapide. Grâce aux fonctions
graphiques de MATLAB, il devient très facile de modifier interactivement les différents
paramètres des graphiques pour les adapter selon nos souhaits.
L'approche ouverte de MATLAB permet de construire un outil sur mesure. On peut inspecter le
code source et les algorithmes des bibliothèques de fonctions (Toolboxes), modifier des
fonctions existantes et ajouter d’autres.
MATLAB possède son propre langage, intuitif et naturel qui permet des gains de temps de CPU
spectaculaires par rapport à des langages comme le C, le TurboPascal et le Fortran. Avec
MATLAB, on peut faire des liaisons de façon dynamique, à des programmes C ou Fortran,
échanger des données avec d'autres applications (via la DDE : MATLAB serveur ou client) ou
utiliser MATLAB comme moteur d'analyse et de visualisation.
MATLAB comprend aussi un ensemble d'outils spécifiques à des domaines, appelés Toolboxes
(ou Boîtes à Outils). Indispensables à la plupart des utilisateurs, les Boîtes à Outils sont des
collections de fonctions qui étendent l'environnement MATLAB pour résoudre des catégories
spécifiques de problèmes. Les domaines couverts sont très variés et comprennent notamment le
traitement du signal, l'automatique, l'identification de systèmes, les réseaux de neurones, la
logique floue, le calcul de structure, les statistiques, etc.
MATLAB fait également partie d'un ensemble d'outils intégrés dédiés au Traitement du Signal.
En complément du noyau de calcul MATLAB, l'environnement comprend des modules
optionnels qui sont parfaitement intégrés à l'ensemble :
1) une vaste gamme de bibliothèques de fonctions spécialisées (Toolboxes)
2) Simulink, un environnement puissant de modélisation basée sur les schémas-blocs et de
simulation de systèmes dynamiques linéaires et non linéaires
3) Des bibliothèques de blocs Simulink spécialisés (Blocksets)
4) D'autres modules dont un Compilateur, un générateur de code C, un accélérateur,...
5) Un ensemble d'outils intégrés dédiés au Traitement du Signal : le DSP Workshop.
Quelles sont les particularités de MATLAB ?
MATLAB permet le travail interactif soit en mode commande, soit en mode programmation ;
tout en ayant toujours la possibilité de faire des visualisations graphiques. Considéré comme un
des meilleurs langages de programmations (C ou Fortran), MATLAB possède les particularités
suivantes par rapport à ces langages :
•
•
•
•
•
•
la programmation facile,
la continuité parmi les valeurs entières, réelles et complexes,
la gamme étendue des nombres et leurs précisions,
la bibliothèque mathématique très compréhensive,
l’outil graphique qui inclus les fonctions d’interface graphique et les utilitaires,
la possibilité de liaison avec les autres langages classiques de programmations (C ou
Fortran).
Dans MATLAB, aucune déclaration n’est à effectuer sur les nombres. En effet, il n'existe pas de
distinction entre les nombres entiers, les nombres réels, les nombres complexes et la simple ou
double précision. Cette caractéristique rend le mode de programmation très facile et très rapide.
En Fortran par exemple, une subroutine est presque nécessaire pour chaque variable simple ou
double précision, entière, réelle ou complexe. Dans MATLAB, aucune nécessité n’est demandée
pour la séparation de ces variables.
La bibliothèque des fonctions mathématiques dans MATLAB donne des analyses mathématiques
très simples. En effet, l’utilisateur peut exécuter dans le mode commande n’importe quelle
fonction mathématique se trouvant dans la bibliothèque sans avoir à recourir à la programmation.
Pour l’interface graphique, des représentations scientifiques et même artistiques des objets
peuvent être créées sur l’écran en utilisant les expressions mathématiques. Les graphiques sur
MATLAB sont simples et attirent l’attention des utilisateurs, vu les possibilités importantes
offertes par ce logiciel.
MATLAB peut-il s’en passer de la nécessité de Fortran ou du C ?
La réponse est non. En effet, le Fortran ou le C sont des langages importants pour les calculs de
haute performance qui nécessitent une grande mémoire et un temps de calcul très long. Sans
compilateur, les calculs sur MATLAB sont relativement lents par rapport au Fortran ou au C si
les programmes comportent des boucles. Il est donc conseillé d'éviter les boucles, surtout si
celles-ci est grande.
2. Démarrage de MATLAB
Pour lancer l’exécution de MATLAB :
•
•
sous Windows, il faut cliquer sur Démarrage, ensuite Programme, ensuite MATLAB,
sous d’autres systèmes, se référer au manuel d’installation.
L’invite ‘>>’ de MATLAB doit alors apparaître, à la suite duquel on entrera les commandes.
La fonction "quit" permet de quitter MATLAB :
>>quit
La commande "help" permet de donner l’aide sur un problème donné.
Exemple :
>> help cos
COS Cosine.
COS(X) is the cosine of the elements of X.
Autres commandes :
•
•
•
what : liste les fichiers *.m et *.mat dans le directory utilisé
who : liste les variables utilisées dans l’espace courant
ans : réponse retournée après exécution d’une commande
Exemple :
>>x=[1:5,1]
x=
123451
ou bien :
>>[1:5,1]
ans =
123451
clock : affiche l’année, le mois, le jour, l’heure, les minutes et les secondes.
>>clock
ans =
1.0e+003 *
1.9980 0.0100 0.0180 0.0170 0.0020 0.0098
>>date
ans =
18-Oct-1998
Calcul en mode Commande dans MATLAB :
Soit à calculer le volume suivant :
où R=4cm
Pour calculer V, on exécute les commandes suivantes :
>>R=4
R=
4
>>V=4/3*pi*R^3
V=
268.0826
(Ici, pi=π).
Calcul arithmétique :
+
plus
-
moins
/
division
*
multiplication
Exemple :
x=2,
>>x=2
x=
2
>>P=(4*x^2-2*x+3)/(x^3+1)
P=
1.6667
Test ‘if’
Ce test s'emploie, souvent, dans la plupart des programmes. Un test ‘if’ est toujours
suivi par un ‘end’.
Exemple :
>>V=268.0826
V=
268.0826
>>if V>150, surface=pi*R^2, end
surface =
50.2655
L’opérateur ‘NON’
Il est noté (ou symbolisé) par ‘~=’
Exemple :
>>R=4
R=
4
>>if R~=2, V=4/3*pi*R^3;end
L’opérateur ‘égal’ (==) dans ‘if’
Il est noté (ou symbolisé) par ‘==’.
Exemple :
>>R=4
R=
4
>>if R==4, V=4/3*pi*R^3;end
L’opérateur ‘ou’
Il est noté (ou symbolisé) par ‘|’
Exemple : Si R=4 ou m=1, alors
>>if R==4 | m==1, V=4/3*pi*R^3;end
Autres opérateurs :
>
supérieur à
<
inférieur à
>=
supérieur ou égal
<=
inférieur ou égal
>
supérieur à
.*
produit élément par élément de matrices
<
inférieur à
.^
puissance élément par élément de matrices
>=
supérieur ou égal
./
division élément par élément de matrices
<=
inférieur ou égal
xor
Error
affiche le message : 'error'
OU exclusif (XOR)
message spécifié, émet un 'bip' et interrompt l'exécution du
programme
Exemples :
Si g>2 ou g<0, alors a=4
>> if g>2 |g<0, a=4, end
Si a>3 et C<0, alors b=15
>>if a>3 & c<0, b=15, end
Les opérateurs ‘&’ et ‘|’ peuvent être utilisés dans la même chaîne :
>>if ((a==2 | b==3)&(c<5),g=1,end
L’opérateur ‘if…….else…….elseif…….end’:
Exemples :
>>R=2, if R>3, b=1 ; elseif R==3, b=2, else b=0, end
L’instruction ‘elseif’ peut être répétée dans un programme autant de fois.
Variables et noms de variables :
Les variables et les noms de variables n’ont pas à être déclarés, car dans MATLAB, il n’y a
aucune distinction entre variable ‘entière’, variable ‘réelle’ ou variable ‘complexe’.
Variables complexes :
Traditionnellement, en Fortran les variables i, j, k, l, m et n sont réservées aux variables entières.
ou
). Mais, on
Dans MATLAB, i et j sont réservées aux unités imaginaires (
peut également les utiliser commes d'autres variales (entières ou réelles) si on les précise.
Dans le tableau ci-dessous, on dresse les noms de variables et les nombres spéciaux utilisés par
MATLAB :
Nom de la variable
Signification
Valeur
eps
précision relative des nombres réels (distance entre 1.0 et
le nombre réel flottant le plus proche)
2.2204.10-16
pi
π
3.14159………..
i et j
unités imaginaires
inf
nombre infini (1/0=inf)
NAN
ce n’est pas un nombre : 0/0=NAN
date
date
nargin
nombre d’arguments d'appel transmis à une fonction
flops
compteur opérations en virgule flottante
nargout
nombre d’arguments de retour demandés à une fonction
Opérateurs ‘for/end’ et ‘while/end’
Exemples :
>>for R=1 :5, V=4/3*pi*R^3; disp([R,V]), end
Dans ce cas, R varie de 1 à 5, et la commande "disp([R,V])" retourne la matrice suivante :
[R=1 :5,V (V(1) :V(5)]
On peut définir également l’instruction ‘length’ qui représente la taille de la variable. En effet,
dans ce cas, on a :
length(R)=5 ; (R=1 :5) et length(R)-1=4 (4 intervalles de pas 1).
>>while R<5, R=R+1 ; V=4/3*pi*R^3; disp([R,V]), end
while exécute l’instruction qui suit tant que le test logique est vrai.
Exemple de pas dans la boucle for :
>>for R=5 :-1 :1, V=4/3*pi*R^3; disp([R,V]), end
Ici, le pas utilisé est dégressif (=-1). On peut utiliser les imbrications de ‘for’ autant de fois que
l’on souhaite.
Exemple :
>> for i=0 :10, for j=1 :5, V=4/3*pi*R^3;disp([R,V]);end,end
* format :
>>format affiche les résultats avec 4 chiffres après la virgule.
>>format long affiche les résultats avec 16 chiffres après la vrgule.
* break :
Interrope l’exécution d’un ‘for’ ou d’un ‘while’
* goto :
Dans MATLAB l’instruction ‘goto’ est remplacée par ‘break’.
Exemple :
while R==1
.
.
.
if x>Xlimite, break, end
.
.
.
.
end
* clear :
Efface toutes les variables existantes en mémoire
* clc :
Efface l’écran (fenêtre) de MATLAB
* input(' ') :
Introduire une ou des variables par l’intermédiaire du clavier.
Exemple :
>>z=input(‘Longueur L=’);
retourne :
Longueur L=
>>y=input(‘Introduire votre nom’,’s’);
Le second argument indique que la variable à introduire peut être un (ou des) caractère(s).
* fprintf(' ')
format de sortie sur écran
Exemples :
1. fprintf(‘La longueur L=%f\n’,L)
Dans cette chaîne, on a :
%
f
\n
L
pour la sortie de la variable,
format de sortie
retour à la ligne
variable.
2. fprintf(‘La longueur L= %e%f\n’,L)
le résultat affiché est avec des puissances de 10 (exemple : 2.5e04)
3. fprintf(‘Nom_fichier’,’Volume= %e%12.5f\n’,V)
écrit la valeur = variable V dans un fichier Nom_fichier.
la variable V est avec 5 chiffres après la virgule.
Pour l’ouverture et la fermeture des fichiers, on peut utiliser également ‘fopen’ et ‘fclose’. Ainsi,
on peut joindre à l’ouverture de fichier par exemple, la permission d’ouvrir uniquement, de lire
uniquement, de lire et écrire, etc.
Exemple :
>>fich=fopen(‘Nom_fichier’,’ ?’)
?
représente la permission :
‘w’
écriture : créer si nécessaire,
‘r’
lecture uniquement (pas de création),
‘+r’
lecture et écriture.
Ecriture d’un fichier ou de variables dans un fichier :
Ouvrir tout d’abord le fichier :
>>fich=fopen(‘Nom_fichier’,’ r’) ; y=fscanf(fich,’%f’)
La variable y est maintenant égale à la (ou les) variable(s) de fich.
Produit factoriel :
La fonction ‘gamma’ donne le produit factoriel d’un nombre n.
Exemple : pour n=6, on a : 6!=6*5*4*3*2*1=720
>>factorielle=gamma(6+1)
factorielle =
720
La fonction ‘gamma’ peut calculer la factorielle des nombres entiers et même des nombres réels.
Utilisation de nombres ou de variables complexes :
MATLAB, peut utiliser et gérer les variables ou les nombres complexes. La plupart des fonctions
implicites définies pour les réels existent pour les complexes, y compris la puissance.
Exemple :
>>z=3.5-1.25i ;
>>log(z)
ans =
1.3128 - 0.3430i
>>cos(2-i)
ans =
-0.6421 + 1.0686i
L’imaginaire pur est noté par i ou j. Ainsi, i2 ou j2 donne :
>>i^2
ans =
-1.0000 + 0.0000i
Soit z un nombre complexe. Son conjugué est donné par la fonction ‘conj(z)’.
>>z=3.5-1.25i
z=
3.5000 - 1.2500i
>>conj(z)
ans =
3.5000 + 1.2500i
Opérations sur les nombres complexes :
1. Addition de nombres complexes :
>>z1
z1 =
3.5000 - 1.2500i
>>z2
z2 =
1.3140 - 0.0948i
>>z1+z2
ans =
4.8140 - 1.3448i
2. Soustraction de nombres complexes :
>>z1-z2
ans =
2.186 - 1.1552i
3. Multiplication de nombres complexes :
>>z1*z2
ans =
4.4805 - 1.9743i
4. Division de nombres complexes :
>>z1/z2
ans =
2.7181 - 0.7551i
5. Opération de puissance :
>>z1^z2
ans =
4.5587 - 2.9557i
5. Module et argument d’un nombre complexe :
Dans MATLAB, les fonctions ‘abs’ et ‘angle’ permettent l’obtention directe du module et de
l’argument d’un nombre complexe.
Exemple :
>>r=abs(z1)
r=
3.7165
>>theta=angle(z1)
theta =
-0.3430
L’angle theta est en radians.
Il est possible d’utiliser la notation exponentielle.
Exemple :
>>Z=exp(z1)
Z=
10.4420 -31.4261i
Comme on peut définir des tableaux ou des matrices de réels, il est aussi possible de définir des
tableaux ou de matrices complexes avec MATLAB.
Exemples :
>>Z=[1+2i 0 z1;1 z2 z1+z2;z1*z2 z1-z2 z1/z2]
Z=
1.0000 + 2.0000i 0 3.5000 - 1.2500i
1.0000 1.3140 - 0.0948i 4.8140 - 1.3448i
4.4805 - 1.9744i 2.1860 - 1.1552i 2.7181 - 0.7551i
On peut également faire des opérations arithmétiques sur les matrices :
>>A=Z^(-1)
A=
0.2279 - 0.1872i -0.2475 + 0.1665i 0.1564 - 0.0282i
-0.6237 + 0.3429i 0.4146 - 0.4741i 0.0537 + 0.3314i
0.1251 - 0.0321i 0.1174 + 0.1358i -0.0282 - 0.0914i
>>A*Z
ans =
1.0000 + 0.0000i -0.0000 + 0.0000i -0.0000 + 0.0000i
0.0000 1.0000 - 0.0000i 0.0000 - 0.0000i
-0.0000 - 0.0000i 0.0000 - 0.0000i 1.0000 + 0.0000i
>>A/Z
ans =
0.1328 - 0.2826i -0.0267 + 0.2886i -0.0451 - 0.1223i
-0.1566 + 0.6725i 0.0057 - 0.5356i 0.1202 + 0.1689i
-0.1037 - 0.0857i 0.0965 + 0.0148i -0.0276 + 0.0428i
Déclarations et affectations des variables :
fprintf(‘caractère : %c\n’,c) ;
c=’#’
fprintf(‘entier: %d\n’,i) ;
i=1, 2, 3, … , n
fprintf(‘flottant: %f\n’,f) ;
fprintf(‘flottant: %s\n’,s) ;
Il existe également d’autres types
d’affectations. Ces dernières sont analogues
à celles du langage ‘C’.
Arrangement de variables :
des entiers
par exemple (si
)
s : la valur peut être la plus petite que
posssible.
Exemple : s=1.35e-17.
Une matrice d’ordre 0 est un scalaire. Une matrice d’ordre 1 est un vecteur. Ce vecteur peut être
un vecteur ligne ou un vecteur colonne.
Exemples :
>>x=[0,1,2,3]
x =0 1 2 3
retourne un vecteur ligne :
ou encore :
>>x=[0 1 2 3]
retourne aussi un vecteur ligne.
x(2)=1 par exemple.
>>x=[0 ;1 ;2 ;3]
x=
0
1
2
3
retourne un vecteur colonne.
>>x=[0 ;1 ;2 ;3]’
retourne un vecteur ligne.
>>x=[0 1 2 3]’
retourne un vecteur colonne. x(1)=0, x(2)=1, x(4)=3.
Remarque :
Dans MATLAB, les numéros de lignes ou de colonnes commencent toujours par 1 et non par
zéro comme c’est le cas dans les autres langages de programmation. Exemple : x(0) n’existe pas.
Matrice d’ordre supérieur à 1 :
Une matrice d’ordre supérieur à 1 est une matrices à deux dimensions. Exemple : x(i,j).
Exemples :
>>x=[0 :2 ;4 :6]
x=
012
456
retourne :
C’est une matrice à 2 lignes et 3 colonnes.
>>y=[0 :2 ;4 :6]’
y=
04
retourne la matrice transposée :
15
26
La taille de la matrice y est donnée par la fonction ‘size(y)’ :
>>size(y)
ans =
32
La réponse est : 3 lignes et 2 colonnes.
La colonne j de la matrice x est donnée par : y(:,j)
y(:,2)=
4
5
6
La ligne i de la matrice x est donnée par : y(i,:)
y(2,:)=
5
pour j=2, on a :
pour i=2, on a :
Pour une matrice carrée A d’ordre n, on a sa matrice identité qui est donnée par la fonction ‘eye’.
Exemple : pour n=3, on a :
>>A
A=
123
456
678
>>eye(size(A))
ans =
100
010
001
eye(size(A)) donne la matrice identité de même ordre que celle de A.
Aspect des nombres dans MATLAB :
Dans MATLAB, il n’existe aucune distinction entre les nombres entiers, les nombres réels ou le
nombres complexes. Les nombres sont donc traités automatiquement. La précision des calculs
est affectée par le nombre de variables enregistrées et traitées.
Les paramètres essentiels qui déterminent cette précision dans un langage de programmation
sont :
•
•
le plus petit nombre positif : x_min
le plus grand nombre positif : x_max
•
l’erreur de la machine (epsilon) : eps
Le tableau ci-dessous donne une comparaison des différents paramètres obtenus par le langage
Fortran et MATLAB :
Précision du langage
MATLAB
Fortran sur station
(sur station)
Simple (double)
Fortran (Cray)
x_min
4.5e-324
2.9e-39 (même)
4.6e-2476
x_max
9.9e+307
1.7e+38 (même)
5.4e+2465
eps
2.2ee-16
1.2e-7 (2.8e-17)
1.3e-29
Dans MATLAB, l’infini est représenté par ‘inf’ (= ). Si on exécute la commande x=1/inf, la
réponse sera ‘NAN’ c’est à dire : ‘Not A Number’.
Pour chercher x_min, x_max et eps, on peut utiliser les programmes suivants :
Cherche de x_min :
% Recherche de de x_min
x=1 ; while x>0, x=x/2, end
Cherche de x_max :
% Recherche de de x_max
x=1 ; while x<inf, x= x*2, end
Cherche de eps :
% Recherche de de eps
x=1 ; while x>0, x=x/2 ; ex=0.98*x+1,ex=ex-1, if ex>0,ex ;end,end
Fonctions Mathématiques dans MATLAB :
Fonctions trigonométriques
sin(x)
cos(x)
tan(x)
asin(x)
acos(x)
atan(x)
Remarques
atan2(x,y)
:
sinh(x)
cosh(x)
tanh(x)
asinh(x)
acosh(x)
atanh(x)
Autres fonctions mathématiques (élémentaires)
Remarques
abs(x)
Valeur absolue de x
angle(x)
Valeur complexe de l’angle de phase :
Si x=réel angle=0
Si
angle=π/2
sqrt(x)
Racine carrée de x
real(x)
Partie réelle de la valeur complexe de x
imag(x)
Partie imaginaire de la valeur complexe de x
conj(x)
Complexe conjugué de x
round(x)
Arrondi entier de x
fix(x)
Arrondi par défaut du réel x
floor(x)
Arrondi au voisinage de
du réel x
ceil(x)
Arrondi au voisinage de
du réel x
sign(x)
=+1 six>0 ; =-1 si x<0
rem(x,y)
Le reste de la division : = x-y*fix(x/y)
exp(x)
Exponentielle (de base e)
log(x)
Log (de base e)
log10(x)
log (de base 10)
Autres fonctions :
Soit x=[2 15 0] une matrice ligne (vecteur ligne)
sort(x)
donne une matrice ligne dont les éléments sont en ordre croissant :
>>sort(x)
ans =
0 2 15
sort(x’)
donne une matrice colonne dont les éléments sont en ordre croissant :
>>sort(x’)
ans =
0
2
15
sum(x) calcule la somme des éléments de la matrice x.
>>sum(x)
ans =
17
>>sum([4 2 1 0;8 9 3 12])
ans =
12 11 4 12
Pour trouver le maximum et le minimum du vecteur x, on utilise les fonctions max(x) et min(x) :
>>max(x)
ans =
15
>>min(x)
ans =
0
pour une matrice y quelconque, le max(y) et min(y) donnent :
>>y
y=
4210
8 9 3 12
>>max(y)
ans =
8 9 3 12
>>min(y)
ans =
4210
Pour trouver la valeur moyenne d’un vecteur de la matrice x par exemple, on utilise la fonction
‘mean(x,i)’où i est le numéro de la colonne :
Exemple : si
Alors mean(x,1) est :
>>mean(x,1)
ans =
1.5000 2.5000 3.5000
et mean(x,2) est :
>>mean(x,2)
ans =
14
* Nombres aléatoires :
Les nombres aléatoires peuvent être générés par la fonction ‘rand’. Son expression est ‘rand(n)’
où n est le rang de la matrice.
Si n=3 par exemple, rand(3) va générer 3 lignes et 3 colonnes de la matrice dont les coefficients
sont aléatoires et compris entre 0 et 1.
Exemple :
>> rand(3)
ans =
0.4154 0.0150 0.9901
0.3050 0.7680 0.7889
0.8744 0.9708 0.4387
On peut donner à la variable z une initialisation dans un programme. Pour cela, on peut générer
des valeurs aléatoires grâce à la fonction ‘seed’ (c’est à dire ensemencer)
rand(‘seed’,z)
* Écriture de fonctions personnelles :
Dans MATLAB, les programmes qui sont sauvegardés comme des fichiers_.m sont équivalentes
à des sous-programmes et des fonctions dans d’autres langages.
Fonction retournant une seule variable :
Exemple :
Supposons que le programme MATLAB correspondant est sauvegardé sous le nom demof_.m.
ce programme est le suivant :
function y=demof_(x)
y=(2*x.^3+7*x.^2+3*x-1)/(x.^2-3*x+5*exp(-x)) ;
Pour déterminer f(x=3) par exemple, il suffit d’exécuter la commande : "y=demof_(3),et la
réponse sera :
>>y=
502.1384
* Fonction retournant plusieurs variables :
Une fonction peut retourner plus qu’une variable. Considérons la fonction qui permet d’évaluer
la moyenne et l’écart type de données.
Pour retourner les 2 variables, un vecteur est utilisé du côté gauche de la fonction, comme
l’illustre le cas suivant :
function [mean, stdv]=mean_st(x)
n=length (x) ;
mean=sum(x)/n ;
stdv=sqrt(sum(x.^2)/n-mean.^2) ;
Exemple :
>>x=[1 5 3 4 6 5 8 9 2 4];
>>[m,s]=mean_st(x)
La réponse est : m=4.7000 et s=2.3685
* Fonction pouvant utiliser une autre :
Exemple :
Le sous programme de la fonction fav est donné ci-dessous :
function wa=f_av(f_nom,a,b,c)
wa=(feval(f_nom,a)+2*feval(f_nom,b)+feval(f_nom,c))/4 ;
où f_nom est le nom de la fonction f(x).
la fonction ‘feval’ est une commande de MATLAB qui évalue la fonction de nom f_nom et
d’argument x . Exemple : y=feval(‘sin’,x) est équivalente à y=sin(x).
* Écriture d’un programme MATLAB :
En MATLAB, les programmes se terminent par une extension ‘.m’ dans le nom du fichier
programme. Aucune compilation n’est à faire avant l’exécution du programme. Au cours de
l’exécution, un message d’erreur apparaît et indique les lieux où se trouvent les erreurs.
Pour lancer l’exécution du programme, il faut se mettre toujours dans le même répertoire où se
trouve ce programme.
Exemple : ce dernier se trouve dans c:\utilisateur ; il faut changer tout d’abord de répertoire après
avoir lancé MATLAB en tapant :
"cd c:\utilisateur"
Les fichiers de données sont enregistrés avec une extension ‘.mat’ et les variables sont
enregistrées en double précision.
3. Génération de graphique avec MATLAB
MATLAB est un outil très puissant et très convivial pour la gestion des graphiques, que ce soit
en une dimension, en deux dimensions ou en trois dimensions. Pour tracer une courbe y=sin(x)
par exemple, où x=0 :50 ; il suffit de faire :
>>x=0:50;y=sin(x);plot(x,y)
Ci-dessous, un petit résumé très succinct est donné pour tracer, concernant le traçage des
graphiques et la manipulation des axes et des échelles :
•
•
•
xlabel(‘temps’) pour donner un titre à l’axe x,
ylabel(‘vitesse’) pour donner un titre à l’axe y,
title(‘évolution de la vitesse’) pour donner un titre au graphique,
•
text(2,4,’+++Température T1’) au point
, écrire la légende de la courbe tracée
avec "+++",
loglog(x,y) tracer la courbe en échelle logarithmique (log-log),
semilogx(t,f(t)) tracer la courbe seulement en échelle logarithmique suivant x,
semilogy(t,f(t)) tracer la courbe seulement en échelle logarithmique suivant y,
grid on afficher le quadrillage dans le graphique,
grid off masquer le quadrillage dans le graphique,
clf effacer le graphique,
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
close figure(i) fermer (ou quitter) la figure (i),
close all
fermer tous les graphiques ouverts,
plot(x,y,x,z,x,w) tracer y, z et w en fonction de x sur le même graphe,
polar(x,y) tracer la courbe y en fonction de x en coordonnées polaires,
plot(x,y,’+g’) tracer y en fonction de x avec des marques ‘+’ en couleur verte,
fplot(‘f_nom’,[x-mini, x-maxi]) tracer la fonction f_nom selon les axes données (x),
axis(‘square’) tracer un graphe géométriquement carré,
axis(‘off’) masque les axes x et y,
axis(‘on’) affiche les axes x et y,
axis([x-mini, x-maxi, y-mini,y-maxi]) affiche le graphique selon les limites
données des axes x et y,
hold(‘on’) traçage des courbes sur le même graphique à chaque fois qu’on exécute la
fonction plot,
hold(‘off’) traçage de chaque courbe sur un nouveau graphique à chaque fois qu’on
exécute la fonction plot,
plot3(x,y,z) tracer z en fonction de x et de y en 3D,
la fonction ‘meshgrid’ est utilisée pour créer un maillage 2D (x,y) ; si on se donne
xa=[… : …] et ya=[… : …], ceci est très important sont des valeurs complexes
[x,y]=meshgrid(xa,ya),
•
mesh(xa,ya,z)
•
quiver(x,y,u,v,s) tracer le champ vectoriel
dans le plan (x,y) où ‘s’ est la taille
de base à donner aux vecteurs,
contour(x,y,z,’niveau’) tracer les lignes iso-valeurs de z dans le plan (x,y) où le niveau
représente le nombre de lignes iso-courbes.
•
tracer le graphique en 3D de z,
Exemple :x=0 :50 ; y=sin(x) ; z=cos(y) +4*x ; contour(x,y,z,40)
courbes.
•
text(2,0,’a-b’,’FontName’,’symbol’)
on obtient 40 iso-
écrire sur le graphique au point
α-β, (a-b en police symbol),
•
subpot(m,n,k) tracer mxn graphiques séparés dans la feuille, où k est le numéro de
chaque graphiques. Exemple :
x=0 :25 ;y=x ;
subplot(2,2,1),plot(x,y) ;ylabel(‘y’) ;title(‘(2,2,1)’) ;
subplot(2,2,2),plot(x,2*y) ;ylabel(‘y’) ;title(‘(2,2,2)’) ;
subplot(2,2,3),plot(x,3*y) ; ;xlabel(‘x’) ;ylabel(‘y’) ;title(‘(2,2,3)’) ;
subplot(2,2,4),plot(x,4*y) ; ;xlabel(‘x’) ;ylabel(‘y’) ;title(‘(2,2,4)’) ;
Systèmes d'équations linéaires
1. Matrices et Vecteurs dans MATLAB
En mathématique, une matrice est constituée de n lignes et de m colonnes. Les coefficients de la
matrice sont situés entre 2 parenthèses. Dans MATLAB, les parenthèses n’y figurent pas.
Une matrice carrée est une matrice dont le nombre de lignes est égal au nombre de colonnes
(n=m). Une matrice ligne est une matrice d’ordre 1 appelée vecteur ligne. Une matrice colonne
est une matrice d’ordre 1 appelée vecteur colonne. Une matrice d’ordre 0 est un scalaire.
Dans le cas général, une matrice de n lignes et de m colonnes a pour coefficients
et
, où
. Si cette matrice est appelée A, ses coefficients sont les suivant :
Si B est autre matrice à p lignes et q colonnes, alors le produit de C=A*B n’est possible que si
m=p. Dans ce cas, le coefficient c11, par exemple de cette matrice C s’écrit :
(avec m=p).
Dans Matlab, la matrice produit C (= A*B) a pour coefficients cij. Ces coefficients sont calculés
en fonction de aij et de bij :
Une matrice d’ordre zéro est une matrice à une ligne et une colonne : elle représente un scalaire.
Une matrice nulle est une matrice dont les coefficients sont tous nuls. En attribuant le nom ‘A’ à
cette matrice, alors dans Matlab A s’écrit :
>>A=zeros(n,m)
où n et m sont respectivement le nombre de lignes et le nombre de colonnes.
La matrice identité est définie dans Matlab par la fonction : ‘eye’
Exemple :
C’est une matrice carrée d’ordre 5. Dans Matlab, on peut l’écrire :
>>B=eye(5)
B=
10000
01000
00100
00010
00001
Si Bt est la matrice transposée de B, cette dernière s’écrit dans Matlab :
>>C=B'
(l’appostrophe représente la transposée)
C=
10000
01000
00100
00010
00001
Le déterminant d’une matrice carrée (C par exemple) est donné par :
>>det(C)
ans =
1
Soit A une matrice non nulle. La matrice inverse A-1 de A (si elle existe) est telle que :
A*A-1=IId
Dans Matlab, cette matrice inverse est donnée par :
A-1=A^(-1)=inv(A)=pinv(A)
Exemple :
>>A=[1 3 5;2 -1 0;5 4 3]
A=
135
2 -1 0
543
La matrice inverse de A est :
>>inv(A)
ans =
-0.0682 0.2500 0.1136
-0.1364 -0.5000 0.2273
0.2955 0.2500 -0.1591
ou encore :
>>pinv(A)
ans =
-0.0682 0.2500 0.1136
-0.1364 -0.5000 0.2273
0.2955 0.2500 -0.1591
2. Equations et systèmes linéaires dans MATLAB
Considérons le systèmes suivants de n équations à m inconnues :
Dans ce système, on a
•
•
Si n>m
Si n=m
connue,
connues et
inconnues.
système sur-déterminé,
système de Cramer une solution unique (si det(A)
),
•
Si n<m
système sous-déterminé
La solution numérique du système (pour n=m) donne les inconnues xi :
x=A/y
Pour un vecteur colonne y donné (
>>x=A^(-1)*y
x=
-0.5227
-1.0455
1.9318
par exemple), la solution par Matlab est :
Notation :
Soit la matrice :
Dans Matlab, la Matrice A peut être écrite sous les deux formes :
>>A=[1,3,5;2,-1,0;5,4,3];
ou bien :
>>A=[1 3 5;2 -1 0;5 4 3];
La séparation des lignes se fait par un point virgule et la séparation des colonnes se fait par un
espace ou une virgule.
Exemple :
>>A=[1 3 5;2 -1 0;5 4 3]
A=
135
2 -1 0
543
Problèmes mal conditionnés :
Il existe un certain nombre d’équations linéaires solvables, mais leurs solutions sont incertaines à
cause des erreurs d’arrondi lors des calculs. Les problèmes de ce type sont appelés ‘problèmes
mal conditionnés’. L’arrondi durant les calculs ou les petits changements dans les coefficients
calculés peuvent induire des erreurs significatives dans la résolution d’un problème (mal
conditionné).
Cet effet d’arrondi, peut être illustré par le système des 2 équations suivantes, par exemple :
La solution de ce système est :
Pour monter l’erreur introduite sur les solutions en modifiant les coefficients (arrondi), on donne
au coefficient ‘2,01045’ de la première équation une légère augmentation de ‘0,001’.
Dans ce cas, le système devient :
Ceci met en évidence l'erreur engendrée par un arrondi.
La matrice C correspondant au système précédent est :
La norme de C s’écrit :
Dans Matlab on définit le nombre-condition de la matrice C [notation cond(C)] par :
Ce nombre satisfait toujours la condition :
Pour les matrices inconditionnées, ce nombre-condition attiend des grandes valeurs, mais ne
donne pas une estimation directe de l’erreur sur la solution.
Dans Matlab, ce nombre se calcule par la fonction ‘cond(C)’ où C est la matrice.
Exemple1 :
>>C
C=
0.1206 0.9878 0.9876
>>cond(C)
ans =
6.5598e+003
Exemple2 :
L'exemple de la matrice d’Hilbert représente un problème à matrice mal conditionnée. Cette
matrice est définie par :
, où
Programmer le nombre-condition (cond(A)) ainsi que det(A).det(A-1) pour une matrice d’Hilbert
de 5 par 5 à 14 par 14 :
Solution :
clear;
for n=5:14
for i=1:n
for j=1:n
a(i,j)=1/(i+j-1);
end
end
C=cond(a);
d=det(a)*det(a^(-1));
fprintf('n=%3.0f\t cond(a)=%e\t det*det=%e\n',n,C,d);
end
Après exécution du programme, on obtient les résultats suivants :
n= 5 cond(a)=4.766073e+005 det*det=1.000000e+000
n= 6 cond(a)=1.495106e+007 det*det=1.000000e+000
n= 7 cond(a)=4.753674e+008 det*det=1.000000e+000
n= 8 cond(a)=1.525758e+010 det*det=9.999999e-001
n= 9 cond(a)=4.931532e+011 det*det=1.000001e+000
n= 10 cond(a)=1.602534e+013 det*det=9.999812e-001
n= 11 cond(a)=5.218389e+014 det*det=1.000119e+000
n= 12 cond(a)=1.768065e+016 det*det=1.015201e+000
n= 13 cond(a)=3.682278e+018 det*det=9.707419e-001
n= 14 cond(a)=1.557018e+018 det*det=-4.325761e+000
Durant l’exécution du programme, un message s’affiche sur l’écran pour n=11 à n=14 :
Warning: Matrix is close to singular or badly scaled. Results may be inaccurate. RCOND =
3.659249e-017.
Ce qui signifie qu’à partir de n=11 jusqu’à n=14, on a det(a)*det(a-1) différent de 1, donc les
erreurs d’arrondi commencent leurs apparitions.
3. Méthode directe (Méthode du pivot)
Soit à résoudre le système suivant de 3 équations à 3 inconnues par la méthode du pivot (dans
Matlab) :
déterminer
.
Solution :
1. On définit tout d’abord la matrice argument dans Matlab par :
>>A=[-0.04 0.04 0.12 3;0.56 -1.56 0.32 1; -0.24 1.24 -0.28 0] ;
2. On choisit la ligne 1 comme ligne pivot : a(1,1)=-0.04,
on divise la ligne 1 par a(1,1)
b(1,:)=a(1,:)/a(1,1)
nouvelle ligne,
on annule le 1er terme de la ligne 2 et le 1er terme de la ligne 3 :
b(2,:)=a(2,:)-b(1,:)*a(2,1),
b(3,:)=a(3,:)-b(1,:)*a(3,1).
On obtient après calculs :
b=
1 -1 -3 -75
0 -1 2 43
0 1 -1 -18
3. On choisit la ligne 2 comme ligne pivot.
On divise cette ligne par b(2,2)=-1, on obtient :
c(2,:)=b(2,:)/b(2,2)
nouvelle ligne = 0 1 -2 -43
on annule le terme b(1,2) de la ligne 1 et le terme b(3.2) de la ligne 3 :
c(1,:)=b(1,:)-c(2,:)*b(1,2)
c(3,:)=b(3,:)-c(2,:)*b(3,2)
1 0 -5 118,
0 0 1 25.
4. On choisit la ligne 3 comme ligne pivot c(3, :).
On divise cette ligne par c(3,3)=1, on obtient :
d(3,:)=c(3,:)
nouvelle ligne = 0 0 1 25
on annule dans la ligne 1 c(1,3) et dans la ligne 2 c(2,3) :
d(1,:)=c(1,:)-d(3,:)*c(1,3)
d(2,:)=c(2,:)-d(3,:)*c(2,3)
1 0 0 7,
0 1 0 7.
D’où la matrice d s’écrit :
d=
1007
0107
0 0 1 25
et la solution est :
L’algorithme suivant (dans Matlab) permet de résoudre le système précédent :
clear %effacer toutes les variables en mémoire dans Matlab
a=[-0.04 0.04 0.12 3;0.56 -1.56 0.32 1;-0.24 1.24 -0.28 0];a
x=[0 0 0]'; %x est le vecteur colonne de composantes xi qui est
initialisé ici
% 1er point pivot ligne 1 -calculs sur les lignes 2 et 3
b(1,:)=a(1,:)/a(1,1);
b(2,:)=a(2,:)-b(1,:)*a(2,1);
b(3,:)=a(3,:)-b(1,:)*a(3,1);b
% 2ème pivot ligne 2 - calculs sur les lignes 1 et 3
c(2,:)=b(2,:)/b(2,2);
c(1,:)=b(1,:)-c(2,:)*b(1,2);
c(3,:)=b(3,:)-c(2,:)*b(3,2);c
% 3ème pivot ligne 3 - calculs sur les lignes 1 et 2
d(3,:)=c(3,:)/c(3,3);
d(1,:)=c(1,:)-d(3,:)*c(1,3);
d(2,:)=c(2,:)-d(3,:)*c(2,3);d
%Solutions recherchées
x(1)=d(1,4);
x(2)=d(2,4);
x(3)=d(3,4);x
après l’exécution de ce programme, on obtient :
a=
-0.0400 0.0400 0.1200 3.0000
0.5600 -1.5600 0.3200 1.0000
-0.2400 1.2400 -0.2800 0
b=
1.0000 -1.0000 -3.0000 -75.0000
0 -1.0000 2.0000 43.0000
0 1.0000 -1.0000 -18.0000
c=
1.0000 0 -5.0000 -118.0000
0 1.0000 -2.0000 -43.0000
0 0 1.0000 25.0000
d=
1.0000 0 0 7.0000
0 1.0000 0 7.0000
0 0 1.0000 25.0000
x=
7.0000
7.0000
25.0000
4. Méthodes itératives
4.1. Méthode de Jacobi
Résoudre le système suivant par la méthode itérative de Jacobi :
Écrire un algorithme permettant de calculer x1, x2 et x3 par itérations. Déterminer le nombre
d’itérations nécessaires pour obtenir :
.
Solution :
‘jacobi.m’. Dans cet algorithme,
Appelons l’algorithme permettant de calculer la solution
nous avons utilisé un facteur de relaxation "λ" pour réaliser la convergence, car sinon le système
diverge.
4.2. Méthode de Gauss-Seidel
Résoudre le même système précédent par la méthode de Gauss-Seidel. Écrire un algorithme
(Matlab) permettant de résoudre ce système et déterminer le nombre d’itérations nécessaires pour
obtenir une erreur
.
Comparer les résultats avec la méthode de Jacobi et conclure.
Représenter sur le même graphe l’évolution des solutions
Changer les valeurs initiales
en fonction du nombre d’itérations.
, exécuter le programme puis conclure.
Solution :
* Méthode itérative générale :
Appelons l’algorithme permettant de calculer la solution
On se donne des valeurs arbitraires
A*x=y ; où
,
: par exemple
‘G-seid.m’
=0. Le système à résoudre est :
et
La matrice A et le vecteur colonne y sont connus, le vecteur colonne x reste inconnu. Ainsi, la
méthode itérative générale consiste à écrire :
pour
et
.
En particulier, pour un système de 3 équations à 3 inconnues, on a :
i=1
j=2 et 3
i=2
j=1 et 3
i=3
j=1 et 2
et ceci pour chaque itération.
Programme itmg.m :
%******************************
% Résolution d'un système linéaire *
% par la méthode itérative générale *
%******************************
clear all;
clc;
fprintf('Méthode itérative générale\n');
n=30000;
a=[1 1 1;2 -1 3;3 2 -2];
y=[1 4 -2];
x=zeros(1,3);
w=0.2; % facteur de relaxation : 0<w<1
epsilon=1e-10;
for k=1:n
erreur=0;
for i=1:3
s=0;
xb=x(i);
for j=1:3
if i~=j
s=s+a(i,j)*x(j);
end
end
x(i)=w*(y(i)-s)/a(i,i)+(1-w)*x(i);
erreur=erreur+abs(x(i)-xb);
end
if (erreur/3<epsilon)
fprintf('Itération no. : %d\t Erreur = %7.2e\n',k,erreur);
break;
end
end
x
Polynômes et interpolation
polynomiale Résolution des
équations non linéaires
L’objectif principal de l’interpolation est d’interpoler des données connues à partir des points
discrets. Dans ce cas, la valeur de la fonction entre ces points peut être estimée. Cette méthode
d’estimation peut être étendue et utilisée dans divers domaines ; à savoir la dérivation et
l’intégration numérique des polynômes.
1. Opérations sur les polynômes dans MATLAB
Dans MATLAB, les polynômes sont représentés sous forme de vecteurs lignes dont les
composantes sont données par ordre des puissances décroissantes. Un polynôme de degré n est
représenté par un vecteur de taille (n+1).
Exemple :
Le polynôme :
est représenté par :
>>f=[8 0 2 -3 4 -2]
f =8 0 2 -3 4 -2
D’autres fonctions dans MATLAB telles que : ‘conv’, ‘deconv’, ‘roots’, etc. peuvent être
utilisées en plus des opérations propres aux vecteurs (cf. chapitre précédent).
1.1. Multiplication des polynômes
La fonction ‘conv’ donne le produit de convolution de deux polynômes. L’exemple suivant
montre l’utilisation de cette fonction.
Soient :
Le produit de convolution :
est donné par :
>>f=[3 2 -1 4];
>>g=[2 0 -3 5 -1];
>>h=conv(f,g)
h=
6 4 -11 17 10 -19 21 -4
obtenu est :
Ainsi, le polynôme
1.2. Division des polynômes
La fonction ‘deconv’ donne le rapport de convolution de deux polynômes (déconvolution des
coefficients du polynôme). L’exemple suivant montre l’utilisation de cette fonction.
Soient les mêmes fonctions précédentes
La division de
par
et
:
est donnée par la fonction ‘deconv’ :
>>f=[3 2 -1 4];
>>g=[2 0 -3 5 -1];
>>h=deconv(g,f)
h=
0.6667 -0.4444
et le polynôme
obtenu est :
:
2. Manipulation de fonctions polynomiales dans MATLAB
Soit le polynôme suivant :
où n est degré du polynôme et
sont les coefficients du polynôme.
Ce polynôme peut être écrit sous la forme :
Après factorisation, on a :
où
sont les racines du polynômes
.
Exemple :
Ce polynôme est équivalent à :
ou encore :
Un polynôme d’ordre n possède n racines qui peuvent être réelles ou complexes.
Dans MATLAB, un polynôme est représenté par un vecteur contenant les coefficients dans
un ordre décroissant.
Exemple :
Le polynôme :
>>P=[2 1 4 5];
qui est représenté dans MATLAB par :
a pour racines
. Pour trouver ces racines, on doit exécuter la fonction ‘roots’.
D’où :
>>r=roots(P);
et le résultat donné est :
>> r
r=
0.2500 + 1.5612i
0.2500 - 1.5612i
-1.0000
Les trois racines de ce polynôme (dont 2 sont complexes) sont données sous forme d’un vecteur
colonne. Quand les racines
commande ‘poly’.
sont connues, les coefficients peuvent être recalculés par la
Exemple :
>>poly(r)
ans =
1.0000 0.5000 2.0000 2.5000
La fonction ‘poly’ accepte aussi une matrice comme argument dont elle retourne le polynôme
caractéristique.
Exemple :
>>A=[3 1;2 4];
>>p=poly(A)
p=
1 -7 10
Ainsi, le polynôme caractéristique de la matrice A est :
Les racines de ce polynôme sont les valeurs propres de la matrice A. ces racines peuvent être
obtenues par la fonction ‘eig’ :
>>Val_prop=eig(A)
Val_prop =
2
5
2.1. Évaluation d’un polynôme
•
Pour évaluer le polynôme
en un point donné, on doit utiliser la fonction ‘polyval’.
On évalue ce polynôme pour x=1, par exemple :
>>polyval(P,1)
ans =
12
•
Exemple :
On veut évaluer en x=2.5 le polynôme suivant :
>>C=[3 -7 2 1 1];
>>x=2.5;
>> y=polyval(C,x)
y=
23.8125
Si x est un vecteur contenant plusieurs valeurs, y sera aussi un vecteur qui contiendra le même
nombre d’éléments que x.
2.2. Interpolation au sens des moindres carrés
Dans le domaine de l’analyse numérique des données, on a souvent besoin d’établir un modèle
mathématique liant plusieurs séries de données expérimentales. L’interpolation polynomiale
consiste à approcher la courbe liant les deux séries de mesures par un polynôme. Les coefficients
optimaux de ce polynôme sont ceux qui minimisent la variance de l’erreur d’interpolation. Ce
principe (voir cours) est connu sous le nom de la méthode des moindres carrés. La fonction
‘polyfit’ retourne le polynôme P de degré n permettant d’approcher la courbe
des moindres carrés.
Exemple :
au sens
>> x=[1.1 2.3 3.9 5.1];
>>y=[3.887 4.276 4.651 2.117];
>>a=polyfit(x,y,length(x)-1)
a=
-0.2015 1.4385 -2.7477 5.4370
Ainsi, le polynôme d’interpolation de y (d’ordre length(x)-1=3) est :
Pour déduire l’erreur entre les valeurs expérimentales et le modèle obtenu par la fonction
‘polyfit’, on dispose de la fonction ‘polyval’ qui retourne la valeur du polynôme P pour toutes les
composantes du vecteur (ou de la matrice) x.
Ainsi, cette fonction donne :
>>yi=polyval(a,x)
yi =
3.8870 4.2760 4.6510 2.1170
On remarque ici que les valeurs expérimentales de y sont bien restituées (y=yi). Dans ce cas, on
a un coefficient de corrélation qui est égal à 1 (voir la définition de ce coefficient dans le cours).
Pour mieux comprendre ces fonctions prédéfinis dans MATLAB, on va simuler une courbe
expérimentale par une sigmoïde à laquelle on superpose un bruit du type Gaussien. Cette courbe
sera donnée par :
Le programme correspondant à l’approximation des ces données dans MATLAB (regres.m, par
exemple) est le suivant :
%******************************************
% Génération de données expérimentales:
*
% y=1./(1+exp(-x))+0.05*randn(1,length(x))*
%******************************************
clc; % Effacer l'écran
clear all; % Effacer des variables de l'espace de travail
x=-5:0.1:5; % Intervalle de définition et de calcul de la sigmoïde
% Fonction sigmoïde bruitée
y=1./(1+exp(-x))+0.05*randn(1,length(x));
plot (x,y); % Tracé de la sigmoïde bruitée
title('Fonction sigmoïde bruitée - Polynôme d''interpolation');
xlabel('x');ylabel('y');
% Polynôme d'interpolation d'ordre 1
P=polyfit(x,y,1);
% Valeurs du polynôme d'interpolation
Vp=polyval(P,x);
% Tracé du polynôme d'interpolation
hold on;
plot(x,Vp,'--');
% Calcul de l'erreur d'interpolation
erreur=y-Vp;
% Tracé de la courbe de l'erreur
plot(x,erreur,':')
grid
gtext('Mesures')
gtext('Erreur')
gtext('Modèle')
hold off
% Affichage du polynôme d'interpolation
disp('Polynôme d''interpolation')
P
Var_erreur=num2str(std(erreur).^2);
disp(['La variance de l''erreur d''interpolation est : ',Var_erreur])
Après exécution du programme, on obtient à l’ordre 1 (droite affine : fig. 1 ci-dessous) les
résultats suivants :
>> regres
Polynôme d'interpolation
P=
0.1309 0.5008
La variance de l'erreur d'interpolation est : 0.011277
On remarque ici que le polynôme d’interpolation d’ordre 1 n’est pas une bonne approximation
pour ces données. En effet, un polynôme d’ordre 5 donne une meilleure approximation de la
sigmoïde (fig. 2). Ainsi, dans le programme précédent (sigreg.m), on change dans le ‘1’ par ‘5’
dans la fonction ‘polyfit’, et on obtient les résultats suivants :
>> regres
Polynôme d'interpolation
P=
0.0002 -0.0000 -0.0111 0.0008 0.2326 0.4844
La variance de l'erreur d'interpolation est : 0.002279
Fig.1 : Interpolation linéaire
Fig.2 : Interpolation par un polynôme d’ordre 5
3. Interpolation linéaire et non linéaire
Une interpolation consiste à relier les points expérimentaux par une courbe sous forme de
segments de droites ou de courbes polynomiales. Ceci peut être réalisé par la fonction ‘interp1’.
La commande ‘interp1(x,y,xi,’type’)’ retourne un vecteur de mêmes dimensions que xi et dont les
valeurs correspondent aux images des éléments de xi déterminées par interpolation sur x et y. Si f
est l’interpolation de y, la chaîne ‘type’ spécifie alors le type d’interpolation qui doit être parmi
les suivants :
•
•
•
‘linear’
‘spline’
‘cubic’
interpolation linéaire
interpolation par splines cubiques,
interpolation cubique.
Si on ne spécifie pas le type, l’interpolation linéaire est choisie par défaut.
Exemple 1 :
>>x = 0:10; y = sin(x); xi = 0:.25:10;
>>yi = interp1(x,y,xi,’cubic’); plot(x,y,'o',xi,yi)
Fig. 3 : Interpolation cubique
Exemple 2 :
Dans le cas suivant, on étudiera ces différents types d’interpolation sur un même exemple de
valeurs discrètes de la fonction ‘cosinus’. On appellera l’algorithme : ‘interpol.m’.
%*************************************
% Utilisation de la fonction interp1 *
%*************************************
clear all;
clc;
x=0:10;
y=cos(x); % Points à interpoler
z=0:0.25:10; % Le pas du vecteur z est inférieur à celui de x
% Interpolation linéaire
figure(1);
f=interp1(x,y,z);
% Tracé des valeurs réelles et de la courbe d'interpolation
plot(x,y,'*r',z,f);
grid on;
xlabel('Interpolation');
% Interpolation par splines cubiques
figure(2);
f=interp1(x,y,z,'spline');
plot(x,y,'*r',z,f);
grid on;
xlabel('Interpolation par splines cubiques');
En exécutant ce programme, on obtient les courbes suivantes :
Fig. 4 : Interpolation linéaire
Fig. 5 : Interpolation par splines cubiques
La fonction ‘interp2’ réalise l’interpolation dans l’espace trois dimensions (3D).
4. Interpolation de Lagrange
Exemple :
Les masses volumiques du matériau pour différentes températures sont données par le tableau cidessous :
•
•
i
1
2
3
Température T (en °C)
94
205
371
Masse volumique R(T) : (en kg/m3)
929
902
860
Écrire la formule d’interpolation de Lagrange qui permet d’interpoler les différents
points de données précédentes.
Trouver les masses volumiques du sodium pour T=251 °C, T=305 °C et T=800 °C en
utilisant l'interpolation de Lagrange.
Solution :
a) Puisque le nombre de points est égal à 3, alors le polynôme de Lagrange sera de degré 2. Ce
polynôme s’écrit :
Soit :
D’où pour T=251 °C, on obtient R(251) = 890.5 kg/m3.
L'algorithme de calcul de R(251), R(305) et R(800) est : ‘polylag.m’ qui est listé ci-dessous :
%****************************************
% Interpolation polynomiale de Lagrange *
%****************************************
clc;
clear;
T=[94 205 371];
R=[929 902 860];
Ti=[251 305 800];
Ri=lag(T,R,Ti)
La fonction ‘lag.m’ est un sous programme permettant de donner l’interpolation de Lagrange. La
liste de ce sous programme est :
%***************************
% Sous-programme Lagran_.m *
%***************************
function Ri=lag(T,R,Ti)
Ri=zeros(size(Ti)); % Initialisation des Ti
n=length(R); % Nombre de points
for i=1:n
y=ones(size(Ti));
for j=1:n
if i~=j
y=y.*(Ti-T(j))/(T(i)-T(j));
end
Ri=Ri+y*R(i)
end
end
return
Il suffit maintenant d’exécuter le programme ‘polylag.m’ pour obtenir les résultats de Ri.
Ces résultats sont les suivants :
>>Ri
Ri =
890.5561 876.9316 742.45559
5. Résolution d’équations et de Systèmes d’équations non Linéaire
5.1. Résolution d’équations non Linéaires
Dans cette partie, on s’intéressera à la méthode de Newton-Raphson pour la résolution des
équations non linéaires à une ou à plusieurs variables. On cherchera ensuite à trouver la
valeur
qui annulera la fonction
.
La méthode de Newton-Raphson permet d’approcher par itérations la valeur
relation suivante :
au moyen de la
Dans toutes les méthodes itératives, il est nécessaire pour éviter une divergence de la solution, de
bien choisir la valeur initiale
. Celle-ci peut être obtenue graphiquement.
On se propose d’appliquer cette méthode pour la recherche des racines de la fonction non
linéaire suivante :
Dans un premier temps, on se propose de tracer la courbe représentative de cette fonction en
utilisant le programme ci-dessous ‘pnum1.m’:
%*************************
% Etude de la fonction : *
% f(x)=exp(x)-2.cos(x)
*
%*************************
x=-1:0.1:1;
f=exp(x)-2*cos(x);
plot(x,f); grid on;
title('Fonction : f(x)=exp(x)-2.cos(x)');
Après exécution du programme, on obtient la courbe sur la figure 6. D ‘après cette courbe, il est
judicieux de choisir un
rapide.
La fonction dérivée
; car
est proche de zéro pour avoir une convergence
a pour expression :
fig. 6 : Localisation de la valeur
Pour chercher la solution de
quelques lignes :
.
où
, on peut rajouter au programme précédent ‘pnum1.m’
%*************************
% Etude de la fonction : *
% f(x)=exp(x)-2.cos(x) *
%*************************
clf;
x=-1:0.1:1;
f=exp(x)-2*cos(x);
figure(1);
plot(x,f); grid on;
title('Fonction : f(x)=exp(x)-2.cos(x)');
clear all;
clc;
x(1)=input('Donner la valeur initiale x(1): \n');
e=1e-10;
n=5000;
for i=2:n
f=exp(x(i-1))-2*cos(x(i-1));
diff=exp(x(i-1))+2*sin(x(i-1));
x(i)=x(i-1)-f/diff;
if abs(x(i)-x(i-1))<=e
xp=x(i);
fprintf('xp=%f\n',x(i));
break;
end
end
j=1:i;
figure(2);
plot(j,x(j),'*r',j,x(j));
xlabel('Nombre d''itérations');
title('Convergence de la solution : Méth. de Newt.-Raph.');
disp('Les valeurs successives de x(i) sont :');
x'
Ainsi, après exécution de ce programme, on obtient alors toutes les valeurs successives de
pour chaque itération. Les résultats sont données ci-dessous. On remarque qu’il y a convergence
après 5 itérations :
>>pnum1
Donner la valeur initiale x(1):
0.5
xp=0.539785
Les valeurs successives de x(i) sont :
ans =
0.5000
0.5408
0.5398
0.5398
0.5398
Fig. 7 : Évolution de la solution x(i) en fonction du nombre d’itérations
Dans MATLAB, on peut obtenir la même solution avec la fonction ‘fzero’. Pour cela, il faut
créer le fichier.m MATLAB (‘f.m’, par exemple) dans lequel sera programmé
.
%***********************************
% Fichier MATLAB représentant f(x) *
%***********************************
function f=f(x)
f=exp(x)-2*cos(x)
Pour obtenir la solution de
au voisinage de
, on exécute la commande
‘fzéro(‘f’,0.5)’. Cette fonction affiche les valeurs obtenues de
donner à la fin la solution recherchée
.
>>d=fzero('f',0.5)
f=
-0.1064
-0.1430
-0.0692
-0.1579
-0.0536
-0.1788
-0.0313
-0.2080
à chaque itération pour
5.8950e-004
-3.0774e-005
-4.1340e-009
2.2204e-016
-8.8818e-016
d=
0.5398
5.2. Résolution de systèmes d’équations non Linéaires
Nous allons appliquer cette méthode à un cas très simple : résolution d’un système de deux
équations non linéaires à 2 inconnues, par exemple :
l’algorithme de Newton-Raphson devient :
Exemple :
Les fonctions
et
admettent comme dérivées partielles :
Afin de déterminer si le système admet des solutions sur
représentatives des fonctions
et
, on tracera les surfaces
dans le but de montrer l’existence éventuelle d’un
couple
pour lequel elles s’annulent. L’algorithme ‘pnum2.m’ ci-dessous permet de tracer
en 3 dimensions ces deux fonctions sur le même graphe.
%*****************************
% Fonctions à deux variables *
%*****************************
x=-1:0.1:1;
y=x;
[x,y]=meshgrid(x,y);
f=x.^2+y.^2-x;
g=x.^2-y.^2-y;
figure(1);
mesh(f);
grid on;
hold on;
mesh(g);
title('Courbes f(x,y) et g(x,y)');
xlabel('x'); ylabel('y');zlabel('f(x,y) et g(x,y)');
hold off;
On peut remarquer sur le graphe obtenu (en 3D) que les 2 fonctions et s’annulent
simultanément en différents points. Grâce aux fonctionnalités de MATLAB, on peut rechercher
les solutions éventuelles ou les conditions initiales pour l’algorithme de Newton-Raphson en
faisant varier simultanément les variables et à l’aide de la fonction ‘meshgrid’. On obtient
alors les courbes de niveaux des fonctions
Fig. 8 : Fonctions
et
.
et
en 3D
On peut développer davantage l’algorithme ‘pnum2.m’ pour chercher, par exemple, les
conditions initiales et les solutions évidentes.
%*****************************
% Fonctions à deux variables *
%*****************************
x=-1:0.1:1;
y=x;
[x,y]=meshgrid(x,y);
f=x.^2+y.^2-x;
g=x.^2-y.^2-y;
figure(1);
mesh(f);
grid on;
hold on;
mesh(g);
title('Courbes f(x,y) et g(x,y)');
xlabel('x'); ylabel('y');zlabel('f(x,y) et g(x,y)');
hold off;
figure(2);
plot(f);
hold on;plot(g);grid on;
title('Intersection de f et g');
xlabel('x');ylabel('y');
axis([0 20 -0.5 0.5]);
gtext('f(x,y)');
gtext('g(x,y)');
Après exécution de ‘pnum.m’, on obtient les courbes de
dimensions :
et
(fig. 9) en deux
Fig. 9 : Fonctions
et
en 2D
Les solutions évidentes s’obtiennent par :
>> [i,j]=find(f==0 & g==0)
i=
11
j=
11
>>[x(11),y(11)]
ans =
-1 0
De cette façon, on peut retrouver plusieurs solutions évidentes si le pas d’échantillonnage est
assez faible. Avec le pas de 0,1 choisi, on ne retrouve pas la solution évidente (0,0).
Graphiquement, en faisant un zoom autour de l’abscisse ‘x=11’ avec la fonction ‘axis’, on peut
cerner cette solution évidente.
>>axis([10.5 11.5 -0.02 0.02]);
Fig. 10 : zoom autour de l’abscisse
Ainsi, l’algorithme de Newton-Raphson appliqué au système précédent, est représenté par la
suite du programme MATLAB (pnum2.m) :
%*****************************
% Fonctions à deux variables *
%*****************************
clf;
clear all;
clc;
x=-1:0.1:1;
y=x;
[x,y]=meshgrid(x,y);
f=x.^2+y.^2-x;
g=x.^2-y.^2-y;
figure(1);
mesh(f);
grid on;
hold on;
mesh(g);
title('Courbes f(x,y) et g(x,y)');
xlabel('x'); ylabel('y');zlabel('f(x,y) et g(x,y)');
hold off;
figure(2);
plot(f);
hold on;plot(g);grid on;
title('Intersection de f et g');
xlabel('x');ylabel('y');
axis([0 20 -0.5 0.5]);
gtext('f(x,y)');
gtext('g(x,y)');
hold off;
clear x y;
% Conditions initiales
x(1)=0.85; y(1)=0.35;
% Algorithme de Newton-Raphson
for i=2:10
diff=inv([2*x(i-1)-1 2*y(i-1);2*x(i-1) -2*y(i-1)-1]);
f=x(i-1)^2-x(i-1)+y(i-1)^2;
g=x(i-1)^2-y(i-1)^2-y(i-1);
xy=[x(i-1) y(i-1)]'-diff*[f,g]';
x(i)=xy(1);
y(i)=xy(2);
end
Le choix des conditions initiales influe sur la convergence de l’algorithme. Dans ce qui suit
(suite de ‘pnum2.m’), nous étudierons l’évolution des solutions par 2 jeux de conditions initiales.
%*****************************
% Fonctions à deux variables *
%*****************************
clf;
clear all;
clc;
x=-1:0.1:1;
y=x;
[x,y]=meshgrid(x,y);
f=x.^2+y.^2-x;
g=x.^2-y.^2-y;
figure(1);
mesh(f);
grid on;
hold on;
mesh(g);
title('Courbes f(x,y) et g(x,y)');
xlabel('x'); ylabel('y');zlabel('f(x,y) et g(x,y)');
hold off;
figure(2);
plot(f);
hold on;plot(g);grid on;
title('Intersection de f et g');
xlabel('x');ylabel('y');
axis([0 20 -0.5 0.5]);
gtext('f(x,y)');
gtext('g(x,y)');
hold off;
clear x y;
% Conditions initiales
x(1)=0.85; y(1)=0.35;
% x(1)=0.2; y(1)=0.1;
% Algorithme de Newton-Raphson
for i=2:10
diff=inv([2*x(i-1)-1 2*y(i-1);2*x(i-1) -2*y(i-1)-1]);
f=x(i-1)^2-x(i-1)+y(i-1)^2;
g=x(i-1)^2-y(i-1)^2-y(i-1);
xy=[x(i-1) y(i-1)]'-diff*[f,g]';
x(i)=xy(1);
y(i)=xy(2);
end
% Tracé des courbes d'évolution des solutions
figure(3);
plot(1:10,x,'*r',1:10,x);
hold on;
plot(1:10,y,'og',1:10,y);
title('Evolution des solutions : ***-->x et ooo-->y');
grid on;
hold off;
L’évolution des solutions x et y (pour les conditions initiales :
par la figure 11 ci-après. Ces solutions sont les suivantes :
et
) est donnée
>>x
x=
0.8500 0.7800 0.7719 0.7718 0.7718 0.7718 0.7718 0.7718 0.7718 0.7718
>>y
y=
0.3500 0.4271 0.4197 0.4196 0.4196 0.4196 0.4196 0.4196 0.4196 0.4196
Les 2 solutions peuvent être obtenues au bout de 2 itérations grâce au bon choix des conditions
initiales. Avec les conditions initiales x(1)=0,2 et y(1)=0.1, il y a convergence vers la solution
(0,0) au bout de 3 itérations.
Fig. 11 : Convergence des solutions (x,y) : x(1)=0,85 et y(1)=0,35
Pour les conditions initiales x(1)=0,2 et y(1)=0,1, l’évolution des solutions x et y est :
>>x
x=
0.2000 -0.1031 -0.0112 -0.0002 -0.0000 -0.0000 -0.0000 0 0 0
>>y
y=
0.1000 -0.0594 -0.0054 -0.0001 -0.0000 -0.0000 -0.0000 0 0 0
La boite à outil ‘Optimisation Toolbox’ propose les fonctions ‘fsolve’ et ‘fsolve2’ qui permettent
respectivement, la recherche des racines d’une fonction dans un intervalle donné et les solutions
d’équations non linéaires et de systèmes d’équations non linéaires.
Fig. 12 : Convergence des solutions (x,y) : x(1)=0,2 et y(1)=0,1
Intégration numérique des
fonctions
1. Introduction
Dans la plupart des cas, les fonctions analytiques, du fait de leurs complexités, ne sont pas
intégrables analytiquement. Dans d'autres cas, on a des fonctions qui sont évaluées
numériquement en différents points de l’intervalle où ces dernières sont données, et l’intégrale de
ces types de fonctions ne peut être obtenue que par des approches numériques. Dans ce chapitre,
on s’intéresse aux méthodes utilisées fréquemment ; à savoir la méthode des trapèzes, la méthode
de Simpson, les formules de Newton-Cotes et la méthode de Gauss. Nous étudierons également
les méthodes de calcul d’intégrales doubles et les intégrales des fonctions non définies sur leurs
bornes.
2. Méthodes d’intégrations numériques
2.1. Méthode des trapèzes
la fonction à intégrer sur
Soit
des trapèzes :
où
;
;
. L’intégrale
de
et
s’écrit en utilisant la méthode
.
Le terme représentant l’erreur est :
est la moyenne de
la valeur de
sur l’intervalle
. L’erreur
est inversement proportionnelle à
.
est donnée sur les intervalles réguliers (
Si la fonction
peut être écrite dans Matlab sous la forme :
), la méthode des trapèzes
avec :
On peut également faire un programme pour calculer l'intégrale
Celui-ci appelé 'trapez_v.m' par exemple, est listé ci-dessous :
.
function I=trapez_v(g,h)
I=(sum(f)-(f(1)+f(length(f)))/2)*h;
Considérons par exemple la fonction à intégrer :
sur un intervalle
où
le pas est "h" égal à 1. En mode interactif dans MATLAB (mode commande), avant de lancer le
programme 'trapez_v.m', on donne la fonction
ainsi que ses bornes :
>>x=-10:1:8;
>>f=x.^2+2*x-1;
>>h=1;
On exécute ensuite le programme 'trapez_v.m', et on obtient :
>>I=trapez_v(f,h)
I=
2265
En utilisant les programmes 'trapez_n.m' et 'trapez_g.m' listés ci-après, on peut calculer aussi
l'intégrale I.
>>I=trapez_n('fonction_f',a,b,n)
ou
>>I=trapez_g('fonction_f',a,b,n)
Liste du programme 'trapez_n.m' :
function I=trapez_n(fonction_f,a,b,n)
h=(b-a)/n;
x=a+(0:n)*h;
f=feval(fonction_f,x);
I=trapez_v(f,h)
Liste du programme 'trapez_g.m' :
function I=trapez_g(fonction_f,a,b,n);
n=n;
hold off;
h=(b-a)/n;
x=a+(0:n)*h;
f=feval(‘fonction_f’,x);
I=h/2*(f(1)+f(n+1));
if n>1
I=I+sum(f(2:n))*h;
end
h2=(b-a)/100;
xc=a+(0:100)*h2;
fc=feval(‘fonction_f’,xc);
plot(xc,fc,'r');
hold on;
title('Méthode des trapèzes');
xlabel('x');
ylabel('y');
grid on;
plot(x,f,'m');
plot(x,zeros(size(x)),'c')
for i=1:n;
plot([x(i),x(i)],[0,f(i)],'g');
end
La fonction 'fonction_f' est donnée par le programme 'fonction_f.m'.
Remarque :
La fonction y=feval('sin',x) est équivalente à y=sin(x).
Exemples :
1°) On donne la fonction 'fonction_f' par le sous-programme 'fonction_f.m' listé ci-dessous :
%****************
% fonction f(x) *
%****************
function f=f(x);
f=x+2*log(0.0000025235*x);
En exécutant le programme trapez_g('fonction_f',1,50,60), où les bornes
respectivement à 1 et 50 et le nombre d'intervalles
sur
pour 60 pas :
>>trapez_g('fonction_f',1,50,60)
ans =
279.3889
et
sont égales
est égal 60, on obtient l'intégrale de
Fig. 1 : Intégrale de la fonction
2°) Un véhicule de masse m=2000 kg se déplace à la vitesse de V=30 m/s. Soudainement, le
. L'équation du mouvement après l'instant
est donnée par :
moteur est débrayé à
(a)
où x est la distance linéaire mesurée à partir de
.
Dans cette équation (a), le terme de gauche représente la force d'accélération, le 1er terme de
droite représente la résistance aérodynamique exercée par le vent sur le véhicule et le second
terme est le coefficient de frottement. Calculer la distance au delà de laquelle la vitesse de la
voiture se réduit à 15 m/s.
Solution :
L'équation (a) peut être écrite sous la forme :
L'intégration de cette équation donne :
Cette intégrale peut être évaluée par la méthode des trapèzes.
Si on se donne 60 intervalles (ou 61 points), on peut écrire :
où
et
.
En définissant :
et en appliquant la méthode des trapèzes pour l'intégration, on obtient :
(b)
Le programme suivant (trapeze.m)permet de calculer la valeur
précédente (b) :
donnée par la formulation
>>trapeze
x=
127.5066
En comparant cette solution à la solution exacte (=127,51 m), on remarque que l'erreur relative
induite par cette méthode est de l'ordre de 2,7.10-3 %.
La liste du programme trapeze.m est la suivante :
clear;
clc;
nb_points=61;
i=1:nb_points;
h=(30-15)/(nb_points-1);
V=15+(i-1)*h;
f=2000*V./(8.1*V.^2+1200);
x=trapez_v(f,h)
3°) Connaissant l'intégrale exacte de la fonction
a
. Étudier l'effet du nombre d'intervalles
méthode trapézoïdale :
sur l'intervalle
sur l'erreur de calcul en adoptant la
Solution :
Le programme suivant 'trz.m' permet de calculer l'intégrale
:
clc;
clear;
Iexact=4.006994;
a=0;b=2;
fprintf('\n Méthode Trapézoïdale étendue \n');
fprintf('\n n\t \t I\t Pourc. erreur relat.\n');
fprintf('---------------------------------------------\n');
n=1;
for k=1:10
n=2*n;
h=(b-a)/n;
i=1:n+1;
x=a+(i-1)*h;
f=sqrt(1+exp(x));
I=trapez_v(f,h);
erreur=abs(Iexact-I)/Iexact;
fprintf('%d\t %10.5f\t %10.8f\n',n,I,erreur);
end
Les résultats obtenus sont les suivants :
Méthode Trapézoïdale étendue
n
I
Pourc. erreur relat.
--------------------------------------------2
4
8
16
32
64
128
256
512
1024
4.08358
4.02619
4.01180
4.00819
4.00729
4.00707
4.00701
4.00700
4.00700
4.00699
0.01911429
0.00478998
0.00119825
0.00029965
0.00007496
0.00001878
0.00000474
0.00000123
0.00000035
0.00000013
, on
D'après ces résultats, on montre que quand
est doublé, l'erreur relative décroît par un facteur 4.
2.2. Méthode de Simpson
Soit
l'intégrale de
;
où
Le terme
et
sur l'intervalle
et
. Par la méthode de Simpson,
s'écrit :
.
est donné par :
est la moyenne de
sur l'intervalle ouvert
.
Exemple :
Évaluer l'intégrale de
pour
sur l'intervalle
et
avec la méthode de Simpson
.
Solution :
La liste du programme 'msimp.m' est la suivante :
clc;
clear;
Iexact=4.006994;
a=0;b=2;
fprintf('\n Méthode de Simpson \n');
fprintf('\n n\t \t I\t Pourc. erreur relat.\n');
fprintf('---------------------------------------------\n');
n=1;
for k=1:4
n=2*n;
h=(b-a)/n;
i=1:n+1;
x=a+(i-1)*h;
f=sqrt(1+exp(x));
I=h/3*(f(1)+4*sum(f(2:2:n))+f(n+1));
if n>2
I=I+h/3*2*sum(f(3:2:n));
end
erreur=abs(Iexact-I)/Iexact;
fprintf('%d\t %10.5f\t %10.8f\n',n,I,erreur);
end
Les résultats de cet algorithme sont donnés ci-dessous :
Méthode de Simpson
n
I
Pourc. erreur relat.
--------------------------------------------2
4
8
16
4.00791
4.00705
4.00700
4.00699
0.00022935
0.00001521
0.00000101
0.00000012
, l'erreur relative devient presque nulle (de l'ordre de
On montre qu'à partir de
Les programmes 'simp_v' et 'simp_n' peuvent être utilisés pour intégrer la fonction
).
. Dans
l'algorithme 'simp_v(f,h)',
est un vecteur contenant les ordonnées de l'intégrante et
représente le pas de l'intervalle d'intégration.
D'où :
>>I=simp_n('fonction_f',a,b,n)
dans laquelle 'fonction_f' est le nom du sous-programme contenant
permet d'évaluer l'intégrale
la fonction
,
et
sont les limites de l'intervalle d'intégration et
.
Exemple :
Soit
où
et
.
Ecrire un algorithme utilisant le sous-programme simp_v(f,h) (à écrire) et qui permet d'évaluer
sur 100 intervalles.
Solution :
Appelons ce programme simp.m par exemple, et donnons sa liste :
clear;
R=5;g=9.81;b=0.1;
x1=-0.90*R;x2=R;
h=(x2-x1)/100;
x=x1:h:x2;
f=(R^2-x.^2)./(b^2*sqrt(2*g*(x+R)));
I=simp_v(f,h)
Le sous-programme simp_v(f,h) est :
function I=simp_v(f,h);
n=length(f)-1; % Nombre d’intervalles
if n==1
fprintf('Données à un seul intervalle'\n');
return;
end
if n==2
I=h/3*(f(1)+4*f(2)+f(3));
return; % Revenir et continuer le calcul
end
if n==3
I=(3/8)*h*(f(1)+3*f(2)+3*f(3)+f(4));
return;
end
I=0;
if 2*floor(n/2)~=n ; %Le nombre d’intervalle doit être pair
I=3*h/8*(f(n-2)+3*f(n-1)+3*f(n)+f(n+1));
m=n-3;
else
m=n;
end
I=I+h/3*(f(1)+4*sum(f(2:2:m))+f(m+1));
if m>2
I=I+(h/3)*2*sum(f(3:2:m))
end
En exécutant le programme simp.m, on trouve l'intégrale
par la méthode de Simpson.:
>>simp
I=
1.8522e+003
3. Fonctions MATLAB utilisées pour l'intégration numérique
Dans Matlab (Toolbox), il existe 2 fonctions appelées 'quad' et 'quad8' pour l'intégration
numérique. La fonction 'quad' utilise la méthode de Simpson et la fonction 'quad8' utilise les
formules de Newton-Cotes à l'ordre 8. Ces deux fonctions sont utilisées de la façon suivante :
•
•
•
quad('fonction_f',a,b)
quad('fonction_f',a,b,tol)
quad('fonction_f',a,b,tol,trace)
Dans la première forme, la tolérance 'tol' qui correspond à l'erreur relative , est considérée
égale à 0,001 par défaut. Ainsi, le calcul quadratique de l'intégrale est réitéré jusqu'à ce que la
tolérance soit satisfaite. Si la 3ème forme est utilisée avec une valeur non nulle de 'trace', un
graphique d'évolution des itérations sera affiché sur l'écran. Quand à la fonction 'quad8', elle est
utilisée de la même manière que la fonction 'quad' dans les 3 formes d'expressions précédentes.
Exemple :
Soit à calculer l'intégrale suivante :
avec la transformation suivante :
Dans ce cas, on a :
On obtient donc :
Or, on connaît la fonction
par :
où
Pour un entier
(fonction Gamma) eulérienne du deuxième espèce qui est définie
est un réel.
strictement positif,
a la propriété suivante :
On pourra donc s'en servir pour calculer la factorielle d'un entier naturel
:
Dans Matlab, cette fonction est notée 'gamma'.
Exemple :
La factorielle de 10 est donnée par gamma(10+1)=gamma(11) :
>> fact=gamma(11)
fact =
3628800
Cette propriété est à l'origine du nom de la 'fonction factorielle', attribuée souvent à la fonction
'Gamma'. La fonction 'gamma' est donc prédéfinie dans Matlab. Cette fonction permet, de part sa
définition pour tous les arguments réels positifs, d'introduire 'la factorielle' des arguments non
entiers.
Exemple :
>> format long
>>gamma(0.5)
ans =
1.77245385090552
>>racine_de_pi=sqrt(pi)
racine_de_pi =
1.77245385090552
>>gamma(0)
Warning: Divide by zero.
ans =
Inf
>>gamma(-2)
Warning: Divide by zero.
ans =
-Inf
Tracé de la fonction Gamma
Tracer la fonction Gamma pour
.
>>x=-3:0.1:3;
>>gx=gamma(x);
>>plot(x,gx);grid;title('Allure de la fonction Gamma');
>>xlabel('x');ylabel('Gamma(x)');
>>hold on;plot(x,zeros(size(x)))
Fig. 2 : Fonction
Revenons maintenant à l'intégration de la fonction
:
D'après le changement de variable effectué, cette intégrale s'écrit :
Calculons cette intégrale par les fonctions Matlab 'quad8' et 'gamma'. La fonction 'quad8'
nécessite l'écriture de la fonction à intégrer dans un fichier contenant l'extension '.m' (programme
Matlab).
Liste du programme fct.m :
function f=fct(x);
% fonction à intégrer
f=(x-1).*exp(-x.*(x-2));
Tracé de la fonction à intégrer :
>>x=0:0.01:5;
>>ft=fct(x);
>>plot(x,ft);
>>grid; title('fonction à intégrer');
>>xlabel('x');ylabel('f(x)');
Fig. 3 :
Dans le programme donné ci-dessous (quadgamm.m), on calcule l'intégrale précédente par les
fonctions 'quad8' et 'gamma', pour lesquelles on compare les performances en terme de temps de
calcul et du nombre d'opérations en virgule flottante.
%***************************************
% Calcul de l'intégrale de f(x) par la *
% la fonction 'quad8' sur un K6-233 *
%***************************************
clear all; clc;
flops(0); % Mise à zéro du compteur d'opérations
tic; % Déclenchement du compteur temps de calcul
Iquad=quad8('fct',0,5)
Nbre_op1=flops, %Arrêt du compteur d’opérations
tps_q=toc, %Arrêt du compteur de temps de calcul
%***************************************
% Calcul de l'intégrale de f(x) par la *
% la fonction 'gamma' *
%***************************************
flops(0);
tic;
Igamma=gamma(1)/2
Nbre_op2=flops
tps_g=toc
En exécutant le programme quadgamm.m, on obtient les résultats suivants :
>> format long
>> quadgamm
Iquad =
0.49999987773178
Nbre_op1 =
686
tps_q =
0.06000000000000
Igamma =
0.50000000000000
Nbre_op2 =
40
tps_g =
0.05000000000000
D'après ces résultats, on remarque bien que le nombre d'opérations en virgule flottante et le
temps d'exécution dans le cas de l'utilisation de la fonction 'gamma' sont nettement inférieurs à
ceux que l'on obtient en utilisant la fonction 'quad8'.
La fonction 'gamma' prend des valeurs très grandes au voisinage de zéro et des entiers négatifs.
Afin d'éviter un dépassement de capacité, MATLAB dispose de la fonction 'gammaln' qui
retourne le logarithme népérien de ces valeurs.
Exemple :
>>format
>>x=5e-200;
>>gamma(x)
ans =
2.0000e+199
>>gammaln(x)
ans =
458.9076
Résolution numérique des
équations différentielles et
des équations aux dérivées
partielles
1. Introduction
Le comportement dynamique des systèmes est un sujet très important en physique. Un système
mécanique par exemple, se traduit par des déplacements, des vitesses et des accélérations. Un
système électrique ou électronique, se traduit par des tensions, des intensités et des dérivées
temporelles sur ces quantités. Un système thermique se traduit par des températures, des
gradients de température, de coefficients d’échanges thermiques, etc. En général, les équations
utilisées pour décrire de tels comportements dynamiques, incluent des quantités inconnues
représentant les fonctions recherchées et leurs dérivées.
Une équation qui comporte une ou plusieurs dérivées de la fonction inconnue est appelée
‘équation différentielle’, qui est représentée dans MATLAB par l’abréviation ‘ODE’. L’ordre de
cette équation est déterminé par l’ordre du degré le plus élevé de la dérivation.
Les équations différentielles peuvent être classée en deux catégories : les équations
différentielles avec des conditions initiales et les équations différentielles avec des conditions
aux limites.
2. Équations différentielles du 1er ordre
Les équations du 1er ordre à conditions initiales peuvent être écrites sous la forme :
où
est une fonction de et de , et la seconde équation représente la condition initiale
sans laquelle la solution de l’équation différentielle ne peut être évaluée.
Exemple 1 :
Soit à résoudre l’équation différentielle suivante :
où :
Déterminer numériquement
condition initiale
pour
.
. On choisit un pas de temps
, et on donne comme
. Tracer la solution de cette équation différentielle
Solution :
est équivalente à
L’équation
et
où
.
La solution de cette équation peut être effectuée par la méthode d’Euler, qui consiste à écrire :
Le programme MATLAB suivant (eul1.m) permet la résolution de cette équation :
%*******************************************
% Résolution d'une équation différentielle *
% par la méthode d'Euler à l'ordre 1
*
%*******************************************
clear ; clc ;
t=0 ;n=0 ;V=0 ;
C=0.27 ;M=70 ;g=9.81 ;h=0.1 ;
t_R(1)=t ;V_R(1)=V ;
while t<=20
n=n+1 ;
V=V+h*(-C/M*V.^2+g);
t=t+h;
t_R(n+1)=t;
V_R(n+1)=V;
end
plot(t_R,V_R);
xlabel('Temps (en s)');
ylabel('Vitesse (en m/s)');
grid on;
On obtient ainsi un graphique (fig. 1) qui donne l’évolution de la solution
temps.
Fig. 1 : évolution de la vitesse en fonction du temps
Exemple 2 :
en fonction du
On veut résoudre l’équation différentielle du 1er ordre suivante :
en utilisant les formules d’Adams ouvertes à l’ordre 1 et les formules d’Adams (prédicteurcorrecteur) pour un pas
. On donne la limite de convergence
.
•
Calculer
•
Ecrire un programme dans Matlab permettant de calculer et de tracer les résultats de ces
deux méthodes sur le même graphe,
•
Conclusion.
par les deux méthodes pour
Solution :
* Les formules d’Adams (prédicteur-correcteur) consiste à écrire la solution sous la
forme :
Dans ce cas, on a :
or
est inconnue ; donc
est aussi inconnue.
Dans ce cas, on utilise la méthode itérative suivante :
où
est la kième valeur itérée de
, et
résolution doit se faire de façon à ce que :
Si
, on obtient :
est une valeur arbitraire initiale de
. La
On arrête les calculs si
.
** Formules d’Adams ouvertes à l’ordre 1 (Méthode d’Euler) :
Pour la méthode d’Euler, la solution
est donnée par l’expression :
b) Le programme suivant ‘eul2.m’ permet d’inclure les 2 méthodes :
%*******************************************
% Résolution d'une équation différentielle *
% du 1er ordre par deux méthodes *
%*******************************************
clear;
clf;
hold off;
% Méthode d'Euler à l'ordre 1
y1(1)=10;t(1)=0;h=0.1;n=1;
while t(n)<1.5
n=n+1;
t(n)=t(n-1)+h;
y1(n)=y1(n-1)+h*(-y1(n-1).^1.5+1);
end
% Méthode du prédicteur-correcteur
ym(1)=10.5;t(1)=0;h=0.1;n=1;e=1e-4;n1=10000;
while t(n)<1.5
n=n+1;
t(n)=t(n-1)+h;
ym(n)=ym(n-1)+h*(-ym(n-1).^1.5+1);
% Itération succéssives et substitution
for k=1:n1
ymb=ym(n)+0.5*h*(-(ym(n)).^1.5-(ym(n-1)).^1.5+2);
if abs(ym(n)-ymb)<=e;
break;
printf('Erreur de (%d)=%f\n',k,abs(ym(n)-ymb));
end
if k==n1
fprintf('Pas de convergence pour t=%f\n',t(n));
end
end
end
fprintf('t=%f\t y1=%f\t ym=%f\n',t,y1,ym);
grid on;
hold on;
plot(t,y1,t,y1,'*');
plot(t,ym,'-r');
xlabel('t');ylabel('y');
gtext('***Méthode d''Euler (ordre 1)');
gtext('-Prédicteur-correcteur');
Après exécution du programme ci-dessus, on obtient le graphique de la figure 2 ci-dessous dans
lequel il y a les 2 solutions (méthode d'Euler et Méthode d'Adams).
Fig. 2 : Comparaison des deux méthodes de résolution numérique
3. Équations différentielles du second ordre
Ces équations sont du type :
où
,
et
et
sont des constantes ou des fonctions de .
sont des conditions initiales.
Avant d'appliquer la méthode d'Euler par exemple, on peut rendre l'équation précédente à une
équation du type 1er ordre. Dans ce cas, on pose
.
D'où :
Les conditions initiales deviennent :
où :
En faisant le calcul pas par pas, on obtient :
,
pour
,
pour
Ainsi, dans Matlab, le calcul pour chaque pas de temps peut être décrit par les matrices cidessous.
On définit au départ
et
par :
et
ensuite, on écrit
, et on résout l'équation :
Exemple :
Résoudre l'équation différentielle suivante :
avec :
On donne le pas
.
•
Calculer
•
Calculer, en utilisant un algorithme dans Matlab, la solution
différentielle précédente pour
.
•
Tracer l'évolution de
pour
en utilisant la méthode d'Euler à l'ordre 1 (calcul manuel).
pour
.
Solution :
•
a. Le système précédent peut être écrit sous la forme :
avec :
Pour
, on a :
,
,
de l'équation
•
b. Sous une forme vectorielle, l'équation précédente s'écrit :
où
La méthode d'Euler donne :
Le programme 'eul3.m', listé ci-dessous permet de calculer la solution
différentielle proposée :
%*******************************************
% Résolution d'une équation différentielle *
% du second ordre par la méthode d'Euler *
%*******************************************
clc;
clear;
clf;
hold off;
t_max=5;h=0.05;n=1;
y(:,1)=[0;1];t(1)=0;
while t(n)<t_max
y(:,n+1)=y(:,n)+h*def_f(y(:,n),t);yb=y;
t(n+1)=t(n)+h;
n=n+1;
end
axis([0 5 -1 1]);
plot(t,y(1,:),t,y(2,:),':r');
xlabel('Temps (en s)');ylabel('v(t) et u(t)');
gtext('Solution : v(t)');
L=length(t);
text(t(L-2),y(2,L-5),'Solution : u(t)');
de l'équation
La fonction 'def_f(y,t)' est un sous programme dont la liste est dressée ci-dessous :
%********************************
% Définition de la fonction : *
% def_f(y,t) *
%********************************
function f=def_f(y,t);
a=5;C=20;
f=[y(2);(-a*abs(y(2))*y(2)-C*y(1))];
La figure 3 ci-après donne l'évolution des solutions
et
. La solution
oscille
autour de 0 et tend à s'amortir au fur et à mesure que le temps t augmente. On pourrait
éventuellement utiliser une autre méthode de résolution numérique pour chercher
.
À titre d'exemple, essayer d'utiliser la méthode itérative d'Adams (Prédicteur-Correcteur) pour
retrouver la solution
.
Comparer cette solution à celle d'Euler à l'ordre 1.
Fig. 3 : évolution des solutions
4. Méthode de Runge-Kutta
4.1. Méthode de Runge-Kutta du second ordre
et
en fonction du temps
Elle est de la forme :
ou bien sa forme standard peut être écrite ainsi :
Cette méthode est équivalente à celle d'Euler à deux itérations seulement.
Exemple :
Une plaque métallique épaisse à la température de 200°C (ou 473°K) est soudainement placée
dans une chambre de 25°K, où la plaque est refroidie à la fois par la convection naturelle et le
transfert radiatif de chaleur. On donne les constantes physiques suivantes :
En supposant que la distribution de température dans le métal est uniforme, l'équation donnant la
température en fonction du temps est :
Résoudre cette équation différentielle par la méthode de Runge-Kutta à l'ordre 2 pour
et
.
Solution :
La liste du programme 'RK2.m' est la suivante :
%*************************************
% Méthode de Runge-Kutta à l'ordre 2 *
%*************************************
clear;clf;clc;hold off;
ro=300;V=0.001;A=0.25;C=900;hc=30;
epsi=0.8;sig=5.67e-8;i=1;
h=1;T(1)=473;t(1)=0;
Av=A/(ro*C*V);Epsg=epsi*sig;
while t(i)<180
k1=h*fonc_(T(i),Av,Epsg,hc);
k2=h*fonc_(T(i)+k1,Av,Epsg,hc);
T(i+1)=T(i)+0.5*(k1+k2);
t(i+1)=t(i)+h;
i=i+1;
end
plot(t,T);grid on;xlabel('Temps (en s)');
ylabel('Température (en °K)');
La fonction 'fonc_.m' est un sous programme dont la liste est :
%***************************
% Sous programme : fonc_.m *
%***************************
function f=fonc_(T,Av,Epsg,hc);
f=Av*(Epsg*(297^4-T^4)+hc*(297-T));
La solution
obtenue de l'équation différentielle précédente est donnée par la figure 4 ciaprès. Ainsi, la température obtenue, décroît en fonction du temps d'une façon hyperbolique.
Fig. 4 : évolution de la température du métal en fonction du temps
4.2. Méthode de Runge-Kutta à l'ordre 4
Cette méthode s'exprime sous la forme :
et la solution
est donnée par :
Exemple 1 :
Résoudre le système suivant par la méthode de Runge-Kutta à l'ordre 4 :
avec les conditions initiales suivantes :
On donne :
Les constantes sont égales à :
Solution :
Si on définit :
;
et
, le système précédent devient :
Ce système peut s'écrire sous la forme matricielle suivante :
où
et :
Le programme suivant 'RK4.m' permet la résolution du système précédent :
%*************************************
% Méthode de Runge-Kutta à l'ordre 4 *
%*************************************
clear;clc;clf;
M1=1;M2=1;M3=1;
K1=1;K2=1;K3=1;
F1=0.01;F3=0;F=[0 0 0 F1/M1 0 F3/M3]';
B1=0.1;B3=0.1;h=0.1;
y(:,1)=[0 0 0 0 0 0]';t(1)=0;i=1;
C=[0 0 0 1 0 0;
0 0 0 0 1 0;
0 0 0 0 0 1;
-K1/M1 K2/M1 0 -B1/M1 B1/M1 0;
K1/M2 -(K1+K2)/M2 K2/M2 B1/M2 -B1/M2 0;
0 K2/M3 -(K2+K3)/M3 0 0 -B3/M3];
while t<=30
k1=h*f1m(y(:,i),C,F);
k2=h*f1m(y(:,i)+k1/2,C,F);
k3=h*f1m(y(:,i)+k2/2,C,F);
k4=h*f1m(y(:,i)+k3,C,F);
y(:,i+1)=y(:,i)+(1/6)*(k1+2*k2+2*k3+k4);
t(i+1)=i*h;
i=i+1;
end
plot(t,y(1:3,:));
grid on;
text(t(70),y(1,70),'y1');
text(t(70),y(2,70),'y2');
text(t(70),y(3,70),'y3');
xlabel('Temps (en s)');
ylabel('Solutions,y1, y2, y3');
La fonction 'f1m.m' est le sous programme listé ci-dessous :
%*****************
% Fonction f1m.m *
%*****************
function f=f1m(y,C,F);
f=C*y+F;
Après exécution du programme 'RK4.m', on obtient le graphe suivant donnant les solutions
) recherchées.
(
Fig. 5 : évolution des trois solutions
,
et
Exemple 2 :
Une baguette de longueur 0,2 m (
) est placée dans un écoulement d’air à la température
de 293°K. La température à gauche de la baguette (en x=0) est maintenue égale à 493°K, mais le
côté droit est isolé. Le transfert de chaleur dans la baguette se fait par convection. Déterminer la
distribution de la température le long de l’axe de la baguette, sachant que les caractéristiques du
matériau constituant cette baguette sont :
Solution :
L'équation de la conduction de la chaleur dans la direction de l'axe
par :
de la baguette est donnée
avec les conditions aux limites suivantes :
La température de l'air est à 293 °K.
Ce problème est à conditions aux limites en
et
les conditions aux limites en conditions initiales.
. Pour le résoudre, on doit rendre
On définit :
Ainsi, l'équation différentielle (1er ordre) ci-dessus à conditions aux limites peut être rendue en
une équation différentielle du 1er ordre à conditions initiales, en posant :
Seule, une condition initiale est connue à partir des conditions aux limites, mais la seconde
condition initiale qui doit être
reste inconnue.
Cependant, on peut résoudre l'équation en faisant une transformation de la condition aux limites
connue
en une condition initiale
.
Ainsi, on cherche la valeur
donner
de telle sorte que
permet de
.
Le programme suivant 'RK4pcl.m' permet de calculer
pour chaque
valeur arbitraire de introduite par l'intermédiaire du clavier. Une fois cette valeur satisfait la
condition
, on peut arrêter les calculs en tapant la valeur –99999.
clear;clc;clf;
while 1
y2=input('Donner le type du gradient, y2(0);ou -99999 pour quitter : ');
if y2<-88888
break;
end
A=0.0001;P=0.01; hc=120;k=60;b=293;l=0.2 ;
a=P*l*hc/A/k;
i=1;x(1)=0;h=0.01;
y(:,1)=[493;y2];
while x<=0.3
k1=h*f2m(y(:,i),x(i),a,b);
k2=h*f2m(y(:,i)+k1/2,x(i)+h/2,a,b);
k3=h*f2m(y(:,i)+k2/2,x(i)+h/2,a,b);
k4=h*f2m(y(:,i)+k3,x(i)+h,a,b);
y(:,i+1)=y(:,i)+(1/6)*(k1+2*k2+2*k3+k4);
x(i+1)=i*h;
if (x(i)-0.2001)*(x(i)-0.1999)<0
y2_fin=y(2,i+1);
break;
end
i=i+1;
end
% y2_fin =(y(1,n+1)-y(1,n))/h;
plot(x,y(1,:),'-',x,y(2,:)/10,':');
xlabel('x (en m)');ylabel('y:- et v/10:...');
text(0.15,-200,['y2(0.2)=',num2str(y2_fin)]);
text(0.02,-200,['Val. arb. y2(0)=',num2str(y2)]);
text(x(10),y(1,10)-20,'y1(x)');
text(x(10),y(2,10)/10-20,'y2(x)/10');
axis([0 0.2 -300 500]);
end
La fonction 'f2m.m' est un sous programme permettant l'obtention de la fonction f :
function f=f2m(y,x,a,b);
f=[y(2);a*(y(1)-b)];
Après exécution du programme 'RK4pcl.m'; on obtient la figure 6 sur laquelle se trouvent les
solutions
et
.
Fig. 6 : évolution des solutions
et
pour
5. Méthode Matricielle avec des "Conditions aux Limites"
Considérons l'équation de la conduction de la chaleur selon la direction
où la condition initiale est :
et les conditions aux limites sont :
:
En utilisant les différences finies, l'équation différentielle ci-dessus s'écrit :
,
où
est le nombre d'intervalles sur
,
et
.
Dans ce cas, les conditions aux limites s'écrivent :
On obtient ainsi le système suivant :
où
et
sont des vecteurs colonnes et
;
est une matrice carrée d'ordre
, définis ci-après :
et
Ce système peut être résolu par la méthode de Runge-Kutta par exemple.
Exemple 1 :
La température d'une barre de fer de longueur
est initialement à la température de
.
La température du côté gauche est soudainement réduite à
à
, mais la température
du côté droit est maintenue constante à
. Tracer la l'évolution de la température dans
la barre à chaque intervalle de temps égal à
, et ceci jusqu'à
(c'est à
dire :
,
,
,
,
,
).
Les propriétés thermiques du matériau sont :
Solution :
La diffusivité thermique est calculée par :
Pour chercher l'évolution de la température dans la barre, on divise l'intervalle
en 49 petits
intervalles (par exemple). L'équation différentielle à résoudre est celle de la chaleur définie
précédemment.
Les valeurs des conditions aux limites sont
et
telles que :
Le programme suivant ('RK4cc.m'), utilise la méthode de Runge-Kutta à l'ordre 4 pour la
résolution de l'équation aux dérivées partielles de la conduction de la chaleur suivant la
direction et en fonction du temps.
%*************************************************
% Conduction de la chaleur dans une barre de fer *
%*************************************************
clear;clf;clc;hold off;
k=80.2;ro=7870;Cp=447e3;TL=0;TR=200;
alpha=k/ro/Cp;dx=(50-1)/49;
%*******************************
% Construction de la matrice A *
%*******************************
A(1,1:2)=[-2 1];A(1,3:50)=0;
A(50,1:48)=0;A(50,9:10)=[1 -2];
for i=2:49
for j=1:50
if i<j-1 & j>i+1
A(i,j)=0;
end
if i==j
A(i,j)=-2;
A(i,j-1)=1;
A(i,j+1)=1;
end
end
end
M=A*alpha*1/dx^2;
S(1)=TL;S(50)=TR;S(2:49)=0;S=S*alpha/dx^2;S=S';
T(1:50)=40;
T=200*ones(T);
T=T';
n=0;t=0;h=20;m=0;
axis([0 10 0 220]);
j=[0,1:length(T),length(T)+1];
T_p=[TL,T',TR];
plot(j,T_p);
text(j(2),T_p(2),['t=',int2str(t),'s']);
xlabel('i : Nombre de points');
ylabel('T (en °C)');
for k=1:5
for m=1:50
n=n+1;
k1=h*(A*T+S);
k2=h*(A*(T+k1/2)+S);
k3=h*(A*(T+k2/2)+S);
k4=h*(A*(T+k3)+S);
T=T+(k1+2*k2+2*k3+k4)/6;
t=h*n;
end
hold on;
j=[0,1:length(T),length(T)+1];
T_p=[TL,T',TR];
plot(j,T_p);
text(j(k+1),T_p(k+1),int2str(t));
end
Exemple 2 :
Étude de la répartition de la température dans les parois un four
On considère un four dans le plan de la section droite représentés ci-dessous. On appelle
surface interne du four et
la
la surface externe.
En régime permanent, la température
Laplace :
en un point
de la paroi vérifie l'équation de
avec les conditions aux limites suivantes :
Fig. 7 : Géométrie et maillage des parois du four
- Ecrire un programme calculant la température
définie sur la figure 7 ci-dessus (figure en haut).
On suppose que les dimensions
,
,
et
de la paroi du four aux points de la grille
permettent ce quadrillage.
Application Numérique :
et :
Solution :
Équation de Laplace :
avec :
Le développement en série de Taylor de la fonction
s'écrit :
autour de
En additionnant ces deux relations et en divisant par
, on trouve :
En opérant de la même manière pour la variable
, on trouve :
où
Dans notre cas, on a
. Donc, le Laplacien bidimensionnel s'écrit :
On pose :
Pour simplifier la notation, l'expression précédente s'écrit sous la forme :
(*)
Cette équation peut être représentée par la forme moléculaire suivante :
Pour
et
par exemple, on obtient 26 nœuds à l'intérieur du domaine (fig. 7).
Donc,
, où
(et
;
est l'ensemble des points intérieurs du domaine
sur
et
sur
).
Écrivons les premières et dernières lignes du système (*) :
Remarquons que :
et que :
On a le système suivant alors :
On a donc un système de 26 équations à 26 inconnues. Donc, ce système (ou l'équation de
Laplace discrétisée) peut être résolu(e) par la méthode de Gauss-Seidel (méthode explicite) où
l'équation de Laplace donne le point central de chaque forme moléculaire par l'expression :
(**)
Remarque :
Avec l'algorithme précédent (**), il est inutile de mémoriser explicitement la matrice du système
(*). Il suffit de mémoriser la température
de chacun des points de la grille.
Définissons les valeurs particulières des indices correspondants aux parois de la figure 8
suivante :
Fig. 8 : Définition des indices caractérisant les parois
Le programme suivant appelé 'laplace.m' permet de résoudre le système (**) par la méthode
explicite. Pour cela, on se donne une valeur (distribution) arbitraire initiale
l'équation (**) au second membre pour chaque couple
ainsi de suite. L'arrêt des calculs se fait quand
convergence que l'on se donne.
, donne une nouvelle valeur
où
est la limite de
%*****************************************
% Etude de la répartition de température *
% dans les parois d'un four *
% Résolution d'un système linéaire par *
% la méthode itérative de Gauss-Seidel *
% Méthode explicite *
%*****************************************
tic;
flops(0);
clear all; clc;clf;
eps=1e-4;k1=300;
% Données initiales
L1=input ('Introduire la valeur de L1 :\n');
L2=input ('Introduire la valeur de L2 :\n');
L3=input ('Introduire la valeur de L3 :\n');
L4=input ('Introduire la valeur de L4 :\n');
dx=input ('Introduire la valeur du pas dx :\n');
Thetaint=input ('Introduire la valeur de Theta interne :\n');
Thetaext=input ('Introduire la valeur de Theta externe :\n');
% Calcul des indices
m=round(L1/dx)+1;
n=round(L2/dx)+1;
m1=round((L1-L3)/(2*dx))+1;
n1=round((L2-L4)/(2*dx))+1;
m2=m1+round(L3/dx);
n2=n1+round(L4/dx);
% Initialisation de la température dans le four
for i=1:n
for j=1:m
T(i,j)=Thetaint;
, qui portée dans
, et
end
end
% Température de la paroi externe
for i=1:n
T(i,1)=Thetaext;
T(i,m)=Thetaext;
end
for j=1:m
T(1,j)=Thetaext;
T(n,j)=Thetaext;
end
% Température de la paroi interne
for i=n1:n2
T(i,m1)=Thetaint;
T(i,m2)=Thetaint;
end
for j=m1:m2
T(n1,j)=Thetaint;
T(n2,j)=Thetaint;
end
% Méthode de Gauss-Seidel (Itérations)
for k=1:k1
for i=2:n-1
for j=2:m1-1
T(i,j)=0.25*(T(i-1,j)+T(i+1,j)+T(i,j-1)+T(i,j+1));
end
end
for i=2:n-1
for j=m2+1:m-1
T(i,j)=0.25*(T(i-1,j)+T(i+1,j)+T(i,j-1)+T(i,j+1));
end
end
for i=2:n1-1
for j=m1:m2
T(i,j)=0.25*(T(i-1,j)+T(i+1,j)+T(i,j-1)+T(i,j+1));
end
end
for i=n2+1:n-1
for j=m1:m2
T(i,j)=0.25*(T(i-1,j)+T(i+1,j)+T(i,j-1)+T(i,j+1));
end
end
if abs(T(n-1,m-1)-T(2,2))<=eps
fprintf('\n \n');
fprintf('Températures après "%d itérations\n',k);
fprintf('\n \n');
break;
end
end
for i=1:n
fprintf('%5.0f\t',T(i,1:m));
fprintf('\n');
end
% Tracé des courbes de température en 3D
hold off;
if n==m
figure(1);
i=1:n;
j=1:m;
grid on;
[x,y]=meshgrid((i-1)*dx,(j-1)*dx);
mesh(x,y,T);
Title('Evolution de la température dans le four');
xlabel('i');ylabel('j');zlabel('T (en °C)');
end
% Tracé des courbes isothermes en 2D
figure(2);
i=1:n;j=1:m;
grid on;
contour(i,j,T(i,j),15);
title('Lignes isothermes dans les parois du four');
xlabel('i');ylabel('j');
t_mis=toc
Nb_opt=flops
On exécute ce programme (laplace.m), en rentrant les valeurs
de
,
,
,
,
>>Introduire la valeur de L1 :
60
Introduire la valeur de L2 :
60
Introduire la valeur de L3 :
20
Introduire la valeur de L4 :
20
Introduire la valeur du pas dx :
1
Introduire la valeur de Theta interne :
1220
Introduire la valeur de Theta externe :
35
et enfin
et
.
t_mis=
113.9700
Nb_opt=
7362728
Fig. 9 : Évolution en 3D de la température dans les parois du four
Fig. 10 : Lignes isothermes dans les parois du four
6. Conversion de coordonnées
Dans Matlab, il existe plusieurs commandes pour la conversion des coordonnées. Nous en
donnons ci-après un bref apperçu.
6.1. Coordonnées polaires
Les fonctions 'cart2pol' et 'pol2cart' permettent respectivement le passage des coordonnées
cartésiennes en coordonnées polaires et inversement. Les syntaxes sont :
>>[theta,r]=cart2pol(x,y)
>>[x,y]=pol2cart(theta,r)
et doivent être des vecteurs de même taille représentant les coordonnées des points
considérés,
r et
que
représentent les coordonnées polaires et sont des vecteurs de mêmes dimensions
et , où
est exprimée en radians.
6.2. Coordonnées cylindriques
Les fonctions 'cart2pol' et 'pol2cart' permettent respectivement le passage des coordonnées
cartésiennes en coordonnées cylindriques et inversement. Les syntaxes sont :
>>[theta,r,z]=cart2pol(x,y,z)
>> [x,y,z]=pol2cart(theta,r,z)
,
et
et
radians.
sont des vecteurs de même taille,
sont des vecteurs de mêmes dimensions que
,
et
, et
est exprimée en
6.3. Coordonnées sphériques
Les fonctions 'cart2sph' et 'sph2cart' permettent respectivement le passage des coordonnées
cartésiennes en coordonnées sphériques et inversement. Les syntaxes sont :
>>[Az,Elv,r]=cart2sph(x,y,z)
>>[x,y,z]=sph2cart(Az,Elv,r)
r, , et sont des vecteurs de même taille,
et
sont respectivement l'azimut et
l'élévation exprimées en radians, de mêmes dimensions que , et .
7. Problèmes en Coordonnées Cylindriques
Considérons l'équation de la conduction de la chaleur exprimée en coordonnées cartésiennes :
En coordonnées polaires, cette équation s'écrit sous la forme :
sur la domaine
Sur ce domaine
, on construit un maillage en coordonnées polaires
figure 11 ci-dessous, avec
et
où et
sont des entiers.
comme le montre la
Fig. 11 : Système de maillage en coordonnées polaires
Ainsi, la température
et la fonction
deviennent au point
Pour des valeurs non nulles de , les dérivées secondes de
s'écrivent sous la forme disrétisée suivante :
En utilisant les différences centrées,
peut s'écrire au point
Ainsi, l'équation de la chaleur discrétisée est :
Soit, après regroupement des différents termes :
:
par rapport à
sous la forme :
et
C'est l'équation de conduction de la chaleur discrétisée (différences finies) en coordonnées
cylindriques, obtenue pour des valeurs de non nulles (
). Les indices i et sont des
entiers (commençant par 1 dans Matlab).
A l'origine (
), l'équation de la conduction en coordonnées polaires présente une singularité.
Cette dernière doit être éliminée. Pour cela, on utilise le Laplacien de l'équation de la conduction
non pas en coordonnées cylindriques, mais en coordonnées cartésiennes :
quand
On construit ensuite un cercle de rayon
, centré en
. Considérons
la température
à
, et , ,
et
sont les températures sur le cercle aux 4 nœuds (intersection avec les
et oy). Ainsi, l'équation précédente (en coordonnées cartésiennes) s'écrit sur le cercle de
axes
rayon
:
La rotation des axes
et oy autour de
conduit aux mêmes résultats (équation de la
chaleur en coordonnées cartésiennes discrétisée). En considérant
comme la moyenne
arithmétique des températures autour du cercle de rayon
, l'équation précédente devient :
à
où
centre
est la moyenne arithmétique des valeurs de
et
est la valeur de la température à
Les coordonnées polaires
autour du cercle de rayon
et de
.
-deux dimensions- peuvent être extrapolées en coordonnées
cylindriques
(trois dimensions) pour l'obtention de l'équation de la conduction de la
chaleur discrétisée.
Pour le problème bidimensionnel en
évoqué précédemment, compte tenu de la symétrie
axiale, l'équation de la conduction de la chaleur peut être réduite à :
Pour
, l'équation précédente discrétisée s'écrit sous la forme :
où
,
Au centre (
, et
est un entier positif.
), en utilisant la règle de l'Hopital nous obtenons :
Ainsi l'équation de la conduction de la chaleur en deux dimensions
la symétrie axiale du problème :
s'écrit compte tenu de
en
Soit en différences finies :
pour
En coordonnées cylindriques, l'équation de la conduction de la chaleur est donnée par
l'expression suivante :
Les coordonnées
où et
La température
sont représentées par :
sont des entiers.
au nœud
est notée par :
et les différentes dérivées partielles deviennent :
L'équation de la chaleur discrétisée en coordonnées cylindriques au nœud
pour des valeurs de
Pour
devient :
non nulles.
, on a :
et l'équation de conduction en
devient :
en
Soit en utilisant les différences finies au nœud
:
8. Discrétisation de l'équation de la Conduction en régime instationnaire
Dans le système de coordonnées cartésiennes (trois dimensions), l'équation de conduction de la
):
chaleur en régime instionnaire (temporel) s'écrit (si
Pour résoudre cette équation aux dérivées partielles en utilisant la méthode des différences finies,
on utilise un maillage cubique (mailles de côtés
avec :
où , et sont entiers positifs, et le domaine temporel est divisé en petits intervalles de
de telle sorte que :
temps
Dans ce cas, la température
par :
au point P(x,y,z) à un temps donné
est représentée
En utilisant la méthode des différences finies, les différents termes de l'équation ci-dessus au
dérivées partielles s'écrivent au point P(x,y,z) :
et l'équation de la conduction discrétisée en trois dimensions devient :
En regroupant les différents termes de cette équation, on obtient :
Cette équation ne peut être résolue que par une méthode itérative (méthode de Gauss-Seidel par
exemple).
Si on pose :
alors, la condition de convergence de la solution recherchée dépend essentiellement du signe de
la quantité . Cette quantité doit être strictement positive.
Ainsi, une condition doit relier le pas de temps
et les autres pas spatiaux (
Pour amorcer le calcul itératif, on ensemence le domaine de frontière
arbitraires (
réalisée :
où
,
et
):
par des valeurs
par exemple), et on arrête les calculs quand la condition suivante sera
est la précision que l’on se fixera.
Was this manual useful for you? yes no
Thank you for your participation!

* Your assessment is very important for improving the work of artificial intelligence, which forms the content of this project

Download PDF

advertising