Rechteckiges Dreieck in C lösen

Einführung

In diesem Labor lernen Sie, wie man ein rechtwinkliges Dreieck mithilfe trigonometrischer Berechnungen in der C-Programmierung löst. Das Labor behandelt die wesentlichen Schritte zur Bestimmung der fehlenden Seiten und Winkel eines rechtwinkligen Dreiecks, gegeben eine Reihe bekannter Werte. Sie beginnen damit, die bekannten Seiten und Winkel des Dreiecks zu lesen und zu definieren, verwenden dann trigonometrische Verhältnisse, um die unbekannten Werte zu berechnen, und geben schließlich die fehlenden Informationen aus. Dieses Labor vermittelt Ihnen ein solides Verständnis der Anwendung trigonometrischer Prinzipien in einem praktischen Programmierkontext.

Bekannte Seiten/Winkel einlesen

In diesem Schritt lernen wir, bekannte Seiten und Winkel eines rechtwinkligen Dreiecks in der C-Programmierung einzulesen und zu definieren. Das Verständnis der Eingabe und Speicherung von Dreiecksinformationen ist entscheidend für die Durchführung trigonometrischer Berechnungen.

Erstellen wir zunächst eine neue C-Datei, um unsere Dreiecksstruktur und die Eingabemethode zu definieren:

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

// Definition einer Struktur zur Darstellung eines rechtwinkligen Dreiecks
struct RightTriangle {
    double side_a;     // Ankathete
    double side_b;     // Gegenkathete
    double side_c;     // Hypotenuse
    double angle_A;    // Winkel gegenüber Seite a
    double angle_B;    // Winkel gegenüber Seite b
    double angle_C;    //rechter Winkel (90 Grad)
};

int main() {
    struct RightTriangle triangle;

    // Eingabe bekannter Seiten oder Winkel
    printf("Geben Sie die bekannten Seiten/Winkelwerte ein (geben Sie 0 ein, falls unbekannt):\n");

    printf("Seitenlänge a: ");
    scanf("%lf", &triangle.side_a);

    printf("Seitenlänge b: ");
    scanf("%lf", &triangle.side_b);

    printf("Seitenlänge c (Hypotenuse): ");
    scanf("%lf", &triangle.side_c);

    printf("Winkel A (in Grad): ");
    scanf("%lf", &triangle.angle_A);

    printf("Winkel B (in Grad): ");
    scanf("%lf", &triangle.angle_B);

    return 0;
}

Kompilieren und ausführen wir das Programm, um unsere Eingabemethode zu testen:

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

Beispielausgabe:

Geben Sie die bekannten Seiten/Winkelwerte ein (geben Sie 0 ein, falls unbekannt):
Seitenlänge a: 3
Seitenlänge b: 4
Seitenlänge c (Hypotenuse): 5
Winkel A (in Grad): 36.87
Winkel B (in Grad): 53.13

Verständnis des Codes

1. Wir definieren eine RightTriangle-Struktur, um alle möglichen Dreiecksmessungen zu speichern.
2. Die Struktur enthält drei Seiten (a, b, c) und drei Winkel (A, B, C).
3. Wir verwenden scanf(), um Benutzern die Eingabe bekannter Werte zu ermöglichen.
4. Benutzer können 0 für unbekannte Werte eingeben, die wir in den folgenden Schritten verwenden, um fehlende Informationen zu berechnen.

Überlegungen zur Eingabe

• Seitenlängen können beliebige positive reelle Zahlen sein.
• Winkel sind in Grad angegeben.
• Bei einem rechtwinkligen Dreieck beträgt ein Winkel immer 90 Grad.
• Sie benötigen mindestens zwei bekannte Werte, um das Dreieck vollständig zu lösen.

Use Trigonometric Ratios to Find Unknowns

In this step, we will extend our triangle solver program to calculate unknown sides and angles using trigonometric ratios. We'll update the previous code to include functions for solving right-angled triangles.

Let's modify our triangle_solver.c file to add calculation functions:

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

#define PI 3.14159265358979323846

struct RightTriangle {
    double side_a;     // Adjacent side
    double side_b;     // Opposite side
    double side_c;     // Hypotenuse
    double angle_A;    // Angle opposite to side a
    double angle_B;    // Angle opposite to side b
    double angle_C;    // Right angle (90 degrees)
};

// Function to convert degrees to radians
double to_radians(double degrees) {
    return degrees * (PI / 180.0);
}

// Function to convert radians to degrees
double to_degrees(double radians) {
    return radians * (180.0 / PI);
}

// Calculate missing sides using trigonometric ratios
void solve_triangle(struct RightTriangle *triangle) {
    // If hypotenuse and one side are known, calculate the third side
    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);
    }

    // If two sides are known, calculate 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;
    }

    // If two sides are known, calculate hypotenuse
    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);
    }
}

// Print triangle information
void print_triangle_info(struct RightTriangle *triangle) {
    printf("\nTriangle Information:\n");
    printf("Side a: %.2f\n", triangle->side_a);
    printf("Side b: %.2f\n", triangle->side_b);
    printf("Side c (Hypotenuse): %.2f\n", triangle->side_c);
    printf("Angle A: %.2f degrees\n", triangle->angle_A);
    printf("Angle B: %.2f degrees\n", triangle->angle_B);
    printf("Angle C: 90.00 degrees\n");
}

int main() {
    struct RightTriangle triangle = {0}; // Initialize all values to 0

    // Input known sides or angles
    printf("Enter known side/angle values (enter 0 if unknown):\n");

    printf("Side a length: ");
    scanf("%lf", &triangle.side_a);

    printf("Side b length: ");
    scanf("%lf", &triangle.side_b);

    printf("Side c (hypotenuse) length: ");
    scanf("%lf", &triangle.side_c);

    printf("Angle A (in degrees): ");
    scanf("%lf", &triangle.angle_A);

    printf("Angle B (in degrees): ");
    scanf("%lf", &triangle.angle_B);

    // Solve for unknown values
    solve_triangle(&triangle);

    // Print results
    print_triangle_info(&triangle);

    return 0;
}

Now, let's compile and run the updated program:

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

Example input and output:

Enter known side/angle values (enter 0 if unknown):
Side a length: 3
Side b length: 4
Side c (hypotenuse) length: 0
Angle A (in degrees): 0
Angle B (in degrees): 0

Triangle Information:
Side a: 3.00
Side b: 4.00
Side c (Hypotenuse): 5.00
Angle A: 36.87 degrees
Angle B: 53.13 degrees
Angle C: 90.00 degrees

Understanding Trigonometric Calculations

1. solve_triangle() uses trigonometric ratios to calculate missing values:
   • Pythagorean theorem for side calculations
   • asin() for angle calculations
2. to_radians() and to_degrees() help convert between degrees and radians
3. The program can solve the triangle with various input combinations

Key Trigonometric Relationships

• Sine: opposite / hypotenuse
• Cosine: adjacent / hypotenuse
• Tangent: opposite / adjacent
• Pythagorean theorem: a² + b² = c²

Ausgabe der fehlenden Werte

In diesem letzten Schritt erweitern wir unser Dreieckslöser-Programm, um detailliertere Ausgaben zu liefern und verschiedene Eingabefälle zu handhaben. Wir werden den Code modifizieren, um fehlende Werte auszugeben und Fehlerprüfungen hinzuzufügen.

Aktualisieren Sie die Datei triangle_solver.c mit folgenden Verbesserungen:

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

#define PI 3.14159265358979323846
#define EPSILON 0.0001 // Kleiner Wert für Gleitkommavergleiche

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

// Vorherige Funktionen (to_radians, to_degrees, solve_triangle) bleiben gleich

// Erweiterte Ausgabefunktion mit fehlender Wertdetektion
void print_triangle_info(struct RightTriangle *triangle) {
    printf("\nErgebnisse der Dreiecksberechnung:\n");
    printf("------------------------------\n");

    // Seiten ausgeben
    printf("Seiten:\n");
    if (triangle->side_a > 0) {
        printf("  Seite a: %.2f\n", triangle->side_a);
    } else {
        printf("  Seite a: FEHLEND (Kann nicht berechnet werden)\n");
    }

    if (triangle->side_b > 0) {
        printf("  Seite b: %.2f\n", triangle->side_b);
    } else {
        printf("  Seite b: FEHLEND (Kann nicht berechnet werden)\n");
    }

    if (triangle->side_c > 0) {
        printf("  Seite c (Hypotenuse): %.2f\n", triangle->side_c);
    } else {
        printf("  Seite c (Hypotenuse): FEHLEND (Kann nicht berechnet werden)\n");
    }

    // Winkel ausgeben
    printf("Winkel:\n");
    if (triangle->angle_A > 0) {
        printf("  Winkel A: %.2f Grad\n", triangle->angle_A);
    } else {
        printf("  Winkel A: FEHLEND (Kann nicht berechnet werden)\n");
    }

    if (triangle->angle_B > 0) {
        printf("  Winkel B: %.2f Grad\n", triangle->angle_B);
    } else {
        printf("  Winkel B: FEHLEND (Kann nicht berechnet werden)\n");
    }

    // Winkel C ist in einem rechtwinkligen Dreieck immer 90 Grad
    printf("  Winkel C: 90,00 Grad (rechter Winkel)\n");
}

// Funktion zur Eingabevalidierung
int validate_input(struct RightTriangle *triangle) {
    int bekannteWerte = 0;

    // Zählen der bekannten Werte
    if (triangle->side_a > 0) bekannteWerte++;
    if (triangle->side_b > 0) bekannteWerte++;
    if (triangle->side_c > 0) bekannteWerte++;
    if (triangle->angle_A > 0) bekannteWerte++;
    if (triangle->angle_B > 0) bekannteWerte++;

    // Mindestens zwei bekannte Werte erforderlich, um das Dreieck zu lösen
    if (bekannteWerte < 2) {
        printf("Fehler: Nicht genügend Informationen zum Lösen des Dreiecks.\n");
        printf("Sie müssen mindestens zwei bekannte Werte angeben.\n");
        return 0;
    }

    return 1;
}

int main() {
    struct RightTriangle triangle = {0};

    // Eingabe bekannter Seiten oder Winkel
    printf("Rechter Winkel Dreieckslöser\n");
    printf("Geben Sie bekannte Werte ein (geben Sie 0 ein, falls unbekannt):\n");

    // ... (Eingabe-Code)

    // Eingabevalidierung
    if (!validate_input(&triangle)) {
        return 1;
    }

    // Lösen der unbekannten Werte
    solve_triangle(&triangle);

    // Ausgabe der Ergebnisse
    print_triangle_info(&triangle);

    return 0;
}

// ... (Kompilierungs- und Ausführungscode)

Wichtige Verbesserungen

1. Erweiterte Funktion print_triangle_info(), um fehlende Werte anzuzeigen.
2. Hinzugefügte Funktion validate_input(), um ausreichende Dreiecksinformationen zu überprüfen.
3. Verbesserte Fehlerbehandlung und Benutzerfeedback.
4. Konsistente Formatierung der Ausgabe.

Lernziele

• Verständnis der Handhabung fehlender Dreieckswerte.
• Validierung geometrischer Berechnungen.
• Übung fortgeschrittener C-Programmiertechniken.

Zusammenfassung

In diesem Labor haben wir gelernt, bekannte Seiten und Winkel eines rechtwinkligen Dreiecks in der C-Programmierung zu lesen und zu definieren. Wir haben eine RightTriangle-Struktur erstellt, um alle möglichen Dreiecksmessungen zu speichern, einschließlich drei Seiten (a, b, c) und drei Winkel (A, B, C). Anschließend haben wir scanf() verwendet, um Benutzern die Eingabe bekannter Werte zu ermöglichen, wobei die Eingabe von 0 für unbekannte Werte möglich ist. Dieser Schritt ist entscheidend für die Durchführung trigonometrischer Berechnungen, um die fehlenden Werte im nächsten Teil des Labors zu ermitteln.

Nachdem die Eingabemethode definiert wurde, besteht der nächste Schritt darin, trigonometrische Verhältnisse zu verwenden, um die unbekannten Seiten oder Winkel basierend auf den bekannten Informationen zu berechnen. Der letzte Schritt besteht darin, die fehlenden Werte auszugeben und dem Benutzer eine vollständige Lösung für das rechtwinklige Dreiecks-Problem zu liefern.