std::norm(std::complex)

Определено в заголовочном файле `<complex>`
template< class T > T norm( const std::complex<T>& z );	(1)	(до C++20)
template< class T > constexpr T norm( const std::complex<T>& z );	(1)		(начиная с C++20)
Дополнительные перегрузки (начиная с C++11)
Определено в заголовочном файле `<complex>`
float norm( float f ); double norm( double f ); long double norm( long double f );	(A)	(до C++20)
constexpr float norm( float f ); constexpr double norm( double f ); constexpr long double norm( long double f );			(начиная с C++20) (до C++23)
template< class FloatingPoint > constexpr FloatingPoint norm( FloatingPoint f );			(начиная с C++23)
template< class Integer > double norm( Integer i );	(B)	(до C++20)
template< class Integer > constexpr double norm( Integer i );	(B)		(начиная с C++20)

1) Возвращает квадрат модуля комплексного числа z.

A,B) Предоставляются дополнительные перегрузки для всех целочисленных типов и типов с плавающей точкой, которые рассматриваются как комплексные числа с нулевой мнимой частью.

(начиная с C++11)

Параметры

z	-	комплексное значение
f	-	значение с плавающей точкой
i	-	целочисленное значение

Возвращаемое значение

1) Квадрат модуля z.

A) Квадрат f.

B) Квадрат i.

Примечания

Норма, вычисляемая этой функцией, также известна как норма поля или абсолютный квадрат.

Евклидова норма комплексного числа вычисляется функцией std::abs, вычисление которой обходится дороже. В некоторых ситуациях её можно заменить на std::norm, например, если abs(z1) > abs(z2), то norm(z1) > norm(z2).

Дополнительные перегрузки не обязательно должны быть предоставлены в точности в виде (A,B). Они должны лишь обеспечивать следующее для аргумента num:

Если num имеет стандартный(до C++23) тип с плавающей точкой T, то std::norm(num) имеет тот же эффект, что и std::norm(std::complex<T>(num)).
В противном случае, если num имеет целочисленный тип, то std::norm(num) имеет тот же эффект, что и std::norm(std::complex<double>(num)).

Пример

#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';
}

Вывод:

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

См. также

abs(std::complex)	возвращает модуль комплексного числа (шаблон функции)
conj	возвращает комплексно-сопряжённое число (шаблон функции)
polar	создаёт комплексное число по модулю и углу фазы (шаблон функции)

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/cpp/numeric/complex/norm