Bibliothèque standard C -<math.h>
Introduction
math.hLe fichier d'en-tête définit diverses fonctions mathématiques et une macro. Toutes les fonctionnalités disponibles dans cette bibliothèque sont accompagnées de paramètres de typedouble, et toutes renvoient un résultat de typedouble.
<math.h>Il s'agit d'un fichier d'en-tête de la bibliothèque standard C, contenant un grand nombre de fonctions et de macros utilisées pour les opérations mathématiques. Ces fonctions et macros fournissent des opérations arithmétiques de base, des fonctions trigonométriques, exponentielles, logarithmiques, de puissance, d'arrondi, etc.
Macros de bibliothèque
Dans<math.h>Parmi elles, certaines macros servent à représenter l'état d'erreur des fonctions mathématiques :
| Macro | Description |
|---|---|
HUGE_VAL | Valeur renvoyée lorsque le résultat de la fonction déborde (infini positif). Cette macro représente un très grand nombre à virgule flottante en double précision, généralement utilisé comme valeur de retour de certaines fonctions mathématiques lorsque le résultat dépasse la plage représentable. Lorsque le résultat d'une fonction est trop grand pour être représenté comme un nombre à virgule flottante normal (c'est-à-dire qu'un débordement se produit), errno est défini sur ERANGE (erreur de plage), et HUGE_VAL ou sa valeur négative (pour l'infini négatif) est renvoyé. |
HUGE_VALF | Valeur renvoyée lorsque le résultat de la fonction déborde (infini positif, type à virgule flottante) |
HUGE_VALL | Valeur renvoyée lorsque le résultat de la fonction déborde (infini positif, précision long double) |
INFINITY | Infini positif |
NAN | Une valeur non numérique (Not-A-Number) |
FP_INFINITE | Représente l'infini |
FP_NAN | Représente une valeur non numérique |
FP_NORMAL | Représente un nombre à virgule flottante normal |
FP_SUBNORMAL | Représente un nombre sous-normal |
FP_ZERO | Représente zéro |
Fonctions de bibliothèque
La liste suivante répertorie les fonctions définies dans le fichier d'en-tête math.h :
| Numéro de série | Fonction & Description |
|---|---|
| 1 | double acos(double x) Renvoie l'arc cosinus de x en radians. |
| 2 | double asin(double x) Renvoie l'arc sinus de x en radians. |
| 3 | double atan(double x) Renvoie l'arc tangente de x en radians. |
| 4 | double atan2(double y, double x) Renvoie l'arc tangente de y/x en radians. Les signes des valeurs de y et x déterminent le quadrant correct. |
| 5 | double cos(double x) Renvoie le cosinus d'un angle x en radians. |
| 6 | double cosh(double x) Renvoie le cosinus hyperbolique de x. |
| 7 | double sin(double x) Renvoie le sinus d'un angle x en radians. |
| 8 | double sinh(double x) Renvoie le sinus hyperbolique de x. |
| 9 | double tanh(double x) Renvoie la tangente hyperbolique de x. |
| 10 | double exp(double x) Renvoie e élevé à la puissance x. |
| 11 | double frexp(double x, int *exponent) Décompose le nombre à virgule flottante x en une mantisse et un exposant. La valeur de retour est la mantisse, et l'exposant est stocké dans exponent. La valeur résultante est x = mantisse * 2 ^ exponent. |
| 12 | double ldexp(double x, int exponent) Renvoie x multiplié par 2 élevé à la puissance exponent. |
| 13 | double log(double x) Renvoie le logarithme népérien de x (logarithme de base e). |
| 14 | double log10(double x) Renvoie le logarithme décimal de x (logarithme de base 10). |
| 15 | double modf(double x, double *integer) La valeur de retour est la partie fractionnaire (la partie après le point décimal), et définit integer comme la partie entière. |
| 16 | double pow(double x, double y) Renvoie x élevé à la puissance y. |
| 17 | double sqrt(double x) Renvoie la racine carrée de x. |
| 18 | double ceil(double x) Renvoie la plus petite valeur entière supérieure ou égale à x. |
| 19 | double fabs(double x) Renvoie la valeur absolue de x. |
| 20 | double floor(double x) Renvoie la plus grande valeur entière inférieure ou égale à x. |
| 21 | double fmod(double x, double y) Renvoie le reste de x divisé par y. |
Constantes mathématiques courantes
Les suivantes sont<math.h>Quelques constantes mathématiques couramment utilisées définies dans :
| Constantes | Valeur | Description |
|---|---|---|
M_PI | 3.14159265358979323846 | Pi π |
M_E | 2.71828182845904523536 | La base des logarithmes népériens, e |
M_LOG2E | 1.44269504088896340736 | log2(e) |
M_LOG10E | 0.43429448190325182765 | log10(e) |
M_LN2 | 0.69314718055994530942 | ln(2) |
M_LN10 | 2.30258509299404568402 | ln(10) |
M_PI_2 | 1.57079632679489661923 | π/2 |
M_PI_4 | 0.78539816339744830962 | π/4 |
M_1_PI | 0.31830988618379067154 | 1/π |
M_2_PI | 0.63661977236758134308 | 2/π |
M_2_SQRTPI | 1.12837916709551257390 | 2/√π |
M_SQRT2 | 1.41421356237309504880 | √2 |
M_SQRT1_2 | 0.70710678118654752440 | 1/√2 |
Ce qui suit utilise<math.h>Exemple de code pour les fonctions et constantes dans :
Exemple
#include <math.h>
int main() {
double x = 2.0;
double y = 3.0;
// Opérations de base
printf("sqrt(%.1f) = %.2f\n", x, sqrt(x));
printf("pow(%.1f, %.1f) = %.2f\n", x, y, pow(x, y));
printf("exp(%.1f) = %.2f\n", x, exp(x));
printf("log(%.1f) = %.2f\n", x, log(x));
printf("log10(%.1f) = %.2f\n", x, log10(x));
// Fonctions trigonométriques
double angle = M_PI / 4; // 45 degrés
printf("sin(%.2f) = %.2f\n", angle, sin(angle));
printf("cos(%.2f) = %.2f\n", angle, cos(angle));
printf("tan(%.2f) = %.2f\n", angle, tan(angle));
// Fonctions d'arrondi
double z = 5.8;
printf("ceil(%.1f) = %.1f\n", z, ceil(z));
printf("floor(%.1f) = %.1f\n", z, floor(z));
printf("fabs(%.1f) = %.1f\n", z, fabs(z));
return 0;
}
L'exécution du programme ci-dessus produira une sortie semblable à ce qui suit :
sqrt(2.0) = 1.41 pow(2.0, 3.0) = 8.00 exp(2.0) = 7.39 log(2.0) = 0.69 log10(2.0) = 0.30 sin(0.79) = 0.71 cos(0.79) = 0.71 tan(0.79) = 1.00 ceil(5.8) = 6.0 floor(5.8) = 5.0 fabs(5.8) = 5.8
<math.h>Elle fournit une série de fonctions et de constantes mathématiques pour aider les programmeurs à effectuer divers calculs mathématiques en C. En utilisant ces fonctions et constantes, des opérations mathématiques complexes peuvent être facilement mises en œuvre, ce qui améliore l'efficacité et la lisibilité du programme.