Fonctions trigonométriques en C++

C++ fournit des fonctions sinus, cosinus, tangente, trigonométriques inverses et hyperboliques dans l’en-tête standard <cmath>. Les fonctions trigonométriques usuelles prennent des angles en radians et renvoient des valeurs à virgule flottante. Utilisez les noms qualifiés par std:: pour indiquer clairement que le code fait appel à la bibliothèque standard.

Calculer sinus, cosinus et tangente avec std::sin, std::cos et std::tan en radians

Appelez std::sin(angle), std::cos(angle) et std::tan(angle) pour calculer le sinus, le cosinus et la tangente d’un angle. Incluez <cmath> pour leurs déclarations. Ces fonctions ont des surcharges pour les types à virgule flottante ; le résultat utilise le type à virgule flottante correspondant (les arguments entiers sont convertis pour utiliser une surcharge à virgule flottante).

Exécutez cet exemple :

Le code et les libellés ou sorties affichés dans cette section restent en anglais.

#include <cmath>
#include <iomanip>
#include <iostream>

int main() {
  const double angle = 1.0; // radians
  std::cout << std::fixed << std::setprecision(6)
            << "sin(" << angle << ") = " << std::sin(angle) << '\n'
            << "cos(" << angle << ") = " << std::cos(angle) << '\n'
            << "tan(" << angle << ") = " << std::tan(angle) << '\n';
}

La sortie observée lors de cette exécution est :

sin(1.000000) = 0.841471
cos(1.000000) = 0.540302
tan(1.000000) = 1.557408

L’argument vaut un radian. std::fixed et std::setprecision(6) affichent chaque valeur renvoyée avec six chiffres après la virgule.

Récupérer des angles avec les fonctions trigonométriques inverses

Utilisez std::asin(x) pour retrouver un angle à partir d’une valeur de sinus, std::acos(x) à partir d’une valeur de cosinus et std::atan(x) à partir d’une valeur de tangente. Leurs résultats sont en radians. asin accepte les valeurs comprises entre -1 et 1 et renvoie un angle dans [-π/2, π/2] ; acos accepte le même intervalle en entrée et renvoie un angle dans [0, π]. atan accepte toute valeur réelle finie et renvoie un angle dans (-π/2, π/2).

Pour obtenir une direction à partir de ses deux coordonnées, utilisez std::atan2(y, x). Contrairement à atan(y / x), cette fonction tient compte des signes des deux arguments pour déterminer le quadrant ; il n’est donc pas nécessaire de diviser les coordonnées au préalable. Elle renvoie un angle en radians, généralement compris dans [-π, π] (la représentation exacte de l’extrémité peut dépendre du zéro signé fourni en entrée).

Les fonctions inverses renvoient un angle principal, pas tous les angles qui auraient pu produire la valeur d’origine. Par exemple, plusieurs angles peuvent avoir le même sinus : asin ne peut donc pas retrouver à lui seul l’angle d’origine s’il se trouve hors de son intervalle principal. Pour choisir l’angle final, tenez compte de la géométrie du problème et des informations sur le quadrant.

Utiliser les fonctions hyperboliques pour les valeurs hyperboliques

Les fonctions std::sinh, std::cosh et std::tanh calculent le sinus, le cosinus et la tangente hyperboliques. Elles sont définies à partir de fonctions exponentielles et ne remplacent pas std::sin, std::cos et std::tan : leurs arguments sont des valeurs réelles, et non des angles sur un cercle, et leurs intervalles de valeurs diffèrent. Par exemple, cosh(x) est toujours supérieur ou égal à 1, tandis que le cosinus usuel reste entre -1 et 1.

Les fonctions hyperboliques inverses sont std::asinh, std::acosh et std::atanh. Leurs domaines réels diffèrent : asinh accepte toute valeur réelle, acosh exige une valeur supérieure ou égale à 1, et atanh exige une valeur strictement comprise entre -1 et 1. Choisissez ces fonctions pour les relations hyperboliques ; on ne forme pas leurs noms en ajoutant un a à ceux des fonctions trigonométriques usuelles.

Gérer les unités d’angle, les domaines et les résultats à virgule flottante

Les fonctions trigonométriques de <cmath> en C++ attendent des radians. Convertissez les degrés avec radians = degrees * π / 180 ; par exemple, 90 degrés correspondent à π/2 radians. En C++ portable, obtenez π avec std::acos(-1.0) ou définissez la constante dont vous avez besoin, car M_PI ne fait pas partie des noms standard du C++.

Les arguments des fonctions inverses doivent appartenir à leurs domaines réels. Vérifiez ou bornez une valeur uniquement si cela correspond aux mathématiques de votre application : borner une valeur légèrement en dehors de [-1, 1] peut compenser une erreur d’arrondi accumulée, mais ne doit pas masquer une valeur réellement hors limites. Le traitement d’une erreur de domaine dépend du comportement de la bibliothèque mathématique C++ et de l’implémentation ; il ne s’agit pas d’un comportement indéfini. Si votre application doit distinguer un résultat valide d’une erreur mathématique, consultez math_errhandling et vérifiez les indicateurs d’erreur correspondants pris en charge par l’implémentation.

std::tan prend des valeurs très grandes près des multiples impairs de π/2 et n’a pas de valeur réelle finie aux pôles mathématiques correspondants. Une approximation en virgule flottante d’un pôle peut produire une grande valeur finie au lieu d’un signal d’erreur explicite. Si le comportement près de ces pôles est important, vérifiez l’entrée en fonction des besoins et de la tolérance de votre application.

Les calculs en virgule flottante sont des approximations. Des valeurs telles que std::sin(std::acos(-1.0)) peuvent être proches de zéro sans lui être exactement égales. Comparez les valeurs calculées avec une tolérance adaptée à votre application plutôt qu’avec une égalité exacte. Utilisez double pour les calculs courants et ne choisissez un type plus large que si sa précision et sa prise en charge sont nécessaires. Préférez la bibliothèque standard aux approximations écrites à la main et stockez une valeur calculée si vous la réutilisez.