Cours de Matlab avec exemples d'application
...
Fonction help
Lorsque vous recherchez de l'aide sur une fonction précise de Matlab, vous pouvez simplement taper la commande:
>> help nom_de_la_fonction
Exemple
>> help det
DET Determinant.
DET(X) is the determinant of the square matrix X.
Use COND instead of DET to test for matrix singularity.
See also COND. Overloaded methods
help sym/det.m
Note
Dans l'aide de Matlab, même si les noms des fonctions sont indiqués en majuscule, il convient d'écrire ces noms en minuscule lors de l'appel de ces fonctions. Par exemple, si on souhaite calculer le déterminant de la matrice on écrira dans Matlab:
>> det([4 2; 1 3])
ans =
10
>>
Fonction lookfor
La fonction lookfor permet de rechercher les fonctions se rapportant à un certain sujet. Vous devez simplement veiller à entrer les mots-clés en anglais. >> lookfor mot_clé_en_anglais
Exemple
>> lookfor determinant
DET Determinant.DET
Fonction helpwin
La fonction helpwin fait apparaître une fenêtre qui vous permet de naviguer à travers l'aide des fonctions de Matlab. On écrira dans Matlab:
>> helpwin
Fonction doc
Matlab dispose d'une documentation très fournie sous la forme de pages HTML. Pour accéder à ces pages, tapez la commande: doc ou helpdesk . Si vous recherchez une information sur une commande précise : doc nom_de_la_commande
Introduction
Matlab, et non pas Mathlab est l'abréviation de MATRIX LABORATORY. C'est un logiciel de calcul numérique, utilisant des matrices comme objets de base. Ces matrices peuvent aussi être des vecteurs (ligne ou colonne), ainsi que des scalaires. Matlab manipule aussi bien les nombres réels que les nombres complexes.
Ce qui fait la popularité de Matlab, c'est la facilité avec laquelle on peut programmer des méthodes numériques, les tester et visualiser les résultats sous forme graphique. C'est un logiciel qui se destine plus à l'expérimentation numérique. Lorsqu'on doit résoudre un problème de très grande taille demandant une importante puissance de calcul, il vaut souvent mieux utiliser des logiciels spécifiques, ou programmer soi-même les méthodes numériques dans un langage tel que C, C++, Fortran, Java,....
Interface
Les menus et les boutons au sommet de la fenètre permettent d'accéder à certaines fonctionalités de Matlab sous Windows (éditeur de scripts, gestion des variables, gestion des chemins d'accès,...). Au centre de la fenètre, on trouve la ligne de commande de Matlab qui permet d'entrer des instructions et de lire les résultats. C'est là que nous allons travailler.
Créer une matrice
On peut créer une matrice A explicitement:
>> A = [1 2 3 ; 4 5 6]
A =
1 2 3
4 5 6
La matrice est délimitée par des crochets, on entre les éléments ligne par ligne, avec un point-virgule pour séparer les lignes de la matrice. De la mème façon, on peut créer un vecteur ligne:
>> B = [1 5]
B =
1 5
ou un vecteur colonne:
>> C = [3 ; 4 ; 5]
C =
3
4
5
Une autre façon de faire est de créer un vecteur colonne et de le transposer avec l'opérateur de transposition: l'apostrophe.
>> D = [1 2]'
D =
1
2
Les scalaires se déclarent indifféremment comme des matrices 1*1, soit directement comme des scalaires:
>> E = [5]
E =
5
>> F = 6
F =
6
On accède aux éléments d'une matrice en spécifiant entre parenthèses et séparés d'une virgule, la ligne et la colonne de l'élément désiré:
>> A(2,3)
ans =
6
Pour les vecteurs colonne (resp. ligne), on peut choisir de ne pas spécifier la colonne (resp. ligne):
>> C(2,1)
ans =
4
Ou de façon équivalente:
>> C(2)
ans =
4
Pour les scalaires, on peut ne pas spécifier ni la ligne, ni la colonne:
>> F(1,1)
ans =
6
Ou encore:
>> F(1)
ans =
6
Ou encore:
>> F
F =
6
Pour connaître la signification du mot clé ans, on peut taper :
>> help ans
ANS Most recent answer.
ANS is the variable created automatically when expressions
are not assigned to anything else. ANSwer.
Pour une introduction à l'aide de Matlab, cliquez [ici]. Matlab possède aussi tout une série de fonctions pour créer des matrices spéciales essayez:
>> help elmat
Attention, la casse a de l'importance pour Matlab, A n'est pas équivalent à a ! On peut, par exemple, définir:
>> a = 2
a =
2
La variable A existe toujours:
>> A
A =
1 2 3
4 5 6
Modifier une matrice
Il est possible de modifier un des éléments d'une matrice :
>> A(1,3) = 2
A =
1 2 2
4 5 6
Si on modifie un élément inexistant d'une matrice, la matrice est agrandie jusqu'à ce que cet élément existe :
>> A(3,3) = 1 A =
1 2 2
4 5 6
0 0 1
Gestion de la mémoire
La facilité avec laquelle on crée de nouvelles variables dans Matlab fait que la mémoire risque vite d'ètre encombrée avec une multitude de variables dont on ne se sert plus. La commande who donne la liste des variables de l'espace de travail. La commande whos donne la mème liste, ainsi que des informations sur la nature et la taille de chaque variable.
>> who
Your variables are:
A C E a
B D F
>> whos
Name Size Bytes Class
A 3x3 72 double array
B 1x2 16 double array
C 3x1 24 double array
D 2x1 16 double array
E 1x1 8 double array
F 1x1 8 double array
a 1x1 8 double array
Grand total is 19 elements using 152 bytes
Pour effacer une variable et libérer la mémoire qu'elle occupait, il faut effectuer la commande:
clear nom_de_la_variable
>> clear F
>> who
Your variables are:
A C E
B D a
La commande clear all efface toutes les variables de l'espace de travail. Il n'est pas possible d'annuler (undo) la commande clear.
Affichage
Lorsqu'on souhaite que le résultat d'une commande ne s'affiche pas, il faut placer un point-virgule à la fin de celle-ci:
>> T = [1 2 3];
Aucun résultat n'est affiché, pourtant, la commande a bien été exécutée.
>> T
T =
1 2 3
Pour cette partie, on réutilisera les matrices qui ont été définies à la partie précédente [les bases].
Opérations sur les scalaires
Matlab permet d'effectuer les opérations classiques sur les scalaires :
>> toto = (E-a)^a*a/E+1
toto =
4.6000
Les fonctions classiques comme sin, cos, log, ... existent aussi. (essayez helpwin ops, ou helpwin elfun)
>> titi = sin(a)
titi =
0.9093
NB : Les fonctions trigonométriques travaillent en radians.
Valeurs particulières
Certaines valeurs particulières sont définies dans Matlab:
pi : c'est la constante pi avec un maximum de chiffres après la virgule.
i ou j : l'unité imaginaire. Si on a déjà utilisé i et j comme noms pour d'autres variables, ces constantes sont inaccessibles. On peut alors utiliser sqrt(-1)
>> tata = a + sqrt(-1) + 2*i;
>> tata = 2.0000 + 3.0000i;
On a un nombre complexe !
Inf : L'infini. C'est le résultat renvoyé par Matlab quand un calcul devrait avoir un résultat infini.
NaN : Not a Number. Lorsque le résultat d'un calcul est indéterminé.
>> b = -3/0
Warning: Divide by zero.
b = -Inf
>> c = 0/0
Warning: Divide by zero.
c = NaN
Opérations sur les matrices
Les opérations +, - ,*, / existent aussi pour les matrices. S'il n'y a pas d'ambiguïtés pour l'addition et la soustraction, il faut faire attention pour les opération de multiplication, division, puissance, etc.
Exemples:
>> a*A
ans =
2 4 4
8 10 12
0 0 2
>> A*A
ans =
9 12 16
24 33 44
0 0 1
>> A*C
ans =
21
62
5
>> T*A
ans =
9 12 17
>> A*T
??? Error using ==> *
Inner matrix dimensions must agree.
Les matrices doivent avoir des dimensions compatibles.
Le signe * est soit l'opérateur de produit matriciel, soit l'opérateur de multiplication d'une matrice par un scalaire. Si on souhaite multiplier deux à deux les éléments de deux matrices, il faut utiliser l'opérateur .* .
>> C .* [2; 1; 2]
ans =
6
4
10
C'est la même chose pour l'opérateur ^. Si A^2 signifie A*A au sens matriciel, A.^2 signifie qu'on prend tous les éléments de A élevés au carré. Pour plus de détail essayez : helpwin ops.
Résolution de systèmes linéaires
Une façon de résoudre un système linéaire A*x = C, est de calculer l'inverse de A:
>> x = inv(A)*C
x =
-5.6667
-0.6667
5.0000
Cette façon de procéder peut être très imprécise si la matrice A est mal conditionnée. En outre calculer l'inverse de la matrice demande beaucoup plus d'opérations qu'il n'en faut pour résoudre le système uniquement. Une meilleure façon de procéder est d'utiliser l'opérateur de division à gauche de Matlab ( \ ). Matlab utilise alors un ensemble de méthodes mieux appropriées pour résoudre le système (Par exemple la factorisation LU de la matrice, suivie de la résolution de deux systèmes triangulaires).
>> x = A\C
x =
-5.6667
-0.6667
5.0000
Concaténation et extraction
Il est possible de créer de nouvelles matrices en concaténant des matrices déjà existantes. La syntaxe est similaire à celle de la création de matrices à partir de scalaires.
>> [A C;1 T]
ans =
1 2 2 3
4 5 6 4
0 0 1 5
1 1 2 3
Lorsqu'on écrit A(1,3), on extrait en fait une sous-matrice de dimensions 1*1. Cette syntaxe est en fait extensible à des sous-matrices de plus grande taille.
>> A(2,[1 3])
ans =
4 6
Ici, on a extrait la sous matrice composée de la deuxième ligne de A et des colonnes 1 et 3.
>> A(2,[3 1 2])
ans =
6 4 5
Ici, on crée un matrice qui est constituée d'une permutation de la deuxième ligne de A.
>> A([1 3 2],[3 1 2])
ans =
2 1 2
1 0 0
6 4 5
Ici, on a simplement créé une matrice : A, dont on a permuté les lignes et les colonnes.
L'opérateur ":" (colon) est un opérateur permettant de générer des suites de nombres. Il est très utile pour extraire des sous-matrices, gérer les boucles d'itérations (voir la partie : structures de contrôle), etc.
Générer une suite de nombres
>> a = -2:3
a =
-2 -1 0 1 2 3
>> b = [-2:3]
b =
-2 -1 0 1 2 3
>> c = [-2:3]'
c =
-2
-1
0
1
2
3
La notation "a:b" signifie : tous les nombres de a à b par pas de 1.0 . Si ce n'est pas possible, on obtient un message d'erreur.
>> 3:-1
ans =
Empty matrix: 1-by-0
Modifier le pas
Si on avait voulu générer la liste de l'exemple précédent, mais en allant de 3 à 2, on aurait pu faire:
>> a = fliplr([-2:3])
a =
3 2 1 0 -1 -2
Mais il est plus simple d'écrire :
>> a = 3:-1:-2
a =
3 2 1 0 -1 -2
La notation "a : h : b" signifie : tous les nombres de a à b par pas de h. Le pas h peut être positif ou négatif. Pour générer tous les nombres pairs de 4 à 20, on écrit :
>> b = 4:2:20
b =
4 6 8 10 12 14 16 18 20
Sélectionner une sous-matrice
Soit la matrice A:
>> A = [1 2 3 4; 5 6 7 8 ; 9* ones(1,4); zeros(1,4)]
A =
1 2 3 4
5 6 7 8
9 9 9 9
0 0 0 0
Pour extraire la sous matrice 3*3 composée des 3 premières lignes et colonnes on écrit :
>> B = A(1:3,1:3)
B =
1 2 3
5 6 7
9 9 9
Pour extraire la dernière colonne :
>> A(1:4,4)
ans =
4
8
9
0
Il existe un raccourci qui permet de spécifier d'un coup toutes les lignes ou colonnes d'une matrice :
>> A(:,2)
ans =
2
6
9
0
Il faut lire : A(toutes les lignes, deuxième colonne). Cette notation est équivalente à :
>> A(1:size(A,1),2)
ans =
2
6
9
0
De la même façon, on peut écrire :
>> A(1,:)
ans =
1 2 3 4
>> A(1,1:size(A,2))
ans =
1 2 3 4
Tracer le graphe d'une fonction
Un moyen simple de visualiser le graphe d'une fonction de R dans R est d'évaluer cette fonction en un certain nombres de points, et de relier ces points par des segments de droite. Visualisons la fonction sin(x) pour x valant de 0 à 12.
>> x = [0:0.05:12];
>> y = sin(x);
>> plot(x,y)
A la première ligne, on génère des valeurs de 0 à 12, espacées de 0.05. Ensuite, on évalue la fonction sinus en ces points. Enfin on affiche ces points, reliés par des lignes. Le résultat est:
Note
Si vous voulez de l'aide sur l'opérateur ":", tapez help colon essayez aussi : help linspace , help logspace
Le langage de Matlab n'aurait pas beaucoup d'intérêt s'il n'était pas possible d'effectuer des tests, de programmer des boucles, etc., comme dans la majorité des langages de programmation. L'aide concernant les structures de contrôle peut être accédé via:
>> helpwin lang
Opérations booléennes
Les valeurs booléennes "vrai" et "faux" sont respectivement représentées dans Matlab par les valeurs 1 et 0. Les opérateurs booléens de Matlab sont décrits à la rubrique d'aide relop (helpwin relop). On a les opérateurs : > , >= , < , <= , == (égal), ~= (différent), & (et), | (ou), ~ (non), xor (ou exclusif).
Exemples:
>> a = 2; b = 3;
>> a>b
ans =
0
>> a>=a
ans =
1
>> a==a
ans =
1
>> a~=a
ans =
0
>> (b>a) & (a~=4)
ans =
1
>> (b<a) | (a==2)
ans =
1
Attention : Lorsque vous écrivez une expression qui combine des opérations arithmétiques et des opérations booléennes, veillez à bien utiliser les parenthèses.
Structure if
La structure if est similaire à celle de nombreux langages de programmation (C, C++, Java,...):
IF expression1
statements1
ELSEIF expression2
statements2
ELSE
statements3
END
Si l'expression expression1 est vraie, alors les commandes statements1 sont exécutées, sinon, si l'expression expression2 est vraie alors les commandes statements2 sont exécutées, enfin, si ni expression1 ni expression2 ne sont vraies, alors ce sont les commandes statements3 qui sont exécutées. Les clauses ELSEIF et ELSE sont optionnelles.
Exemple :
>> if (a==3) [ENTER]
b = 2 [ENTER]
else [ENTER]
b = 4 [ENTER]
end [ENTER]
b =
4
Attention : Une erreur fréquente est d'écrire un THEN après expression1. THEN n'existe pas dans Matlab !
Structure while
La structure while est une structure puissante permettant de faire de répéter une séquence d'instructions, tant qu'une certaine condition est vérifiée:
WHILE expression
statements
END
Tant que expression est vraie, alors les commandes statements sont exécutées. A titre d'exemple, calculons la somme des carrés des entiers de 1 à 11:
>> i = 0;
>> somme = 0;
>> while(i<=10)
i=i+1;
somme = somme + (i*i);
end
>> somme
somme =
506
On aurait aussi pu se passer de l'utilisation d'une boucle:
>> sum([1:11].^2)
ans =
506
Il faut faire attention à ne pas créer de boucle sans fin. Exemple:
>> while (i>0)
i = i+1;
end
Cette boucle ne s'arrêtera jamais. On peut toujours stopper une commande Matlab en cours d'exécution en tapant : [CTRL] + C (combinaisons des touches Ctrl et C).
Structure for
FOR variable = expr
statement
END
Si n est la longueur du vecteur représenté par expr , les commandes statement seront exécutées n fois, lors de la première exécution, variable aura la valeur expr(1), ... et ainsi de suite jusqu'à la dernière fois où variable aura la valeur expr(n). A titre d'exemple, calculons le produit des entiers impairs de 1 à 11:
>> p = 1;
>> for i=[1:2:11]
p = p*i;
end >> p p =
10395
Sans utiliser de boucle, on aurait fait:
>> prod([1:2:11])
ans =
10395
Commande break
La commande break permet de sortir d'une boucle (for ou while). Exemple : >> i = 0;
>> while (i>=0)
i = i+1;
if (i==10)
break;
end
end
>> i
i =
10
Matlab aurait une utilité fort limitée s'il n'était pas possible d'écrire des scripts et des fonctions:
Script: Un ensemble d'instructions, écrites dans un fichier qu'on peut exécuter en une fois.
Fonction: Un ensemble d'instructions, prenant certains arguments en entrée et renvoyant un ou plusieurs résultats.
Scripts
Les scripts sont stockés dans des fichiers dont l'extension est ".m". Ils contiennent une suite d'instructions Matlab, écrites comme si on les avait entrées dans la fenêtre de Matlab. Pour exécuter un script, il faut juste taper son nom (sans l'extension ".m") dans la fenêtre de commande de Matlab.
Exemple: monscript.m. A l'exécution, on obtient le résultat suivant:
>> monscript
Bonjour, ceci est un script.
Appuyez sur [Espace] pour continuer
A =
1 2 3
4 5 6
B =
3
5
7
A =
1 2 3
4 5 6
0 0 1
C = A*B ,.... voici le résultat
C =
34
79
7
Les scripts peuvent accéder aux variables qui ont été définies avant son lancement, et les variables qui ont été définies durant le script restent accessible après par l'utilisateur. Pour plus d'informations : helpwin script
Fonctions
Les fonctions sont aussi stockées dans des fichiers ".m" (mfiles). Le fichier doit porter le même nom que la fonction. La syntaxe pour écrire une fonction est la suivante:
function [Sortie1, ... , SortieN] = nom_de_la_fonction(Argument1, ... , ArgumentP)
instructions
Les instructions peuvent utiliser les variables Argument1, ... ,ArgumentP, et doivent attribuer une valeur aux variables Sortie1, ... ,SortieN.
Exemple : mafonction.m. A l'exécution, on obtient:
>> [r1 r2 r3] = mafonction(5,9);
>> r1
r1 =
14
>> r2
r2 =
45
>> r3
r3 = 5
>> help mafonction
Ceci servira d'aide.
Si on tape help mafonction, ce sont les premières lignes
de commentaires de la fonction qui sont affichées.
[somme produit minimum] = mafonction(a,b)
renvoie la somme le produit et le minimum de a et b
Pour plus d'informations : helpwin function
Problèmes de chemin d'accès
Matlab ne pourra exécuter un script ou une fonction que si il sait dans quel répertoires il doit rechercher les mfiles correspondants. Par défaut, Matlab recherche dans certains de ses répertoires, ainsi que dans le répertoire courant. Pour savoir quel est le répertoire courant, utilisez la commande pwd (print working directory).
>> pwd
ans =
/home/schubert.user1
Pour changer de répertoire, utilisez la commande cd:
>> cd mfiles (pour descendre dans le sous répertoire mfiles)
Si vous ne souhaitez pas changer de répertoire, mais ajouter un répertoire à la liste des répertoire dans lesquels Matlab recherche les scripts et fonctions, utilisez la commande addpath:
>> addpath('./utils') (pour ajouter le sous-répertoire utils)
Attention
Il y a un bug (une erreur) dans certaines versions de Matlab: Matlab oublie de rechercher les scripts et fonctions dans le répertoire courant. Pour résoudre ce problème, taper la commande addpath('./') pour ajouter explicitement le répertoire courant dans la liste des répertoires explorés. Pour plus d'informations : helpwin path, helpwin what, ...
Thèmes choisis
Nous vous conseillons d'ouvrir une fenêtre Matlab et de reproduire les exemples donnés dans chacun des points suivants.
Equations différentielles ordinaires
Utiliser Matlab pour résoudre numériquement des systèmes d équations différentielles ordinaires.
Cliquez [ici]
Les polynômes
Représentation et manipulation des expressions polynômiales
Cliquez [ici]
La vectorisation
Pourquoi utiliser des vecteurs plutôt que des boucles
Cliquez [ici]
Les graphes 2D
Présentation des fonctions de base permettant de réaliser des graphes en 2 dimensions
Cliquez [ici]
Introduction
Les modèles mathématiques des sciences et techniques se présentent très souvent sous la forme de systèmes d'équations différentielles ordinaires, qui lient des fonctions (inconnues) du temps à leurs dérivées temporelles. En ajoutant des conditions aux limites à ces équations, on peut alors calculer ces fonctions inconnues. Par exemple, la loi de Newton permet de trouver les équations qui régissent le mouvement en chute libre d'un corps représenté par une masse ponctuelle, dans un champ de gravité constant. Si on connaît la position et la vitesse initiale du corps, on peut alors résoudre les équations du mouvement et obtenir la position et la vitesse du corps comme des fonctions du temps.
Dans de nombreux cas, ces équations sont trop complexes pour pouvoir être résolues de façon analytique et l'unique possibilité est d'essayer d'approximer les fonctions inconnues au moyen de méthodes numériques. L'idée de base consiste à ne chercher la valeur des fonctions qu'en un certain nombre de points : le problème est discrétisé.
Un certain nombre de ces méthodes numériques ont été implémentées dans le logiciel Matlab et permettent de résoudre relativement facilement un grand nombre de problèmes. Ce document constitue une introduction à l'utilisation des méthodes implémentées dans Matlab. Une utilisation efficace et avertie de ces méthodes suppose un minimum de connaissance des concepts sur lesquelles elles se basent.
Solution numérique d'EDO avec Matlab
Pour résoudre numériquement une EDO avec Matlab (ou un système d'EDOs) il faut d'abord faire un peu d'algèbre pour ramener l'équation ou le système d'équations différentiel sous la forme:
où u(t) est le vecteur des fonctions inconnues. Sa dérivée temporelle est exprimée par la fonction g, qui est une fonction du temps et de u(t).
On peut ensuite lancer ODE45 pour trouver la valeur de u(t). Il faut pour cela lui fournir 3 éléments:
La fonction g(t,u) qui donne la valeur de la dérivée de u(t) en fonction de t et de u. Cette fonction sera décrite dans un fichier .m
Un intervalle de temps sur lequel on souhaite connaître la valeur de la fonction inconnue
Une condition initiale, c'est à dire un point de passage de la fonction inconnue.
Le pourquoi du comment
Cette partie décrit le fonctionnement interne de ODE45. Tout ceci se passe automatiquement à l'intérieur de ODE45. Si ce fonctionnement ne vous intéresse pas, passez cette partie et allez directement voir la partie "Mais encore" ci-dessous.
ODE45 va utiliser les éléments que vous lui fournissez pour reconstruire, pas à pas, la fonction inconnue. ODE45 va commencer par découper en morceaux l'intervalle de temps sur lequel vous lui avez demandé la valeur de la fonction u(t) (l'explication de ceci va apparaître par la suite). Soit [T0 T1 ... TN] cet intervalle. Notez que vous ne pouvez contrôler la manière dont ODE45 découpe l'intervalle. Vous ne pouvez que lui fournir les valeurs extrèmes: T0 et TN.
L'information qui sera ensuite utilisée par ODE45 est la condition initiale que vous lui avez fournie, c'est-à-dire la valeur u(0) de la fonction inconnue au temps t=T0. Connaissant T0 et u(t=T0), et connaissant la fonction g, ODE45 peut calculer la valeur de u'(t) au temps t=T0.
Autour de la condition initiale, on peut approximer la fonction inconnue par sa tangente, obtenue à l'aide du point de passage (condition initiale) et de la valeur de la dérivée au point de passage:
u'(t=T0)=g(T0,u(t=T0))
Ces étapes sont résumées sur la figure suivantes:
La suite de l'histoire est assez simple. ODE45 va calculer la valeur de la fonction inconnue en t=T1 en utilisant 2 approximations différentes de cette fonction inconnue (même principe que celui de la tangente ci-dessus). Si les 2 estimations sont proches, il garde la plus précise. Si ce n'est pas le cas, il choisit un T1 plus proche de T0 (on se rappelera que plus on se rapproche de T0, plus la fonction colle à sa tangente).
Une fois la valeur de u(t=T1) connue, on peut itérer. A l'aide de g, on calcule:
u'(t=T1)=g(T1,u(t=T1))
Ceci nous donne la direction de la fonction inconnue au point de passage connu (T1,u(T1)) et permet de choisir T2 et ainsi de suite.
Mais encore
On peut se poser toute une série de questions à propos de ODE45. En voici 2 importantes:
Que fait-on si l'équation à résoudre est d'ordre supérieur à 1 ?
Quelles sont les sorties fournies par ODE45 ?
Lorsque l'équation à résoudre est d'ordre supérieur à 1, on la transforme en un système de plusieurs équations chacune étant d'ordre 1.
Par exemple :
On désire résoudre numériquement l'équation différentielle décrivant le mouvement d'un pendule amorti (voir cours de mécanique). L'équation différentielle qui donne la position x(t) du pendule au cours du temps est:
Pour rappel, m est la masse du pendule et k le coéfficient de frottement. Cette équation est équivalente au système d'équations suivant:
où on a posé:
Il est à noter que dans ce cas, la condition initiale à fournir sera bien entendu un vecteur puisque nous avons maintenant 2 fonctions inconnues à retrouver. Matlab ne peut savoir qu'elles sont liées entre-elles par une relation de dérivée.
