Namespaces
Variants

std:: conj (std::complex)

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

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

std:: complex < long double > conj ( long double f ) ;
(hasta 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 ) ;
(desde C++20)
(hasta C++23)
template < class FloatingPoint >
constexpr std:: complex < FloatingPoint > conj ( FloatingPoint f ) ;
(desde C++23)
(B)
template < class Integer >
constexpr std:: complex < double > conj ( Integer i ) ;
(hasta C++20)
template < class Integer >
constexpr std:: complex < double > conj ( Integer i ) ;
(desde C++20)
1) Calcula el conjugado complejo de z invirtiendo el signo de la parte imaginaria.
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 cero.
(since C++11)

Contenidos

Parámetros

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

Valor de retorno

1) El conjugado complejo de z .
A) std:: complex ( f ) .
B) std:: complex < double > ( i ) .

Notas

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 :: conj ( num ) tiene el mismo efecto que std :: conj ( std:: complex < T > ( num ) ) .
  • De lo contrario, si num tiene un tipo entero, entonces std :: conj ( num ) tiene el mismo efecto que std :: conj ( std:: complex < double > ( num ) ) .

Ejemplo

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

Salida: 

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

Véase también

devuelve la magnitud de un número complejo
(plantilla de función)
devuelve la magnitud al cuadrado
(plantilla de función)
construye un número complejo a partir de magnitud y ángulo de fase
(plantilla de función)
Documentación C para conj