Calcular o Determinante de uma Matriz em C

Introdução

Neste laboratório, você aprenderá a calcular o determinante de uma matriz quadrada em programação C. O laboratório cobre os seguintes passos: leitura da dimensão e elementos da matriz, utilização de um método recursivo ou de decomposição LU para calcular o determinante e impressão do resultado final. As instruções passo a passo guiam você através do processo de criação de um programa que pode lidar com matrizes quadradas de até 10x10, permitindo a entrada dinâmica dos elementos da matriz e a exibição do determinante calculado.

Ler Dimensão e Elementos (Matriz Quadrada)

Neste passo, você aprenderá a ler a dimensão e os elementos de uma matriz quadrada em programação C. Criaremos um programa que permite ao usuário inserir dinamicamente o tamanho da matriz e seus elementos.

Primeiro, vamos criar um novo arquivo C para nosso programa de determinante de matriz:

cd ~/project
nano matrix_determinant.c

Agora, adicione o seguinte código para ler a dimensão e os elementos da matriz:

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

#define MAX_SIZE 10

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

    // Ler a dimensão da matriz
    printf("Digite o tamanho da matriz quadrada (1-%d): ", MAX_SIZE);
    scanf("%d", &n);

    // Validar o tamanho da matriz
    if (n < 1 || n > MAX_SIZE) {
        printf("Tamanho da matriz inválido. Por favor, digite um tamanho entre 1 e %d.\n", MAX_SIZE);
        return 1;
    }

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

    // Imprimir a matriz para verificar a entrada
    printf("\nMatriz digitada:\n");
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            printf("%d ", matrix[i][j]);
        }
        printf("\n");
    }

    return 0;
}

Compile e execute o programa:

gcc matrix_determinant.c -o matrix_determinant
./matrix_determinant

Exemplo de saída:

Digite o tamanho da matriz quadrada (1-10): 3
Digite os elementos da 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 o elemento [2][0]: 7
Digite o elemento [2][1]: 8
Digite o elemento [2][2]: 9

Matriz digitada:
1 2 3
4 5 6
7 8 9

Vamos decompor o código:

• Definimos um tamanho máximo de matriz de 10 para evitar alocação excessiva de memória.
• O programa primeiro solicita ao usuário que insira o tamanho da matriz.
• Ele valida a entrada para garantir que esteja dentro do intervalo permitido.
• Em seguida, solicita ao usuário que digite cada elemento da matriz individualmente.
• Finalmente, imprime a matriz inserida para verificar a entrada.

Usar um Método Recursivo ou de Decomposição LU

Neste passo, implementaremos um método recursivo para calcular o determinante de uma matriz. Modificaremos o programa anterior para incluir uma função de cálculo do determinante.

Atualize o arquivo matrix_determinant.c:

nano matrix_determinant.c

Substitua o conteúdo anterior pelo seguinte código:

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

#define MAX_SIZE 10

// Função para calcular o determinante recursivamente
int determinant(int matrix[MAX_SIZE][MAX_SIZE], int n) {
    int det = 0;
    int submatrix[MAX_SIZE][MAX_SIZE];

    // Caso base para matriz 1x1
    if (n == 1) {
        return matrix[0][0];
    }

    // Caso base para matriz 2x2
    if (n == 2) {
        return matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0];
    }

    // Caso recursivo para matrizes maiores
    int sign = 1;
    for (int k = 0; k < n; k++) {
        // Criar submatriz
        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++;
        }

        // Cálculo recursivo
        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];

    // Ler a dimensão da matriz
    printf("Digite o tamanho da matriz quadrada (1-%d): ", MAX_SIZE);
    scanf("%d", &n);

    // Validar o tamanho da matriz
    if (n < 1 || n > MAX_SIZE) {
        printf("Tamanho da matriz inválido. Por favor, digite um tamanho entre 1 e %d.\n", MAX_SIZE);
        return 1;
    }

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

    // Calcular e imprimir o determinante
    int det = determinant(matrix, n);
    printf("\nDeterminante da matriz: %d\n", det);

    return 0;
}

Compile e execute o programa:

gcc matrix_determinant.c -o matrix_determinant
./matrix_determinant

Exemplo de saída:

Digite o tamanho da matriz quadrada (1-10): 3
Digite os elementos da 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 o elemento [2][0]: 7
Digite o elemento [2][1]: 8
Digite o elemento [2][2]: 9

Determinante da matriz: 0

Pontos-chave sobre o cálculo recursivo do determinante:

• A função determinant() utiliza uma abordagem recursiva para calcular o determinante da matriz.
• Para matrizes 1x1 e 2x2, temos casos base com cálculos diretos.
• Para matrizes maiores, usamos o método de expansão de cofatores ao longo da primeira linha.
• A função cria submatrizes e calcula recursivamente seus determinantes.

Imprimir o Determinante

Neste passo final, melhoraremos nosso programa de determinante de matriz adicionando saída mais detalhada e tratamento de erros para aprimorar a experiência do usuário.

Atualize o arquivo matrix_determinant.c:

nano matrix_determinant.c

Substitua o conteúdo anterior pelo seguinte código aprimorado:

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

#define MAX_SIZE 10

// Função para calcular o determinante recursivamente
int determinant(int matrix[MAX_SIZE][MAX_SIZE], int n) {
    int det = 0;
    int submatrix[MAX_SIZE][MAX_SIZE];

    // Caso base para matriz 1x1
    if (n == 1) {
        return matrix[0][0];
    }

    // Caso base para matriz 2x2
    if (n == 2) {
        return matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0];
    }

    // Caso recursivo para matrizes maiores
    int sign = 1;
    for (int k = 0; k < n; k++) {
        // Criar submatriz
        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++;
        }

        // Cálculo recursivo
        det += sign * matrix[0][k] * determinant(submatrix, n - 1);
        sign = -sign;
    }

    return det;
}

// Função para imprimir a matriz com formatação
void print_matrix(int matrix[MAX_SIZE][MAX_SIZE], int n) {
    printf("\nMatriz:\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) {
        // Ler a dimensão da matriz
        printf("Digite o tamanho da matriz quadrada (1-%d): ", MAX_SIZE);
        if (scanf("%d", &n) != 1) {
            printf("Entrada inválida. Por favor, digite um número.\n");
            while (getchar() != '\n'); // Limpar o buffer de entrada
            continue;
        }

        // Validar o tamanho da matriz
        if (n < 1 || n > MAX_SIZE) {
            printf("Tamanho da matriz inválido. Por favor, digite um tamanho entre 1 e %d.\n", MAX_SIZE);
            continue;
        }

        valid_input = true;
    }

    // Ler os elementos da matriz
    printf("Digite os elementos da matriz:\n");
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            printf("Digite o elemento [%d][%d]: ", i, j);
            while (scanf("%d", &matrix[i][j]) != 1) {
                printf("Entrada inválida. Por favor, digite um inteiro para o elemento [%d][%d]: ", i, j);
                while (getchar() != '\n'); // Limpar o buffer de entrada
            }
        }
    }

    // Imprimir a matriz de entrada
    print_matrix(matrix, n);

    // Calcular e imprimir o determinante
    int det = determinant(matrix, n);

    // Saída formatada do determinante
    printf("\n--- Cálculo do Determinante ---\n");
    printf("Dimensão da Matriz: %d x %d\n", n, n);
    printf("Determinante: %d\n", det);

    return 0;
}

Compile e execute o programa:

gcc matrix_determinant.c -o matrix_determinant
./matrix_determinant

Exemplo de saída:

Digite o tamanho da matriz quadrada (1-10): 3
Digite os elementos da 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 o elemento [2][0]: 7
Digite o elemento [2][1]: 8
Digite o elemento [2][2]: 9

Matriz:
    1     2     3
    4     5     6
    7     8     9

--- Cálculo do Determinante ---
Dimensão da Matriz: 3 x 3
Determinante: 0

Melhorias-chave:

• Adição de validação de entrada para lidar com entradas inválidas.
• Criação de uma função separada para imprimir a matriz com melhor formatação.
• Saída aprimorada para mostrar a dimensão da matriz e o determinante claramente.
• Tratamento de erros aprimorado para entradas do usuário.

Resumo

Neste laboratório, você aprendeu como ler a dimensão e os elementos de uma matriz quadrada em programação C. Você criou um programa que permite aos usuários inserir dinamicamente o tamanho da matriz e seus elementos. O programa valida o tamanho da matriz e, em seguida, solicita ao usuário que insira os elementos da matriz. Finalmente, imprime a matriz inserida para verificar a entrada.

Os próximos passos deste laboratório abordarão como usar um método recursivo ou de decomposição LU para calcular o determinante da matriz de entrada e como imprimir o determinante.