Introduction
Dans ce laboratoire, vous apprendrez à approximer les racines d'une fonction à l'aide de la méthode de Newton en C. Le laboratoire couvre les étapes suivantes :
Tout d'abord, vous définirez la fonction f(x) et sa dérivée f'(x). Ensuite, vous implémenterez la formule itérative de la méthode de Newton pour calculer la racine approximative. Enfin, vous afficherez la racine approximative résultante.
Ce laboratoire fournit un exemple pratique de l'application de méthodes numériques pour résoudre des problèmes mathématiques à l'aide du langage C. À la fin du laboratoire, vous aurez une meilleure compréhension de l'utilisation de la méthode de Newton pour trouver les racines d'une fonction.
Définition de f(x) et f'(x)
Dans cette étape, nous définirons la fonction mathématique f(x) et sa dérivée f'(x) pour implémenter la méthode de Newton afin d'approcher les racines.
Tout d'abord, créons un nouveau fichier C dans le répertoire ~/project :
cd ~/project
nano newton_method.c
Maintenant, écrivons le code initial pour définir notre fonction et sa dérivée :
#include <stdio.h>
#include <math.h>
// Définition de la fonction f(x)
double f(double x) {
return x * x - 4; // Fonction d'exemple : f(x) = x^2 - 4
}
// Définition de la dérivée f'(x)
double f_derivative(double x) {
return 2 * x; // Dérivée de f(x) = 2x
}
int main() {
printf("Fonction f(x) = x^2 - 4\n");
printf("Dérivée f'(x) = 2x\n");
return 0;
}
Exemple de sortie :
Fonction f(x) = x^2 - 4
Dérivée f'(x) = 2x
Décomposons le code :
f(x)est définie commex^2 - 4, qui possède des racines en x = 2 et x = -2f_derivative(x)est la dérivée de f(x), qui est2x- Nous utiliserons ces fonctions dans les étapes suivantes pour implémenter la méthode de Newton.
Compilons le code pour vérification :
gcc -o newton_method newton_method.c -lm
./newton_method
Itérer x_{n+1}=x_n - f(x_n)/f'(x_n)
Dans cette étape, nous implémenterons la formule itérative de la méthode de Newton pour approximer la racine de notre fonction.
Ouvrez le fichier précédent newton_method.c :
cd ~/project
nano newton_method.c
Mettez à jour le code pour inclure l'itération de la méthode de Newton :
#include <stdio.h>
#include <math.h>
// Les définitions de fonctions précédentes restent les mêmes
double f(double x) {
return x * x - 4;
}
double f_derivative(double x) {
return 2 * x;
}
// Implémentation de la méthode de Newton
double newton_method(double initial_guess, int max_iterations, double tolerance) {
double x = initial_guess;
for (int i = 0; i < max_iterations; i++) {
double fx = f(x);
double fpx = f_derivative(x);
// Vérification de la division par zéro
if (fabs(fpx) < tolerance) {
printf("Dérivée trop proche de zéro. Impossible de continuer.\n");
return x;
}
// Formule d'itération de la méthode de Newton
double x_next = x - fx / fpx;
printf("Itération %d : x = %f\n", i + 1, x_next);
// Vérification de la convergence
if (fabs(x_next - x) < tolerance) {
return x_next;
}
x = x_next;
}
printf("Nombre maximal d'itérations atteint.\n");
return x;
}
int main() {
double initial_guess = 1.0;
int max_iterations = 10;
double tolerance = 1e-6;
double root = newton_method(initial_guess, max_iterations, tolerance);
printf("\nRacine approximative : %f\n", root);
printf("f(racine) = %f\n", f(root));
return 0;
}
Compilez et exécutez le code :
gcc -o newton_method newton_method.c -lm
./newton_method
Exemple de sortie :
Itération 1 : x = 2.500000
Itération 2 : x = 2.050000
Itération 3 : x = 2.000610
Itération 4 : x = 2.000000
Itération 5 : x = 2.000000
Racine approximative : 2.000000
f(racine) = 0.000000
Points clés de l'implémentation :
newton_method()prend une estimation initiale, un nombre maximal d'itérations et une tolérance.- Implémente la formule d'itération de la méthode de Newton : x_{n+1} = x_n - f(x_n) / f'(x_n).
- Vérifie la convergence et la possibilité de division par zéro.
- Affiche les itérations intermédiaires pour montrer le processus d'approximation.
Affichage de la Racine Approchée
Dans cette étape, nous allons améliorer notre implémentation de la méthode de Newton pour fournir des informations plus détaillées sur l'approximation de la racine.
Ouvrez le fichier précédent newton_method.c :
cd ~/project
nano newton_method.c
Mettez à jour le code pour améliorer l'affichage de l'approximation de la racine :
#include <stdio.h>
#include <math.h>
// Les définitions de fonctions et de méthodes précédentes restent les mêmes
double f(double x) {
return x * x - 4;
}
double f_derivative(double x) {
return 2 * x;
}
double newton_method(double initial_guess, int max_iterations, double tolerance) {
double x = initial_guess;
printf("Approximation de la Racine par la Méthode de Newton\n");
printf("-----------------------------------------------------\n");
printf("Estimation Initiale : %f\n", x);
printf("Tolérance : %e\n", tolerance);
printf("Nombre Maximal d'Itérations : %d\n\n", max_iterations);
for (int i = 0; i < max_iterations; i++) {
double fx = f(x);
double fpx = f_derivative(x);
if (fabs(fpx) < tolerance) {
printf("Erreur : Dérivée trop proche de zéro.\n");
return x;
}
double x_next = x - fx / fpx;
printf("Itération %d :\n", i + 1);
printf(" Valeur courante de x : %f\n", x_next);
printf(" f(x) : %f\n", f(x_next));
printf(" |x_next - x| : %e\n\n", fabs(x_next - x));
if (fabs(x_next - x) < tolerance) {
printf("Convergence atteinte !\n");
return x_next;
}
x = x_next;
}
printf("Nombre maximal d'itérations atteint.\n");
return x;
}
int main() {
double initial_guess = 1.0;
int max_iterations = 10;
double tolerance = 1e-6;
double root = newton_method(initial_guess, max_iterations, tolerance);
printf("Résultats Finaux :\n");
printf("-----------------\n");
printf("Racine Approchée : %f\n", root);
printf("f(racine) : %f\n", f(root));
printf("Erreur Absolue : %e\n", fabs(f(root)));
return 0;
}
Compilez et exécutez le code :
gcc -o newton_method newton_method.c -lm
./newton_method
Exemple de sortie :
Approximation de la Racine par la Méthode de Newton
-----------------------------------------------------
Estimation Initiale : 1.000000
Tolérance : 1.000000e-06
Nombre Maximal d'Itérations : 10
Itération 1 :
Valeur courante de x : 2.500000
f(x) : 2.250000
|x_next - x| : 1.500000e+00
... (plus d'itérations)
Convergence atteinte !
Résultats Finaux :
-----------------
Racine Approchée : 2.000000
f(racine) : 0.000000
Erreur Absolue : 0.000000e+00
Améliorations clés :
- Ajout d'informations détaillées sur les itérations.
- Affichage des paramètres initiaux.
- Affichage de la progression de la convergence.
- Affichage des résultats finaux avec l'erreur absolue.
Résumé
Dans ce laboratoire, nous avons d'abord défini la fonction mathématique f(x) et sa dérivée f'(x) pour implémenter la méthode de Newton afin d'approcher les racines. Nous avons ensuite implémenté la formule itérative x_{n+1} = x_n - f(x_n)/f'(x_n) pour effectuer l'approximation de la racine. Enfin, nous afficherons la racine approximative obtenue par ce processus.
Les étapes clés abordées dans ce laboratoire sont la définition de la fonction cible et de sa dérivée, puis l'application itérative de la formule de la méthode de Newton pour converger vers la racine. Cette approche nous permet de trouver efficacement les racines de diverses fonctions mathématiques en utilisant le langage C.
