Évaluer les Approximations aux Différences Finies en C

Introduction

Dans ce laboratoire, vous apprendrez à évaluer les approximations aux différences finies des dérivées en C. Le laboratoire couvre les étapes suivantes :

1. Définir une fonction mathématique f(x) et configurer le pas h pour les approximations aux différences finies.
2. Calculer les approximations aux différences finies avant et arrière de la dérivée de f(x) à un point d'évaluation donné x.
3. Afficher les approximations calculées et les comparer à la dérivée réelle.

À la fin de ce laboratoire, vous aurez une bonne compréhension de la manière de mettre en œuvre les méthodes aux différences finies en C et d'évaluer la précision des approximations.

Définition de f(x) et de la taille d'étape h

Dans cette étape, vous apprendrez à définir une fonction mathématique et à configurer la taille d'étape pour les approximations aux différences finies en C.

Tout d'abord, créez un nouveau fichier C pour votre programme d'approximation aux différences finies :

cd ~/project
nano finite_difference.c

Maintenant, ajoutez le code suivant pour définir la fonction et la taille d'étape :

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

// Définition de la fonction f(x)
double f(double x) {
    return x * x;  // Fonction d'exemple : f(x) = x^2
}

int main() {
    // Définition de la taille d'étape h
    double h = 0.0001;  // Petite taille d'étape pour une approximation précise

    // Point d'évaluation de la dérivée
    double x = 2.0;

    printf("Fonction : f(x) = x^2\n");
    printf("Taille d'étape h : %f\n", h);
    printf("Point d'évaluation x : %f\n", x);

    return 0;
}

Exemple de sortie :

Fonction : f(x) = x^2
Taille d'étape h : 0.000100
Point d'évaluation x : 2.000000

Décomposons les composants clés :

1. Fonction f(x) : Nous avons défini une fonction quadratique simple f(x) = x^2. Vous pouvez modifier cette fonction pour représenter n'importe quelle fonction mathématique que vous souhaitez approximer.

2. Taille d'étape h : Il s'agit d'une petite valeur utilisée dans les approximations aux différences finies. Une valeur h plus petite fournit généralement des résultats plus précis, mais des valeurs extrêmement petites peuvent entraîner des problèmes de précision numérique.

3. Point d'évaluation x : Il s'agit du point auquel nous calculerons l'approximation de la dérivée.

Compilez le programme pour vous assurer qu'il fonctionne :

gcc -o finite_difference finite_difference.c -lm
./finite_difference

Exemple de sortie :

Fonction : f(x) = x^2
Taille d'étape h : 0.000100
Point d'évaluation x : 2.000000

Calcul des différences avant/arrière

Dans cette étape, vous apprendrez à calculer les approximations aux différences finies avant et arrière des dérivées.

Ouvrez le fichier précédent et modifiez le code pour inclure les méthodes d'approximation de la dérivée :

cd ~/project
nano finite_difference.c

Mettez à jour le code avec les calculs de différences avant et arrière :

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

// Définition de la fonction f(x)
double f(double x) {
    return x * x;  // Fonction d'exemple : f(x) = x^2
}

int main() {
    // Définition de la taille d'étape h
    double h = 0.0001;  // Petite taille d'étape pour une approximation précise

    // Point d'évaluation de la dérivée
    double x = 2.0;

    // Approximation par différence avant
    double forward_diff = (f(x + h) - f(x)) / h;

    // Approximation par différence arrière
    double backward_diff = (f(x) - f(x - h)) / h;

    printf("Approximation par différence avant : %f\n", forward_diff);
    printf("Approximation par différence arrière : %f\n", backward_diff);

    return 0;
}

Compilez et exécutez le programme :

gcc -o finite_difference finite_difference.c -lm
./finite_difference

Exemple de sortie :

Approximation par différence avant : 4.000100
Approximation par différence arrière : 3.999900

Décomposons les approximations aux différences finies :

1. Différence avant : Calcule la dérivée en utilisant le point situé après x.

   • Formule : (f(x + h) - f(x)) / h
   • Approximer le taux de variation en se déplaçant vers l'avant.

2. Différence arrière : Calcule la dérivée en utilisant le point situé avant x.

   • Formule : (f(x) - f(x - h)) / h
   • Approximer le taux de variation en se déplaçant vers l'arrière.

Notez que pour la fonction f(x) = x^2, la dérivée réelle est 2x (qui vaut 4 pour x = 2).
Les approximations sont très proches de la valeur réelle de la dérivée.

Affichage des approximations

Dans cette étape, vous améliorerez le programme pour afficher les résultats d'approximation détaillés et les comparer à la dérivée réelle.

Ouvrez le fichier précédent et modifiez le code pour inclure une sortie complète :

cd ~/project
nano finite_difference.c

Mettez à jour le code pour afficher les approximations détaillées :

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

// Définition de la fonction f(x)
double f(double x) {
    return x * x;  // Fonction d'exemple : f(x) = x^2
}

// Fonction de la dérivée réelle
double actual_derivative(double x) {
    return 2 * x;  // Dérivée de x^2 est 2x
}

int main() {
    // Définition de plusieurs tailles d'étape pour la comparaison
    double step_sizes[] = {0.1, 0.01, 0.001, 0.0001};
    int num_steps = sizeof(step_sizes) / sizeof(step_sizes[0]);

    // Point d'évaluation de la dérivée
    double x = 2.0;

    // Valeur de la dérivée réelle
    double true_derivative = actual_derivative(x);

    printf("Analyse de l'approximation de la dérivée\n");
    printf("----------------------------------------\n");
    printf("Fonction : f(x) = x^2\n");
    printf("Point d'évaluation : x = %f\n", x);
    printf("Dérivée réelle : %f\n\n", true_derivative);

    printf("Taille d'étape | Diff. avant | Diff. arrière | Erreur avant | Erreur arrière\n");
    printf("-----------------------------------------------------------------------\n");

    // Calcul et affichage des approximations pour différentes tailles d'étape
    for (int i = 0; i < num_steps; i++) {
        double h = step_sizes[i];

        // Approximation par différence avant
        double forward_diff = (f(x + h) - f(x)) / h;

        // Approximation par différence arrière
        double backward_diff = (f(x) - f(x - h)) / h;

        // Calcul des erreurs absolues
        double forward_error = fabs(forward_diff - true_derivative);
        double backward_error = fabs(backward_diff - true_derivative);

        printf("%9f | %11f | %12f | %11f | %12f\n",
               h, forward_diff, backward_diff, forward_error, backward_error);
    }

    return 0;
}

Compilez et exécutez le programme :

gcc -o finite_difference finite_difference.c -lm
./finite_difference

Exemple de sortie :

Analyse de l'approximation de la dérivée
----------------------------------------
Fonction : f(x) = x^2
Point d'évaluation : x = 2.000000
Dérivée réelle : 4.000000

Taille d'étape | Diff. avant | Diff. arrière | Erreur avant | Erreur arrière
-----------------------------------------------------------------------
    0.100000 |     4.100000 |      3.900000 |      0.100000 |       0.100000
    0.010000 |     4.010000 |      3.990000 |      0.010000 |       0.010000
    0.001000 |     4.001000 |      3.999000 |      0.001000 |       0.001000
    0.000100 |     4.000100 |      3.999900 |      0.000100 |       0.000100

Observations clés :

1. À mesure que la taille d'étape h diminue, l'approximation devient plus précise.
2. Les différences avant et arrière convergent vers la dérivée réelle.
3. L'erreur diminue avec des tailles d'étape plus petites.

Résumé

Dans ce laboratoire, vous avez appris à définir une fonction mathématique et à configurer la taille d'étape pour les approximations aux différences finies en C. Vous avez également appris à calculer les approximations aux différences finies avant et arrière des dérivées. Les étapes clés abordées incluent la définition de la fonction f(x) et de la taille d'étape h, ainsi que la mise en œuvre des méthodes de différence avant et arrière pour approximer la dérivée à un point d'évaluation x donné. Cela fournit une base pour comprendre et mettre en œuvre les techniques de différences finies en analyse numérique et en calcul scientifique.