Apprendre_MATLAB

Introduction au logiciel MATLAB Version 6 et 6.5 ALIA. Med

2

CHAPITRE E

LES EXPRESSIONS Comme la plupart des autres langages de programmation, MATLAB fournit des expressions mathématiques, mais à la différence de la plupart des langages de programmation, ces expressions impliquent les matrices entières. Les modules des expressions sont : **- Variables **- Numbers **- Operators **- Functions **E.1: ..-Les variables: MATLAB n'exige aucun type déclarations ou rapports de dimension. Quand MATLAB rencontre un nouveau nom variable, il crée automatiquement la variable et assigne la quantité appropriée de stockage. Si la variable existe déjà, MATLAB change son contenu et, au besoin, assigne le nouveau stockage. Par exemple: num_students = 25 Crée une matrice 1-par-1 appelée num_students et stocke la valeur 25 dans son simple élément. Les noms variables se composent d'une lettre, suivie de tout nombre de lettres, des chiffres, ou des soulignages. MATLAB emploie seulement les 31 premières lettres de l'alphabet pour designer les variables. MATLAB est sensible; il distingue les lettres majuscules et minuscules. A et a ne sont pas la même variable. Pour visualiser la matrice assignée à la variable, il suffit d'écrire simplement le nom de la variable. ** E.2 : ..- Les Nombres: MATLAB emploie la notation décimale conventionnelle, avec une virgule décimale et des signes (facultatifs pour les positifs) ou sans le signe, pour des nombres. La notation scientifique emploie la lettre e pour indiquer la puissance de dix. Les nombres imaginaires emploient i ou j comme suffixe. Quelques exemples des nombres légaux sont : 3 -99 0.0001 9.6397238 1.60210e-20 6.02252e23 1i -3.14159j 3e5i Tous les nombres sont stockés intérieurement en utilisant le format long indiqué par la norme à point mobile. Les nombres à point mobile ont une précision finie d'approximativement 16 chiffres décimaux significatifs et d'une gamme finie approximativement de 10.^-308 à 10.^308. **E.3 : ..- Les opérateurs: Les expressions emploient les opérateurs arithmétiques familiers et les règles de priorité. + Addition ; - Subtraction ; * Multiplication / Division ; \ Left division ; ^ Power ' Complex conjugate transpose; ( ) Specify evaluation order **E.4 : ..- Les fonctions: MATLAB fournit un grand nombre de fonctions mathématiques élémentaires standard, y compris l'abs, le sqrt, l'exp, le sinus,... Le calcul de la racine carrée ou du logarithme d'un nombre négatif n'est pas une erreur ; le résultat est un complexe approprié et automatiquement produit. MATLAB fournit également beaucoup plus de fonctions mathématiques avancées, y compris celles Bessel et la fonction gamma. La plupart de ces fonctions acceptent des arguments complexes. Pour prendre connaissance de la liste des fonctions mathématiques élémentaires, taper la commande "help elfun". Pour une liste des fonctions mathématiques les plus avancées, taper la commande "help specfun". Pour les matrices, taper "help elmat". Certaines fonctions, comme la sqrt (la racine carré) et le sinus, sont intégrées. Elles font partie du noyau de MATLAB ainsi elles sont très efficaces, mais les détails de leur programmation ne sont pas aisément accessibles. D'autres fonctions, comme gamma et le sinh (sinus hyper), sont mises en application (programmées) dans les M-files. On peut voir leurs codes et même les modifier à convenance. Plusieurs fonctions spéciales fournissent des valeurs des constantes utiles:


3

pi 3.14159265... ; i ou j imaginaire eps : Floating-point relative precision=2.^-52 eps : la plus petite valeur pour les testes realmin : le plus petit nombre à virgule flottante= 2.^1022=2.2251e-308 realmax : le plus grand nombre à virgule mobile= 1.7977e+308 inf : infini,est produit lors du déplacement de realmax ou lors de la division d'un nombre non nulle par zéro NAN : Non Nombre lorsque il n'y a pas de chiffre à afficher Les noms de ces fonctions ne sont pas réservés. Il est possible de recouvrir à n'importe laquelle avec une nouvelle variable, comme eps = 1.e-6, et employer alors cette valeur dans les calculs suivants. La fonction originale peut être reconstituée à l’aide de la commande : clear eps **E.5: ..- Exemples d'expression: 1°) ali=(1+sqrt(5))/2 | 2°) a=abs(3+4i) ali= | a= 1.6180 | 5 3°) z=sqrt(besselk(4/3,ali-1)) |4°)ahmed=exp(log(realmax)) z= | ahmed= 0.3730+0.3214i | 1.7977e+308 5°)Salim=pi*ahmed | Salim= | Inf |

CHAPITRE - M - MANIPULATION DES MATRICES

**M.1: ..- Saisir une matrice : ================ Pour écrire une matrice: A=[1 2 3;4 5 6;7 8 9] Ou bien A=[1,2,3;4,5,6;7,8,9] Ou A=[1 2 3 � Pour passer à la ligne suivante utiliser la touche entrée 4 5 6 7 8 9] Pour générer la matrice magique d'ordre n il suffit de taper: B=magic(n) =>Ex : C=magic(6) ; donne: c = 35 1 6 26 19 24 3 32 7 21 23 25 31 9 2 22 27 20 8 28 33 17 10 15 30 5 34 12 14 16 4 36 29 13 18 11 **M.2: ..- Saisir un Vecteur : ================ M.2.1--Vecteur ligne: X=[x

1 x

2 x

3 x

4 ... x

n] ; => Ex : T= [10 11 21 35]

Ou bien X=[x1,x

2,x

3,x

4,...,x

n] ; => Ex : T= [10,11,21,35]

Ce qui donne: T = 10 11 21 35


4

M.2.3--Vecteur colonne:

Y=[y1;y

2;y

3;...;y

n]; => Ex :S=[10;11;21;35]

Donne le résultat: S = 10 11 21 35 **M.3: ..- Manipulation à l'intérieur d'une matrice : ================================= Opérateurs : a) (+) Addition de matrices. A + B addition de A et B. Les matrices A et B doivent avoir les mêmes dimensions, à moins qu'on soit en présence de scalaires. b)( -) Soustraction de matrices. A - B soustrait B de A. A et B doit avoir les mêmes dimensions, à moins que l'un soit un scalaire. c) (*) Multiplication de matrice. A*B est le produit algébrique linéaire de A et le nombre de colonnes de B. Le nombre de colonne de A doit égaler le nombre de rangées (ou de lignes) de B, à moins que l'un soit une grandeur scalaire. d) Multiplication de rangées (ou de ligne) A.*B est le produit d'entrée-par-entrée (remarquer le point après A et avant le signe*) de A et B. A et B doit avoir les mêmes dimensions, à moins que l'un soit un scalaire. e) (\) Division destinée pour les matrices de types X = A\B qui résout les équations linéaires symboliques du problème fréquent : A*X=B. Noter qu'A\B est rudement équivalent à inv(A)*B. Des messages d'avertissement sont produits si X n'existe pas ou n'est pas unique. Les matrices rectangulaires A sont permises, mais les équations doivent être conformes ; une solution des moindres carrés ne peut pas être calculée. f) (.\) Division à gauche par rangée. A.\B est la matrice avec des entrées B(i, j)/A(i, j). A et B doivent avoir les mêmes dimensions, à moins qu'on soit scalaire. g) / Division à droite de matrice. X=B/A résout l'équation linéaire symbolique X*A=B. Noter que B/A est identique à (A.'\B.'). Des messages d'avertissement sont produits si X n'existe pas ou n'est pas unique. Les matrices rectangulaires sont permises, mais les équations doivent être conformées ; une solution des moindres carrés ne peut pas être calculée. h) (./) Division à droite des lignes de A par B. le quotient de A./B est la matrice avec des entrées A(i, j)/B(i, j). A et B doivent avoir les mêmes dimensions, à moins que l'un soit un scalaire. i) (^) Puissance de matrice. X^P élève la matrice carrée X à la puissance P .Si X est une grandeur scalaire et P une matrice carrée, X^P élève la matrice X à la puissance P , en utilisant des valeurs propres et des vecteurs propres. Avec X^P, où X et P sont les deux des matrices, un message d'erreur est produit. j) (. ^) Puissance des lignes. A.^B est la matrice avec des entrées A(i, j)^B(i, j). A et B doivent avoir les mêmes dimensions, à moins que l'un soit un scalaire. k) (') La matrice Hermitienne transposée. Si A est complexe, A 'est la transposé du complexe conjugué. l) (.') La transposée des lignes. A.' est le transposé du réel A. A.' ne donne pas le conjugué des entrées complexes. M.3.1--Calcul de la somme de tous les éléments des colonnes: Soit la matrice A=[a

11,a

12,a

13,...,a

1n

a21

,a22

,a23

,...,a2n

. . . . . . . . . . . . . a

n1,a

n2,a

n3,....,a

nm]

La commande : sum(A) donne le résultat: sum(A)= a

11+a

21+a

31+...+a

n1 ; a

12+a

22+a

32+a

42+...+a

n2 ; ... ...; a

1n+a

2n+a

3n+...+a

mn

=> Ex: alpha=[1 2 3 4 5 6 7 8 9] sum (alpha) Donne le résultat : sum(alpha) ans = 12 15 18 M.3.1--Transposition: Définition : Transposer c'est rendre les lignes des colonnes M.3.1.1--Pour transposer le vecteur X il suffit de donner la commande X' M.3.1.2--Pour transposer la matrice N il suffit de donner la commande N'


5

=> Ex : Alpha' donne alpha' ans = 1 4 7 2 5 8 3 6 9 M.3.2--Affichage des éléments de la diagonale d'une matrice: La commande est : daig(A) => Ex:A=[11 21 13 36 39 38 25 28 227] Produit le résultat: diag(A) ans = 11 39 227 M.3.3--Inverser l’ordre d'écriture des colonnes d'une matrice : La commande est : fliplr(A) => Ex : C=[35 1 6 26 19 24 3 32 7 21 23 25 31 9 2 22 27 20 8 28 33 17 10 15 30 5 34 12 14 16 4 36 29 13 18 11] fliplr(C) ans = 24 19 26 6 1 35 25 23 21 7 32 3 20 27 22 2 9 31 15 10 17 33 28 8 16 14 12 34 5 30 11 18 13 29 36 4 M.3.4.--Affichage d'un élément : La commande est A(i,j); cela affiche l'élément dont les indices sont i et j. A(i,j) : Signifie afficher l'élément qui se trouve dans : la ieme ligne | la jeme colonne ; => Ex : A(5,4) : Affichera le 5eme élément de la 4eme colonne. M.3.5--Affichage d'une colonne : A(:,j) ; où j est la colonne à afficher M.3.6--Addition, soustraction, multiplication de certains éléments d'une matrice: Il faut indiquer chaque élément par ses indices (A(i,j); i= le ieme élément, de la jieme=colonne où il se trouve)et indiquer l'opération à effectuer. => Ex: a) B(1,3)+B(5,4)+B(1,5) b) B(1,2)-B(4,1)+b(6,4) c) B(1,1)/B(2,3)+B(4,8)*B(2,2) => Ex numérique : A = 1 2 3 4 5 6 7 8 9 B= 10 11 12 13 14 15 16 17 18


6

1°) A(1,2)+A(3,3)+A(2,1) ans = 15 2°) A(1,2)+A(3,3)+A(2,1)-B(1,1)*A(3,2) ans = -65 3°) t=A(2,1) t = 4 4°) X=A; X = 1 2 3 4 5 6 7 8 9 X(2,1) ans = 4 **M.4: ..- Inversion de matrice : =================== Pour cela il suffit de taper la commande: inv(A), où A est la matrice à inverser. ==> Ex:B = 17 24 1 8 15 23 5 7 14 16 4 6 13 20 22 10 12 19 21 3 11 18 25 2 9 D=inv(B) D = -0.0049 0.0512 -0.0354 0.0012 0.0034 0.0431 -0.0373 -0.0046 0.0127 0.0015 -0.0303 0.0031 0.0031 0.0031 0.0364 0.0047 -0.0065 0.0108 0.0435 -0.0370 0.0028 0.0050 0.0415 -0.0450 0.0111 Remarque :Il faut vérifier le produit par : B*inv(B) ;qui doit donner la matrice identité I = D*B ans = 1.0000 -0.0000 -0.0000 -0.0000 0.0000 -0.0000 1.0000 0 -0.0000 0.0000 0 0.0000 1.0000 0.0000 0.0000 0.0000 0.0000 -0.0000 1.0000 0.0000 0.0000 0.0000 0.0000 0.0000 1.0000 **M.5: ..- Définir une matrice à partir d'une autre : =============================== Si l'on veut définir la matrice A à partir de certaines colonne de B la commande à utiliser est : A=B (:,[k

1 k

2 k

3]) Où k

1, k

2, k

3... sont les indices des lignes

==> Ex : B=magic(5) A=B(:,[1 3 2]) B=magic(5) B = 17 24 1 8 15 23 5 7 14 16 4 6 13 20 22 10 12 19 21 3 11 18 25 2 9 A=B(:,[1 3 2])


7

A = 17 1 24 23 7 5 4 13 6 10 19 12 11 25 18 Remarques : Pour plus d’information: 1°) Taper "help elmat" 2°)taper: a) pascal(5,0); b)pascal(5,1); c)pascal(5,2) d) pascal(5,3) **M.6: ..- Générer des matrices particulières : =========================== M.6.1 Matrice nulle, la commande est : zeros(n,m) ===> Ex : zeros(3,6) M.6.2 Matrice unité, la commande est: ones(n,m) ===> Ex : ones(4,5) M.6.3 Matrice Normale (loi normale) mais aléatoire, la commande est: randn(n,m) ===> Ex : randn(3,5) M.6.4 Matrice uniforme, la commande est:rand ===> Ex : rand(6,3) M.6.5 On peut utiliser les commandes suivantes. a°) F=5*ones(n,m) ===> Matrice unité multipliée par 5. b°) N=fix(10*rand(1,10)) ===> Affiche les parties fixes des chiffres. M.6.6 Utiliser les crochets [ ] pour générer des tableaux ou de matrices; pour cela on procédera de la manière suivante : a°) Définir une série de valeur comme par exemple : x=(pi:pi/10:2*pi)' b°) Définir les séries de valeurs, par des expressions mathématique, que le tableau doit contenir; sous la forme : nomination=[expression1 expression 2 ... expression n] où "nomination" désigne le nom du tableau (Ex : T1, Ahmed,...) expression1, expression 2,...sont des expressions telle que : sin(x), x.^3,2*x, exp(x.^3)... M6.7 Utiliser z=speaks(n) : Distribution de Gausse. **M.7: ..- Concaténation : ================== *- Définition : La concaténation est le processus de joindre de petites matrices pour en faire une plus grands. En fait, on devrait avoir définit au préalable la première matrice en enchaînant ses différents éléments. *- La paire de crochets, [ ], est l'opérateur de concaténation. ===> Ex : Commencez par créer une matrice magic de 4-par-4 ensuite définissez B=[A A+32; A+48 A+16]. Le résultat devrait être le suivant : A=magic(4) A = 16 2 3 13 5 11 10 8 9 7 6 12 4 14 15 1


8

B=[A A+32;A+48 A+16] B = 16 2 3 13 48 34 35 45 5 11 10 8 37 43 42 40 9 7 6 12 41 39 38 44 4 14 15 1 36 46 47 33 64 50 51 61 32 18 19 29 53 59 58 56 21 27 26 24 57 55 54 60 25 23 22 28 52 62 63 49 20 30 31 17 **M.8: ..- Suppression de colonne ou de ligne : ============================= M.8.1--Suppression de colonne : Pour supprimer une colonne la commande est : [ ] A: Étant la matrice concernée par la suppression; j : la colonne à supprimer. A(:,j)=[ ] ===> Ex : A = 16 2 3 13 5 11 10 8 9 7 6 12 4 14 15 1 A(:,2)=[ ] A = 16 3 13 5 10 8 9 6 12 4 15 1 ===> Exercice : Essayer les commandes: A(1:2:5), A(1:2:10),... M.8.2--Suppression d'un élément: La commande : A(i,j)=[ ]; génère une erreur **M.9: ..-- ALGEBRE LINEAIRE : ====================== Officieusement, les termes matrices et son rang sont souvent employés l'un pour l'autre dans la littérature anglaise. Avec plus de précision, une matrice est un ensemble de rangées numériques bidimensionnelles qui représente une transformation linéaire. Les opérations mathématiques définies sur des matrices relèvent de l'algèbre linéaire. (Consulter un manuel de mathématique). M.9.1--L'addition d'une matrice (A) et de sa transposé (A’) devrait produire une matrice symétrique. La commande est : A+A' => Ex : A=[1 2 3 4 5 6 7 8 9] A = 1 2 3 4 5 6 7 8 9 A+A' ans = 2 6 10 6 10 14 10 14 18


9

M.9.2--La multiplication de la transposée par la matrice originelle produit aussi une matrice symétrique. La commande est : A'*A ===> Ex : A=[1 2 3 4 5 6 7 8 9] A'*A ans = 66 78 90 78 93 108 90 108 126 M.9.3--Déterminant d'une matrice : La commande est : det(A) ===> Ex :[1 2 3 4 5 6 7 8 9] det(A) ans =0 Ce qui indique que la matrice A est singulier. M.9.4--Forme réduit à un échelon d'une matrice: Pour avoir la forme réduite à un échelon la commande est : rref(A) ===> Ex :A=[1 2 3 4 5 6 7 8 9] rref(A) ans = 1 0 -1 0 1 2 0 0 0

M.9.5--Valeurs propres d'une matrice: La commande qui affiche les valeurs propres d'une matrice est : eig(A). *-Il est recommandé de voir les cours de Math concernant les valeurs propres. *-Jeter un coup d'oeil sur le help de MATLAB : Linear Algebra. **M.10: ..-- Opérations sur les matrices : ======================= (+) : Adition de matrices. (-) : Soustraction de matrice. (.*) : Multiplication élément par élément. (./) : Division élément par élément. (.\) : Division à gauche élément par élément. (.^ ): Elévation à la puissance élément par élément. (.') : Enlever, la conjugaison d'un complexe (c’est-à-dire on retrouve le complexe originel), ou annule la transposition dune matrice (c’est-à-dire on retourne à la matrice originelle). **M.11: ...-- Données à multi variables : ================================ MATLAB emploie l'analyse colonne-orientée pour des données statistiques multi-variables. Chaque colonne dans un ensemble de données représente une variable et chaque rangée (ou ligne) une observation. L'élément (i,j) est la ieme observation de la jeme variable. Comme exemple, considérer une donnée avec trois variables (concernant une personne) : . Fréquence cardiaque . Poids (en livre) . Heures d'exercice par semaine Pour cinq observations, on a enregistré les résultats suivant concernant ces trois variables peuvent être consignées dans une matrice :


10

D = 72 134 3.2 81 201 3.5 69 156 7.1 82 148 2.4 75 170 1.2 La première rangée (ligne) contient la fréquence cardiaque, le poids, et des heures d'exercice pour le patient N°1, pour un deuxième patient on peut avoir des données similaires, et ainsi de suite. Maintenant on peut appliquer plusieurs fonctions d'analyse de données de MATLAB à ces données. Par exemple, pour obtenir l'écart type moyen et de chaque colonne : mu = mean(D), sigma = std(D) mu = 75.8 161.8 3.48 sigma = 5.6303 25.499 2.2107 Pour une liste des fonctions d'analyse de données disponibles dans MATLAB, taper : help datafun Pour acceder à la boite à outils de la statistique taper: help stats **M.12: ...-- Format d'écriture : ================= Pour avoir des chiffres sous différentes formes envisager les exemples suivants : x = [4/3 1.2345e-6] format short 1.3333 0.0000 format short e 1.3333e+000 1.2345e-006 format short g 1.3333 1.2345e-006 format long 1.33333333333333 0.00000123450000 format long e 1.333333333333333e+000 1.234500000000000e-006 format long g 1.33333333333333 1.2345e-006 format bank 1.33 0.00 format rat 4/3 1/810045 format hex 3ff5555555555555 3eb4b6231abfd271 Vectorisation: ========= Pour avoir une rapide exécution des programmes de calculs, en dehors de la commande de MATLAB il est préférable de vectorisés l’algorithme dans un fichier M-files. Là où d’autres programmes demandent l’utilisation des boucles, MATLAB vous offre la possibilité d’utiliser des vecteurs ou des matrices. Prenons l’exemple qui permet de dresser une table logarithmique : x = 0.01; for k = 1:1001 y(k) = log10(x); x = x +0.01; end La version vectorisée de ce petit programme est : x =0 .01:0.01:10; y = log10(x); Pour un code plus compliqué, les options de vectorisation ne sont pas toujours si évidentes. , cependant, pour avoir des vitesses importantes vous devriez toujours rechercher, d’une manière ou d’une autre, à vectorisé vos algorithmes.


11

CHAPITRE - G - LES GRAPHES

**G.1 : ...-- Pour en avoir une première idée : ======================================= Exécuter se petit programme pour débuter ce chapitre: x = 0:pi/100:2*pi; y = sin(x); y2 = sin(x-.25); y3 = sin(x-.5); plot(x,y,x,y2,x,y3); legend('sin(x)','sin(x-.25)','sin(x-.5)');grid **G.2 : ...-- Démarche basique pour tracer des graphes : =================================== MATLAB a des équipements étendus pour montrer des vecteurs et des matrices comme graphiques, aussi bien qu'annoter et imprimer ces graphiques. Cette section décrit quelques unes des fonctions de graphiques les plus importantes et fournit des exemples de quelques applications typiques. La fonction "plot" a différentes formes, selon les arguments d'entrée. Si y est un vecteur, la fonction plot(y) produit un graphique par morceaux linéaire des éléments de y en fonction l'index des éléments du y. Si l'on indique deux vecteurs à la fonction, x et y, c'est-à-dire : plot(x, y) produit un graphique de y en fonction x. Par exemple, ce programme emploie l'opérateur de deux points (:) pour créer un vecteur x s'étendant de zéro à 2*pi, calcule le sinus de ces valeurs, et trace le résultat. ===> Ex : x = 0:pi/100:2*pi; y = sin(x); plot(x,y) Maintenant marquons les axes et ajoutons un titre au graphe. Le caractères ( \pi) créent le symbole de pi. *- La commande "xlabel" crée sur l'axe des xx le texte que l'on souhaite indiquer. *- La commande "ylabel" crée sur l'axe des yy le texte que l'on souhaite indiquer. *- La commande "zlabel" crée sur l'axe des zz le texte que l'on souhaite indiquer. *- La commande "title" ajout le titre du graphe. *- La commande "grid" ajout une grille. ===> Ex : xlabel('x = 0:2\pi') ylabel('Sine of x') title('Plot of the Sine Function','...FontSize',12) Comme exemple de tracer complet réunissons les deux Exemples précédents x = 0:pi/100:2*pi; y = sin(x); plot(x,y) xlabel('x = 0:2\pi') ylabel('Sine of x') title('Plot of the Sine Function','FontSize',12) grid *- Pour avoir des axes identiques donner la commande : "axis equal" juste après la commande "plot" **G.3 : ...-- Tracer de plusieurs courbes sur un même graphe: ======================================= Afin de tracer des courbes sur un méme graphe la commande "plot" doit comporter l'ensemble des arguments et des fonctions à tracer telle que plot(x,y1,x,y2,x,y3,...,yn) où x : est l'argument ou la variable yi: sont les fonctions à tracer. ===> Ex : x=-pi: pi/100 : 2*pi; y1=sin(x); Y2=sin(x-.25); y3=sin(x-.5); z =cos(2*x); plot(x,y1,x,Y2,x,y3,x,z); legend('sin(x)','sin(x-0.25)','sin(x-0.5)','cos(2*x)'); grid; Ou bien : legend('y1','y2','y3','z')


12

*- Pour mieux identifier les courbes on utilise la légende "legend" qui donne à chaque courbe une couleur d'identification. **G.4 : ...-- Spécification du style de la ligne du tracer et de sa couleur : ========================================= Il est possible de spécifier la couleur, le style, et le marquage de la ligne (comme + ou carré...), pour cela, lors du traçage des données, user de la commande : plot(x,y,'couleur_style_marque'). *- Où couleur peut être l'une de ces lettres: 'c' :couleur cyan ; 'm' : magenda ; 'y' : yellow ; 'r' : red ; 'g' : green 'b' : blue ; 'w' : white ; 'k' : black. *- Pour le style de la ligne : '-' : pour solide(continue) ; '--' :pour dash (pointiellé). ':' :pour des points ; '-.' :pour tiret point. 'none' : pour aucune ligne *- Le marquage : '+' ; 'o'; '*'; 'x'; 's' : Pour un carré ; '^' :pour un triangle vers le haut. 'd' : Pour diamant ; 'v' :pour un triangle vers le bas. '>' : Pour un triangle vers la droite. '<' : Pour un triangle vers la gauche. 'p' : Pour pentagone. 'h' : Pour hexagone. 'none': Pour aucune marque *- Si on indique uniquement le marquage et non le style MATLAB dessine seulement le marqueur,mais il ne les lie pas entre eux. ===> EX : plot(x,y,'ks') *- On peut combiner : c, m, y ,r g, b ,w ,k avec +, o, *, x, s, d, <, >, p, h ; comme par exemple : 'c+','cs'... ===> EX :x=0:pi/100:pi; y1=sin(x); plot(x,y,'m+') Pour plus d'exercices essayer les commandes : plot(x,y1,'k<') plot(x,y1,'mp') plot(x,y1,'m+') plot(x,y1,'mo') plot(x,y1,'r:+') plot(x,y1,'b:-') plot(x,y1,'b:o') plot(x,y1,'b:p') plot(x,y1,'b:<') plot(x,y1,'b:h')

Traiter l'exemple suivant : x1 = 0:pi/100:2*pi; x2 = 0:pi/10:2*pi; plot(x1,sin(x1),'r:',x2,sin(x2),'r+') **G.5 : ...-- Donnée sous forme d'imaginaire et de complexe : =================================== Quand les arguments à tracer sont complexes, la partie imaginaire est ignorée à moins que la commande comporte un argument complexe simple; c’est à dire "plot(z)". Pour ce cas spécial, la commande "plot" est un raccourci pour le tracer la partie réelle en fonction de la partie imaginaire par conséquent, la commande : "plot(Z)" est équivalente à : "plot(real(Z),imag(Z))".Où Z est un vecteur ou une matrice complexe. Considérons l'exemple : t = 0:pi/10:2*pi; plot(exp(i*t),'-o') axis equal


13

Dessine un polygone à 20 cotés avec de petits cercles aux sommets. La commande, "axe égal", marques les différents incrémentations à des longueurs égales sur l'axe des xx et axes ordonnées, ce qui rend cette figure parfaitement circulaire dans le plan. **G.6 : ...-- Ajouter un autre graphe à un graphe qui existe déjà : =========================================== La commande "hold on"(tenir dessus ou ajouter dessus) nous permet d'ajouter des graphes à un graphique existant. Quand on tape "hold on"MATLAB ne remplace pas le graphique existant quand on émet une autre commande de traçage ; il ajoute les nouvelles données au graphique courant, il rééchelonne au besoin les axes si nécessaire. Par exemple, ces programmes créent d'abord une courbe de la fonction "peaks" et découpe des crêtes, puis superposent une courbe de pseudo couleur de la même fonction. ==> Ex : [x,y,z] = peaks; contour(x,y,z,20,'k') hold on pcolor(x,y,z) shading interp hold off **G.7 : ...-- Fenêtre du graphe (Figure Windows) : ================================ La fonction graphique ouvre automatiquement une nouvelle fenêtre s'il n'y a pas une fenêtre déjà ouverte sur l'écran. Par contre s'il y a une fenêtre ouverte MATLAB l'utilise pour le nouveau graphe. Quand il y a plusieurs fenêtres ouvertes il utilisera la fenêtre courante (c’est à dire la dernière ouverte). Pour faire d'une figure existante une fenêtre courante, on peut cliqueter, à l'aide de la souris, sur son indicateur, ou on peut taper: figure(n); où n est le N° de la figure. ===> Ex : x=0:pi/100:2*pi; y=sin(x); z=sin(x-.25); figure(1);plot(x,y,'ro');grid; figure(2);plot(x,z,'b*');grid Utiliser alors la commande "figure (1)" ou "figure (2)" pour visualiser l'une ou l'autre des figures. *-Pour ouvrir une nouvelle fenêtre de figure taper : figure. **G.8 : ...-- Multiples graphes sur une même figure : ================================ La commande "subplot(m,n,p)nous permet de tracer plusieurs graphes dans une même fenêtre, et nous pouvons les imprimer. Détaillons "subplot(m,n,p) : a°) Divise la fenêtre m par n partie; chacune étant une petite fenêtre. b°) Puis elle sélectionne le nom du graphe par p ===> Ex : t = 0:pi/10:2*pi; [X,Y,Z] = cylinder(4*cos(t)); subplot(2,2,1); mesh(X) subplot(2,2,2); mesh(Y) subplot(2,2,3); mesh(Z) subplot(2,2,4); mesh(X,Y,Z) ===> Ex : x=0:pi/100:2*pi; y1=sin(x); y2=sin(x-0.25); y3=sin(x-0.5); subplot(2,2,1);plot(x,y1,'r+');grid; subplot(2,2,2);plot(x,y2,'b<');grid; subplot(2,2,3);plot(x,y3,'g>');grid; **G.9 : ...-- Contrôle des axes : ================= La commande "axis" soutient un certain nombre d'options pour placer les graduations, l'orientation, et l'aspect du graphe. Où peut également placer ces options interactivement.


14

G.9.1--Fixer des limites d'Axe : Par défaut, MATLAB trouve les maximums et les minimums des données. Pour choisir les limites d'axes placer les valeurs dans la commande "axis" ; cela nous permet d'indiquer nos propres limites: axis([Xmin Xmax YminYymax]) Avec : Xmin : Borne inférieure de l’intervalle des xx Xmax : Borne supérieure de l’intervalle des xx Ymin : Borne inférieure de l’intervalle des yy Xmax : Borne supérieure de l’intervalle des yy Pour un graphe tridimensionnel : axis([xmin xmax ymin ymax zmin zmax]) ===> Ex : axis([-pi pi -2 3]) G.9.2--User de la commande "axis auto"pour permettre de nouveau à MATLAB un choix automatique de la limite des axes. G.9.3--Réglage de l'étendue des axes : La commande "axis" nous permet aussi certains nombres de modes prédéfinis. Par exemple : a°) axis square ; qui génère des axes xx et yy de même longueur. b°) axis equal ; génère des axes avec les mêmes échelles. ===> Ex : x=0:pi/10:2*pi; y=sin(x); subplot(2,2,1);plot(x,y);axis square; subplot(2,2,2);plot(x,y);axis equal; G.9.4--Visibilité et non visibilité des axes: - a°) La commande "axis on" rend les axes visibles. - b°) La commande "axis off" rend les axes non visibles. G.9.5--Grille visible ou non : -a°)"grid on" : grille visible. -b°)"grid off" : gille non visible. G.9.6--Libeller les axes, le graphe et mettre du texte à l'intérieur du graphe : -Les fonctions "xlabel","ylabel" et "zlabel" commande la nomination des axes xx, yy et zz. -La fonction "title" nous permet d'écrire un titre sur le graphe. -La fonction "TeX" produit la notation grecque. -La fonction "text" insère une du texte à l'intérieur du graphe. Remarque: Pour les lettres grec voir le help et taper: Txt [1]. ===> Ex: t = -pi:pi/100:pi; y = sin(t); plot(t,y) axis([-pi pi -1 1]) xlabel('-\pi \leq {\itt} \leq \pi') ylabel('sin(t)') title('Graph of the sine function') text(1,-1/3,'{\itNote the odd symmetry.}') Amusez vous à exécuter ce petit programme :

theta=-pi:pi/100:pi; y=sin(theta); plot(theta,y); ylabel('sin{(}theta{)}') xlabel('-pi\leq\theta\leq\sigma') **G.10 : ...-- Sauvegarde des figures : ===================== Pour sauver une figure, choisie "Save" du menu File. Pour le sauver choisissez les formats graphiques, comme TIFF, pour un usage antérieur ou "Export" pour l'exporter vers d'autres applications, toujours dans le menu File. On peut également le sauver à l'aide de "save as"qui inclue toutes les options de la sauvegarde la figure dans un format différent.


15

**G.11 : ...-- Edition de graphes : ================== Pour éditer un graphe MATLAB permet de : - Utiliser la sourie. - Utiliser la ligne de commande. - Utiliser les M-file. Pour plus de détaille voir : "Using Plot Editing Mode», "Using the Property Editor" ou les fonctions d'édition telle que "Handle Graphics". **G.12 : ...-- Tracer des surfaces et maillage (Mesh and surface plots): ============================================= MATLAB définit une surface par la coordonne z des points au-dessus d'une grille dans le plan de (x y), en utilisant les lignes droites pour relier les points adjacents. La "mesh" (maille) et la" surf "(surface) traçant les surfaces de visualisation de la fonction à trois dimensions.La "mesh" et " surf" sont des fonctions traçant les surfaces de visualisation à trois dimensions. la "mesh" produit les surfaces de wireframe qui colorent seulement les lignes reliant les points de définition."surf" montre les lignes de connections de et les faces de la surface en couleurs. G.12.1--Visualiser des fonctions à deux variables : z=f(x,y) -a°) Générer deux matrices X et Y qui contiennent les couples de points du domaine où l'on trace la courbe. -b°) Utiliser les matrices X et Y pour évaluer la fonction et tracer son graphe.

La fonction "meshgrid" transforme le domaine spécifié en (a°) par un seul ou deux vecteurs x et y en deux matrices X et Y afin d'évaluer les fonctions à deux variables. Les lignes de X sont copiées dans le vecteur x et les colonne de Y sont copiées dans le vecteur y. Ex : Graphe de la fonction sinc (c.-à-d. sin(R)/R au voisinage de 0):

Cet exemple évalue et trace la fonction "sinc" dans trois dimensions. R est la distance à l'origine. Pour éviter la division par zéro on doit user de la petite valeur "eps".

[X,Y]=meshgrid(-8:.5:8); R=sqrt(X.^2+Y.^2)+eps; Z=sin(R)./R; mesh(X,Y,Z) surf(X,Y,Z,'EdgeColor','red')

Ex : Utilisation de la commande "surf"

[X,Y]=meshgrid(-8:.5:8); R=sqrt(X.^2+Y.^2)+eps; Z=sin(R)./R; surf(X,Y,Z,'FaceColor','red','EdgeColor','none'); camlight left; lighting phong % Ajoute un aspect de brillance. view(-15,65) % les dimension de la vue.

Ex : load clown

surface(peaks,flipud(X),... 'FaceColor','texturemap',... 'EdgeColor','none',...

'CDataMapping','direct') colormap(map) view(-35,45)

**G.13 : ...-- Impression des graphes : ===================== On peut imprimer les figures de MATLAB directement sur une imprimante reliée à notre ordinateur comme on peut les exporter vers un des fichiers de formats standard compatible avec MATLAB. Il y a deux manières d'imprimer et d’exporter des figures : -a°) User de l'option "print" dans le menu File (où l’on trouve Prin stup et Print preview). -b°) User de la commande "print" Explicitons ces deux points : a°) Imprimer à partir du Menu File :


16

Il y en a quatre options d'impression sous le Menu File : *** L'option "Page Setup" qui ouvre une boit de dialogue, nous permettant d'ajuster les caractéristiques du graphe sur la page à imprimer. *** L'option de "Print Setup" montre une zone de dialogue qui imprime par défauts, mais qui n'actualise pas réellement la figure. *** L'option de "Print Preview" permet d’avoir un aperçu de la figure telle qu'elle sera imprimée. *** L'option de "Print" montre une zone de dialogue qui donne le choix des options d'impression standard et imprimer la figure. **G.14 : ...-- Manipulation des Graphes: ======================= Quand on emploie une commande de traçage, MATLAB crée le graphique en utilisant de divers objets de graphiques, tels que les lignes, le texte, et les surfaces (voir Graphics Objects pour une liste complète).Tous les objets de graphiques ont des propriétés qui commandent l'aspect et le comportement de l'objet. MATLAB nous permet d’examiner la valeur de chaque propriété et de placer la valeur de la plupart des propriétés.Chaque fois que MATLAB crée les graphiques objets, il assigne une marque (appelée Handle= poignée) à l'objet. On peut utiliser cette poignée, Handle, pour accéder aux propriétés de l'objet. Les handle-graphiques sont très utile si on veut : *- Modifier l'apparence des graphes. *- Créer des commandes personnalisées de traçage par l'inscription dans des M-File qui créent et manipulent des objets directement. G.14.1--Graphes Objects: Graphics objects sont les éléments de base employés pour montrer des graphiques et des éléments d'interface utilisateur. Le tableau suivant présente les graphiques objects:

Object Description

Root Dessus de la hiérarchie correspondant à l'écran d'ordinateur

Figure La fenêtre montrait des graphiques et des interfaces utilisateur.

Axes Axes pour montrer des graphiques dans une figure

Uicontrol Commande d'interface utilisateur qui exécute une fonction en réponse à l'interaction d'utilisateur

Uimenu le menu de la fenêtre Figure définie pour l'utilisateur

Uicontextmenu Le menu instantané appelé par bon cliqueter droit sur des graphes objects.

Image Image bidimensionnelle basée sur des Pixels (donnée sous forme de Pixels)

Light Sources lumineuses qui affectent la coloration des de pièce rapportée et des surfaces objets

Line Ligne employée par des fonctions telles que plot, plot3, semilogx.

Patch Polygone rempli avec des bords.

Rectangle Forme bidimensionnelle changeante des rectangles aux ovales.

Surface

Représentation tridimensionnelle des données de matrice créées par le plotting, la valeur de ces données est de la taille plan x/y

Text Chaîne de caractères.

Remarque: Pour les lettres Grec voir le help et taper: Text[1]. G.14.2--Hiérarchie des Objects: Les objets sont organisés dans une hiérarchie structurée par arbre reflétant leur interdépendance. Par exemple, la ligne objets exige des « Axes objects » comme cadre de référence. Tour à tour, les Axes objets existent seulement dans l'object figure. Ce diagramme illustre la structure arborescente:(voir help: Graphics objects). G.14.3--Création d'objets: Chaque objet a une fonction associée qui crée l'objet. Ces fonctions ont le même nom que les objets qui ils créent. Par exemple, la fonction textes crée des objets textes, la fonction figure crée l'objets figure, et ainsi de suite.Les fonctions à niveau élevé des graphiques de MATLAB (comme la "plot" et la" surf") appellent la fonction de bas niveau appropriée pour tracer leurs graphiques respectifs. Pour plus d'informations sur un objet et une description de ses propriétés, voir la page de référence pour la fonction de la création de l'objet. Les fonctions de création d'objet ont le même nom que l'objet. Par exemple, la fonction de création d'objet pour la création des axes objets s'appellera axes.


17

G.14.4--Commandes pour travailler avec des objets: Ce tableau présente des commandes généralement utilisées pour travaillant avec des objets. |-----------------------------------------------------| | Fonction | Ce que la fonction réalise -------------------------------------------------------| | copyobj | Copoie les graphiques objets. | delete | suprime les objets. | findobje | Trouver les entrées des objets ayant été spécifiés | | par les valeurs de leurs propriétés. | gca | Renvoyer la manipulation des axes courant | gcf | Renvoyer la manipulation des figures courantes | gco | Renvoyer la manipulation des objet courant. | get | Vérifie la valeur des propriétés d'objets. | set |Placer la valeur des propriétés des d'objets |----------------|-------------------------------------| G.14.5--Placer des propriétés d'objet: Toutes les propriétés d'objet ont des valeurs par défaut. Cependant, on peut trouver utile de changer quelques propriétés et des arrangements pour les adapter à notre graphique (notre cas). Il y a deux manières pour placer des propriétés d'objet : a°)En spécifiant la valeur lors de la création de l'objet. b°)Placer la valeur de propriété sur un objet qui existe déjà G.14.5.1-Placer des propriétés dans les commandes plot: On peut indiquer des valeurs de propriété d'objet comme des arguments pour objecter des fonctions de création aussi bien qu'avec les fonctions tracer, telle que la "plot", la "mesh", et "surf". Par exemple, les commandes de traçage (ploting) qui créent des lignes ou des surfaces nous permettent d'indiquer la valeur de la propriété name/property par paire d'arguments. Par exemple la commande: plot(x,y,'LineWidth',1.5)Trace les données qui se trouvent dans les variables x et y en utilisant des lignes ayant une propriété de largeur des trais réglée à 1.5 point (un point = 1/72 pouce).On peut placer n'importe quelle ligne de propriété d'objet de cette façon. ===> Ex : x=0:pi/100:pi; y=sin(x); plot(x,y,'LineWidth',1.5) - - - - - - - - - - - - - - - ===> Ex : x=0:pi/100:pi; y=sin(x); plot(x,y,'LineWidth',1.5,'color','r') ===> Ex : x=0:pi/100:pi; y=sin(x); plot(x,y,'LineWidth',3,'color','b') G.14.5.2-Placer des propriétés dans des objets qui existent: Pour modifier les valeurs de propriété des objets existants, on peut employer la commande "set" ou, si le mode de l'éditeur de"plot" nous le permet: "Property Editor" . "Property Editor" fournit une interface utilisateur graphique à plusieurs propriétés d'objet. Cette section décrit comment employer la commande "set".Voire Using the Property Editor pour plus d'information. Beaucoup de commandes de traçage peuvent renvoyer des entrées de création d' objets ainsi on peut modifier les objets en utilisant la command "set". Par exemple, ces programmes tracent cinq-par-cinq la matrice (créant cinq lignes, une par colonne) et puis placent le marqueur à leur place et le MarkerFaceColor au vert:

Ex: h = plot(magic(5)); set(h,'Marker','s','MarkerFaceColor','g')

Dans ce cas-ci, h est un vecteur contenant cinq déclarations, une pour chacune des cinq lignes dans "plot".L'ensemble des déclarations place les propriétés de marquage et de MarkerFaceColor de toutes les lignes aux mêmes valeurs.

Ex : h=plot(magic(5)); set(h,'Marker','s',...


18

'MarkerFaceColor','b')

G.14.5.3--Mettre et manipuler de multiples valeurs de propriété: Si on veut placer des propriétés de chaque ligne à une valeur différente, on peut employer des rangées de cellules pour stocker toutes les données et pour les passer à la commande "set". Par exemple, créer un "plot" et sauver la ligne d'entrés.

Ex : h = plot(magic(5));

Supposer que l'on veut ajouter différents marqueurs à chaque ligne et colorer la face c du marqueur à la même couleur que la ligne. On doit définir deux rangées de cellules - une contenant les noms de propriété et l'autre qui contient les valeurs désirées des propriétés. Par exemple: La rangée de cellules de "prop_name" contient deux éléments: prop_name(1) = {'Marker'}; prop_name(2) = {'MarkerFaceColor'}; La rangée de cellules de prop_values contient 10 valeurs - cinq valeurs pour la propriété de marqueur et cinq valeurs pour la propriété de MarkerFaceColor. Noter que les prop_values est une rangée bidimensionnelle de cellules. La première dimension indique à quelle entrée dans h les valeurs sont appliquées et la deuxième dimension indique à quelle propriété la valeur est assignée. prop_values(1,1) = {'s'}; prop_values(1,2) = {get(h(1),'Color')}; prop_values(2,1) = {'d'}; prop_values(2,2) = {get(h(2),'Color')}; prop_values(3,1) = {'o'}; prop_values(3,2) = {get(h(3),'Color')}; prop_values(4,1) = {'p'}; prop_values(4,2) = {get(h(4),'Color')}; prop_values(5,1) = {'h'}; prop_values(5,2) = {get(h(5),'Color')}; Le MarkerFaceColor est toujours assigné à la valeur de la couleur correspondante à ligne (obtenue par la propriété de couleur grâce à la commande "Color" amenée par la commande get). Après avoir défini les rangées de cellules, on appelle "set" pour indiquer les nouvelles valeurs de propriété: set(h,prop_name,prop_values) G.14.5.4--Trouver les entrées (handles) des objets existants: La commande de "findobj" nous permet d'obtenir les entrés (handles) des objets graphiques en recherchant les objets avec des valeurs de propriété particulières. Avec la "findobj" on peut indiquer la valeur de n'importe quelle combinaison des propriétés, qui rend facile la sélectionner (ou de trouver) d'un objet parmi d'autre. Par exemple, on peut vouloir trouver la ligne bleue avec le marqueur carré ayant la couleur des faces bleues. On peut également indiquer quelles figures (ou axes) à rechercher, s'il y a plus d'un. Les sections suivantes fournissent des exemples illustrant comment employer la"findobj". G.14.5.4.1--Trouver tous les objets d'un certain type: Puisque tous les objets ont un type propriété qui identifie le type d'objet, on peut trouver les entêtes (handles) de toutes les occurrences d'un type particulier d'objet. Par exemple Par exemple, trouver les entêtes (handles) de toutes les lignes object: h = findobj('Type','line'); G.14.5.4.2--Trouver des objets qui ont des propriétés particulières: On peut indiquer de multiples propriétés pour cerner la recherche. Par exemple chercher toutes les entêtes (handles) des lignes pointillées rouge('r' dans le programme) h = findobj('Type','line','Color','r','LineStyle',':'); G.14.5.4.3--Limitation de la portée de la recherche: On peut indiquer le point de départ dans la hiérarchie d'objet en passant l’entête (handle) de commencement de la figure ou des axes comme premier argument. Par exemple, trouver la chaîne pi/2 seulement dans les axes courants: h = findobj(gca,'Type','text','String','\pi/2');


19

G.14.5.4.4--Employer la "findobj" comme argument: Puisque la "findobj" renvoie les entêtes (handles) qu'il trouve, on peut alors employer ces entêtes comme argument afin de raffiner la recherche. Par exemple, trouver toutes lignes rouges et ensembles des lignes (modèle) a pointillé: set(findobj('Type','line','Color','red'),'LineStyle',':') **G.15: ...--Utilation de l'interface graphique (Graphics User Interfaces) --Graphical User Interface Design Tools. --Animations --Erase Mode Method --Creating Movies

RESTE A DEVELOPPER **G.16 : Voir : SPARSE MATRICE L = numgrid('L',65); A = delsq(L); [v,d] = eigs(A,1,0); Iteration 1: a few Ritz values of the 20-by-20 matrix: 0 L(L>0) = full(v(L(L>0))); x = -1:1/32:1; contour(x,x,L,15) axis square.

QUELQUES EXEMPLES : -------------------- 1°) x = -2.9:0.2:2.9; bar(x,exp(-x.*x)) colormap hsv ------------------- 2°) Y = round(rand(5,3)*10); subplot(2,2,1) bar(Y,'group') title 'Group' subplot(2,2,2) bar(Y,'stack') title 'Stack' subplot(2,2,3) barh(Y,'stack') title 'Stack' subplot(2,2,4) bar(Y,1.5) title 'Width = 1.5' -------------------- 3°)Y = cool(7); subplot(3,2,1) bar3(Y,'detached') title('Detached') subplot(3,2,2) bar3(Y,0.25,'detached') title('Width = 0.25') subplot(3,2,3) bar3(Y,'grouped') title('Grouped') subplot(3,2,4) bar3(Y,0.5,'grouped') title('Width = 0.5') subplot(3,2,5) bar3(Y,'stacked') title('Stacked') subplot(3,2,6) bar3(Y,0.3,'stacked')


20

title('Width = 0.3') colormap([1 0 0;0 1 0;0 0 1]) ----------------------- 4°)surf(peaks) axis vis3d off for x=-200:5:200 campos([x,5,10]) drawnow end ----------------------- 5°)surf(peaks); axis vis3d xp=linspace(-150,40,50); xt=linspace(25,50,50); for i=1:50camup([xp(i),25,5]) Warning: Unmatched "end". (Type "warning off MATLAB:m_warning_end_without_block" to suppress this warning.) camup([xp(i),25,5]); drawnow end ---------------------- 6°) axis([0 10 0 10]) hold on % Initially, the list of points is empty. xy = []; n = 0; % Loop, picking up the points. disp('Left mouse button picks points.') disp('Right mouse button picks last point.') but = 1; while but == 1 [xi,yi,but] = ginput(1); plot(xi,yi,'ro') n = n+1; xy(:,n) = [xi;yi]; end % Interpolate with a spline curve and finer spacing. t = 1:n; ts = 1: 0.1: n; xys = spline(t,xy,ts); % Plot the interpolated curve. plot(xys(1,:),xys(2,:),'b-'); hold off

CAPITRE P ************************************* PROGRAMMER avec MATLAB

************************************* ** P.1 : ..--Champs de contrôle de MATLAB : ========================== MATLAB a plusieurs champs de contrôles constitués par: * if Déclaration * switch Déclarations * for Boucles * while Boucle * continue Déclaration * break Déclaration P.1.1-- if :


21

La déclaration "if" évalue une expression logique et exécute un groupe de déclaration quand l'expression est vraie. L'"elseif" facultatif et les mots-clés "else" (autre) prévoient l'exécution des groupes alternatifs de déclarations. Un mot-clé "end" (fin), qui assortit l'"if", termine le dernier groupe de déclaration. Les groupes de déclarations ne sont tracées par les quatre mots clés aucun croisement ou parenthèse n'est impliqué. L'algorithme de MATLAB pour produire de matrices (ou table) magique d'ordre (n); implique trois cas différents : quand (n) est impair, quand (n) est pair mais non divisible par 4, ou quand (n) est divisible par 4. Ceci est décrit dans cet exemple, les trois cas sont mutuellement exclusifs, mais s'ils ne l'étaient pas, le premier état vrai serait exécuté: if rem(n,2) ~= 0 M = odd_magic(n) elseif rem(n,4) ~= 0 M = single_even_magic(n) else M = double_even_magic(n) end Il est important de comprendre comment les relations des opérateurs des déclarations de "if " travaillent avec des matrices. Quand on veut vérifier l'égalité entre deux variables, on pourrait employer: If A = = B, ... Ce code légal (correcte) de MATLAB, tant que A et B sont des grandeurs scalaires. Mais quand A et B sont des matrices, A = = B n'examine pas s'ils sont égaux, il examine où elles ne le sont pas; le résultat est une matrice de 0 et 1, produite en comparant l’égalité d’élément par élément quand les éléments sont égaux un à un le chiffre est 1 sinon c'est 0.Enfin, si A et B ne sont pas de la même taille, MATLAB indique une erreur: A = = B is an error. La manière appropriée de vérifier l'égalité entre deux variables est d'employer la fonction "isequal", if isequal(A,B), ... Voici un autre exemple pour souligner ce point. Si A et B sont des grandeurs scalaires, le programme suivant n'atteindra jamais la situation attendue. Mais pour la plupart des paires de matrices, y compris nos matrices magiques avec des colonnes inter changées, aucune des conditionnes A > B, le A = = B , A < B n’est vraie pour tous les éléments et ainsi la condition "else" est exécutée. if A > B 'greater' % Ecrire "greater" = plus grande elseif A < B 'less' % Ecrire "less" =moins elseif A = = B 'equal' % Ecrire "equal"=égale else error ('Unexpected situation') % Ecrire situation inattendue. end Plusieurs fonctions sont utiles pour ramener les résultats des comparaisons de matrices aux conditions de comparaisons des scalaires pour cela il est utile de se servir des déclarations: - isequal (est ce qu'ils sont égaux) - isempty (est ce qu'ils sont vides) - all (est ce qu'ils sont tous non nuls) - any (est ce qu'il y a qui sont nuls) * isequal : Teste l'égalité. Ex : A=[1 0;0 1]; B=[0 1;0 1]; C=[0 1;0 0] isequal(A,B) ans= 1 % Proposition vraie car A=B ----------------- isequal(A,C) ans= 0 % Proposition fausse car A#C. ----------------- isequal(A,C,B)


22

ans= 0 % Proposition fausse car A#C et B#C * isempty : Teste si la variable/matrice est vide(empty) ou non. Elle retourne 1 si la variable/matrice est vide. Elle retourne 0 si la variable/matrice est non vide. Ex : d=[;] isempty(d) ans=1 % Proposition vraie d est vide ----------------- b=[0,0;0,0] isempty(b) ans =0 % Proposition fausse car b n'est pas vide. * all : Teste si tous les éléments sont non nuls. Ex : A[1 2 3;6 5 4] all(A) ans=1 1 1 % Proposition vraie. ------------------- Ex : A[0 2 3; 5 6 7] all (A) ans=0 1 1 ------------------- Ex : A=[0 2 3;6 5 0] all(A) ans=0 1 0 * any : Teste si tous les éléments sont nuls. Ex : A=[0 6 7;3 0 1] any(A) ans=1 1 1 ------------------- Ex : A=[0 0 0;3 0 0] any(A) ans= 1 0 0 ------------------- Ex : A=[0 0 0;0 0 0] any(A)=0 0 0 ------------------- Ex : A=[0.8,.75,.95;.52,.63,.46] any(A<.5) % Teste les éléments de A qui sont <0,5. ans=0 0 1 % Un seul : 0,46 P1.2-- switch and case: La déclaration "switch" exécute des groupes de déclarations basés sur la valeur d'une variable ou d'une expression. Les mots-clés "case" et "otherwise" tracent les groupes. Seulement le premier cas assorti est exécuté. On doit toujours avoir une "end" pour sortir de "switche". La logique de l'algorithme de la matrice "magic" peut également être décrite par: Ex : switch (rem(n,4)==0) + (rem(n,2)==0)


23

case 0 M = odd_magic(n) case 1 M = single_even_magic(n) case 2 M = double_even_magic(n) otherwise error('This is impossible') end P1.3-- for : La boucle "for" répète un groupe de déclarations un nombre de fois fixe et prédéterminé. Une "end" nécessaire pour sortir de la boucle "for". Ex : for n=3:32 r(n)= rank(magic(n)); end r Remarques : 1°) Le point virgule terminant la déclaration intérieure supprime l'impression répétée à l’écran, et le r après la boucle montre le résultat final. 2°) C'est une bonne idée de denteler les boucles pour la lisibilité des programme, particulièrement quand elles sont imbriquées. Ex : for i = 1:m for j = 1:n H(i,j) = 1/(i+j); end end P1.4.-- while : La boucle "while" répète un groupe de déclarations un nombre de fois indéfini sous la commande d'un état logique. La déclaration "end" métra fin à "while". Voici un programme complet, illustrant l'"while", " if", "else", et "end", l'utilisation de la bissection d'intervalle pour trouver la racine d'un polynôme. Ex : a = 0; fa = -Inf; b = 3; fb = Inf; while b-a > eps*b x = (a+b)/2; fx = x^3-2*x-5; if sign(fx) == sign(fa) a = x; fa = fx; else b = x; fb = fx; end end x Ce programme donnera le résultat x=2,09455148154233. Les affirmations comportant les comparaisons de matrices qui sont discutées dans la section sur la déclaration de "if" s'appliquent également à la déclaration de "while". P1.5.-- continue : La déclaration "continue" passe la main à la prochaine itération de la boucle "for" ou de "while" dans laquelle elle apparaît, sautant toutes les déclarations restantes dans le corps de la boucle. Dans les boucles imbriquées (c-à-d à l'intérieur de continue), "continue" passe la main à la prochaine itération de la boucle de "for" ou de "while" l'enfermant. L'exemple ci-dessous montre une boucle "continue" qui compte les lignes du code dans le dossier, magic.m, sautant tous les interlignes(c’est à dire les lignes blanche qui ne contiennent rien) et les commentaires. Une déclaration "continue" est employé pour avancer à la prochaine ligne dans magic.m sans incrémenter le comptage chaque fois qu'un interligne ou la ligne de commentaire est rencontrée.


24

fid = fopen('magic.m','r'); count = 0; while ~feof(fid) line = fgetl(fid); if isempty(line) | strncmp(line,'%',1) continue end count = count + 1; end disp(sprintf('%d lines',count)); La déclaration "break" nous permet de sortir tôt d'une boucle "for" ou de "while".L'instruction "break" nous donne le moyen de sortir de la seule boucle où elle est incluse. Voici une amélioration sur l'exemple de la section précédente. Est ce que c'est une bonne idée? a = 0; fa = -Inf; b = 3; fb = Inf; while b-a > eps*b x = (a+b)/2; fx = x^3-2*x-5; if fx == 0 break elseif sign(fx) == sign(fa) a = x; fa = fx; else b = x; fb = fx; end end x P1.6 Autres structure de données: P1.6.1 Multidimensional Arrays:(Array=tableau, vecteur, matrice,...) Les données multidimensionnelles (matrices, vecteurs, tableau) dans MATLAB sont des rangées avec plus de deux indices. Elles peuvent être créées en invoquant les matrices "zéros", "ones", l"rand", ou "randn" avec plus de deux arguments. Par exemple: R = randn(3,4,5); Cette commande crée une rangée 3-par-4-par-5 (5 matrices de 4 colonnes par 3 lignes)avec un total de 3x4x5 = 60 éléments aléatoires normalement distribués. Une rangée tridimensionnelle pourrait représenter des données physiques tridimensionnelles, disent la température dans une chambre, prélevée sur une grille rectangulaire. Et il pourrait représenter un ordre des matrices, de l'A(k), ou des échantillons d'une matrice dépendant du temps, A(t).Dans ces derniers cas,l'élément (I, j) de la matrice de k, ou de la kieme matrice , est noté par A(i, j, k). Les versions de MATLAB et de Dürer qui génèrent des matrices carrées magiques d'ordre 4 diffèrent par un échange de deux colonnes différentes matrices carrées magiques peuvent être produites en échangeant des colonnes. La déclaration : p=perms(1:4); Génère 4!=24 permutations de 1:4 .La kiéme permutation est le vécteur ligne p(k,:). *** Pour la suite voir : **- Multidimensionel array (matrices). **- Cellules arrays **- Caractere et texts **- Structures.

Types de données et programmation

MATLAB est un langage de haut niveau qui inclut des structures de données, des fonctions, des commandes d’acheminement et d’exécution des commandes, d'entrée-sortie, et des possibilités de programmation d'objet orienté. Cette section présente les dispositifs de programmation et les techniques de MATLAB.


25

* Programmation des M-File - Décrit des langages de constructions et comment créer des programmes de MATLAB (M-Files).Il couvre des types de données, le contrôle de l’exécution, l'indexation de rangée (élément des), la linéarisation, et d'autres matières.

* Les ensembles de caractères - Couvre le support de MATLAB les chaines de données, incluant comment créer des ensembles de caractères et des rangées de cellules de chaines, les manières de représenter des chaines, comment exécuter les chaines d'opérations, et la conversion entre les chaines et les formats numériques.

Multidimensional Arrays

(Les espaces multidimensionnels) Les « functions »

(À ne pas confondre avec les fonctions mathématiques)

Les ’’ functions’’ sont des M-file qui acceptent des arguments d'entrée et des arguments de retour ou de sortie. Elles opèrent sur, ou utilise, des variables qui se trouvent dans leur propre zone de travail. Cela sépare l'espace de travail de la zone de commande de MATLAB.

Cette section couvre les points suivants concernant des fonctions :

* Simple Script Example : Un simple exemple de scripte * Basic Parts of a Function M-File : Les éléments de base des fonctions écrites dans M-file * Function Names : Nomination des fonctions * How Functions Work : Ce que peut faire une fonction * Checking the Number of Function Arguments : Vérification du nombre d'arguments d’une fonction * Passing Variable Numbers of Arguments : Dépassement du nombre de variables d'arguments

Simple Exemple de Fonction :

La fonction "average" (moyenne) est un M-file simple qui calcule la moyenne des éléments d’un vecteur : 1°) Commencer par ouvrir un M-file. 2°) Écrire se qui suit:

function y = average(x) % AVERAGE Mean of vector elements % AVERAGE(X), where X is a vector is the mean of vector elements % Non-vector input results in an error. [m,n] = size(x); if (~((m == 1) | (n == 1)) | (m == 1 & n == 1)) error('Input must be a vector') end y = sum(x)/length(x); % Actual computation 3°) Sauver le sous le nom de la fonction « average » 4°) Chaque fois que vous voulez calculer la moyenne des éléments d’un vecteur il suffirait de donner le vecteur et exécuter la commande « average » ; si les donnés ne sont pas relatives à un vecteur le résultat est un message d’erreur : ”error('Input must be a vector') ” 5°) Vérifier le résultat en jetant un coup d’ail sur la valeur de y

Si vous voudrais, essayer ces commandes, que vous avez noté dans le M-file a appelé "average.m". La fonction "average" accepte un argument simple comme entrée et renvoie un argument simple de sortie. Pour exécuter la fonction "average", faites entrer le vecteur z est calculer la moyenne de ces éléments :

z = 1:99; average(z) % Le résultat sera : ans = 50


26

Les Éléments de Base des Fonctions Écrites Dans les M-File :

Un M-File d'une fonction se compose de : * The Function Definition Line : Définition de la fonction * The H1 Line : La ligne H1. * Help Text : Texte de l’aide. * The Function Body : Le corps de la function. * Comments : Commentaires. Définition la ligne de la fonction :

La ligne de définition de fonction qui doit informer MATLAB que le M-File contient, et la spécification de l'argument d'appel de la fonction sont indiqués par le schémas qui suit. Comme exemple la ligne de définition de la fonction pour la" moyenne" est :

Fig.1 : Définition de la ligne de function

Toutes les fonctions de MATLAB ont une ligne de définition de fonction qui suit ce modèle.

Si la fonction a de multiples valeurs de retour ou de sortie, il faut joindre la liste de ces arguments (de sortie) entre crochets ( [] ). Les arguments d'entrée, s'ils sont présents, il faut les mettre entre parenthèses. Employer les virgules pour séparer les arguments (d'entrée ou de sortie) les un des autres. Voici un exemple un peu compliqué : function [x,y,z] = sphere(theta,phi,rho)

S'il n'y a aucun argument de sortie (ici x, y ou z), laisser sa place libre c'est à dire un "blanc". Exemple : function printresults(x)

Ou l'utilisation de crochets vides

function [ ] = printresults(x) Les variables que l'on passe à la fonction n'ont pas besoin d'avoir le même nom que ceux dans la ligne de définition de fonction. La ligne H1

La ligne H1, ainsi appelée parce que c'est la première ligne des textes d'aide, est une ligne de commentaire juste après la ligne de définition de fonction. Puisqu'elle se compose du texte de commentaire, la ligne H1 commence par un signe pour cent signent, "%." Pour la fonction moyenne, la ligne H1 est :

% AVERAGE Mean of vector elements.

function y=average(X)

Argument d’entrée

Nom de la fonction

Argument de sortie

Mot clé utilisé par MATLAB

Ligne de la ‘‘function’’


27

C'est la première ligne du texte qui apparaît quand un utilisateur sollicite laide en écrivant dans la commande : "help

function_name". La fonction "lookfor" permet de rechercher et de montre seulement la ligne H1. Puisque cette ligne fournit des informations récapitulatives importantes au sujet du M-File concerné, il est important de le rendre aussi descriptif que possible c'est-à-dire le commentaire dans la ligne H1 doit fournir les informations nécessaires au sujet de la fonction. Texte d’aide :

On peut créer l'aide en ligne pour nos M-Files en écrivant le texte sur une ou plusieurs lignes de commentaire, commençant par la ligne juste après la ligne H1.Le texte d'aide pour la fonction "moyenne" est :

% AVERAGE(X), where X is a vector, is the mean of vector elements. % Nonvector input results in an error.

En tapant la commande "help function_name", MATLAB montre les lignes de commentaire qui apparaissent entre la ligne de définition de fonction et la première la première qui ne comporte aucun commentaire (exécutable ou blanche).Le système d'aide ignore toutes les lignes de commentaire qui apparaissent après ce bloc d'aide. Par exemple, le résultat de "help sin" est:

SIN Sine. SIN(X) is the sine of the elements of X. Overloaded methods help sym/sin.m

Le Corps de la Fonction :

Le corps de fonction contient tout le code de MATLAB qui exécute des calculs et assigne des valeurs aux arguments de retour. Les instructions dans le corps de fonction peuvent se composer des appels de fonction, programmant des constructions comme la commande d'exécution et l'entrée-sortie interactive, des calculs, des tâches, des commentaires, et des interlignes. Par exemple, le corps de la fonction "moyenne" contient un certain nombre d'instructions de programmations simples :

[m,n] = size(x); if (~((m == 1) | (n == 1)) | (m == 1 & n == 1)) % Flow control error('Input must be a vector') % Error message display end y = sum(x)/length(x); % Computation and assignment

Commentaires :

Comme cité précédemment, les lignes de commentaire commencent par un signe de pourcentage (%). Les lignes de commentaire peuvent apparaître n'importe où dans un M-File, et on peut ajouter des commentaires à l'extrémité d'une ligne de code. Par exemple:

% Add up all the vector elements. y = sum(x) % Use the sum function.

La première ligne de commentaire juste après la ligne de définition de fonction est considérée comme la ligne H1 pour la fonction. La ligne H1 et toutes les lignes de commentaire juste après elle constituent l'entrée en ligne d'aide pour le dossier.

En plus des lignes de commentaire, on peut insérer les interlignes n'importe où dans un M-File. Des interlignes sont ignorés. Cependant, un interligne peut indiquer l'extrémité de l'enregistrement de texte d'aide pour un M-File.

Nom de la Fonction :

Les noms des fonctions de MATLAB ont les mêmes contraintes que les noms des variables. MATLAB emploie les 31 premiers caractères des noms. Les noms de fonction doivent commencer par une lettre ; les caractères restants peuvent être n'importe quelle combinaison des lettres, des nombres, et des soulignages. Quelques logiciels d'exploitation peuvent limiter des noms de fonction à des longueurs plus courtes.

Les textes définissant le nom du dossier qui contient une fonction de MATLAB comprennent l'extension .m. Par exemple :

average.m

Si le nom de fichier et la ligne nom de définition de fonction sont différents, le nom interne est ignoré. Ainsi, alors si le nom de fonction spécifié sur la ligne de définition de fonction n'est pas identique à celui du fichier, la fonction est ignorée ; nous recommandons vivement d'employer le même nom pour tous les deux.


28

Quel est le travail qu’exécute une fonction :

On peut appeler les fonctions inscrites sur les M-Files à partir de la ligne de commande de MATLAB ou de dans d'autres M-Files. Il faut s'assurer d'inclure tous les arguments nécessaires, en inserant les arguments d'entrée entre parenthèses et des arguments de sortie entre crochets.

Cette section fournit les informations suivantes sur l'appel des fonctions de MATLAB : * Function Name Resolution : Nom d’exécution de la fonction. * What Happens When You Call a Function : Ce qui se produit quand tu appelles une fonction. * Creating P-Code Files : Créer des dossiers qui contiennent des P-Code. * How MATLAB Passes Function Arguments : Comment MATLAB passe les arguments aux fonctions. * Function Workspaces : Les espaces de travail des fonctions. Execution des Functions Nommées: Quand MATLAB agit sur un nouveau nom spécifique d'une fonction, il le résout l'une après l'autre ces étapes :

1) Vérifie pour voir si le nom est une variable. 2) Vérifie pour voir si le nom est une subfunction, une fonction de MATLAB qui réside dans le même M-File que la fonction appelante. Les Subfunctions sont discutés dans la section, Subfunctions 3) Vérifie pour voir si le nom est une fonction privée, une fonction de MATLAB qui réside dans un annuaire privé, un

annuaire accessible seulement aux M-Files dans l'annuaire immédiatement au-dessus de lui. Des annuaires privés sont discutés dans la section, les fonctions privées

4) Vérifie pour voir si le nom est une fonction sur le chemin de recherche de MATLAB. MATLAB emploie le premier dossier rencontré dont le nom indiqué.

Si on invoque des noms de fonction, MATLAB exécute celui trouvé en premier d'abord en utilisant les règles ci-dessus. Il est également possible de surcharger des noms de fonctions. Ceci emploie des règles d'expédition additionnelles et est discuté dans la section, How MATLAB Determines Which Method to Call (comment MATLAB détermine quelle méthode à appeler). Ce qui se produit quand on appelle une fonction :

Quand tu appelles un M-File de fonction à partir de la ligne de commande ou d'un autre M-File, MATLAB analyse la fonction dans le pseudo-code et la stocke dans la mémoire. Ceci empêche MATLAB de la rechercher de nouveau (elle reste sous sa disposition) et l'utilise chaque fois qu'on lui fait appel, pendant la session. Le pseudo-code demeure dans la mémoire jusqu'à ce que on le dégages en employant la fonction "clair", ou jusqu'à ce que l'on stoppe MATLAB. On peut employer "clair" de n'importe manières pour supprimer des fonctions dans la zone de travail de MATLAB. Création P-Code Files :

On sauve la version d'une fonction au cours de préparation ou d'un manuscrit, dans les dossiers appelée P-code, pour des sessions postérieures de MATLAB en utilisant la fonction "pcode". Par exemple:

pcode average

Analyse "average.m" et sauve le pseudo-code résultant au dossier appelé "average.p". Ceci donne à MATLAB la possibilité de recourir à "average.m" la première fois qu'on l'appelle en chaque session.

Ainsi MATLAB fait très rapidement à l'analyse de la fonction dans le "pcode" avec une vitesse incomparable.

Une situation où le pcode fournit un avantage, de vitesse certaine, est pour de grandes applications de "GUI". Dans ce cas-ci, beaucoup de M-Files doivent être analysés avant que l'application devienne évidente. Une autre situation pour "pcode" est quand, pour des raisons de propriété industrielle, on veut cacher des algorithmes que l'on a créés dans un M-File. Comment MATLAB Fait Passer Arguments aux Fonctions :

De la perspective du programmeur, MATLAB semble passer tous les arguments de fonction par valeur. En fait, cependant, MATLAB passe par valeur seulement ces arguments qu'une fonction modifie. Si une fonction ne change pas un argument mais l'emploie simplement dans un calcul, MATLAB passe l'argument en se référant à l'optimisation l'utilisation de la mémoire.


29

Zones de Travail de Fonction :

Chaque fonction de M-file a un secteur de mémoire, séparé de la zone de base de travail de MATLAB, dans laquelle il fonctionne. Ce secteur s'appelle la zone de travail de fonction, avec chaque fonction ayant son propre contexte de zone de travail.

Tout en utilisant MATLAB, les seules variables auxquelles on acced sont celles se trouvant dans le contexte appelant, ou celle qui se trouvent dans la base de zone de travail ou celle d'une autre fonction. Les variables que l'on passes à une fonction doivent être dans le contexte appelant, et la fonction renvoie ses arguments de sortie au contexte appelant de zone de travail.On peut cependant, définir des variables en tant que variables globales explicitement, permettant à plus d'un contexte de zone de travail d'y accéder.

Vérification du nombre d'arguments de fonction :

Les fonctions " nargin"et "nargout" nous permettent de déterminer combien des arguments d'entrée et de sortie une fonction peut faire appel. On peut alors employer des codes conditionnels pour accomplir différentes tâches selon le nombre d'arguments.

Ex : function c = testarg1(a,b) if (nargin == 1) c = a.^2; elseif (nargin == 2) c = a + b; end

Cette fonction permet de :

- Si on lui donner un simple argument d'entrée, cette fonction ajuste la valeur d'entrée. - lui donner deux arguments d’entrés, elle les ajoute ensemble.

Voici un exemple plus avancé qui trouve la première marque dans une chaîne de caractères. Une marque est un ensemble de caractères délimités par un espace blanc ou un autre caractère. Donner une entrée, à la fonction, elle assume une délimitation par défaut c'est un espace blanc ; si on lui donne deux donnés d'entrées, elle nous laisse indiquer un autre délimitation si on le désir. Elle tient compte également de deux listes possibles d'argument de sortie :

function [token,remainder] = strtok(string,delimiters) % Function requires at least one input argument if nargin < 1 error('Not enough input arguments.'); end token = []; remainder = []; len = length(string); if len == 0 return end % If one input, use white space delimiter if (nargin == 1) delimiters = [9:13 32]; % White space characters end i = 1; % Determine where non-delimiter characters begin while (any(string(i) == delimiters)) i = i + 1; if (i > len), return, end end % Find where token ends start = i; while (~any(string(i) == delimiters)) i = i + 1; if (i > len), break, end end finish = i - 1; token = string(start:finish);


30

% For two output arguments, count characters after % first delimiter (remainder) if (nargout == 2) remainder = string(finish + 1:end); end

La fonction " strtok " est un M-file de MATLAB dans l'annuaire de " strfun"

Note : L'ordre dans lequel les arguments de retour apparaissent dans la ligne de déclaration de fonction est important. L'argument que la fonction renvoie dans la plupart des cas apparaît d'abord dans la liste. Des arguments additionnels et facultatifs sont annexés à la liste.

Dépassement du Nombres de Variables des Arguments : Les fonctions " varargin" et "varargout" nous ont laissé passer tout nombre d'entrées ou renvoyer n'importe quel nombre de sorties à une fonction. Cette section décrit comment utiliser ces fonctions et également couvertures :

* Unpacking varargin Contents : Déballage de la table des matières de variable et arguments d’entrée * Packing varargout Contents : Table des matières de variable et arguments de sortie * Varargin and varargout in Argument Lists : Varargin (variable d’entrées) et varargout (variable de sortie) dans des

listes d'argument MATLAB inscrit tous les arguments indiqués d'entrée dans une rangée de cellules, un genre spécial de rangée de MATLAB qui se compose des cellules au lieu des éléments de rangée.Chaque cellule peut tenir n'importe quelle taille ou genre de données - l'on a pourrait fair tenir un vecteur des données numériques, des autres dans la même rangée pourraient contenir un choix de données de corde, et ainsi de suite.Pour des arguments de sortie, votre code de fonction doit les inscrire dans une rangée de cellules de sorte que MATLAB puisse renvoyer les arguments à l'utilisateur qui les appelle.

Voici l’exemple d' une fonction qui accepte tout nombre de vecteurs de deux éléments et trace une ligne pour les relier :

function testvar(varargin) for i = 1:length(varargin) x(i) = varargin{i}(1); % Cell array indexing y(i) = varargin{i}(2); end xmin = min(0,min(x)); ymin = min(0,min(y)); axis([xmin fix(max(x))+3 ymin fix(max(y))+3]) plot(x,y)

Codé de cette façon, fonction testvar travail avec diverses listes d'entrée ; par exemple :

testvar([2 3],[1 5],[4 8],[6 5],[4 2],[2 3]) testvar([-1 0],[3 -5],[4 2],[1 1])

Développement du Contenu de "varargin" (variables et argument d’entrée)

Puisque le "varargin" contient tous les arguments d'entrée dans une rangée de cellules, il est nécessaire d'employer l'indexation de la rangée de la cellule pour en extraire les données. Par exemple :

y(i) = varargin{i}(2);

L'indexation de la rangée de cellules a deux composantes souscrites : * Les expressions sont indexées par des cellules, à l'intersection de la ligne et de colonne auxquelles elle appartient

* Le contenu de l'expression(s) est placé entre parenthèses. Dans le code ci-dessus, l'indexation {i} exprime qu'il faut accéder à la 'iemme' cellule du "varargin". L'indexation(2)exprime ou représente le deuxième élément du contenu de la cellules. Développement du Contenu du "varargout " (variables et argument de sortie)

En affectant tout nombre comme arguments de sortie, on dois mettre tous ces argument de sortie dans la rangée des cellules de "varargout". Employer le " nargout" pour déterminer avec combien d'arguments de sortie on peut appel à la fonction . Par exemple, ce code accepte une rangée d'entrée de deux colonnes, où la première colonne représente les abscisse x et la seconde représente les coordonnés y. elle les calasse sous forme de vecteur [xi yi]que l'on peut passer dans la fonction "testvar" pour effectuer son test ; ce qui sera fait dans la page suivante la page suivante.


31

function [varargout] = testvar2(arrayin) for i = 1:nargout varargout{i} = arrayin(i,:) % Cell array assignment end

L'instruction d'affectation à l'intérieur du la boucle for emploie la syntaxe des tâche assignée aux rangées de cellules. Le côté gauche de la déclaration, la rangée de cellules, est indexée en utilisant les croisements des lignes et des colonnes, pour indiquer que les données vont à l'intérieur d'une cellule. Pour l'information complète sur la tâche assignée aux rangées de cellules, voir "Structures and Cell Arrays". Voici comment appeler la fonction" testvar2".

a = {1 2;3 4;5 6;7 8;9 0}; [p1,p2,p3,p4,p5] = testvar2(a);

" varargin et varargout dans des listes d'arguments " La fonction "varargin" ou la fonction "varargout" doit faire apparaître le dernier argument dans la liste, après cela elle décide qui des variables requières la priorité entrer parmi les variables d'enté ou de sortie. C'est-à-dire, que l'appel de fonction doit indiquer les arguments exigés d'abord. Par exemple, les lignes de déclaration des fonctions suivantes permettent de visualiser si la déclaration des placements est correcte ou non dans les fonctions "varargin" et "varargout" :

function [out1,out2] = example1(a,b,varargin) function [i,j,varargout] = example2(x1,y1,x2,y2,flag)

Variables Locales et Globales

Les mêmes directives qui s'appliquent aux variables de MATLAB s'appliquent également à la ligne de commande des variables dans les M-Files :

* On n'a pas besoin d'écrire (taper) ou de déclarer des variables. Avant d'assigner à une variable à une l'autre, cependant, il faut s'assure que la variable du côté droit doit être assignée à une valeur. * N'importe quelle opération qui assigne une valeur à une variable crée la variable si nécessaire, ou recouvre sa valeur courante si elle existe déjà. * Les noms variables de MATLAB se composent d'une lettre suivie de tout nombre de lettres, de chiffres, et de soulignages. MATLAB distingue les minuscules majuscules et, ainsi A et a ne sont pas la même variable. * MATLAB emploie seulement les 31 premières lettres pour nommer les variables.

D'habitude, chaque fonction de MATLAB, définie par un M-dossier, a ses propres variables locales, qui sont séparé de

ceux d'autres fonctions, et de ceux de la base de zone de travail .Cependant, si plusieurs fonctions, aussi la base de zone de travail, déclarent un nom particulier comme global, alors ces fonction ainsi que la base de la zone de travail partagent une copie simple de cette variable. En assignant n'importe quelle tâche à cette variable, dans n'importe quelle fonction, elle est disponible à toutes les autres fonctions sous la déclaration "globale". Supposer que l'on veut étudier l'effet des coefficients d'interaction, et, dans le modèle de prédateur-proie de Lotka-Volterra.

'1 1 1 2

'2 2 1 2

y y αy y

y y βy y

= −

= − +

Créer un M-file que l’on nommera « lotka.m. » dans lequel on notera ce programme: function yp = lotka(t,y) %LOTKA Lotka-Volterra predator-prey model. global ALPHA BETA yp = [y(1) - ALPHA*y(1)*y(2) ; -y(2) + BETA*y(1)*y(2)];

Les commandes interactives seront alors :

global ALPHA BETA


32

ALPHA = 0.01 BETA = 0.02 [t,y] = ode23('lotka',0,10,[1; 1]); plot(t,y)

Les deux rapports globaux font les valeurs assignées à l'ALPHA et BÊTAS au message de sollicitation de commande

disponible à l'intérieur de la fonction définie par lotka.m. Ils peuvent être modifiés interactivement et de nouvelles solutions sront obtenues sans avoir le besoin d'éditer aucun dossier. Pour notre application MATLAB travailler avec des variables globales :

* Déclarer la variable comme "globale" dans chaque fonction qui exige l'accès à elle. Pour permettre à la zone de travail d'accéder à la variable globale, la déclarer également comme "globale" par la ligne de commande. * Dans chaque fonction, la commande issue de la déclaration "globale" doit être en l'occurrence la

première avant le nom variable. La déclaration doit être faite tout au début du M-File.

Les noms variables globaux de MATLAB sont en général plus longs et plus descriptifs que des noms variables locaux, et se composent parfois de tous les caractères majuscules. Ce ne sont pas des conditions, mais dans but d'augmenter la lisibilité du code de MATLAB et d'éviter de redéfinir accidentellement une variable globale.

Les Variables Persistantes

Une variable peut être définie comme "persistent" de sorte qu'elle ne change pas la valeur d'un appel à l'autre. Des variables persistantes peuvent être employées dans une fonction seulement. Les variables persistantes demeurent dans la mémoire jusqu'à ce que le M-File soit dégagé ou qu'il ait été changé.

"persistant" est exactement comme "global", sauf que le nom de la variable n'est pas dans la zone de travail globalement, et la valeur est remise à zéro si le M-File est changé ou dégagé.

Trois fonctions de MATLAB portent l'utilisation des variables persistantes.

Function Description

mlock Prevents an M-file from being cleared : Empêche un M-File de s'être dégagé

munlock Unlocks an M-file that had previously been locked by mlock : Ouvre un M-File qui avait été précédemment fermé à clef par la commande"mlock"

mislocked Indicates whether an M-file can be cleared or not : Indique si un M-File peut être dégagé ou pas

Valeurs Spéciales

Plusieurs fonctions renvoient ou retournent les valeurs spéciales importantes que l'on peut employer dans vos M-File.


33

Function Return Value

ans Most recent answer (variable). If you do not assign an output variable to an expression, MATLAB automatically stores the result in ans.

eps Floating-point relative accuracy. This is the tolerance MATLAB uses in its calculations.

realmax Largest floating-point number your computer can represent.

realmin Smallest floating-point number your computer can represent.

pi 3.1415926535897...

i, j Imaginary unit.

inf Infinity. Calculations like n/0, where n is any nonzero real value, result in inf.

NaN Not-a-Number, an invalid numeric value. Expressions like 0/0 and inf/inf result in a NaN, as do arithmetic operations involving a NaN. n/0, where n is complex, also returns NaN.

computer Computer type.

version MATLAB version string.

Voici plusieurs exemples qui emploient ces valeurs dans des expressions de MATLAB. x = 2*pi; A = [3+2i 7-8i]; tol = 3*eps;

Types De Données

Il y a 14 types de données fondamentaux (ou classes) dans MATLAB. Chacun de ces types de données est sous forme de rangée(ou espace ou dimension).Cette rangée(ou espace ou dimension) est un minimum de taille de 0-par-0 et peut devenir au choix un dimensionnel de taille n ou de n'importe quelle autre taille. Les versions bidimensionnelles de ces rangées (ou espace ou dimension) s'appellent les matrices.

Tous les types de données fondamentaux sont montrés en texte minuscule dans le diagramme ci-dessous. Un type de données additionnel et défini pour l'utilisateur, montré ci-dessous comme classe d'utilisateur, est un sous-ensemble du type de structure.


34

Le type de données "char" tient des caractères dans la représentation d'Unicode. Une chaîne de caractères est simplement un choix de 1-par-n caractères. On peut employer "char" pour comparer les longues chaînes ont la même longueur (c'est parce que les espaces de MATLAB doivent être de forme rectangulaires). Pour superposer des chaînes de longueurs inégales, utiliser la commande "cell".

A ce niveau vous êtes bien lancés ; a vous la suite

Documents

Apprendre_MATLAB