Namespaces
Variants

std:: proj (std::complex)

From cppreference.net
C++
Numerics library
std::complex
Definido en el encabezado <complex>
template < class T >
std:: complex < T > proj ( const std:: complex < T > & z ) ;
(1) (desde C++11)
Definido en el encabezado <complex>
(A)
std:: complex < float > proj ( float f ) ;

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

std:: complex < long double > proj ( long double f ) ;
(hasta C++23)
template < class FloatingPoint >
std:: complex < FloatingPoint > proj ( FloatingPoint f ) ;
(desde C++23)
template < class Integer >
std:: complex < double > proj ( Integer i ) ;
(B)
1) Devuelve la proyección del número complejo z sobre la esfera de Riemann .
Para la mayoría de z , std :: proj ( z ) == z , pero todas las infinitas complejas, incluso los números donde un componente es infinito y el otro es NaN, se convierten en infinito real positivo, ( INFINITY , 0.0 ) o ( INFINITY , - 0.0 ) . El signo del componente imaginario (cero) es el signo de std:: imag ( z ) .
A,B) Se proporcionan sobrecargas adicionales para todos los tipos enteros y de punto flotante, los cuales son tratados como números complejos con componente imaginario de cero positivo.

Contenidos

Parámetros

z - valor complejo
f - valor de punto flotante
i - valor entero

Valor de retorno

1) La proyección de z sobre la esfera de Riemann.
A) La proyección de std:: complex ( f ) sobre la esfera de Riemann.
B) La proyección de std:: complex < double > ( i ) sobre la esfera de Riemann.

Notas

La función proj ayuda a modelar la esfera de Riemann mapeando todos los infinitos a uno (dando o tomando el signo del cero imaginario), y debe usarse justo antes de cualquier operación, especialmente comparaciones, que podría dar resultados espurios para cualquiera de los otros infinitos.

Las sobrecargas adicionales no están obligadas a proporcionarse exactamente como (A,B) . Solo necesitan ser suficientes para garantizar que para su argumento num :

  • Si num tiene un tipo de punto flotante estándar (hasta C++23) T , entonces std :: proj ( num ) tiene el mismo efecto que std :: proj ( std:: complex < T > ( num ) ) .
  • En caso contrario, si num tiene un tipo entero, entonces std :: proj ( num ) tiene el mismo efecto que std :: proj ( std:: complex < double > ( num ) ) .

Ejemplo

Ejecutar este código 
#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';
}

Salida: 

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

Véase también

devuelve la magnitud de un número complejo
(function template)
devuelve la magnitud al cuadrado
(function template)
construye un número complejo a partir de magnitud y ángulo de fase
(function template)
C documentation para cproj