Namespaces
Variants

std:: sin, std:: sinf, std:: sinl

From cppreference.net
C++
Numerics library
Common mathematical functions
Nearest integer floating point operations
(C++11)
(C++11)
(C++11) (C++11) (C++11)
Floating point manipulation functions
(C++11) (C++11)
(C++11)
(C++11)
Classification and comparison
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Types
(C++11)
(C++11)
(C++11)
Macro constants
Défini dans l'en-tête <cmath>
(1)
float sin ( float num ) ;

double sin ( double num ) ;

long double sin ( long double num ) ;
(jusqu'à C++23)
/*floating-point-type*/
sin ( /*floating-point-type*/ num ) ;
(depuis C++23)
(constexpr depuis C++26)
float sinf ( float num ) ;
(2) (depuis C++11)
(constexpr depuis C++26)
long double sinl ( long double num ) ;
(3) (depuis C++11)
(constexpr depuis C++26)
Surcharge SIMD (depuis C++26)
Défini dans l'en-tête <simd>
template < /*math-floating-point*/ V >

constexpr /*deduced-simd-t*/ < V >

sin ( const V & v_num ) ;
(S) (depuis C++26)
Défini dans l'en-tête <cmath>
template < class Integer >
double sin ( Integer num ) ;
(A) (constexpr depuis C++26)
1-3) Calcule le sinus de num (mesuré en radians). La bibliothèque fournit des surcharges de std::sin pour tous les types à virgule flottante non qualifiés cv comme type du paramètre. (depuis C++23)
S) La surcharge SIMD effectue un calcul std::sin élément par élément sur v_num .
(Voir math-floating-point et deduced-simd-t pour leurs définitions.)
(depuis C++26)
A) Des surcharges supplémentaires sont fournies pour tous les types entiers, qui sont traités comme double .
(depuis C++11)

Table des matières

Paramètres

num - valeur à virgule flottante ou entière représentant l'angle en radians

Valeur de retour

Si aucune erreur ne se produit, le sinus de num ( sin(num) ) dans l'intervalle [ - 1 , + 1 ] est retourné.

Le résultat peut avoir peu ou pas de signification si l'amplitude de num est grande.

(until C++11)

Si une erreur de domaine se produit, une valeur définie par l'implémentation est retournée (NaN là où supporté).

Si une erreur de plage se produit en raison d'un dépassement inférieur, le résultat correct (après arrondi) est retourné.

Gestion des erreurs

Les erreurs sont signalées comme spécifié dans math_errhandling .

Si l'implémentation prend en charge l'arithmétique à virgule flottante IEEE (IEC 60559),

  • si l'argument est ±0, il est retourné inchangé.
  • si l'argument est ±∞, NaN est retourné et FE_INVALID est déclenché.
  • si l'argument est NaN, NaN est retourné.

Notes

Le cas où l'argument est infini n'est pas spécifié comme une erreur de domaine en C (à laquelle C++ se réfère), mais il est défini comme une erreur de domaine dans POSIX .

POSIX spécifie également qu'en cas de dépassement inférieur, num est retourné inchangé, et si cela n'est pas pris en charge, une valeur définie par l'implémentation non supérieure à DBL_MIN , FLT_MIN , et LDBL_MIN est retournée.

Les surcharges supplémentaires ne sont pas requises d'être fournies exactement comme (A) . Elles doivent seulement être suffisantes pour garantir que pour leur argument num de type entier, std :: sin ( num ) ait le même effet que std :: sin ( static_cast < double > ( num ) ) .

Exemple

Exécuter ce code 
#include <cerrno>
#include <cfenv>
#include <cmath>
#include <iomanip>
#include <iostream>
// #pragma STDC FENV_ACCESS ON
const double pi = std::acos(-1); // or std::numbers::pi since C++20
constexpr double your_sin(double x)
{
    double sin{0}, pow{x};
    for (auto fac{1LLU}, n{1ULL}; n != 20; fac *= ++n, pow *= x)
        if (n & 1)
            sin += (n & 2 ? -pow : pow) / fac;
    return sin;
}
int main()
{
    std::cout << std::setprecision(10) << std::showpos
              << "Utilisation typique :\n"
              << "std::sin(pi/6) = " << std::sin(pi / 6) << '\n'
              << "your sin(pi/6) = " << your_sin(pi / 6) << '\n'
              << "std::sin(pi/2) = " << std::sin(pi / 2) << '\n'
              << "your sin(pi/2) = " << your_sin(pi / 2) << '\n'
              << "std::sin(-3*pi/4) = " << std::sin(-3 * pi / 4) << '\n'
              << "your sin(-3*pi/4) = " << your_sin(-3 * pi / 4) << '\n'
              << "Valeurs spéciales :\n"
              << "std::sin(+0) = " << std::sin(0.0) << '\n'
              << "std::sin(-0) = " << std::sin(-0.0) << '\n';
    // gestion des erreurs
    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout << "std::sin(INFINITY) = " << std::sin(INFINITY) << '\n';
    if (std::fetestexcept(FE_INVALID))
        std::cout << "    FE_INVALID levée\n";
}

Sortie possible : 

Utilisation typique :
std::sin(pi/6) = +0.5
your sin(pi/6) = +0.5
std::sin(pi/2) = +1
your sin(pi/2) = +1
std::sin(-3*pi/4) = -0.7071067812
your sin(-3*pi/4) = -0.7071067812
Valeurs spéciales :
std::sin(+0) = +0
std::sin(-0) = -0
std::sin(INFINITY) = -nan
    FE_INVALID levée

Voir aussi

(C++11) (C++11)
calcule le cosinus ( cos(x) )
(fonction)
(C++11) (C++11)
calcule la tangente ( tan(x) )
(fonction)
(C++11) (C++11)
calcule l'arc sinus ( arcsin(x) )
(fonction)
calcule le sinus d'un nombre complexe ( sin(z) )
(fonction template)
applique la fonction std::sin à chaque élément du valarray
(fonction template)
Documentation C pour sin