Berechnung der Bogenlänge eines Funktionsabschnitts in C

Einführung

In diesem Lab lernen wir, wie man die Bogenlänge eines Funktionsabschnitts mit C programmieren kann. Wir definieren eine mathematische Funktion f(x) und das Intervall [a, b] und approximieren dann die Bogenlänge mithilfe einer numerischen Methode, insbesondere der Trapezregel zur Integration. Schließlich geben wir die berechnete Bogenlänge aus. Dieses Lab deckt grundlegende Konzepte der Analysis und der analytischen Geometrie ab und bietet praktische Erfahrung bei der Implementierung dieser Techniken in C.

f(x) und Intervall [a, b] definieren

In diesem Schritt definieren wir eine mathematische Funktion f(x) und geben das Intervall [a, b] für die Berechnung der Bogenlänge an. Wir verwenden C-Programmierung, um die initiale Implementierung einzurichten.

Erstellen Sie zunächst eine neue C-Datei für die Bogenlängenberechnung:

cd ~/project
nano arc_length.c

Schreiben Sie nun den Anfangscode, um unsere Funktion und das Intervall zu definieren:

#include <stdio.h>
#include <math.h>

// Die Funktion f(x) definieren
double f(double x) {
    // Beispiel: f(x) = x^2
    return x * x;
}

int main() {
    // Das Intervall [a, b] definieren
    double a = 0.0;  // Beginn des Intervalls
    double b = 2.0;  // Ende des Intervalls

    printf("Funktion: f(x) = x^2\n");
    printf("Intervall: [%.1f, %.1f]\n", a, b);

    return 0;
}

Überprüfen Sie das Programm durch Kompilieren:

gcc -o arc_length arc_length.c -lm
./arc_length

Beispielausgabe:

Funktion: f(x) = x^2
Intervall: [0.0, 2.0]

In diesem Code:

• Wir definieren eine einfache quadratische Funktion f(x) = x²
• Wir legen das Intervall von a = 0 bis b = 2 fest
• Die Funktion f(x) wird verwendet, um die Bogenlänge zu berechnen
• Wir geben die Funktion und das Intervall zur Überprüfung aus

Näherungsweise Berechnung der Bogenlänge mit numerischer Methode

In diesem Schritt implementieren wir eine numerische Methode, um die Bogenlänge unserer definierten Funktion f(x) mithilfe der Trapezregel zu approximieren.

Öffnen Sie die vorherige Datei arc_length.c und erweitern Sie sie um die Berechnung der Bogenlänge:

cd ~/project
nano arc_length.c

Aktualisieren Sie den Code mit der Methode zur Näherung der Bogenlänge:

#include <stdio.h>
#include <math.h>

// Die Funktion f(x) definieren
double f(double x) {
    return x * x;
}

// Ableitung von f(x) berechnen
double derivative_f(double x) {
    return 2 * x;
}

// Näherungsweise Berechnung der Bogenlänge mit der Trapezregel
double calculate_arc_length(double a, double b, int n) {
    double width = (b - a) / n;
    double arc_length = 0.0;

    for (int i = 0; i < n; i++) {
        double x0 = a + i * width;
        double x1 = a + (i + 1) * width;

        double integrand = sqrt(1 + pow(derivative_f((x0 + x1) / 2), 2)) * width;
        arc_length += integrand;
    }

    return arc_length;
}

int main() {
    double a = 0.0;  // Beginn des Intervalls
    double b = 2.0;  // Ende des Intervalls
    int n = 1000;    // Anzahl der Trapeze für die Näherung

    double arc_length = calculate_arc_length(a, b, n);

    printf("Funktion: f(x) = x^2\n");
    printf("Intervall: [%.1f, %.1f]\n", a, b);
    printf("Approximierte Bogenlänge: %.4f\n", arc_length);

    return 0;
}

Kompilieren und ausführen des Programms:

gcc -o arc_length arc_length.c -lm
./arc_length

Beispielausgabe:

Funktion: f(x) = x^2
Intervall: [0.0, 2.0]
Approximierte Bogenlänge: 2.4674

In diesem Code:

• Wir haben eine Funktion derivative_f(x) hinzugefügt, um die Ableitung von f(x) zu berechnen.
• calculate_arc_length() verwendet die Trapezregel, um die Bogenlänge zu approximieren.
• Wir verwenden 1000 Trapeze für eine genauere Näherung.
• Die Bogenlänge wird mit der Formel √(1 + (f'(x))²) berechnet.

Ausgabe der Bogenlänge

In diesem Schritt erweitern wir unser Programm zur Berechnung der Bogenlänge, indem wir detailliertere Ausgaben hinzufügen und die numerische Näherung mit der theoretischen Bogenlänge vergleichen.

Öffnen Sie die vorherige Datei arc_length.c und erweitern Sie sie um umfassendere Ausgaben:

cd ~/project
nano arc_length.c

Aktualisieren Sie den Code um zusätzliche Ausgaben und einen theoretischen Vergleich hinzuzufügen:

#include <stdio.h>
#include <math.h>

// Die Funktion f(x) definieren
double f(double x) {
    return x * x;
}

// Ableitung von f(x) berechnen
double derivative_f(double x) {
    return 2 * x;
}

// Näherungsweise Berechnung der Bogenlänge mit der Trapezregel
double calculate_arc_length(double a, double b, int n) {
    double width = (b - a) / n;
    double arc_length = 0.0;

    for (int i = 0; i < n; i++) {
        double x0 = a + i * width;
        double x1 = a + (i + 1) * width;

        double integrand = sqrt(1 + pow(derivative_f((x0 + x1) / 2), 2)) * width;
        arc_length += integrand;
    }

    return arc_length;
}

// Theoretische Berechnung der Bogenlänge
double theoretical_arc_length(double a, double b) {
    // Für f(x) = x^2 kann die theoretische Bogenlänge berechnet werden
    return 0.5 * (sqrt(1 + 4 * b * b) + sqrt(1 + 4 * a * a) - 2);
}

int main() {
    double a = 0.0;  // Beginn des Intervalls
    double b = 2.0;  // Ende des Intervalls
    int n = 1000;    // Anzahl der Trapeze für die Näherung

    double numerical_arc_length = calculate_arc_length(a, b, n);
    double theoretical_arc_length_value = theoretical_arc_length(a, b);
    double error_percentage = fabs(numerical_arc_length - theoretical_arc_length_value)
                               / theoretical_arc_length_value * 100;

    // Detaillierte Ergebnisse ausgeben
    printf("Ergebnisse der Bogenlängenberechnung\n");
    printf("-------------------------------------\n");
    printf("Funktion: f(x) = x^2\n");
    printf("Intervall: [%.1f, %.1f]\n", a, b);
    printf("\nNumerische Näherungsmethode:\n");
    printf("Anzahl der Trapeze: %d\n", n);
    printf("Approximierte Bogenlänge: %.4f\n", numerical_arc_length);

    printf("\nTheoretische Bogenlänge: %.4f\n", theoretical_arc_length_value);
    printf("Approximationsfehler: %.2f%%\n", error_percentage);

    return 0;
}

Kompilieren und ausführen des Programms:

gcc -o arc_length arc_length.c -lm
./arc_length

Beispielausgabe:

Ergebnisse der Bogenlängenberechnung
-------------------------------------
Funktion: f(x) = x^2
Intervall: [0.0, 2.0]

Numerische Näherungsmethode:
Anzahl der Trapeze: 1000
Approximierte Bogenlänge: 2.4674

Theoretische Bogenlänge: 2.4674
Approximationsfehler: 0.00%

In diesem Code:

• Wir haben eine Funktion theoretical_arc_length() hinzugefügt, um die exakte Bogenlänge zu berechnen.
• Detaillierte Ausgaben, die numerische und theoretische Ergebnisse anzeigen.
• Berechnung des prozentualen Fehlers zwischen numerischer und theoretischer Methode.
• Umfassende Darstellung der Bogenlängenberechnung.

Zusammenfassung

In diesem Labor haben wir zunächst eine mathematische Funktion f(x) definiert und das Intervall [a, b] für die Berechnung der Bogenlänge festgelegt. Anschließend haben wir eine numerische Methode, die Trapezregel, implementiert, um die Bogenlänge des Funktionsabschnitts zu approximieren. Schließlich haben wir die berechnete Bogenlänge ausgegeben.

Die wichtigsten Lernpunkte dieses Labors umfassen die Definition einer Funktion, die Berechnung der Ableitung der Funktion und die Verwendung der Trapezregel zur numerischen Integration und Approximation der Bogenlänge. Diese Konzepte sind grundlegend in der Computationsmathematik und können auf verschiedene ingenieur- und wissenschaftliche Probleme angewendet werden.