Namespaces
Variants

std:: norm (std::complex)

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

double norm ( double f ) ;

long double norm ( long double f ) ;
(jusqu'à C++20)
constexpr float norm ( float f ) ;

constexpr double norm ( double f ) ;

constexpr long double norm ( long double f ) ;
(depuis C++20)
(jusqu'à C++23)
template < class FloatingPoint >
constexpr FloatingPoint norm ( FloatingPoint f ) ;
(depuis C++23)
(B)
template < class Integer >
double norm ( Integer i ) ;
(jusqu'à C++20)
template < class Integer >
constexpr double norm ( Integer i ) ;
(depuis C++20)
1) Retourne la magnitude au carré du nombre complexe 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 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) La magnitude au carré de z .
A) Le carré de f .
B) Le carré de i .

Notes

La norme calculée par cette fonction est également connue sous le nom de norme de corps ou carré absolu .

La norme euclidienne d'un nombre complexe est fournie par std::abs , qui est plus coûteuse à calculer. Dans certaines situations, elle peut être remplacée par std::norm , par exemple, si abs ( z1 ) > abs ( z2 ) alors norm ( z1 ) > norm ( z2 ) .

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 :: norm ( num ) a le même effet que std :: norm ( std:: complex < T > ( num ) ) .
  • Sinon, si num a un type entier, alors std :: norm ( num ) a le même effet que std :: norm ( std:: complex < double > ( num ) ) .

Exemple

Exécuter ce code 
#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';
}

Sortie : 

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

Voir aussi

renvoie le module d'un nombre complexe
(modèle de fonction)
renvoie le conjugué complexe
(modèle de fonction)
construit un nombre complexe à partir du module et de l'angle de phase
(modèle de fonction)