Introduction
Dans ce laboratoire, vous apprendrez à trouver l'équation d'une droite à partir de deux points en langage C. Le laboratoire couvre trois étapes principales : le calcul de la pente à partir de deux points, le calcul de l'ordonnée à l'origine en utilisant la pente et un point connu, et enfin l'impression de l'équation complète de la droite sous la forme y = mx + b. À la fin de ce laboratoire, vous aurez une compréhension solide de la manière de travailler avec les droites en géométrie analytique en utilisant C.
Le laboratoire commence par démontrer comment calculer la pente entre deux points à l'aide de la formule (y2 - y1) / (x2 - x1). Il montre ensuite comment déterminer l'ordonnée à l'origine en réarrangeant l'équation y = mx + b pour résoudre la constante b. Enfin, l'équation complète de la droite est imprimée, vous permettant de la représenter sous sa forme standard.
Calculer la pente à partir de deux points
Dans cette étape, vous apprendrez à calculer la pente entre deux points dans un programme C. La pente représente la pente d'une droite et est calculée à l'aide de la formule : pente = (y2 - y1) / (x2 - x1).
Tout d'abord, créez un nouveau fichier C pour implémenter le calcul de la pente :
cd ~/project
nano slope_calculation.c
Maintenant, écrivez le code C suivant pour calculer la pente :
#include <stdio.h>
float calculate_slope(float x1, float y1, float x2, float y2) {
// Vérifier si les points sont sur la même droite verticale
if (x2 - x1 == 0) {
printf("Pente indéfinie (droite verticale)\n");
return 0;
}
// Calculer la pente à l'aide de la formule : (y2 - y1) / (x2 - x1)
float slope = (y2 - y1) / (x2 - x1);
return slope;
}
int main() {
float x1 = 2.0, y1 = 3.0; // Premier point
float x2 = 5.0, y2 = 7.0; // Second point
float slope = calculate_slope(x1, y1, x2, y2);
printf("Point 1 : (%.1f, %.1f)\n", x1, y1);
printf("Point 2 : (%.1f, %.1f)\n", x2, y2);
printf("Pente : %.2f\n", slope);
return 0;
}
Compilez et exécutez le programme :
gcc slope_calculation.c -o slope_calculation
./slope_calculation
Sortie d'exemple :
Point 1 : (2.0, 3.0)
Point 2 : (5.0, 7.0)
Pente : 1.33
Décomposons le code :
- La fonction
calculate_slope()prend quatre paramètres : x1, y1, x2, y2 - Elle vérifie d'abord si les points définissent une droite verticale (x2 - x1 = 0)
- Sinon, elle calcule la pente à l'aide de la formule standard
- La fonction
main()démontre comment utiliser le calcul de la pente
La pente représente le changement de la coordonnée y divisé par le changement de la coordonnée x entre deux points. Dans cet exemple, la pente est d'environ 1,33, ce qui signifie que pour chaque unité de changement en x, y change de 1,33 unités.
Calculer l'ordonnée à l'origine à l'aide de y - mx
Dans cette étape, vous apprendrez à calculer l'ordonnée à l'origine d'une droite à l'aide de la pente et d'un point connu. L'ordonnée à l'origine est le point où la droite coupe l'axe des ordonnées, et elle peut être calculée à l'aide de l'équation : b = y - mx.
Continuez à travailler dans le même répertoire de projet et modifiez le fichier C précédent :
cd ~/project
nano line_equation.c
Écrivez le code C suivant pour calculer l'ordonnée à l'origine :
#include <stdio.h>
float calculate_slope(float x1, float y1, float x2, float y2) {
if (x2 - x1 == 0) {
printf("Pente indéfinie (droite verticale)\n");
return 0;
}
return (y2 - y1) / (x2 - x1);
}
float calculate_intercept(float x, float y, float slope) {
// Calculer l'ordonnée à l'origine à l'aide de la formule : b = y - mx
float intercept = y - (slope * x);
return intercept;
}
int main() {
float x1 = 2.0, y1 = 3.0; // Premier point
float x2 = 5.0, y2 = 7.0; // Second point
float slope = calculate_slope(x1, y1, x2, y2);
float intercept = calculate_intercept(x1, y1, slope);
printf("Point 1 : (%.1f, %.1f)\n", x1, y1);
printf("Point 2 : (%.1f, %.1f)\n", x2, y2);
printf("Pente : %.2f\n", slope);
printf("Ordonnée à l'origine : %.2f\n", intercept);
return 0;
}
Compilez et exécutez le programme :
gcc line_equation.c -o line_equation
./line_equation
Sortie d'exemple :
Point 1 : (2.0, 3.0)
Point 2 : (5.0, 7.0)
Pente : 1.33
Ordonnée à l'origine : 0.33
Décomposons le nouveau code :
- La fonction
calculate_intercept()prend trois paramètres : x, y et la pente - Elle utilise la formule b = y - mx pour calculer l'ordonnée à l'origine
- Dans la fonction
main(), nous utilisons la pente calculée précédemment et un point pour trouver l'ordonnée à l'origine - L'ordonnée à l'origine représente le point où la droite coupe l'axe des ordonnées lorsque x = 0
Le calcul montre que pour les points donnés, la droite a une pente de 1,33 et une ordonnée à l'origine de 0,33.
Afficher l'équation de la droite y = mx + b
Dans cette étape, vous apprendrez à afficher l'équation complète d'une droite en utilisant la pente et l'ordonnée à l'origine calculées dans les étapes précédentes. Nous allons modifier le programme C existant pour afficher l'équation de la droite sous la forme standard y = mx + b.
Continuez à travailler dans le même répertoire de projet :
cd ~/project
nano line_equation_final.c
Écrivez le code C suivant pour afficher l'équation de la droite :
#include <stdio.h>
float calculate_slope(float x1, float y1, float x2, float y2) {
if (x2 - x1 == 0) {
printf("Pente indéfinie (droite verticale)\n");
return 0;
}
return (y2 - y1) / (x2 - x1);
}
float calculate_intercept(float x, float y, float slope) {
return y - (slope * x);
}
void print_line_equation(float slope, float intercept) {
printf("Équation de la droite : y = ");
// Afficher le coefficient de la pente
if (slope == 1) {
printf("x");
} else if (slope == -1) {
printf("-x");
} else if (slope != 0) {
printf("%.2fx", slope);
}
// Afficher l'ordonnée à l'origine
if (intercept > 0) {
printf(" + %.2f", intercept);
} else if (intercept < 0) {
printf(" - %.2f", -intercept);
}
printf("\n");
}
int main() {
float x1 = 2.0, y1 = 3.0; // Premier point
float x2 = 5.0, y2 = 7.0; // Second point
float slope = calculate_slope(x1, y1, x2, y2);
float intercept = calculate_intercept(x1, y1, slope);
printf("Point 1 : (%.1f, %.1f)\n", x1, y1);
printf("Point 2 : (%.1f, %.1f)\n", x2, y2);
printf("Pente : %.2f\n", slope);
printf("Ordonnée à l'origine : %.2f\n", intercept);
print_line_equation(slope, intercept);
return 0;
}
Compilez et exécutez le programme :
gcc line_equation_final.c -o line_equation_final
./line_equation_final
Sortie d'exemple :
Point 1 : (2.0, 3.0)
Point 2 : (5.0, 7.0)
Pente : 1.33
Ordonnée à l'origine : 0.33
Équation de la droite : y = 1.33x + 0.33
Décomposons le nouveau code :
- La fonction
print_line_equation()gère différents cas de pente et d'ordonnée à l'origine - Elle gère les cas spéciaux comme une pente de 1, -1 ou 0
- Elle formate l'équation avec les signes corrects pour l'ordonnée à l'origine
- La fonction fournit une représentation claire et lisible de l'équation de la droite
Le code démontre comment convertir des informations de points et de pente en une équation linéaire standard.
Résumé
Dans ce laboratoire, vous avez d'abord appris à calculer la pente entre deux points à l'aide de la formule (y2 - y1) / (x2 - x1). Cela représente la pente de la droite. Ensuite, vous avez appris à calculer l'ordonnée à l'origine de la droite en utilisant la pente et un point connu, en réarrangeant l'équation y = mx + b pour résoudre b. Enfin, vous avez combiné la pente et l'ordonnée à l'origine pour afficher l'équation complète de la droite sous la forme y = mx + b.
