THEME :

INVERSE D’UNE
MATRICE
GROUPE 17

MEMBRES :

TSAKEM KENGNE DJOUELA JACK KEVIN 21T2526

WOBO POKA RICK JUNIOR 22U2175
MEGOALE IVAN JORDAN 20U2686
EBALE NDONGO CHRISTIAN JUNIOR 21T2455
MITOUVAYA ROMIEL 22U2038

ENCADREUR : Dr FOBASSO Arnaud

 AVANT-PROPOS
Ce rapport de 5 pages se concentra principalement sur l’élimination de Gauss-Jordan pour la
résolution de l’inverse d’une matrice carrée.
Histoire
Cette méthode est connue des mathématiciens chinois depuis au moins le Ier siècle de notre
ère. Elle est référencée dans le livre chinois Jiuzhang suanshu (Les Neuf Chapitres sur l'art
mathématique), dont elle constitue le huitième chapitre, sous le titre « Fang cheng » (la
disposition rectangulaire). La méthode est présentée au moyen de dix-huit exercices. Dans
son commentaire daté de 263, Liu Hui en attribue la paternité à Chang Ts'ang, chancelier de
l'empereur de Chine au IIe siècle avant notre ère.
En Europe, cette méthode a été découverte et présentée sous forme moderne au XIXe siècle.
En 1810, Carl Friedrich Gauss présente sa méthode des moindres carrés dans un livre
étudiant le mouvement de l'astéroïde Pallas. Dans l'article 13 de ce livre, il décrit une
méthode générale de résolution de système d'équations linéaires qui constitue l'essentiel de
la méthode du pivot. En 1888, Wilhelm Jordan publie un livre de géodésie précisant
comment utiliser cette méthode et adoptant une notation un peu différente. C'est grâce à ce
dernier livre que cette méthode se diffusa dans tout l'Occident. Elle est aujourd'hui connue
sous le nom d'élimination de Gauss-Jordan ou méthode du pivot de Gauss.
Implémentation
Nous utiliserons le langage de programmation Python pour implémenter l’algorithme de
Gauss-Jordan.
Limitation
L’implémentation ne couvrira pas les matrices de n’importe quel rang. La matrice carrée de
rang n aura n compris entre 2 et 6, avec 2 et 6 inclus.
En mathématiques, plus précisément en algèbre linéaire, l'élimination de Gauss-Jordan,
aussi appelée méthode du pivot de Gauss, nommée en hommage à Carl Friedrich Gauss et
Wilhelm Jordan, est un algorithme pour déterminer les solutions d'un système d'équations
linéaires, pour déterminer le rang d'une matrice ou pour calculer l'inverse d'une matrice
(carrée) inversible.

RÉSOLUTION D’UNE MATRICE CARRÉE DE TAILLE n (2 ≤ n ≤ 6) PAR

L’ÉLIMINATION DE GAUSS-JORDAN
INTRODUCTION
Lorsqu'on applique l'élimination de Gauss à une matrice, on obtient sa forme échelonnée
réduite. Nous allons implémenter en python le calcul de l’inverse d’une matrice carrée
inversible par l’élimination de Gauss.
UTILITÉ EN INFORMATIQUE
En informatique, cette technique est souvent utilisée dans divers domaines, tels que le
traitement d'images, la simulation numérique, l'apprentissage automatique (Machine
Learning), la cryptographie et d'autres domaines liés aux calculs numériques.

DESCRIPTION DE L’AGORITHME
Voici une description plus détaillée des étapes de l'algorithme :
1. Calcul du déterminant:
La méthode utilisée dans l’algorithme est la méthode de Laplace pour le calcul du
déterminant d'une matrice. La formule de Laplace permet d'exprimer le déterminant
d'une matrice en termes de cofacteurs. Voici la formule de Laplace pour une matrice A
de taille n×n:
n
det ( A )=∑ (−1)k+1 ×a 1k × det ⁡(A 1 k )
k=1

2. Vérification de la singularité :
La fonction `CalculerDeterminant` utilise la fonction `determinant` pour obtenir le
déterminant de la matrice d'origine. Si le déterminant est égal à zéro, cela signifie
que la matrice est singulière (non inversible), et le programme affiche un message
approprié.

3. Construction de la matrice augmentée :

Si le déterminant n'est pas nul, l'algorithme construit une matrice augmentée en
ajoutant une matrice identité à droite de la matrice d'origine. Cela forme une matrice
de taille [n, 2n].

4. Pivotement partiel:

⮚ Cette procédure permet de trouver le pivot partiel de la ligne i de la matrice a.

⮚ Le pivot partiel est le coefficient de la ligne i de la colonne i.

⮚ La fonction recherche la ligne de la matrice qui a la plus grande valeur

absolue.
 ⮚ Si la ligne i n'a pas le pivot partiel le plus grand, la fonction échange les lignes i
et j, ou j est la ligne de la matrice qui a le pivot partiel le plus grand.
5. Élimination gaussienne

⮚ Cette procédure permet d'éliminer les termes non nuls de la colonne i de la

matrice a en dehors de la ligne i.
⮚ La procédure parcourt toutes les lignes de la matrice, sauf la ligne i.

⮚ Pour chaque ligne j, la procédure calcule le ratio, qui est égal au coefficient de
la ligne j de la colonne i divisé par le pivot partiel de la ligne i.
⮚ La fonction utilise ensuite ce ratio pour éliminer les termes non nuls de la
colonne i de la ligne j.

6. Rendre diagonal a 1

⮚ La procédure normalise chaque ligne en divisant chaque élément par le pivot,

rendant ainsi le pivot égal à un.

7. Affichage des étapes intermédiaires :

⮚ À chaque étape importante (pivotement, élimination, normalisation),

l'algorithme affiche la matrice résultante pour aider à visualiser les
changements.

8. Matrice inverse finale :

⮚ Une fois que la matrice échelonnée est obtenue, la partie de droite (matrice
identité) est extraite pour obtenir la matrice inverse.

9. Affichage de la matrice inverse :

⮚ Enfin, l'algorithme affiche la matrice inverse résultante.

ALGORITHE EN PSEUDOCODE
Algorithme CalculerInverse(matrice: tableau de tableau de réel, taille: entier)
fonction determinant(matrice: tableau de tableau de réel, k: entier)
 S, det : réel
m, n, i : entier
s <- 1.0
det <- 0.0
b : tableau de tableau de réel <- tableau de tableau de réel de dimension [25][25]

Si k = 1 alors
Afficher matrice[0][0]
Sinon
det <- 0.0
Pour c allant de 0 à (k - 1) faire
m <- 0
n <- 0
Pour i allant de 0 à (k - 1) faire
Pour j allant de 0 à (k - 1) faire
b[i][j] <- 0.0
Si i != 0 et j != c alors
b[m][n] <- matrice[i][j]
Si n < (k - 2) alors
n <- n + 1
Sinon
n <- 0
m <- m + 1
Fin Si
Fin Si
Fin Pour
Fin Pour
det <- det + s * (matrice[0][c] * determinant(b, k - 1))
s <- s * -1.0
Fin Pour
Afficher det
Fin Si
Fin fonction
dét <- CalculerDeterminant(matrice, taille)

Si det = 0.0 alors

écrire "La matrice est singulière. L'inverse n'existe pas."
Sinon

Pour i allant de 0 à (taille - 1) faire

Pour j allant de taille à (2 * taille - 1) faire
matrice[i][j] <- 1.0 si i = j - taille sinon 0.0
Fin Pour
Fin Pour
écrire "Matrice Augmentée Originale :"
ecrire_matrice(matrice, taille, 2 * taille)
écrire "-" * 40
Pour i allant de 0 à (taille - 1) faire
Procédure pivot_partiel(a: tableau de tableau de réel, i: entier, n: entier)
Ligne_max, j : entier
ligne_max <- i
Pour j allant de (i + 1) à (n - 1) faire
Si valeur_absolue(a[j][i]) > valeur_absolue(a[ligne_max][i]) alors
ligne_max <- j
Fin Si
Fin Pour
Pour k allant de 0 à (2 * n - 1) faire
temp : matrice <- a[i][k]
a[i][k] <- a[ligne_max][k]
a[j][k] <- temp
Fin Pour
Afficher "É tape i + 1 (Pivot Partiel)"
ecrire_matrice(a, n, 2 * n)
Fin Procédure
Procédure ecrire_matrice(a: tableau de tableau de réel, i: entier, n: entier)
Pour i allant de 0 à (n - 1) faire
Pour j allant de 0 à (n - 1) faire
Afficher matrice[i][j]
Fin Pour
Afficher "nouvelle ligne"
Fin Pour
Fin Procédure

Procédure eliminer(a: tableau de tableau de réel, i: entier, n: entier)

Pour j allant de 0 à (n - 1) faire
Si i != j alors
ratio <- a[j][i] / a[i][i]
Pour k allant de 0 à (2 * n - 1) faire
temp <- a[i][k]
a[i][k] <- a[j][k]
a[j][k] <- temp
Fin Pour
Fin Si
Fin Pour
Afficher "É tape i + 1 (É limination) :"
ecrire_matrice(a, n, 2 * n)
Fin Procédure

Procédure ecrire_matrice(a: tableau de tableau de réel, i: entier, n: entier)

Pour i allant de 0 à (n - 1) faire
Pour j allant de 0 à (n - 1) faire
Afficher matrice[i][j]
Fin Pour
 Afficher "nouvelle ligne"
Fin Pour
Fin Procédure

Procédure rendre_diagonale_un(a: tableau de tableau de réel, i: entier, n: entier)

Variables
Diviseur : réel
J : entier
Début
diviseur <- a[i][i]
Si diviseur = 0.0 Alors
Afficher "Erreur : Division par zéro. La matrice est singulière."
Sinon
Pour j allant de 0 à (2 * n - 1) faire
a[i][j] <- a[i][j] / diviseur
Fin Pour
Afficher "É tape " + (i + 1) + " (Rendre Diagonale 1) :"
ecrire_matrice(a, n, 2 * n)
Fin Si
Fin Procédure

Procédure ecrire_matrice(a: tableau de tableau de réel, i: entier, n: entier)

Pour i allant de 0 à (n - 1) faire
Pour j allant de 0 à (n - 1) faire
Afficher matrice[i][j]
Fin Pour
Afficher "nouvelle ligne"
Fin Pour
Fin Procédure

fin pour

écrire "Matrice Inverse Finale :"

pour i à (n) faire
pour j à (n, 2 * n) faire
écrire (a[i][j]) écrire
nouvelle ligne
fin pour fin
fin algorithme

COMPLEXITÉ DE L’ALGORITHME
Analysons la complexité de chaque procédure dans l'algorithme du calcul de l'inverse d'une
matrice carrée par la méthode de Gauss-Jordan, ensuite déduisons la complexité de
l’algorithme.
 ● Fonction déterminant
La fonction déterminant calcule le déterminant d'une matrice carrée en utilisant la
formule récursive. La complexité de la fonction récursive est O(n!), où n est la taille
de la matrice. Cela s'explique par le fait que la fonction effectue n appels récursifs,
chacun prenant O(n) temps.

● Procédure afficher_matrice
La procédure afficher_matrice imprime simplement une matrice sur la
console. La complexité de cette fonction est O(n^2), où n est la taille de la
matrice. Cela s'explique par le fait que la fonction itère sur tous les éléments
de la matrice et les imprime.

● Procédure pivot_partiel
La procedure pivot_partiel effectue une pivotation partielle sur une matrice.
La complexité de cette fonction est O(n^2), où n est la taille de la matrice.
Cela s'explique par le fait que la fonction trouve l'élément maximum dans une
colonne et échange ensuite les lignes pour placer cet élément sur la
diagonale.

● Procedure eliminer
La fonction eliminer élimine les éléments non nuls situés sous l'élément pivot
dans une colonne. La complexité de cette fonction est O(n^2), où n est la
taille de la matrice. Cela s'explique par le fait que la fonction itère sur toutes
les lignes situées sous la ligne pivot et effectue des opérations de ligne pour
éliminer les éléments non nuls.

● Procedure rendre_diagonale_un
La procedure rendre_diagonale_un met l'élément pivot dans une colonne à 1.
La complexité de cette fonction est O(n), où n est la taille de la matrice. Cela
s'explique par le fait que la fonction itère sur tous les éléments de la colonne
pivot et les divise par l'élément pivot.

Complexité globale
 La complexité globale du programme est O(n^3), où n est la taille de la matrice Cela
s'explique par le fait que la fonction effectue n étapes d'élimination de Gauss,
chacune prenant O(n^2) temps.

ANNEXE
CODE