Multiplication de Deux Matrices en Langage C Utilisant des Pointeurs

Dans cet article, nous allons explorer comment multiplier deux matrices en utilisant des pointeurs en langage C.

💡 La multiplication de matrices est une opération fondamentale en algèbre linéaire et est souvent utilisée dans de nombreuses applications informatiques, notamment dans le traitement d’images, les simulations scientifiques, et la programmation graphique. En langage C, l’utilisation de pointeurs est courante pour manipuler les tableaux, y compris les matrices.

Structure de Données pour les Matrices

Avant de procéder à la multiplication, il est important de comprendre comment représenter les matrices en langage C. Nous utiliserons des pointeurs pour créer et manipuler les matrices. Une matrice peut être considérée comme un tableau bidimensionnel dans lequel chaque élément est stocké dans une zone de mémoire contiguë.

Voici comment nous pouvons déclarer une matrice en utilisant des pointeurs en langage C :

#define ROWS 3
#define COLS 3

// Déclaration d'une matrice de dimensions ROWS x COLS
int matrix[ROWS][COLS];
Algorithme de Multiplication de Deux Matrices

Pour multiplier deux matrices ( A ) et ( B ) de dimensions mxn et nxp respectivement, le produit C= AxB est une nouvelle matrice de dimensions mxp. Chaque élément de la matrice produit ( C ) est calculé en prenant le produit scalaire des lignes de la première matrice et des colonnes de la deuxième matrice.

L’algorithme de multiplication de matrices peut être implémenté en langage C comme suit :

void multiplyMatrices(int *A, int *B, int *C, int m, int n, int p) {
    for (int i = 0; i < m; ++i) {
        for (int j = 0; j < p; ++j) {
            *(C + i * p + j) = 0;
            for (int k = 0; k < n; ++k) {
                *(C + i * p + j) += *(A + i * n + k) * *(B + k * p + j);
            }
        }
    }
}

Dans cette fonction multiplyMatrices, les paramètres sont les suivants :

  • A, B, et C sont les pointeurs vers les matrices ( A ), ( B ), et ( C ) respectivement.
  • m, n, et p représentent les dimensions des matrices ( A ), ( B ), et ( C ) respectivement.
Exemple d’Utilisation

Voici un exemple d’utilisation de la fonction multiplyMatrices pour multiplier deux matrices en langage C :

#include <stdio.h>

#define ROWS 3
#define COLS 3

int main() {
    int A[ROWS][COLS] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
    int B[ROWS][COLS] = {{9, 8, 7}, {6, 5, 4}, {3, 2, 1}};
    int C[ROWS][COLS];

    multiplyMatrices(&A[0][0], &B[0][0], &C[0][0], ROWS, COLS, ROWS);

    printf("Matrice C (A x B):\n");
    for (int i = 0; i < ROWS; ++i) {
        for (int j = 0; j < COLS; ++j) {
            printf("%d ", C[i][j]);
        }
        printf("\n");
    }

    return 0;
}

Ce programme affichera la matrice produit ( C ) résultante de la multiplication de ( A ) et ( B ).

Voici quelques ⭐ exemples d’applications ⭐ courantes où la multiplication de matrices est utilisée, accompagnés de code en langage C :

1. Traitement d’Images – Application de Filtres

Dans le traitement d’images, les filtres peuvent être appliqués à une image en utilisant la convolution, qui implique la multiplication de matrices. Voici un exemple simple de l’application d’un filtre de flou gaussien à une image en utilisant la multiplication de matrices :

#include <stdio.h>

#define IMAGE_WIDTH 3
#define IMAGE_HEIGHT 3

void applyFilter(float image[IMAGE_HEIGHT][IMAGE_WIDTH], float filter[3][3], float result[IMAGE_HEIGHT][IMAGE_WIDTH]) {
    for (int i = 0; i < IMAGE_HEIGHT; ++i) {
        for (int j = 0; j < IMAGE_WIDTH; ++j) {
            result[i][j] = 0;
            for (int k = 0; k < 3; ++k) {
                for (int l = 0; l < 3; ++l) {
                    int x = i - 1 + k;
                    int y = j - 1 + l;
                    if (x >= 0 && x < IMAGE_HEIGHT && y >= 0 && y < IMAGE_WIDTH) {
                        result[i][j] += image[x][y] * filter[k][l];
                    }
                }
            }
        }
    }
}

int main() {
    float image[IMAGE_HEIGHT][IMAGE_WIDTH] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
    float filter[3][3] = {{1, 2, 1}, {2, 4, 2}, {1, 2, 1}};
    float result[IMAGE_HEIGHT][IMAGE_WIDTH];

    applyFilter(image, filter, result);

    printf("Image après l'application du filtre de flou gaussien :\n");
    for (int i = 0; i < IMAGE_HEIGHT; ++i) {
        for (int j = 0; j < IMAGE_WIDTH; ++j) {
            printf("%.2f ", result[i][j]);
        }
        printf("\n");
    }

    return 0;
}
2. Simulation Physique – Mécanique des Fluides

Dans la simulation de la mécanique des fluides, la méthode des différences finies peut être utilisée pour résoudre les équations gouvernant le mouvement des fluides. La multiplication de matrices est couramment utilisée pour discrétiser ces équations. Voici un exemple simple d’application de la méthode des différences finies pour résoudre l’équation de la chaleur en 2D :

#include <stdio.h>

#define GRID_SIZE 5
#define TIME_STEPS 10

void solveHeatEquation(float grid[GRID_SIZE][GRID_SIZE], float result[GRID_SIZE][GRID_SIZE]) {
    float dt = 0.1; // Pas de temps
    float dx = 0.1; // Pas d'espace
    float alpha = 0.1; // Coefficient de diffusion thermique

    for (int t = 0; t < TIME_STEPS; ++t) {
        for (int i = 1; i < GRID_SIZE - 1; ++i) {
            for (int j = 1; j < GRID_SIZE - 1; ++j) {
                result[i][j] = grid[i][j] + alpha * dt / (dx * dx) * (grid[i+1][j] + grid[i-1][j] + grid[i][j+1] + grid[i][j-1] - 4 * grid[i][j]);
            }
        }
        // Mettre à jour la grille pour la prochaine itération
        for (int i = 1; i < GRID_SIZE - 1; ++i) {
            for (int j = 1; j < GRID_SIZE - 1; ++j) {
                grid[i][j] = result[i][j];
            }
        }
    }
}

int main() {
    float initialGrid[GRID_SIZE][GRID_SIZE] = {{0}};
    float result[GRID_SIZE][GRID_SIZE];

    // Initialiser la grille avec des conditions initiales

    solveHeatEquation(initialGrid, result);

    printf("Grille après résolution de l'équation de la chaleur :\n");
    for (int i = 0; i < GRID_SIZE; ++i) {
        for (int j = 0; j < GRID_SIZE; ++j) {
            printf("%.2f ", result[i][j]);
        }
        printf("\n");
    }

    return 0;
}

Ces exemples illustrent comment la multiplication de matrices est utilisée dans des applications réelles en langage C.

Voici quelques ⭐ cas particuliers ⭐ de multiplication de matrices avec du code en langage C :

1. Multiplication de Matrices Carrées

Dans ce cas, les deux matrices sont carrées, c’est-à-dire qu’elles ont le même nombre de lignes et de colonnes. Voici un exemple de multiplication de matrices carrées en langage C :

#include <stdio.h>

#define SIZE 3

void multiplySquareMatrices(int A[SIZE][SIZE], int B[SIZE][SIZE], int C[SIZE][SIZE]) {
    for (int i = 0; i < SIZE; ++i) {
        for (int j = 0; j < SIZE; ++j) {
            C[i][j] = 0;
            for (int k = 0; k < SIZE; ++k) {
                C[i][j] += A[i][k] * B[k][j];
            }
        }
    }
}

int main() {
    int A[SIZE][SIZE] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
    int B[SIZE][SIZE] = {{9, 8, 7}, {6, 5, 4}, {3, 2, 1}};
    int C[SIZE][SIZE];

    multiplySquareMatrices(A, B, C);

    printf("Résultat de la multiplication :\n");
    for (int i = 0; i < SIZE; ++i) {
        for (int j = 0; j < SIZE; ++j) {
            printf("%d ", C[i][j]);
        }
        printf("\n");
    }

    return 0;
}
2. Multiplication de Matrices Rectangulaires

Dans ce cas, les deux matrices peuvent avoir des dimensions différentes, mais le nombre de colonnes de la première matrice doit correspondre au nombre de lignes de la deuxième matrice. Voici un exemple de multiplication de matrices rectangulaires en langage C :

#include <stdio.h>

#define ROWS_A 2
#define COLS_A 3
#define COLS_B 2

void multiplyRectangularMatrices(int A[ROWS_A][COLS_A], int B[COLS_A][COLS_B], int C[ROWS_A][COLS_B]) {
    for (int i = 0; i < ROWS_A; ++i) {
        for (int j = 0; j < COLS_B; ++j) {
            C[i][j] = 0;
            for (int k = 0; k < COLS_A; ++k) {
                C[i][j] += A[i][k] * B[k][j];
            }
        }
    }
}

int main() {
    int A[ROWS_A][COLS_A] = {{1, 2, 3}, {4, 5, 6}};
    int B[COLS_A][COLS_B] = {{9, 8}, {7, 6}, {5, 4}};
    int C[ROWS_A][COLS_B];

    multiplyRectangularMatrices(A, B, C);

    printf("Résultat de la multiplication :\n");
    for (int i = 0; i < ROWS_A; ++i) {
        for (int j = 0; j < COLS_B; ++j) {
            printf("%d ", C[i][j]);
        }
        printf("\n");
    }

    return 0;
}

Ces exemples illustrent différentes situations de multiplication de matrices avec du code en langage C.

Autres articles

Pointeur de pointeur en c - Guide...
iIntroduction aux Pointeurs en C : Les pointeurs sont des variables...
Read more
Déclaration de Tableau Dynamique en C avec...
Les tableaux dynamiques en C sont des structures de données...
Read more
QCM de langage C avec corrections
Le langage C est fondamental dans le monde de la...
Read more

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *