Namespaces
Variants

std:: norm (std::complex)

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

double norm ( double f ) ;

long double norm ( long double f ) ;
(hasta C++20)
constexpr float norm ( float f ) ;

constexpr double norm ( double f ) ;

constexpr long double norm ( long double f ) ;
(desde C++20)
(hasta C++23)
template < class FloatingPoint >
constexpr FloatingPoint norm ( FloatingPoint f ) ;
(desde C++23)
(B)
template < class Integer >
double norm ( Integer i ) ;
(hasta C++20)
template < class Integer >
constexpr double norm ( Integer i ) ;
(desde C++20)
1) Devuelve la magnitud al cuadrado del número complejo 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 cero.
(since C++11)

Contenidos

Parámetros

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

Valor de retorno

1) La magnitud al cuadrado de z .
A) El cuadrado de f .
B) El cuadrado de i .

Notas

La norma calculada por esta función también se conoce como field norm o absolute square .

La norma euclidiana de un número complejo es proporcionada por std::abs , que es más costosa de calcular. En algunas situaciones, puede ser reemplazada por std::norm , por ejemplo, si abs ( z1 ) > abs ( z2 ) entonces norm ( z1 ) > norm ( z2 ) .

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

Ejemplo

Ejecutar este código 
#include <cassert>
#include <complex>
#include <iostream>
int main()
{
    constexpr std::complex<double> z {3.0, 4.0};
    static_assert(std::norm(z) == (z.real() * z.real() + z.imag() * z.imag()));
    static_assert(std::norm(z) == (z * std::conj(z)));
           assert(std::norm(z) == (std::abs(z) * std::abs(z)));
    std::cout << "std::norm(" << z << ") = " << std::norm(z) << '\n';
}

Salida: 

std::norm((3,4)) = 25

Véase también

devuelve la magnitud de un número complejo
(function template)
devuelve el conjugado complejo
(function template)
construye un número complejo a partir de magnitud y ángulo de fase
(function template)