UNIVERSITE NOUVEAUX HORIZONS

FACULTE DES SCIENCES TECHNOLOGIQUES

GENIE CIVIL & GENIE ELECTRIQUE

COURS D’INTRODUCTION AUX ELEMENTS

FINIS : EXERCICES MATLAB (SCRIPT)

Fait par : Tous les étudiants de L3 ST 2023_2024

Titulaire du Cours : Professeur OLELA OTAFUDU

ANNEE 2023-2024
 QUELQUES SCRIPT MATLAB SUIVANT L’ORDRE DES
QUESTIONS DANS LE PDF (EXERCICES MATLAB)
NB : Les scripts se trouvant dans ce document commencent à partir de la 3e Question dans le
PDF

Script MATLAB Question 3

t = (1:0.5:10)'; % Vecteur colonne de 1 à 10 par pas de 0,5

% Création de la matrice A avec les colonnes t, t^2, t^3 et t^4

A = [t, t.^2, t.^3, t.^4];

% Ajout d'une colonne qui vaut 1 lorsque t > 5, 0 sinon

B = [A, (t > 5)];
% Ajout d'une colonne qui vaut 1 lorsque t > 5, 0 sinon
C = [A, (t > 5)];

disp('La valeur de t')

disp(t)
disp('La valeur de A')
disp(A)
disp('La valeur de B')
disp(B)
disp('La valeur de C')
disp(C)
 Script MATLAB Question 3 Suite

function exercice()
% Générer une matrice aléatoire de dimension 10x10
matrice_aleatoire = rand(4, 4);

% Calculer la trace de la matrice

trace_matrice = trace(matrice_aleatoire);

% Calculer la transposée de la matrice

transposee_matrice = transpose(matrice_aleatoire);

% Vérifier si la matrice est inversible avant de calculer

l'inverse
if det(matrice_aleatoire) ~= 0
% Calculer l'inverse de la matrice
inverse_matrice = inv(matrice_aleatoire);
else
inverse_matrice = 'La matrice n''est pas inversible.';
end

% Afficher les résultats

disp('Matrice aléatoire de dimension 10x10 :');
disp(matrice_aleatoire);

disp('Trace de la matrice :');

disp(trace_matrice);

disp('Transposée de la matrice :');

disp(transposee_matrice);

disp('Inverse de la matrice :');

disp(inverse_matrice);
end
 Script MATLAB Question 4

% Générer les vecteurs colonnes u1, u2, u3

u1 = [1; 2; 3];
u2 = [-5; 2; 1];
u3 = [-1; -3; 7];

% Ecrivons la matrice A
A = [2,3,4;3,6,5;2,8,7];

% Afficher les résultats

disp('Vecteur colonne u1 :');
disp(u1);

disp('Vecteur colonne u2 :');

disp(u2);

disp('Vecteur colonne u3 :');

disp(u3);

disp('Matrice A :');
disp(A);

% Calcul de u1 + 3u2 - u3/5

resultat = u1 + 3*u2 - (u3/5);

% Afficher le résultat
disp('Résultat de u1 + 3u2 - u3/5 :');
disp(resultat);

% Calcul du produit scalaire entre u1 et u2

produit_scalaire = dot(u1, u2);

% Afficher le résultat
disp('Produit scalaire entre u1 et u2 :');
disp(produit_scalaire);

% Calcul du produit A*u1

produit_A_u1 = A * u1;

% Afficher le résultat
disp('Produit A*u1 :');
disp(produit_A_u1);

% Vecteur colonne u1
u1 = [1; 2; 3];

% Calcul de la norme ||u1||_2

norme_u1_2 = norm(u1, 2);

% Afficher le résultat
disp('Norme ||u1||_2 :');
disp(norme_u1_2);

% Vecteur colonne u2
u2 = [-5; 2; 1];

% Calcul de la norme ||u2||_1

norme_u2_1 = norm(u2, 1);

% Afficher le résultat
disp('Norme ||u2||_1 :');
disp(norme_u2_1);
% Vecteur colonne u3
u3 = [-1; -3; 7];

% Calcul de la norme ||u3||_{\infty}

norme_u3_infini = norm(u3, inf);

% Afficher le résultat
disp('Norme ||u3||_{\infty} :');
disp(norme_u3_infini);

% Dimensions de la matrice A
dimensions_A = size(A);

% Extraire le nombre de colonnes

nombre_colonnes_A = dimensions_A(2);

% Afficher les résultats

disp('Matrice A :');
disp(A);

disp('Dimensions de la matrice A :');

disp(dimensions_A);

disp('Nombre de colonnes de la matrice A :');

disp(nombre_colonnes_A);
% Calcul du déterminant de la matrice A
determinant_A = det(A);

% Vérifier si la matrice est inversible avant de calculer l'inverse

if determinant_A ~= 0
% Calcul de l'inverse de la matrice A
inverse_A = inv(A);
else
inverse_A = 'La matrice n''est pas inversible.';
end

% Afficher les résultats

disp('Matrice A :');
disp(A);

disp('Déterminant de la matrice A :');

disp(determinant_A);

disp('Inverse de la matrice A :');

disp(inverse_A);
% Résoudre le système A*x = u1 en utilisant la division gauche
solution_x1 = A \ u1;

% Afficher la solution
disp('Solution du système 1 A*x = u1 (division gauche) :');
disp(solution_x1);

% Résoudre le système A*x = u1 en utilisant la fonction linsolve

solution_x2 = linsolve(A, u1);

% Afficher la solution
disp('Solution du système 2 A*x = u1 (linsolve) :');
disp(solution_x2);
 Script MATLAB Question 5

% Données d'entrée
A = [5/8, 1/4, 1/8; 1/4, 0, -1/4; 1/8, 1/4, 5/8];
b = [1; -1; 1];
u1 = [5; 2; -4];
nb_it = 10;

% Initialisation du vecteur U
U = zeros(length(u1), nb_it);

% Premier terme de la suite

U(:, 1) = u1;
disp(u1)
% Calcul des termes suivants de la suite
for n = 2:nb_it
U(:, n) = A * U(:, n-1) + b;
end

% Représentation graphique de l'évolution de chaque composante

figure;
for i = 1:length(u1)
subplot(length(u1), 1, i);
plot(1:nb_it, U(i, :), '-o');
title(['Composante ', num2str(i)]);
xlabel('n');
ylabel(['u', num2str(i), '(n)']);
grid on;
end

% Ajuster les espacements entre les sous-graphiques

spacing = 0.01;
subplot(length(u1), 1, 1);
h = title('Evolution de chaque composante de la suite u(n)');
set(h, 'Position', get(h, 'Position') - [0, spacing, 0]);
 Script MATLAB Question 6

% Fonction pour générer une matrice aléatoire d'ordre quelconque

function A = GenereMatrice(n)
% Générer une matrice aléatoire de taille n x n
A = randn(n);
end

% Fonction pour générer et résoudre des systèmes linéaires aléatoires

function GenereSysteme(nb_systemes, taille_systeme)
disp('Génération et résolution de systèmes linéaires aléatoires :');

for i = 1:nb_systemes
% Générer une matrice aléatoire
A = GenereMatrice(taille_systeme);

% Générer un vecteur aléatoire

b = randn(taille_systeme, 1);

% Vérifier si le système est résolvable

if rank(A) == rank([A, b])
disp(['Système ', num2str(i), ' :']);
disp('Matrice A :');
disp(A);
disp('Vecteur b :');
disp(b);

% Résoudre le système
x = A \ b;

disp('Solution x :');
disp(x);
disp('------------------------');
else
disp(['Système ', num2str(i), ' :']);
disp('Le système est singulier (pas de solution unique)');
disp('------------------------');
end
end
end

% Appel de la fonction GenereSysteme avec des paramètres spécifiques

GenereSysteme(5, 3);
 Script MATLAB Question 7

% Contenu du fichier GenereMatrice.m

function A = GenereMatrice(n)
% Générer une matrice aléatoire de taille n x n
A = randn(n);
End

% Contenu du fichier GenereSysteme.m

function GenereSysteme(nb_systemes, taille_systeme)
disp('Génération et résolution de systèmes linéaires aléatoires :');

for i = 1:nb_systemes
% Générer une matrice aléatoire
A = GenereMatrice(taille_systeme);

% Générer un vecteur aléatoire

b = randn(taille_systeme, 1);

% Vérifier si le système est résolvable

if rank(A) == rank([A, b])
disp(['Système ', num2str(i), ' :']);
disp('Matrice A :');
disp(A);
disp('Vecteur b :');
disp(b);

% Résoudre le système
x = A \ b;

disp('Solution x :');
disp(x);
disp('------------------------');
else
disp(['Système ', num2str(i), ' :']);
disp('Le système est singulier (pas de solution unique)');
disp('------------------------');
end
end
end

% Contenu du fichier script_principal.m

% Appel des fonctions GenereMatrice et GenereSysteme
GenereMatrice(5); % Exemple avec GenereMatrice
GenereSysteme(3, 3); % Exemple avec GenereSysteme