Résoudre un triangle rectangle en C

Introduction

Dans ce laboratoire, vous apprendrez à résoudre un triangle rectangle en utilisant des calculs trigonométriques en langage C. Le laboratoire couvre les étapes essentielles nécessaires pour déterminer les côtés et les angles manquants d'un triangle rectangle, étant donné un ensemble de valeurs connues. Vous commencerez par apprendre à lire et à définir les côtés et les angles connus du triangle, puis vous utiliserez les rapports trigonométriques pour calculer les valeurs inconnues, et enfin, vous imprimerez les informations manquantes. Ce laboratoire vous fournira une compréhension solide de l'application des principes trigonométriques dans un contexte de programmation pratique.

Lecture des côtés/angles connus

Dans cette étape, nous allons apprendre à lire et à définir les côtés et les angles connus d'un triangle rectangle en programmation C. Comprendre comment saisir et stocker les informations sur le triangle est crucial pour effectuer des calculs trigonométriques.

Tout d'abord, créons un nouveau fichier C pour définir la structure de notre triangle et la méthode d'entrée :

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

// Définition d'une structure pour représenter un triangle rectangle
struct RightTriangle {
    double side_a;     // Côté adjacent
    double side_b;     // Côté opposé
    double side_c;     // Hypoténuse
    double angle_A;    // Angle opposé au côté a
    double angle_B;    // Angle opposé au côté b
    double angle_C;    // Angle droit (90 degrés)
};

int main() {
    struct RightTriangle triangle;

    // Saisie des côtés ou angles connus
    printf("Entrez les valeurs des côtés/angles connus (entrez 0 si inconnu) :\n");

    printf("Longueur du côté a : ");
    scanf("%lf", &triangle.side_a);

    printf("Longueur du côté b : ");
    scanf("%lf", &triangle.side_b);

    printf("Longueur du côté c (hypoténuse) : ");
    scanf("%lf", &triangle.side_c);

    printf("Angle A (en degrés) : ");
    scanf("%lf", &triangle.angle_A);

    printf("Angle B (en degrés) : ");
    scanf("%lf", &triangle.angle_B);

    return 0;
}

Compilons et exécutons le programme pour tester notre méthode d'entrée :

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

Exemple de sortie :

Entrez les valeurs des côtés/angles connus (entrez 0 si inconnu) :
Longueur du côté a : 3
Longueur du côté b : 4
Longueur du côté c (hypoténuse) : 5
Angle A (en degrés) : 36.87
Angle B (en degrés) : 53.13

Compréhension du code

1. Nous définissons une structure RightTriangle pour stocker toutes les mesures possibles du triangle.
2. La structure inclut trois côtés (a, b, c) et trois angles (A, B, C).
3. Nous utilisons scanf() pour permettre aux utilisateurs de saisir les valeurs connues.
4. Les utilisateurs peuvent entrer 0 pour les valeurs inconnues, que nous utiliserons dans les étapes suivantes pour calculer les informations manquantes.

Considérations relatives à l'entrée

• Les longueurs des côtés peuvent être n'importe quel nombre réel positif.
• Les angles sont en degrés.
• Pour un triangle rectangle, un angle est toujours de 90 degrés.
• Vous avez besoin d'au moins deux valeurs connues pour résoudre complètement le triangle.

Utilisation des rapports trigonométriques pour trouver les inconnues

Dans cette étape, nous allons étendre notre programme de résolution de triangles pour calculer les côtés et les angles inconnus à l'aide des rapports trigonométriques. Nous allons mettre à jour le code précédent pour inclure des fonctions permettant de résoudre des triangles rectangles.

Modifions notre fichier triangle_solver.c pour ajouter des fonctions de calcul :

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

#define PI 3.14159265358979323846

struct RightTriangle {
    double side_a;     // Côté adjacent
    double side_b;     // Côté opposé
    double side_c;     // Hypoténuse
    double angle_A;    // Angle opposé au côté a
    double angle_B;    // Angle opposé au côté b
    double angle_C;    // Angle droit (90 degrés)
};

// Fonction pour convertir des degrés en radians
double to_radians(double degrees) {
    return degrees * (PI / 180.0);
}

// Fonction pour convertir des radians en degrés
double to_degrees(double radians) {
    return radians * (180.0 / PI);
}

// Calcul des côtés manquants à l'aide des rapports trigonométriques
void solve_triangle(struct RightTriangle *triangle) {
    // Si l'hypoténuse et un côté sont connus, calculer le troisième côté
    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);
    }

    // Si deux côtés sont connus, calculer les angles
    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;
    }

    // Si deux côtés sont connus, calculer l'hypoténuse
    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);
    }
}

// Affichage des informations sur le triangle
void print_triangle_info(struct RightTriangle *triangle) {
    printf("\nInformations sur le triangle :\n");
    printf("Côté a : %.2f\n", triangle->side_a);
    printf("Côté b : %.2f\n", triangle->side_b);
    printf("Côté c (Hypoténuse) : %.2f\n", triangle->side_c);
    printf("Angle A : %.2f degrés\n", triangle->angle_A);
    printf("Angle B : %.2f degrés\n", triangle->angle_B);
    printf("Angle C : 90.00 degrés\n");
}

int main() {
    struct RightTriangle triangle = {0}; // Initialisation de toutes les valeurs à 0

    // Saisie des côtés ou angles connus
    printf("Entrez les valeurs des côtés/angles connus (entrez 0 si inconnu) :\n");

    printf("Longueur du côté a : ");
    scanf("%lf", &triangle.side_a);

    // ... (autres saisies)

    // Résolution des valeurs inconnues
    solve_triangle(&triangle);

    // Affichage des résultats
    print_triangle_info(&triangle);

    return 0;
}

Compilons et exécutons le programme mis à jour :

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

Exemple d'entrée et de sortie :

Entrez les valeurs des côtés/angles connus (entrez 0 si inconnu) :
Longueur du côté a : 3
Longueur du côté b : 4
Longueur du côté c (hypoténuse) : 0
Angle A (en degrés) : 0
Angle B (en degrés) : 0

Informations sur le triangle :
Côté a : 3.00
Côté b : 4.00
Côté c (Hypoténuse) : 5.00
Angle A : 36.87 degrés
Angle B : 53.13 degrés
Angle C : 90.00 degrés

Compréhension des calculs trigonométriques

1. solve_triangle() utilise les rapports trigonométriques pour calculer les valeurs manquantes :
   • Théorème de Pythagore pour les calculs de côtés
   • asin() pour les calculs d'angles
2. to_radians() et to_degrees() permettent de convertir entre degrés et radians
3. Le programme peut résoudre le triangle avec différentes combinaisons d'entrées

Relations trigonométriques clés

• Sinus : opposé / hypoténuse
• Cosinus : adjacent / hypoténuse
• Tangente : opposé / adjacent
• Théorème de Pythagore : a² + b² = c²

Affichage des valeurs manquantes

Dans cette dernière étape, nous allons améliorer notre programme de résolution de triangles pour fournir une sortie plus détaillée et gérer différents scénarios d'entrée. Nous allons modifier le code pour afficher les valeurs manquantes et ajouter des vérifications d'erreur.

Mettez à jour le fichier triangle_solver.c avec les améliorations suivantes :

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

#define PI 3.14159265358979323846
#define EPSILON 0.0001 // Petite valeur pour les comparaisons en virgule flottante

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

// Les fonctions précédentes (to_radians, to_degrees, solve_triangle) restent les mêmes

// Fonction d'affichage améliorée avec détection des valeurs manquantes
void print_triangle_info(struct RightTriangle *triangle) {
    printf("\nRésultats du calcul du triangle :\n");
    printf("------------------------------\n");

    // Affichage des côtés
    printf("Côtés :\n");
    if (triangle->side_a > 0) {
        printf("  Côté a : %.2f\n", triangle->side_a);
    } else {
        printf("  Côté a : MANQUANT (Impossible de calculer)\n");
    }

    if (triangle->side_b > 0) {
        printf("  Côté b : %.2f\n", triangle->side_b);
    } else {
        printf("  Côté b : MANQUANT (Impossible de calculer)\n");
    }

    if (triangle->side_c > 0) {
        printf("  Côté c (Hypoténuse) : %.2f\n", triangle->side_c);
    } else {
        printf("  Côté c (Hypoténuse) : MANQUANT (Impossible de calculer)\n");
    }

    // Affichage des angles
    printf("Angles :\n");
    if (triangle->angle_A > 0) {
        printf("  Angle A : %.2f degrés\n", triangle->angle_A);
    } else {
        printf("  Angle A : MANQUANT (Impossible de calculer)\n");
    }

    if (triangle->angle_B > 0) {
        printf("  Angle B : %.2f degrés\n", triangle->angle_B);
    } else {
        printf("  Angle B : MANQUANT (Impossible de calculer)\n");
    }

    // L'angle C est toujours de 90 degrés dans un triangle rectangle
    printf("  Angle C : 90,00 degrés (Angle droit)\n");
}

// Fonction de validation de l'entrée
int validate_input(struct RightTriangle *triangle) {
    int valeurs_connues = 0;

    // Comptage des valeurs connues
    if (triangle->side_a > 0) valeurs_connues++;
    if (triangle->side_b > 0) valeurs_connues++;
    if (triangle->side_c > 0) valeurs_connues++;
    if (triangle->angle_A > 0) valeurs_connues++;
    if (triangle->angle_B > 0) valeurs_connues++;

    // Il faut au moins deux valeurs connues pour résoudre le triangle
    if (valeurs_connues < 2) {
        printf("Erreur : Informations insuffisantes pour résoudre le triangle.\n");
        printf("Vous devez fournir au moins deux valeurs connues.\n");
        return 0;
    }

    return 1;
}

int main() {
    // ... (reste du code main inchangé)
}

(Le reste du code main est inchangé)

Compilation et exécution du programme :

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

Exemple d'entrée et de sortie :

// ... (entrée)

Résultats du calcul du triangle :
------------------------------
Côtés :
  Côté a : 3.00
  Côté b : 4.00
  Côté c (Hypoténuse) : 5.00
Angles :
  Angle A : 36.87 degrés
  Angle B : 53.13 degrés
  Angle C : 90,00 degrés (Angle droit)

Améliorations clés

1. Fonction print_triangle_info() améliorée pour afficher les valeurs manquantes.
2. Ajout de validate_input() pour vérifier la suffisance des informations sur le triangle.
3. Gestion des erreurs et retours d'informations utilisateur améliorés.
4. Formatage cohérent de la sortie.

Résultats d'apprentissage

• Comprendre comment gérer les valeurs de triangle manquantes.
• Apprendre à valider les calculs géométriques.
• Pratiquer des techniques de programmation C avancées.

Résumé

Dans ce laboratoire, nous avons appris à lire et à définir les côtés et les angles connus d'un triangle rectangle en programmation C. Nous avons créé une structure RightTriangle pour stocker toutes les mesures possibles d'un triangle, y compris trois côtés (a, b, c) et trois angles (A, B, C). Nous avons ensuite utilisé scanf() pour permettre aux utilisateurs d'entrer les valeurs connues, avec la possibilité d'entrer 0 pour les valeurs inconnues. Cette étape est cruciale pour effectuer des calculs trigonométriques afin de trouver les valeurs manquantes dans la prochaine partie du laboratoire.

Après avoir défini la méthode d'entrée, l'étape suivante consiste à utiliser les rapports trigonométriques pour calculer les côtés ou les angles inconnus en fonction des informations connues. La dernière étape consiste à afficher les valeurs manquantes, fournissant à l'utilisateur une solution complète au problème du triangle rectangle.