Como Multiplicar Duas Matrizes em C

Introdução

Neste laboratório, você aprenderá a multiplicar duas matrizes em C. O laboratório cobre os seguintes passos:

Leitura de Dimensões e Elementos: Você aprenderá como ler as dimensões e os elementos de duas matrizes a partir da entrada do usuário. Esta etapa garante que as matrizes sejam compatíveis para multiplicação.

Multiplicação de Linhas por Colunas: Você implementará o algoritmo de multiplicação de matrizes, onde cada elemento da matriz produto é calculado multiplicando as linhas e colunas correspondentes das matrizes de entrada.

Impressão da Matriz Produto: Finalmente, você exibirá a matriz produto resultante.

Ao final deste laboratório, você terá um bom entendimento da multiplicação de matrizes em C e poderá aplicá-la a várias aplicações.

Leitura de Dimensões e Elementos

Neste passo, você aprenderá a ler as dimensões e elementos das matrizes para a multiplicação de matrizes em C. Criaremos um programa que permite ao usuário inserir o tamanho e os valores de duas matrizes.

Primeiro, vamos criar um novo arquivo C para nosso programa de multiplicação de matrizes:

cd ~/project
nano matrix_multiply.c

Agora, adicione o seguinte código para ler as dimensões da matriz:

#include <stdio.h>

#define MAX_SIZE 100

int main() {
    int rows1, cols1, rows2, cols2;

    // Ler as dimensões da primeira matriz
    printf("Digite as dimensões da primeira matriz (linhas colunas): ");
    scanf("%d %d", &rows1, &cols1);

    // Ler as dimensões da segunda matriz
    printf("Digite as dimensões da segunda matriz (linhas colunas): ");
    scanf("%d %d", &rows2, &cols2);

    // Verificar se as matrizes podem ser multiplicadas
    if (cols1 != rows2) {
        printf("Multiplicação de matrizes não possível!\n");
        return 1;
    }

    printf("As dimensões das matrizes são válidas para multiplicação.\n");

    return 0;
}

Compile e execute o programa:

gcc matrix_multiply.c -o matrix_multiply
./matrix_multiply

Exemplo de saída:

Digite as dimensões da primeira matriz (linhas colunas): 2 3
Digite as dimensões da segunda matriz (linhas colunas): 3 2
As dimensões das matrizes são válidas para multiplicação.

Vamos analisar o código:

Definimos MAX_SIZE como 100 para limitar as dimensões das matrizes
scanf() é usado para ler as dimensões da matriz a partir da entrada do usuário
Verificamos se a multiplicação de matrizes é possível comparando as colunas da primeira matriz com as linhas da segunda matriz
Se as dimensões forem incompatíveis, o programa imprime uma mensagem de erro

Agora, vamos modificar o código para ler os elementos da matriz:

#include <stdio.h>

#define MAX_SIZE 100

int main() {
    int rows1, cols1, rows2, cols2;
    int matrix1[MAX_SIZE][MAX_SIZE];
    int matrix2[MAX_SIZE][MAX_SIZE];

    // Ler as dimensões da primeira matriz
    printf("Digite as dimensões da primeira matriz (linhas colunas): ");
    scanf("%d %d", &rows1, &cols1);

    // Ler as dimensões da segunda matriz
    printf("Digite as dimensões da segunda matriz (linhas colunas): ");
    scanf("%d %d", &rows2, &cols2);

    // Verificar se as matrizes podem ser multiplicadas
    if (cols1 != rows2) {
        printf("Multiplicação de matrizes não possível!\n");
        return 1;
    }

    // Ler os elementos da primeira matriz
    printf("Digite os elementos da primeira matriz:\n");
    for (int i = 0; i < rows1; i++) {
        for (int j = 0; j < cols1; j++) {
            printf("Digite o elemento [%d][%d]: ", i, j);
            scanf("%d", &matrix1[i][j]);
        }
    }

    // Ler os elementos da segunda matriz
    printf("Digite os elementos da segunda matriz:\n");
    for (int i = 0; i < rows2; i++) {
        for (int j = 0; j < cols2; j++) {
            printf("Digite o elemento [%d][%d]: ", i, j);
            scanf("%d", &matrix2[i][j]);
        }
    }

    printf("Matrizes lidas com sucesso.\n");

    return 0;
}

Compile e execute o programa:

gcc matrix_multiply.c -o matrix_multiply
./matrix_multiply

Exemplo de saída:

Digite as dimensões da primeira matriz (linhas colunas): 2 3
Digite as dimensões da segunda matriz (linhas colunas): 3 2
Digite os elementos da primeira matriz:
Digite o elemento [0][0]: 1
Digite o elemento [0][1]: 2
Digite o elemento [0][2]: 3
Digite o elemento [1][0]: 4
Digite o elemento [1][1]: 5
Digite o elemento [1][2]: 6
Digite os elementos da segunda matriz:
Digite o elemento [0][0]: 7
Digite o elemento [0][1]: 8
Digite o elemento [1][0]: 9
Digite o elemento [1][1]: 10
Digite o elemento [2][0]: 11
Digite o elemento [2][1]: 12
Matrizes lidas com sucesso.

Multiplicação de Linhas por Colunas

Neste passo, você aprenderá a realizar a multiplicação de matrizes multiplicando as linhas da primeira matriz pelas colunas da segunda matriz. Iremos construir sobre o código anterior para implementar o algoritmo de multiplicação de matrizes.

Atualize o arquivo matrix_multiply.c para adicionar a funcionalidade de multiplicação de matrizes:

cd ~/project
nano matrix_multiply.c

Substitua o código anterior pela seguinte implementação:

#include <stdio.h>

#define MAX_SIZE 100

int main() {
    int rows1, cols1, rows2, cols2;
    int matrix1[MAX_SIZE][MAX_SIZE];
    int matrix2[MAX_SIZE][MAX_SIZE];
    int result[MAX_SIZE][MAX_SIZE];

    // Ler as dimensões da primeira matriz
    printf("Digite as dimensões da primeira matriz (linhas colunas): ");
    scanf("%d %d", &rows1, &cols1);

    // Ler as dimensões da segunda matriz
    printf("Digite as dimensões da segunda matriz (linhas colunas): ");
    scanf("%d %d", &rows2, &cols2);

    // Verificar se as matrizes podem ser multiplicadas
    if (cols1 != rows2) {
        printf("Multiplicação de matrizes não possível!\n");
        return 1;
    }

    // Ler os elementos da primeira matriz
    printf("Digite os elementos da primeira matriz:\n");
    for (int i = 0; i < rows1; i++) {
        for (int j = 0; j < cols1; j++) {
            printf("Digite o elemento [%d][%d]: ", i, j);
            scanf("%d", &matrix1[i][j]);
        }
    }

    // Ler os elementos da segunda matriz
    printf("Digite os elementos da segunda matriz:\n");
    for (int i = 0; i < rows2; i++) {
        for (int j = 0; j < cols2; j++) {
            printf("Digite o elemento [%d][%d]: ", i, j);
            scanf("%d", &matrix2[i][j]);
        }
    }

    // Multiplicar as matrizes
    for (int i = 0; i < rows1; i++) {
        for (int j = 0; j < cols2; j++) {
            result[i][j] = 0;
            for (int k = 0; k < cols1; k++) {
                result[i][j] += matrix1[i][k] * matrix2[k][j];
            }
        }
    }

    // Imprimir a matriz resultante
    printf("\nMatriz Resultante:\n");
    for (int i = 0; i < rows1; i++) {
        for (int j = 0; j < cols2; j++) {
            printf("%d ", result[i][j]);
        }
        printf("\n");
    }

    return 0;
}

Compile e execute o programa:

gcc matrix_multiply.c -o matrix_multiply
./matrix_multiply

Exemplo de saída:

Digite as dimensões da primeira matriz (linhas colunas): 2 3
Digite as dimensões da segunda matriz (linhas colunas): 3 2
Digite os elementos da primeira matriz:
Digite o elemento [0][0]: 1
Digite o elemento [0][1]: 2
Digite o elemento [0][2]: 3
Digite o elemento [1][0]: 4
Digite o elemento [1][1]: 5
Digite o elemento [1][2]: 6
Digite os elementos da segunda matriz:
Digite o elemento [0][0]: 7
Digite o elemento [0][1]: 8
Digite o elemento [1][0]: 9
Digite o elemento [1][1]: 10
Digite o elemento [2][0]: 11
Digite o elemento [2][1]: 12

Matriz Resultante:
58 64
139 154

Vamos analisar o algoritmo de multiplicação de matrizes:

Os dois loops externos i e j iteram pela matriz resultante.
O loop interno k realiza o produto escalar da linha i da primeira matriz e da coluna j da segunda matriz.
result[i][j] é calculado somando os produtos dos elementos correspondentes.
Os loops aninhados garantem que cada elemento da matriz resultante seja calculado corretamente.

Pontos chave sobre a multiplicação de matrizes:

O número de colunas na primeira matriz deve ser igual ao número de linhas na segunda matriz.
A matriz resultante terá dimensões (linhas da primeira matriz) × (colunas da segunda matriz).

Imprimir a Matriz Produto

Neste passo final, melhoraremos nosso programa de multiplicação de matrizes adicionando funcionalidades de impressão mais robustas e tratamento de erros. Criaremos funções para imprimir matrizes e melhorar a experiência geral do usuário.

Atualize o arquivo matrix_multiply.c com a seguinte implementação aprimorada:

cd ~/project
nano matrix_multiply.c

Substitua o código anterior por esta versão abrangente:

#include <stdio.h>

#define MAX_SIZE 100

// Função para imprimir uma matriz
void printMatrix(int matrix[MAX_SIZE][MAX_SIZE], int rows, int cols, const char* matrixName) {
    printf("\n%s Matrix:\n", matrixName);
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            printf("%5d ", matrix[i][j]);
        }
        printf("\n");
    }
}

int main() {
    int rows1, cols1, rows2, cols2;
    int matrix1[MAX_SIZE][MAX_SIZE];
    int matrix2[MAX_SIZE][MAX_SIZE];
    int result[MAX_SIZE][MAX_SIZE];

    // Ler as dimensões da primeira matriz
    printf("Digite as dimensões da primeira matriz (linhas colunas): ");
    scanf("%d %d", &rows1, &cols1);

    // Ler as dimensões da segunda matriz
    printf("Digite as dimensões da segunda matriz (linhas colunas): ");
    scanf("%d %d", &rows2, &cols2);

    // Verificar se as matrizes podem ser multiplicadas
    if (cols1 != rows2) {
        printf("Multiplicação de matrizes não possível!\n");
        printf("As colunas da primeira matriz (%d) devem ser iguais às linhas da segunda matriz (%d).\n", cols1, rows2);
        return 1;
    }

    // Ler os elementos da primeira matriz
    printf("Digite os elementos da primeira matriz:\n");
    for (int i = 0; i < rows1; i++) {
        for (int j = 0; j < cols1; j++) {
            printf("Digite o elemento [%d][%d]: ", i, j);
            scanf("%d", &matrix1[i][j]);
        }
    }

    // Ler os elementos da segunda matriz
    printf("Digite os elementos da segunda matriz:\n");
    for (int i = 0; i < rows2; i++) {
        for (int j = 0; j < cols2; j++) {
            printf("Digite o elemento [%d][%d]: ", i, j);
            scanf("%d", &matrix2[i][j]);
        }
    }

    // Imprimir as matrizes de entrada
    printMatrix(matrix1, rows1, cols1, "Primeira Entrada");
    printMatrix(matrix2, rows2, cols2, "Segunda Entrada");

    // Multiplicar as matrizes
    for (int i = 0; i < rows1; i++) {
        for (int j = 0; j < cols2; j++) {
            result[i][j] = 0;
            for (int k = 0; k < cols1; k++) {
                result[i][j] += matrix1[i][k] * matrix2[k][j];
            }
        }
    }

    // Imprimir a matriz resultante
    printMatrix(result, rows1, cols2, "Produto");

    return 0;
}

Compile e execute o programa:

gcc matrix_multiply.c -o matrix_multiply
./matrix_multiply

Exemplo de saída:

Digite as dimensões da primeira matriz (linhas colunas): 2 3
Digite as dimensões da segunda matriz (linhas colunas): 3 2
Digite os elementos da primeira matriz:
... (entrada dos elementos da matriz)
... (entrada dos elementos da matriz)

Primeira Entrada Matrix:
    1     2     3
    4     5     6

Segunda Entrada Matrix:
    7     8
    9    10
   11    12

Matriz Produto:
   58    64
  139   154

Melhorias-chave nesta versão:

Criada uma função printMatrix() para imprimir matrizes com formatação consistente.
Adicionadas mensagens de erro mais descritivas para compatibilidade de multiplicação de matrizes.
Imprime as matrizes de entrada antes de mostrar a matriz produto.
Usa %5d para impressão alinhada da matriz.
Fornece um formato de saída claro e legível.

Explicação da função de impressão:

printMatrix() recebe a matriz, suas dimensões e um nome como parâmetros.
Usa loops aninhados para imprimir cada elemento.
O especificador de formato %5d garante que cada número ocupe 5 espaços para alinhamento.
Adiciona uma nova linha após cada linha para melhor legibilidade.

Resumo

Neste laboratório, você aprenderá como ler as dimensões e os elementos de uma matriz, e então realizar a multiplicação de matrizes em C. Primeiro, você aprenderá a ler as dimensões de duas matrizes e verificar se elas são compatíveis para multiplicação. Em seguida, você aprenderá a ler os elementos das duas matrizes e armazená-los em matrizes bidimensionais. Finalmente, você aprenderá como realizar a multiplicação de matrizes propriamente dita e imprimir a matriz produto resultante.