Namespaces
Variants

std:: conj (std::complex)

From cppreference.net
C++
Numerics library
std::complex
Défini dans l'en-tête <complex>
(1)
template < class T >
std:: complex < T > conj ( const std:: complex < T > & z ) ;
(jusqu'au C++20)
template < class T >
constexpr std:: complex < T > conj ( const std:: complex < T > & z ) ;
(depuis C++20)
Défini dans l'en-tête <complex>
(A)
std:: complex < float > conj ( float f ) ;

std:: complex < double > conj ( double f ) ;

std:: complex < long double > conj ( long double f ) ;
(jusqu'à C++20)
constexpr std:: complex < float > conj ( float f ) ;

constexpr std:: complex < double > conj ( double f ) ;

constexpr std:: complex < long double > conj ( long double f ) ;
(depuis C++20)
(jusqu'à C++23)
template < class FloatingPoint >
constexpr std:: complex < FloatingPoint > conj ( FloatingPoint f ) ;
(depuis C++23)
(B)
template < class Integer >
constexpr std:: complex < double > conj ( Integer i ) ;
(jusqu'au C++20)
template < class Integer >
constexpr std:: complex < double > conj ( Integer i ) ;
(depuis C++20)
1) Calcule le conjugué complexe de z en inversant le signe de la partie imaginaire.
A,B) Des surcharges supplémentaires sont fournies pour tous les types entiers et à virgule flottante, qui sont traités comme des nombres complexes avec une composante imaginaire nulle.
(depuis C++11)

Table des matières

Paramètres

z - valeur complexe
f - valeur à virgule flottante
i - valeur entière

Valeur de retour

1) Le conjugué complexe de z .
A) std:: complex ( f ) .
B) std:: complex < double > ( i ) .

Notes

Les surcharges supplémentaires ne sont pas tenues d'être fournies exactement comme (A,B) . Elles doivent seulement être suffisantes pour garantir que pour leur argument num :

  • Si num a un type standard (jusqu'à C++23) à virgule flottante T , alors std :: conj ( num ) a le même effet que std :: conj ( std:: complex < T > ( num ) ) .
  • Sinon, si num a un type entier, alors std :: conj ( num ) a le même effet que std :: conj ( std:: complex < double > ( num ) ) .

Exemple

Exécuter ce code 
#include <complex>
#include <iostream>
int main()
{
    std::complex<double> z(1.0, 2.0);
    std::cout << "The conjugate of " << z << " is " << std::conj(z) << '\n'
              << "Their product is " << z * std::conj(z) << '\n';
}

Sortie : 

The conjugate of (1,2) is (1,-2)
Their product is (5,0)

Voir aussi

retourne la magnitude d'un nombre complexe
(function template)
retourne la magnitude au carré
(function template)
construit un nombre complexe à partir de la magnitude et de l'angle de phase
(function template)
documentation C pour conj