Standard library header <complex>

From cppreference.net

Cet en-tête fait partie de la bibliothèque numeric .

Table des matières

Classes

un type de nombre complexe
(modèle de classe)

Fonctions

Opérations
operator+ operator-	applique les opérateurs unaires aux nombres complexes (modèle de fonction)
operator+ operator- operator* operator/	effectue des opérations arithmétiques sur des nombres complexes entre deux valeurs complexes ou entre un complexe et un scalaire (modèle de fonction)
operator== operator!= (supprimé en C++20)	compare deux nombres complexes ou un complexe et un scalaire (modèle de fonction)
operator<< operator>>	sérialise et désérialise un nombre complexe (modèle de fonction)
real	renvoie la partie réelle (fonction template)
imag	renvoie la partie imaginaire (fonction template)
abs (std::complex)	retourne la magnitude d'un nombre complexe (modèle de fonction)
arg	renvoie l'angle de phase (modèle de fonction)
norm	retourne la magnitude au carré (modèle de fonction)
conj	renvoie le conjugué complexe (modèle de fonction)
proj (C++11)	retourne la projection sur la sphère de Riemann (fonction template)
polar	construit un nombre complexe à partir de son module et de son angle de phase (modèle de fonction)
Fonctions exponentielles
exp (std::complex)	exponentielle complexe de base e (fonction template)
log (std::complex)	logarithme naturel complexe avec les coupures de branche le long de l'axe réel négatif (modèle de fonction)
log10 (std::complex)	logarithme décimal complexe avec les coupures de branche le long de l'axe réel négatif (modèle de fonction)
Fonctions de puissance
pow (std::complex)	puissance complexe, un ou les deux arguments peuvent être un nombre complexe (fonction template)
sqrt (std::complex)	racine carrée complexe dans le demi-plan droit (modèle de fonction)
Fonctions trigonométriques
sin (std::complex)	calcule le sinus d'un nombre complexe ( $sin(z)$ ) (modèle de fonction)
cos (std::complex)	calcule le cosinus d'un nombre complexe ( $cos(z)$ ) (modèle de fonction)
tan (std::complex)	calcule la tangente d'un nombre complexe ( $tan(z)$ ) (modèle de fonction)
asin (std::complex) (C++11)	calcule l'arc sinus d'un nombre complexe ( $arcsin(z)$ ) (modèle de fonction)
acos (std::complex) (C++11)	calcule l'arc cosinus d'un nombre complexe ( $arccos(z)$ ) (fonction template)
atan (std::complex) (C++11)	calcule l'arc tangente d'un nombre complexe ( $arctan(z)$ ) (modèle de fonction)
Fonctions hyperboliques
sinh (std::complex)	calcule le sinus hyperbolique d'un nombre complexe ( $sinh(z)$ ) (modèle de fonction)
cosh (std::complex)	calcule le cosinus hyperbolique d'un nombre complexe ( $cosh(z)$ ) (modèle de fonction)
tanh (std::complex)	calcule la tangente hyperbolique d'un nombre complexe ( $tanh(z)$ ) (modèle de fonction)
asinh (std::complex) (C++11)	calcule le sinus hyperbolique inverse d'un nombre complexe ( $arsinh(z)$ ) (modèle de fonction)
acosh (std::complex) (C++11)	calcule le cosinus hyperbolique inverse d'un nombre complexe ( $arcosh(z)$ ) (modèle de fonction)
atanh (std::complex) (C++11)	calcule la tangente hyperbolique inverse d'un nombre complexe ( $artanh(z)$ ) (modèle de fonction)
Littéraux
operator""if operator""i operator""il (C++14)	un std::complex littéral représentant un nombre purement imaginaire (fonction)

Synopsis

namespace std {
    template<class T> class complex;
    template<> class complex<float>;
    template<> class complex<double>;
    template<> class complex<long double>;
    // opérateurs :
    template<class T> constexpr complex<T> operator+(
        const complex<T>&, const complex<T>&);
    template<class T> constexpr complex<T> operator+(const complex<T>&, const T&);
    template<class T> constexpr complex<T> operator+(const T&, const complex<T>&);
    template<class T> constexpr complex<T> operator-(
        const complex<T>&, const complex<T>&);
    template<class T> constexpr complex<T> operator-(const complex<T>&, const T&);
    template<class T> constexpr complex<T> operator-(const T&, const complex<T>&);
    template<class T> constexpr complex<T> operator*(
        const complex<T>&, const complex<T>&);
    template<class T> constexpr complex<T> operator*(const complex<T>&, const T&);
    template<class T> constexpr complex<T> operator*(const T&, const complex<T>&);
    template<class T> constexpr complex<T> operator/(
        const complex<T>&, const complex<T>&);
    template<class T> constexpr complex<T> operator/(const complex<T>&, const T&);
    template<class T> constexpr complex<T> operator/(const T&, const complex<T>&);
    template<class T> constexpr complex<T> operator+(const complex<T>&);
    template<class T> constexpr complex<T> operator-(const complex<T>&);
    template<class T> constexpr bool operator==(const complex<T>&, const complex<T>&);
    template<class T> constexpr bool operator==(const complex<T>&, const T&);
    template<class T> constexpr bool operator==(const T&, const complex<T>&);
    template<class T> constexpr bool operator!=(const complex<T>&, const complex<T>&);
    template<class T> constexpr bool operator!=(const complex<T>&, const T&);
    template<class T> constexpr bool operator!=(const T&, const complex<T>&);
    template<class T, class CharT, class Traits>
    basic_istream<CharT, Traits>&
    operator>>(basic_istream<CharT, Traits>&, complex<T>&);
    template<class T, class CharT, class Traits>
    basic_ostream<CharT, Traits>&
    operator<<(basic_ostream<CharT, Traits>&, const complex<T>&);
    // valeurs :
    template<class T> constexpr T real(const complex<T>&);
    template<class T> constexpr T imag(const complex<T>&);
    template<class T> T abs(const complex<T>&);
    template<class T> T arg(const complex<T>&);
    template<class T> constexpr T norm(const complex<T>&);
    template<class T> constexpr complex<T> conj(const complex<T>&);
    template<class T> complex<T> proj(const complex<T>&);
    template<class T> complex<T> polar(const T&, const T& = 0);
    // fonctions transcendantes :
    template<class T> complex<T> acos(const complex<T>&);
    template<class T> complex<T> asin(const complex<T>&);
    template<class T> complex<T> atan(const complex<T>&);
    template<class T> complex<T> acosh(const complex<T>&);
    template<class T> complex<T> asinh(const complex<T>&);
    template<class T> complex<T> atanh(const complex<T>&);
    template<class T> complex<T> cos  (const complex<T>&);
    template<class T> complex<T> cosh (const complex<T>&);
    template<class T> complex<T> exp  (const complex<T>&);
    template<class T> complex<T> log  (const complex<T>&);
    template<class T> complex<T> log10(const complex<T>&);
    template<class T> complex<T> pow(const complex<T>&, const T&);
    template<class T> complex<T> pow(const complex<T>&, const complex<T>&);
    template<class T> complex<T> pow(const T&, const complex<T>&);
    template<class T> complex<T> sin (const complex<T>&);
    template<class T> complex<T> sinh(const complex<T>&);
    template<class T> complex<T> sqrt(const complex<T>&);
    template<class T> complex<T> tan (const complex<T>&);
    template<class T> complex<T> tanh(const complex<T>&);
    // interface tuple :
    template<class T> struct tuple_size;
    template<size_t I, class T> struct tuple_element;
    template<class T> struct tuple_size<complex<T>>;
    template<size_t I, class T> struct tuple_element<I, complex<T>>;
    template<size_t I, class T>
      constexpr T& get(complex<T>&) noexcept;
    template<size_t I, class T>
      constexpr T&& get(complex<T>&&) noexcept;
    template<size_t I, class T>
      constexpr const T& get(const complex<T>&) noexcept;
    template<size_t I, class T>
      constexpr const T&& get(const complex<T>&&) noexcept;
    // littéraux complexes :
    inline namespace literals {
        inline namespace complex_literals {
            constexpr complex<long double> operator""il(long double);
            constexpr complex<long double> operator""il(unsigned long long);
            constexpr complex<double> operator""i(long double);
            constexpr complex<double> operator""i(unsigned long long);
            constexpr complex<float> operator""if(long double);
            constexpr complex<float> operator""if(unsigned long long);
        }
    }
}

Classe std::complex

template<class T>
class complex {
public:
    typedef T value_type;
    constexpr complex(const T& re = T(), const T& im = T());
    constexpr complex(const complex&) = default;
    template<class X> constexpr explicit(/* voir page du constructeur */)
        complex(const complex<X>&);
    constexpr T real() const;
    constexpr void real(T);
    constexpr T imag() const;
    constexpr void imag(T);
    constexpr complex<T>& operator= (const T&);
    constexpr complex<T>& operator+=(const T&);
    constexpr complex<T>& operator-=(const T&);
    constexpr complex<T>& operator*=(const T&);
    constexpr complex<T>& operator/=(const T&);
    constexpr complex& operator=(const complex&);
    template<class X> constexpr complex<T>& operator= (const complex<X>&);
    template<class X> constexpr complex<T>& operator+=(const complex<X>&);
    template<class X> constexpr complex<T>& operator-=(const complex<X>&);
    template<class X> constexpr complex<T>& operator*=(const complex<X>&);
    template<class X> constexpr complex<T>& operator/=(const complex<X>&);
};

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR	Appliqué à	Comportement publié	Comportement corrigé
LWG 79	C++98	l'argument par défaut du second paramètre de `polar` était manquant dans le synopsis	ajouté

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Diagnostics library
Memory management library
Metaprogramming library (C++11)
General utilities library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library (C++17)
Concurrency support library (C++11)
Execution control library (C++26)
Technical specifications
Symbols index
External libraries

cppreference.net

Namespaces

Variants

Standard library header <complex>

Table des matières

Classes

Fonctions

Opérations

Fonctions exponentielles

Fonctions de puissance

Fonctions trigonométriques

Fonctions hyperboliques

Littéraux

Synopsis

Classe std::complex

Rapports de défauts