Namespaces
Variants

std:: proj (std::complex)

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

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

std:: complex < long double > proj ( long double f ) ;
(jusqu'à C++23)
template < class FloatingPoint >
std:: complex < FloatingPoint > proj ( FloatingPoint f ) ;
(depuis C++23)
template < class Integer >
std:: complex < double > proj ( Integer i ) ;
(B)
1) Retourne la projection du nombre complexe z sur la sphère de Riemann .
Pour la plupart des z , std :: proj ( z ) == z , mais tous les infinis complexes, même les nombres dont une composante est infinie et l'autre est NaN, deviennent l'infini réel positif, ( INFINITY , 0.0 ) ou ( INFINITY , - 0.0 ) . Le signe de la composante imaginaire (zéro) est le signe de std:: imag ( z ) .
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 positive nulle.

Table des matières

Paramètres

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

Valeur de retour

1) La projection de z sur la sphère de Riemann.
A) La projection de std:: complex ( f ) sur la sphère de Riemann.
B) La projection de std:: complex < double > ( i ) sur la sphère de Riemann.

Notes

La fonction proj aide à modéliser la sphère de Riemann en mappant tous les infinis vers un (à part le signe du zéro imaginaire), et devrait être utilisée juste avant toute opération, particulièrement les comparaisons, qui pourrait donner des résultats erronés pour l'un des autres infinis.

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'en C++23) à virgule flottante T , alors std :: proj ( num ) a le même effet que std :: proj ( std:: complex < T > ( num ) ) .
  • Sinon, si num a un type entier, alors std :: proj ( num ) a le même effet que std :: proj ( std:: complex < double > ( num ) ) .

Exemple

Exécuter ce code 
#include <complex>
#include <iostream>
int main()
{
    std::complex<double> c1(1, 2);
    std::cout << "proj" << c1 << " = " << std::proj(c1) << '\n';
    std::complex<double> c2(INFINITY, -1);
    std::cout << "proj" << c2 << " = " << std::proj(c2) << '\n';
    std::complex<double> c3(0, -INFINITY);
    std::cout << "proj" << c3 << " = " << std::proj(c3) << '\n';
}

Sortie : 

proj(1,2) = (1,2)
proj(inf,-1) = (inf,-0)
proj(0,-inf) = (inf,-0)

Voir aussi

renvoie la magnitude d'un nombre complexe
(modèle de fonction)
renvoie la magnitude au carré
(modèle de fonction)
construit un nombre complexe à partir de la magnitude et de l'angle de phase
(modèle de fonction)
Documentation C pour cproj