Resolver um Triângulo Retângulo em C

Introdução

Neste laboratório, aprenderá a resolver um triângulo retângulo utilizando cálculos trigonométricos em programação C. O laboratório cobre os passos essenciais para determinar os lados e ângulos desconhecidos de um triângulo retângulo, dados um conjunto de valores conhecidos. Começará aprendendo a ler e definir os lados e ângulos conhecidos do triângulo, depois utilizará as razões trigonométricas para calcular os valores desconhecidos e, finalmente, imprimirá as informações em falta. Este laboratório fornecerá uma compreensão sólida da aplicação de princípios trigonométricos num contexto prático de programação.

Ler Lados/Ângulos Conhecidos

Neste passo, aprenderemos a ler e definir lados e ângulos conhecidos de um triângulo retângulo em programação C. Compreender como introduzir e armazenar informações sobre o triângulo é crucial para realizar cálculos trigonométricos.

Primeiro, vamos criar um novo ficheiro C para definir a estrutura do nosso triângulo e o método de entrada:

// ~/project/triangle_solver.c
#include <stdio.h>
#include <math.h>

// Define uma estrutura para representar um triângulo retângulo
struct RightTriangle {
    double side_a;     // Lado adjacente
    double side_b;     // Lado oposto
    double side_c;     // Hipotenusa
    double angle_A;    // Ângulo oposto ao lado a
    double angle_B;    // Ângulo oposto ao lado b
    double angle_C;    // Ângulo reto (90 graus)
};

int main() {
    struct RightTriangle triangle;

    // Introduzir valores de lados ou ângulos conhecidos
    printf("Introduza os valores dos lados/ângulos conhecidos (introduza 0 se desconhecido):\n");

    printf("Comprimento do lado a: ");
    scanf("%lf", &triangle.side_a);

    printf("Comprimento do lado b: ");
    scanf("%lf", &triangle.side_b);

    printf("Comprimento do lado c (hipotenusa): ");
    scanf("%lf", &triangle.side_c);

    printf("Ângulo A (em graus): ");
    scanf("%lf", &triangle.angle_A);

    printf("Ângulo B (em graus): ");
    scanf("%lf", &triangle.angle_B);

    return 0;
}

Vamos compilar e executar o programa para testar o nosso método de entrada:

gcc ~/project/triangle_solver.c -o ~/project/triangle_solver -lm
~/project/triangle_solver

Exemplo de saída:

Introduza os valores dos lados/ângulos conhecidos (introduza 0 se desconhecido):
Comprimento do lado a: 3
Comprimento do lado b: 4
Comprimento do lado c (hipotenusa): 5
Ângulo A (em graus): 36.87
Ângulo B (em graus): 53.13

Compreendendo o Código

1. Definimos uma estrutura RightTriangle para armazenar todas as possíveis medições do triângulo.
2. A estrutura inclui três lados (a, b, c) e três ângulos (A, B, C).
3. Usamos scanf() para permitir que os utilizadores introduzam valores conhecidos.
4. Os utilizadores podem introduzir 0 para valores desconhecidos, que usaremos em passos subsequentes para calcular informações em falta.

Considerações de Entrada

• Os comprimentos dos lados podem ser qualquer número real positivo.
• Os ângulos estão em graus.
• Para um triângulo retângulo, um ângulo é sempre de 90 graus.
• É necessário pelo menos dois valores conhecidos para resolver completamente o triângulo.

Utilizar Razões Trigonométricas para Encontrar Desconhecidos

Neste passo, estenderemos o nosso programa solucionador de triângulos para calcular lados e ângulos desconhecidos utilizando razões trigonométricas. Iremos atualizar o código anterior para incluir funções para resolver triângulos retângulos.

Vamos modificar o nosso ficheiro triangle_solver.c para adicionar funções de cálculo:

// ~/project/triangle_solver.c
#include <stdio.h>
#include <math.h>

#define PI 3.14159265358979323846

struct RightTriangle {
    double side_a;     // Lado adjacente
    double side_b;     // Lado oposto
    double side_c;     // Hipotenusa
    double angle_A;    // Ângulo oposto ao lado a
    double angle_B;    // Ângulo oposto ao lado b
    double angle_C;    // Ângulo reto (90 graus)
};

// Função para converter graus para radianos
double to_radians(double degrees) {
    return degrees * (PI / 180.0);
}

// Função para converter radianos para graus
double to_degrees(double radians) {
    return radians * (180.0 / PI);
}

// Calcular lados desconhecidos usando razões trigonométricas
void solve_triangle(struct RightTriangle *triangle) {
    // Se a hipotenusa e um lado forem conhecidos, calcular o terceiro lado
    if (triangle->side_c > 0 && triangle->side_a > 0 && triangle->side_b == 0) {
        triangle->side_b = sqrt(triangle->side_c * triangle->side_c - triangle->side_a * triangle->side_a);
    }

    // Se dois lados forem conhecidos, calcular os ângulos
    if (triangle->side_a > 0 && triangle->side_c > 0) {
        triangle->angle_A = to_degrees(asin(triangle->side_a / triangle->side_c));
        triangle->angle_B = 90.0 - triangle->angle_A;
    }

    // Se dois lados forem conhecidos, calcular a hipotenusa
    if (triangle->side_a > 0 && triangle->side_b > 0 && triangle->side_c == 0) {
        triangle->side_c = sqrt(triangle->side_a * triangle->side_a + triangle->side_b * triangle->side_b);
    }
}

// Imprimir informações do triângulo
void print_triangle_info(struct RightTriangle *triangle) {
    printf("\nInformações do Triângulo:\n");
    printf("Lado a: %.2f\n", triangle->side_a);
    printf("Lado b: %.2f\n", triangle->side_b);
    printf("Lado c (Hipotenusa): %.2f\n", triangle->side_c);
    printf("Ângulo A: %.2f graus\n", triangle->angle_A);
    printf("Ângulo B: %.2f graus\n", triangle->angle_B);
    printf("Ângulo C: 90.00 graus\n");
}

int main() {
    struct RightTriangle triangle = {0}; // Inicializar todos os valores para 0

    // Introduzir valores de lados ou ângulos conhecidos
    printf("Introduza os valores dos lados/ângulos conhecidos (introduza 0 se desconhecido):\n");

    printf("Comprimento do lado a: ");
    scanf("%lf", &triangle.side_a);

    // ... (restante do código)
}

Agora, vamos compilar e executar o programa atualizado:

gcc ~/project/triangle_solver.c -o ~/project/triangle_solver -lm
~/project/triangle_solver

Exemplo de entrada e saída:

// ... (entrada)
// ... (saída)

Compreendendo os Cálculos Trigonométricos

1. solve_triangle() utiliza razões trigonométricas para calcular valores desconhecidos:
   • Teorema de Pitágoras para cálculos de lados
   • asin() para cálculos de ângulos
2. to_radians() e to_degrees() ajudam a converter entre graus e radianos
3. O programa pode resolver o triângulo com várias combinações de entrada.

Principais Relações Trigonométricas

• Seno: oposto / hipotenusa
• Cosseno: adjacente / hipotenusa
• Tangente: oposto / adjacente
• Teorema de Pitágoras: a² + b² = c²

Imprimir os Valores Ausentes

Neste passo final, melhoraremos o nosso programa solucionador de triângulos para fornecer uma saída mais detalhada e lidar com diferentes cenários de entrada. Modificaremos o código para imprimir valores ausentes e adicionar verificação de erros.

Atualize o ficheiro triangle_solver.c com as seguintes melhorias:

// ~/project/triangle_solver.c
#include <stdio.h>
#include <math.h>
#include <stdlib.h>

#define PI 3.14159265358979323846
#define EPSILON 0.0001 // Pequeno valor para comparações de ponto flutuante

struct RightTriangle {
    double side_a;
    double side_b;
    double side_c;
    double angle_A;
    double angle_B;
    double angle_C;
};

// Funções anteriores (to_radians, to_degrees, solve_triangle) permanecem as mesmas

// Função de impressão melhorada com deteção de valores ausentes
void print_triangle_info(struct RightTriangle *triangle) {
    printf("\nResultados do Cálculo do Triângulo:\n");
    printf("------------------------------\n");

    // Imprimir lados
    printf("Lados:\n");
    if (triangle->side_a > 0) {
        printf("  Lado a: %.2f\n", triangle->side_a);
    } else {
        printf("  Lado a: AUSENTE (Impossível calcular)\n");
    }

    if (triangle->side_b > 0) {
        printf("  Lado b: %.2f\n", triangle->side_b);
    } else {
        printf("  Lado b: AUSENTE (Impossível calcular)\n");
    }

    if (triangle->side_c > 0) {
        printf("  Lado c (Hipotenusa): %.2f\n", triangle->side_c);
    } else {
        printf("  Lado c (Hipotenusa): AUSENTE (Impossível calcular)\n");
    }

    // Imprimir ângulos
    printf("Ângulos:\n");
    if (triangle->angle_A > 0) {
        printf("  Ângulo A: %.2f graus\n", triangle->angle_A);
    } else {
        printf("  Ângulo A: AUSENTE (Impossível calcular)\n");
    }

    if (triangle->angle_B > 0) {
        printf("  Ângulo B: %.2f graus\n", triangle->angle_B);
    } else {
        printf("  Ângulo B: AUSENTE (Impossível calcular)\n");
    }

    // O ângulo C é sempre 90 graus num triângulo retângulo
    printf("  Ângulo C: 90.00 graus (Ângulo Reto)\n");
}

// Função de validação de entrada
int validate_input(struct RightTriangle *triangle) {
    int valores_conhecidos = 0;

    // Contar valores conhecidos
    // ... (código de validação)
}

int main() {
    // ... (código principal)
}

Compile e execute o programa:

gcc ~/project/triangle_solver.c -o ~/project/triangle_solver -lm
~/project/triangle_solver

Exemplo de entrada e saída:

// ... (entrada)
// ... (saída)

Melhorias Principais

1. Função print_triangle_info() melhorada para mostrar valores ausentes
2. Adicionada validate_input() para verificar a informação suficiente do triângulo
3. Melhor tratamento de erros e feedback ao utilizador
4. Formato consistente para a saída

Resultados de Aprendizagem

• Compreender como lidar com valores de triângulos ausentes
• Aprender a validar cálculos geométricos
• Prática de técnicas avançadas de programação C

Resumo

Neste laboratório, aprendemos a ler e definir lados e ângulos conhecidos de um triângulo retângulo em programação C. Criámos uma estrutura RightTriangle para armazenar todas as possíveis medidas do triângulo, incluindo três lados (a, b, c) e três ângulos (A, B, C). Em seguida, utilizamos scanf() para permitir que os utilizadores introduzissem valores conhecidos, com a opção de introduzir 0 para valores desconhecidos. Este passo é crucial para realizar cálculos trigonométricos para encontrar os valores ausentes na próxima parte do laboratório.

Após definir o método de entrada, o próximo passo é utilizar razões trigonométricas para calcular os lados ou ângulos desconhecidos com base na informação conhecida. O passo final é imprimir os valores ausentes, fornecendo ao utilizador uma solução completa para o problema do triângulo retângulo.