Apprendre MATLAB en 10 Minutes
MATLAB (Matrix Laboratory) est un langage de programmation de haut niveau et un environnement conçus pour le calcul numérique, le développement d’algorithmes et la visualisation de données. Développé à la fin des années 1970, MATLAB est devenu un outil essentiel en ingénierie, en sciences et en mathématiques.
Ce tutorial couvre les fondamentaux de MATLAB et t’aide à démarrer avec cet environnement de calcul puissant.
1. Ton Premier Programme MATLAB
Crée un fichier script nommé hello.m ou tape des commandes directement dans la fenêtre de commande MATLAB.
disp('Hello, World!')
Ou en utilisant la fonction fprintf :
fprintf('Hello, World!\n')
Le résultat sera :
Hello, World!
La fonction disp() affiche le contenu directement, tandis que fprintf() offre un contrôle de formatage plus important, similaire au printf du C.
2. Syntaxe de Base
MATLAB a ses propres règles de syntaxe qui diffèrent de la plupart des langages de programmation généraux. Comprendre ces bases est essentiel pour écrire du code propre et maintenable.
2.1 Commentaires
Les commentaires sur une seule ligne commencent par le signe pourcentage % :
% This is a comment
x = 10; % This assigns 10 to x
Les commentaires multi-lignes utilisent %{ et %} :
%{
This is a multi-line comment.
It can span multiple lines.
%}
2.2 Point-virgules
Le point-virgule ; supprime l’affichage du résultat. Sans lui, MATLAB affiche le résultat :
x = 5 % Displays: x = 5
y = 10; % No output, but y is assigned
2.3 Sensibilité à la Casse
MATLAB est sensible à la casse. A et a sont des variables différentes :
A = 5;
a = 10;
disp(A) % Output: 5
disp(a) % Output: 10
2.4 Nommage des Variables
Les noms de variables doivent commencer par une lettre, suivis de lettres, de chiffres ou de tirets bas :
valid_name = 1;
another_valid_name_123 = 2;
% 123invalid = 3; % Error: cannot start with number
2.5 Opérations de Base
MATLAB excelle dans les opérations matricielles. Créer une matrice est simple :
A = [1 2 3; 4 5 6; 7 8 9] % 3x3 matrix
Résultat :
A =
1 2 3
4 5 6
7 8 9
3. Variables et Types de Données
MATLAB utilise le typage dynamique. Les variables sont créées lors de l’affectation et leur type est déterminé par la valeur assignée.
3.1 Types Numériques
MATLAB stocke tous les nombres en virgule flottante double précision par défaut :
% Integer
int_num = 42;
% Float
float_num = 3.14159;
% Scientific notation
sci_num = 2.5e-3; % 0.0025
3.2 Chaînes de Caractères
Les variables chaînes utilisent des guillemets simples :
str = 'Hello, MATLAB';
str2 = "Hello, MATLAB"; % String array (R2016b+)
Concaténation de chaînes :
str1 = 'Hello';
str2 = 'World';
combined = [str1 ', ' str2]; % 'Hello, World'
3.3 Logique (Booléen)
Les valeurs logiques sont true ou false :
flag = true;
result = false;
% Logical operations
a = true;
b = false;
and_result = a && b; % false
or_result = a || b; % true
not_result = ~a; % false
3.4 Tableaux de Caractères vs Chaînes
MATLAB dispose à la fois de tableaux de caractères et d’objets chaînes :
% Character array (older style)
char_arr = 'Hello';
% String object (modern style, R2016b+)
str_obj = "Hello";
% String objects are easier to work with
name = "Alice";
greeting = "Hello, " + name; % Works naturally
4. Structures de Données
MATLAB propose plusieurs structures de données pour différents cas d’utilisation.
4.1 Vecteurs
Un vecteur est un tableau unidimensionnel :
% Row vector
row_vec = [1 2 3 4 5];
% Column vector
col_vec = [1; 2; 3; 4; 5];
% Using colon operator
range_vec = 1:5; % [1 2 3 4 5]
step_vec = 0:2:10; % [0 2 4 6 8 10]
% linspace for evenly spaced values
lin_vec = linspace(0, 10, 5); % [0 2.5 5 7.5 10]
4.2 Matrices
Les matrices sont le fondement de MATLAB :
% Direct matrix creation
A = [1 2 3; 4 5 6; 7 8 9];
% Accessing elements
element = A(2, 3); % Returns 6 (row 2, column 3)
% Matrix operations
B = A'; % Transpose
C = A * B; % Matrix multiplication
D = A .* B; % Element-wise multiplication
4.3 Tableaux Cellules
Les tableaux cellules peuvent contenir différents types de données :
% Create a cell array
cell_arr = {1, 'hello', [1 2 3], true};
% Access cell contents using curly braces
data = cell_arr{2}; % Returns 'hello'
% Access cell using parentheses
sub_cell = cell_arr(1:2); % Returns {1, 'hello'}
4.4 Structures
Les structures sont comme des dictionnaires avec des champs nommés :
% Create a structure
student.name = 'John';
student.age = 20;
student.major = 'Engineering';
% Access fields
disp(student.name); % Output: John
% Array of structures
students(1).name = 'Alice';
students(1).age = 21;
students(2).name = 'Bob';
students(2).age = 22;
4.5 Tables
Les tables sont adaptées aux données tabulaires :
% Create a table
Age = [25; 30; 35];
Name = {'Alice'; 'Bob'; 'Charlie'};
Salary = [50000; 60000; 70000];
T = table(Name, Age, Salary);
% Access data
disp(T.Age);
disp(T.Name{1});
5. Opérateurs
MATLAB propose différents opérateurs pour les opérations arithmétiques, de comparaison et logiques.
5.1 Opérateurs Arithmétiques
a = 10;
b = 3;
sum = a + b; % 13
diff = a - b; % 7
prod = a * b; % 30
quot = a / b; % 3.3333
int_div = floor(a/b); % 3
mod = mod(a, b); % 1 (remainder)
pow = a ^ b; % 1000
5.2 Opérateurs Élément par Élément
Les opérateurs élément par élément fonctionnent sur les éléments correspondants :
A = [1 2 3];
B = [4 5 6];
C = A .* B; % Element-wise: [4 10 18]
D = A.^2; % Element-wise square: [1 4 9]
5.3 Opérateurs de Comparaison
x = 5;
y = 10;
eq = (x == y); % false
neq = (x ~= y); % true
gt = (x > y); % false
lt = (x < y); % true
ge = (x >= y); % false
le = (x <= y); % true
5.4 Opérateurs Logiques
a = true;
b = false;
and_op = a & b; % false (element-wise AND)
or_op = a | b; % true (element-wise OR)
not_op = ~a; % false
and_short = a && b; % false (short-circuit AND)
or_short = a || b; % true (short-circuit OR)
6. Contrôle de Flux
MATLAB propose des structures de contrôle de flux standard, mais avec une syntaxe différente de langages comme Python.
6.1 if-elseif-else
score = 85;
if score >= 90
grade = 'A';
elseif score >= 80
grade = 'B';
elseif score >= 70
grade = 'C';
else
grade = 'F';
end
disp(grade) % Output: B
6.2 switch
L’instruction switch compare une expression unique contre plusieurs cas :
day = 'Monday';
switch day
case {'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday'}
disp('Weekday');
case {'Saturday', 'Sunday'}
disp('Weekend');
otherwise
disp('Invalid day');
end
6.3 Boucles for
La boucle for itère sur une plage ou un tableau :
% Iterating over a range
for i = 1:5
disp(i);
end
% Iterating over an array
fruits = {'apple', 'banana', 'orange'};
for fruit = fruits
disp(fruit{1});
end
% Nested loops for matrix operations
A = [1 2; 3 4];
B = zeros(2, 2);
for i = 1:2
for j = 1:2
B(i, j) = A(i, j) * 2;
end
end
6.4 Boucles while
count = 0;
while count < 5
disp(count);
count = count + 1;
end
6.5 Contrôle de Boucles
L’instruction break sorts de la boucle, et continue passe à l’itération suivante :
% Using break
for i = 1:10
if i == 5
break;
end
disp(i);
end
% Output: 1 2 3 4
% Using continue
for i = 1:5
if mod(i, 2) == 0
continue; % Skip even numbers
end
disp(i);
end
% Output: 1 3 5
7. Entrée et Sortie
7.1 Entrée Utilisateur
Utilise la fonction input() pour obtenir l’entrée utilisateur :
% Get numeric input
num = input('Enter a number: ');
% Get string input
name = input('Enter your name: ', 's');
% Get expression input (evaluates the input)
expr = input('Enter an expression: ');
7.2 Affichage des Résultats
Plusieurs fonctions permettent d’afficher des résultats :
% disp - simple display
disp('Hello');
disp([1 2 3]);
% fprintf - formatted output
name = 'Alice';
age = 25;
fprintf('Name: %s, Age: %d\n', name, age);
% sprintf - create formatted string
str = sprintf('Value: %.2f', 3.14159);
disp(str);
7.3 Spécificateurs de Format
Les spécificateurs de format courants dans MATLAB :
% %s - string
% %d - integer
% %f - floating point
% %.2f - floating point with 2 decimal places
% %e - scientific notation
fprintf('%d %.2f %e\n', 42, 3.14159, 1000)
% Output: 42 3.14 1.000000e+03
8. Fonctions
Les fonctions dans MATLAB sont généralement définies dans des fichiers séparés, mais les fonctions anonymes offrent une création de fonctions en ligne.
8.1 Fonctions Anonymes
Les fonctions anonymes créent des fonctions simples sans fichiers séparés :
% Single input
square = @(x) x^2;
disp(square(5)); % Output: 25
% Multiple inputs
add = @(x, y) x + y;
disp(add(3, 4)); % Output: 7
% Multiple expressions
hypot = @(x, y) sqrt(x^2 + y^2);
disp(hypot(3, 4)); % Output: 5
8.2 Fichiers de Fonctions
Crée un fichier nommé myfunc.m :
function y = myfunc(x)
y = x^2 + 1;
end
Appelle la fonction :
result = myfunc(5); % Output: 26
8.3 Fonctions avec Plusieurs Sorties
function [sum, prod] = calc(x, y)
sum = x + y;
prod = x * y;
end
Appelle avec plusieurs sorties :
[s, p] = calc(3, 4);
disp(s); % 7
disp(p); % 12
8.4 Arguments Variables
Utilise varargin et varargout pour les arguments variables :
function result = sum_all(varargin)
result = 0;
for i = 1:length(varargin)
result = result + varargin{i};
end
end
% Call with any number of arguments
total = sum_all(1, 2, 3, 4, 5); % Output: 15
9. Fichiers Scripts
Les scripts sont des fichiers .m qui contiennent une séquence de commandes MATLAB. Ils fonctionnent sur les données de l’espace de travail :
% save as myscript.m
% Calculate statistics for a dataset
data = [1 2 3 4 5 6 7 8 9 10];
mean_val = mean(data);
std_val = std(data);
max_val = max(data);
min_val = min(data);
fprintf('Mean: %.2f\n', mean_val);
fprintf('Std: %.2f\n', std_val);
fprintf('Max: %d\n', max_val);
fprintf('Min: %d\n', min_val);
10. Gestion des Erreurs
Utilise try-catch pour la gestion des erreurs :
try
result = risky_operation();
catch ME
fprintf('Error: %s\n', ME.message);
% Handle the error
result = 0;
end
Utiliser error() pour lever des erreurs :
function result = divide(a, b)
if b == 0
error('Division by zero is not allowed');
end
result = a / b;
end
11. Opérations sur Fichiers
11.1 Sauvegarde et Chargement de Données
% Save variables to file
x = [1 2 3];
y = 'hello';
save('data.mat', 'x', 'y');
% Load variables from file
load('data.mat');
% Save to text file
writematrix(x, 'data.txt');
% Read from text file
data = readmatrix('data.txt');
11.2 Opérations sur Fichiers Texte
% Write to text file
fid = fopen('output.txt', 'w');
fprintf(fid, 'Line 1\n');
fprintf(fid, 'Line 2\n');
fclose(fid);
% Read from text file
fid = fopen('output.txt', 'r');
while ~feof(fid)
line = fgetl(fid);
if ischar(line)
disp(line);
end
end
fclose(fid);
Utiliser textscan pour une lecture structurée :
fid = fopen('data.txt', 'r');
format = '%s %d %f';
C = textscan(fid, format);
fclose(fid);
name = C{1};
age = C{2};
score = C{3};
12. Graphiques
Les capacités de représentation graphique de MATLAB sont l’une de ses fonctionnalités les plus puissantes.
12.1 Graphiques 2D de Base
x = 0:0.1:2*pi;
y = sin(x);
plot(x, y);
xlabel('x');
ylabel('sin(x)');
title('Sine Wave');
grid on;
12.2 Graphiques Multiples
x = 0:0.1:2*pi;
% Subplots
subplot(2, 1, 1);
plot(x, sin(x));
title('Sine');
subplot(2, 1, 2);
plot(x, cos(x));
title('Cosine');
12.3 Personnalisation des Graphiques
x = 0:0.1:10;
y1 = x;
y2 = x.^2;
plot(x, y1, 'b-', 'LineWidth', 2); % Blue solid line
hold on;
plot(x, y2, 'r--', 'LineWidth', 2); % Red dashed line
hold off;
xlabel('X');
ylabel('Y');
legend('Linear', 'Quadratic');
title('Linear vs Quadratic');
grid on;
12.4 Autres Types de Graphiques
% Bar chart
bar([1 2 3 4], [10 20 15 25]);
% Histogram
data = randn(1000, 1);
histogram(data, 30);
% Scatter plot
x = rand(100, 1);
y = 2*x + randn(100, 1)*0.1;
scatter(x, y);