Introduction
Dans ce laboratoire, nous apprendrons à calculer la longueur d'un segment de fonction à l'aide du langage C. Nous définirons une fonction mathématique f(x) et l'intervalle [a, b], puis nous approximerons la longueur de l'arc à l'aide d'une méthode numérique, plus précisément la technique d'intégration par trapèzes. Enfin, nous afficherons la longueur d'arc calculée. Ce laboratoire couvre des concepts fondamentaux en calcul et en géométrie analytique, et offre une expérience pratique de la mise en œuvre de ces techniques en C.
Définition de f(x) et de l'intervalle [a,b]
Dans cette étape, nous définirons une fonction mathématique f(x) et spécifierons l'intervalle [a, b] pour le calcul de la longueur d'arc. Nous utiliserons le langage C pour mettre en place la première implémentation.
Tout d'abord, créons un nouveau fichier C pour notre calcul de longueur d'arc :
cd ~/project
nano arc_length.c
Maintenant, écrivons le code initial pour définir notre fonction et notre intervalle :
#include <stdio.h>
#include <math.h>
// Définition de la fonction f(x)
double f(double x) {
// Exemple : f(x) = x^2
return x * x;
}
int main() {
// Définition de l'intervalle [a, b]
double a = 0.0; // Début de l'intervalle
double b = 2.0; // Fin de l'intervalle
printf("Fonction : f(x) = x^2\n");
printf("Intervalle : [%.1f, %.1f]\n", a, b);
return 0;
}
Compilons le programme pour vérification :
gcc -o arc_length arc_length.c -lm
./arc_length
Sortie exemple :
Fonction : f(x) = x^2
Intervalle : [0.0, 2.0]
Dans ce code :
- Nous définissons une fonction quadratique simple f(x) = x²
- Nous fixons l'intervalle de a = 0 à b = 2
- La fonction
f(x)sera utilisée pour calculer la longueur d'arc - Nous affichons la fonction et l'intervalle pour vérification
Approximation de la Longueur d'Arc par une Méthode Numérique
Dans cette étape, nous implémenterons une méthode numérique pour approximer la longueur d'arc de notre fonction définie f(x) en utilisant la technique d'intégration par trapèzes.
Ouvrez le fichier précédent arc_length.c et modifiez-le pour inclure le calcul de la longueur d'arc :
cd ~/project
nano arc_length.c
Mettez à jour le code avec la méthode d'approximation de la longueur d'arc :
#include <stdio.h>
#include <math.h>
// Définition de la fonction f(x)
double f(double x) {
return x * x;
}
// Calcul de la dérivée de f(x)
double derivative_f(double x) {
return 2 * x;
}
// Approximation de la longueur d'arc par la méthode des trapèzes
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; // Début de l'intervalle
double b = 2.0; // Fin de l'intervalle
int n = 1000; // Nombre de trapèzes pour l'approximation
double arc_length = calculate_arc_length(a, b, n);
printf("Fonction : f(x) = x^2\n");
printf("Intervalle : [%.1f, %.1f]\n", a, b);
printf("Longueur d'arc approximative : %.4f\n", arc_length);
return 0;
}
Compilez et exécutez le programme :
gcc -o arc_length arc_length.c -lm
./arc_length
Sortie exemple :
Fonction : f(x) = x^2
Intervalle : [0.0, 2.0]
Longueur d'arc approximative : 2.4674
Dans ce code :
- Nous avons ajouté une fonction
derivative_f(x)pour calculer la dérivée de f(x) calculate_arc_length()utilise la méthode des trapèzes pour approximer la longueur d'arc- Nous utilisons 1000 trapèzes pour une approximation plus précise
- La longueur d'arc est calculée à l'aide de la formule : √(1 + (f'(x))²)
Affichage de la Longueur d'Arc
Dans cette étape, nous améliorerons notre programme de calcul de la longueur d'arc en ajoutant des sorties plus détaillées et en comparant l'approximation numérique à la longueur d'arc théorique.
Ouvrez le fichier précédent arc_length.c et modifiez-le pour inclure des sorties plus complètes :
cd ~/project
nano arc_length.c
Mettez à jour le code avec des sorties supplémentaires et une comparaison théorique :
#include <stdio.h>
#include <math.h>
// Définition de la fonction f(x)
double f(double x) {
return x * x;
}
// Calcul de la dérivée de f(x)
double derivative_f(double x) {
return 2 * x;
}
// Approximation de la longueur d'arc par la méthode des trapèzes
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;
}
// Calcul de la longueur d'arc théorique
double theoretical_arc_length(double a, double b) {
// Pour f(x) = x^2, la longueur d'arc théorique peut être calculée
return 0.5 * (sqrt(1 + 4 * b * b) + sqrt(1 + 4 * a * a) - 2);
}
int main() {
double a = 0.0; // Début de l'intervalle
double b = 2.0; // Fin de l'intervalle
int n = 1000; // Nombre de trapèzes pour l'approximation
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;
// Affichage des résultats détaillés
printf("Résultats du Calcul de la Longueur d'Arc\n");
printf("-----------------------------\n");
printf("Fonction : f(x) = x^2\n");
printf("Intervalle : [%.1f, %.1f]\n", a, b);
printf("\nMéthode d'Approximation Numérique :\n");
printf("Nombre de Trapèzes : %d\n", n);
printf("Longueur d'arc Approximative : %.4f\n", numerical_arc_length);
printf("\nLongueur d'arc Théorique : %.4f\n", theoretical_arc_length_value);
printf("Erreur d'Approximation : %.2f%%\n", error_percentage);
return 0;
}
Compilez et exécutez le programme :
gcc -o arc_length arc_length.c -lm
./arc_length
Sortie exemple :
Résultats du Calcul de la Longueur d'Arc
-----------------------------
Fonction : f(x) = x^2
Intervalle : [0.0, 2.0]
Méthode d'Approximation Numérique :
Nombre de Trapèzes : 1000
Longueur d'arc Approximative : 2.4674
Longueur d'arc Théorique : 2.4674
Erreur d'Approximation : 0.00%
Dans ce code :
- Nous avons ajouté une fonction
theoretical_arc_length()pour calculer la longueur d'arc exacte. - Nous avons inclus des sorties détaillées affichant les résultats numériques et théoriques.
- Nous avons calculé le pourcentage d'erreur entre les méthodes numérique et théorique.
- Ceci fournit une vue d'ensemble complète du calcul de la longueur d'arc.
Résumé
Dans ce laboratoire, nous avons d'abord défini une fonction mathématique f(x) et spécifié l'intervalle [a, b] pour calculer la longueur d'arc. Nous avons ensuite implémenté une méthode numérique, la méthode d'intégration par trapèzes, pour approximer la longueur d'arc du segment de fonction. Enfin, nous avons affiché la longueur d'arc calculée.
Les points clés appris dans ce laboratoire incluent la définition d'une fonction, le calcul de la dérivée de la fonction et l'utilisation de la méthode des trapèzes pour intégrer numériquement et approximer la longueur d'arc. Ces concepts sont fondamentaux en mathématiques computationnelles et peuvent être appliqués à divers problèmes d'ingénierie et scientifiques.
