Calculer le déterminant d'une matrice en C

CCBeginner
Pratiquer maintenant

💡 Ce tutoriel est traduit par l'IA à partir de la version anglaise. Pour voir la version originale, vous pouvez cliquer ici

Introduction

Dans ce laboratoire (lab), vous apprendrez à calculer le déterminant d'une matrice carrée en programmation C. Le laboratoire couvre les étapes suivantes : la lecture de la dimension et des éléments de la matrice, l'utilisation d'une méthode récursive ou de décomposition LU pour calculer le déterminant, et l'affichage du résultat final. Les instructions étape par étape vous guident tout au long du processus de création d'un programme capable de gérer des matrices carrées de taille maximale 10x10, vous permettant d'entrer dynamiquement les éléments de la matrice et d'afficher le déterminant calculé.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL c(("C")) -.-> c/ControlFlowGroup(["Control Flow"]) c(("C")) -.-> c/CompoundTypesGroup(["Compound Types"]) c(("C")) -.-> c/FunctionsGroup(["Functions"]) c(("C")) -.-> c/UserInteractionGroup(["User Interaction"]) c/ControlFlowGroup -.-> c/for_loop("For Loop") c/CompoundTypesGroup -.-> c/arrays("Arrays") c/FunctionsGroup -.-> c/recursion("Recursion") c/UserInteractionGroup -.-> c/user_input("User Input") c/UserInteractionGroup -.-> c/output("Output") subgraph Lab Skills c/for_loop -.-> lab-435157{{"Calculer le déterminant d'une matrice en C"}} c/arrays -.-> lab-435157{{"Calculer le déterminant d'une matrice en C"}} c/recursion -.-> lab-435157{{"Calculer le déterminant d'une matrice en C"}} c/user_input -.-> lab-435157{{"Calculer le déterminant d'une matrice en C"}} c/output -.-> lab-435157{{"Calculer le déterminant d'une matrice en C"}} end

Lire la dimension et les éléments (Matrice carrée)

Dans cette étape, vous apprendrez à lire la dimension et les éléments d'une matrice carrée en programmation C. Nous allons créer un programme qui permet aux utilisateurs d'entrer dynamiquement la taille de la matrice et ses éléments.

Tout d'abord, créons un nouveau fichier C pour notre programme de calcul du déterminant de matrice :

cd ~/project
nano matrix_determinant.c

Maintenant, ajoutez le code suivant pour lire la dimension et les éléments de la matrice :

#include <stdio.h>
#include <stdlib.h>

#define MAX_SIZE 10

int main() {
    int n, i, j;
    int matrix[MAX_SIZE][MAX_SIZE];

    // Lire la dimension de la matrice
    printf("Entrez la taille de la matrice carrée (1-%d) : ", MAX_SIZE);
    scanf("%d", &n);

    // Valider la taille de la matrice
    if (n < 1 || n > MAX_SIZE) {
        printf("Taille de matrice invalide. Veuillez entrer une taille entre 1 et %d.\n", MAX_SIZE);
        return 1;
    }

    // Lire les éléments de la matrice
    printf("Entrez les éléments de la matrice :\n");
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            printf("Entrez l'élément [%d][%d] : ", i, j);
            scanf("%d", &matrix[i][j]);
        }
    }

    // Afficher la matrice pour vérifier l'entrée
    printf("\nMatrice entrée :\n");
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            printf("%d ", matrix[i][j]);
        }
        printf("\n");
    }

    return 0;
}

Compilez et exécutez le programme :

gcc matrix_determinant.c -o matrix_determinant
./matrix_determinant

Exemple de sortie :

Entrez la taille de la matrice carrée (1-10) : 3
Entrez les éléments de la matrice :
Entrez l'élément [0][0] : 1
Entrez l'élément [0][1] : 2
Entrez l'élément [0][2] : 3
Entrez l'élément [1][0] : 4
Entrez l'élément [1][1] : 5
Entrez l'élément [1][2] : 6
Entrez l'élément [2][0] : 7
Entrez l'élément [2][1] : 8
Entrez l'élément [2][2] : 9

Matrice entrée :
1 2 3
4 5 6
7 8 9

Décortiquons le code :

  • Nous définissons une taille maximale de matrice de 10 pour éviter une allocation excessive de mémoire.
  • Le programme demande d'abord à l'utilisateur d'entrer la taille de la matrice.
  • Il valide l'entrée pour s'assurer qu'elle est dans la plage autorisée.
  • Ensuite, il invite l'utilisateur à entrer chaque élément de la matrice individuellement.
  • Enfin, il affiche la matrice entrée pour vérifier l'entrée.

Utiliser une méthode récursive ou de décomposition LU

Dans cette étape, nous allons implémenter une méthode récursive pour calculer le déterminant d'une matrice. Nous allons modifier le programme précédent pour inclure une fonction de calcul du déterminant.

Mettez à jour le fichier matrix_determinant.c :

nano matrix_determinant.c

Remplacez le contenu précédent par le code suivant :

#include <stdio.h>
#include <stdlib.h>

#define MAX_SIZE 10

// Fonction pour calculer le déterminant de manière récursive
int determinant(int matrix[MAX_SIZE][MAX_SIZE], int n) {
    int det = 0;
    int submatrix[MAX_SIZE][MAX_SIZE];

    // Cas de base pour une matrice 1x1
    if (n == 1) {
        return matrix[0][0];
    }

    // Cas de base pour une matrice 2x2
    if (n == 2) {
        return matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0];
    }

    // Cas récursif pour les matrices plus grandes
    int sign = 1;
    for (int k = 0; k < n; k++) {
        // Créer une sous - matrice
        int subi = 0;
        for (int i = 1; i < n; i++) {
            int subj = 0;
            for (int j = 0; j < n; j++) {
                if (j == k) continue;
                submatrix[subi][subj] = matrix[i][j];
                subj++;
            }
            subi++;
        }

        // Calcul récursif
        det += sign * matrix[0][k] * determinant(submatrix, n - 1);
        sign = -sign;
    }

    return det;
}

int main() {
    int n, i, j;
    int matrix[MAX_SIZE][MAX_SIZE];

    // Lire la dimension de la matrice
    printf("Entrez la taille de la matrice carrée (1-%d) : ", MAX_SIZE);
    scanf("%d", &n);

    // Valider la taille de la matrice
    if (n < 1 || n > MAX_SIZE) {
        printf("Taille de matrice invalide. Veuillez entrer une taille entre 1 et %d.\n", MAX_SIZE);
        return 1;
    }

    // Lire les éléments de la matrice
    printf("Entrez les éléments de la matrice :\n");
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            printf("Entrez l'élément [%d][%d] : ", i, j);
            scanf("%d", &matrix[i][j]);
        }
    }

    // Calculer et afficher le déterminant
    int det = determinant(matrix, n);
    printf("\nDéterminant de la matrice : %d\n", det);

    return 0;
}

Compilez et exécutez le programme :

gcc matrix_determinant.c -o matrix_determinant
./matrix_determinant

Exemple de sortie :

Entrez la taille de la matrice carrée (1-10) : 3
Entrez les éléments de la matrice :
Entrez l'élément [0][0] : 1
Entrez l'élément [0][1] : 2
Entrez l'élément [0][2] : 3
Entrez l'élément [1][0] : 4
Entrez l'élément [1][1] : 5
Entrez l'élément [1][2] : 6
Entrez l'élément [2][0] : 7
Entrez l'élément [2][1] : 8
Entrez l'élément [2][2] : 9

Déterminant de la matrice : 0

Points clés concernant le calcul récursif du déterminant :

  • La fonction determinant() utilise une approche récursive pour calculer le déterminant de la matrice.
  • Pour les matrices 1x1 et 2x2, nous avons des cas de base avec des calculs directs.
  • Pour les matrices plus grandes, nous utilisons la méthode de développement par cofacteurs le long de la première ligne.
  • La fonction crée des sous - matrices et calcule récursivement leurs déterminants.

Afficher le déterminant

Dans cette étape finale, nous allons améliorer notre programme de calcul du déterminant de matrice en ajoutant des sorties plus détaillées et une gestion des erreurs pour améliorer l'expérience utilisateur.

Mettez à jour le fichier matrix_determinant.c :

nano matrix_determinant.c

Remplacez le contenu précédent par le code amélioré suivant :

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#define MAX_SIZE 10

// Fonction pour calculer le déterminant de manière récursive
int determinant(int matrix[MAX_SIZE][MAX_SIZE], int n) {
    int det = 0;
    int submatrix[MAX_SIZE][MAX_SIZE];

    // Cas de base pour une matrice 1x1
    if (n == 1) {
        return matrix[0][0];
    }

    // Cas de base pour une matrice 2x2
    if (n == 2) {
        return matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0];
    }

    // Cas récursif pour les matrices plus grandes
    int sign = 1;
    for (int k = 0; k < n; k++) {
        // Créer une sous - matrice
        int subi = 0;
        for (int i = 1; i < n; i++) {
            int subj = 0;
            for (int j = 0; j < n; j++) {
                if (j == k) continue;
                submatrix[subi][subj] = matrix[i][j];
                subj++;
            }
            subi++;
        }

        // Calcul récursif
        det += sign * matrix[0][k] * determinant(submatrix, n - 1);
        sign = -sign;
    }

    return det;
}

// Fonction pour afficher la matrice avec mise en forme
void print_matrix(int matrix[MAX_SIZE][MAX_SIZE], int n) {
    printf("\nMatrice :\n");
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            printf("%5d ", matrix[i][j]);
        }
        printf("\n");
    }
}

int main() {
    int n, i, j;
    int matrix[MAX_SIZE][MAX_SIZE];
    bool valid_input = false;

    while (!valid_input) {
        // Lire la dimension de la matrice
        printf("Entrez la taille de la matrice carrée (1-%d) : ", MAX_SIZE);
        if (scanf("%d", &n)!= 1) {
            printf("Entrée invalide. Veuillez entrer un nombre.\n");
            while (getchar()!= '\n'); // Vider le tampon d'entrée
            continue;
        }

        // Valider la taille de la matrice
        if (n < 1 || n > MAX_SIZE) {
            printf("Taille de matrice invalide. Veuillez entrer une taille entre 1 et %d.\n", MAX_SIZE);
            continue;
        }

        valid_input = true;
    }

    // Lire les éléments de la matrice
    printf("Entrez les éléments de la matrice :\n");
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            printf("Entrez l'élément [%d][%d] : ", i, j);
            while (scanf("%d", &matrix[i][j])!= 1) {
                printf("Entrée invalide. Veuillez entrer un entier pour l'élément [%d][%d] : ", i, j);
                while (getchar()!= '\n'); // Vider le tampon d'entrée
            }
        }
    }

    // Afficher la matrice d'entrée
    print_matrix(matrix, n);

    // Calculer et afficher le déterminant
    int det = determinant(matrix, n);

    // Sortie formatée du déterminant
    printf("\n--- Calcul du déterminant ---\n");
    printf("Dimension de la matrice : %d x %d\n", n, n);
    printf("Déterminant : %d\n", det);

    return 0;
}

Compilez et exécutez le programme :

gcc matrix_determinant.c -o matrix_determinant
./matrix_determinant

Exemple de sortie :

Entrez la taille de la matrice carrée (1-10) : 3
Entrez les éléments de la matrice :
Entrez l'élément [0][0] : 1
Entrez l'élément [0][1] : 2
Entrez l'élément [0][2] : 3
Entrez l'élément [1][0] : 4
Entrez l'élément [1][1] : 5
Entrez l'élément [1][2] : 6
Entrez l'élément [2][0] : 7
Entrez l'élément [2][1] : 8
Entrez l'élément [2][2] : 9

Matrice :
    1     2     3
    4     5     6
    7     8     9

--- Calcul du déterminant ---
Dimension de la matrice : 3 x 3
Déterminant : 0

Améliorations clés :

  • Ajout de la validation des entrées pour gérer les entrées invalides
  • Création d'une fonction distincte pour afficher la matrice avec une meilleure mise en forme
  • Amélioration de la sortie pour afficher clairement la dimension de la matrice et le déterminant
  • Amélioration de la gestion des erreurs pour les entrées utilisateur

Résumé

Dans ce laboratoire (lab), vous avez appris à lire la dimension et les éléments d'une matrice carrée en programmation C. Vous avez créé un programme qui permet aux utilisateurs d'entrer dynamiquement la taille de la matrice et ses éléments. Le programme valide la taille de la matrice, puis invite l'utilisateur à entrer les éléments de la matrice. Enfin, il affiche la matrice entrée pour vérifier l'entrée.

Les étapes suivantes de ce laboratoire couvriront comment utiliser une méthode récursive ou de décomposition LU pour calculer le déterminant de la matrice d'entrée, et comment afficher le déterminant.