std:: hypot, std:: hypotf, std:: hypotl

From ru.cppreference.net

Определено в заголовке `<cmath>`
	(1)
float hypot ( float x, float y ) ; double hypot ( double x, double y ) ; long double hypot ( long double x, long double y ) ;			(начиная с C++11) (до C++23)
/floating-point-type/ hypot ( /floating-point-type/ x, /floating-point-type/ y ) ;			(начиная с C++23) (constexpr начиная с C++26)
float hypotf ( float x, float y ) ;		(2)	(начиная с C++11) (constexpr начиная с C++26)
long double hypotl ( long double x, long double y ) ;		(3)	(начиная с C++11) (constexpr начиная с C++26)
		(4)
float hypot ( float x, float y, float z ) ; double hypot ( double x, double y, double z ) ; long double hypot ( long double x, long double y, long double z ) ;				(начиная с C++17) (до C++23)
/floating-point-type/ hypot ( /floating-point-type/ x, /floating-point-type/ y, /floating-point-type/ z ) ;				(начиная с C++23) (constexpr начиная с C++26)
Дополнительные перегрузки
Определено в заголовке `<cmath>`
template < class Arithmetic1, Arithmetic2 > /common-floating-point-type/ hypot ( Arithmetic1 x, Arithmetic2 y ) ;			(A)	(начиная с C++11) (constexpr начиная с C++26)
template < class Arithmetic1, Arithmetic2, Arithmetic3 > /common-floating-point-type/ hypot ( Arithmetic1 x, Arithmetic2 y, Arithmetic3 z ) ;			(B)	(начиная с C++17)

1-3) Вычисляет квадратный корень из суммы квадратов x и y , без чрезмерного переполнения или потери значимости на промежуточных этапах вычисления. Библиотека предоставляет перегрузки


          std::hypot

для всех неквалифицированных cv типов с плавающей запятой в качестве типа параметров x и y . (since C++23)

4) Вычисляет квадратный корень из суммы квадратов x , y и z , без чрезмерного переполнения или потери точности на промежуточных этапах вычисления. Библиотека предоставляет перегрузки


          std::hypot

для всех cv-неквалифицированных типов с плавающей запятой в качестве типа параметров x , y и z . (since C++23)

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

Значение, вычисляемое двухаргументной версией этой функции, представляет собой длину гипотенузы прямоугольного треугольника со сторонами длиной x и y , или расстояние от точки (x,y) до начала координат (0,0) , или модуль комплексного числа x+ i y .

Значение, вычисляемое трёхаргументной версией этой функции, представляет собой расстояние точки (x,y,z) от начала координат (0,0,0) .

Содержание

Параметры

x, y, z

значения с плавающей точкой или целочисленные значения

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

1-3,A) Если не возникает ошибок, возвращается гипотенуза прямоугольного треугольника,

\sqrt x 2 +y 2

4,B) Если не возникает ошибок, возвращается расстояние от начала координат в трёхмерном пространстве,

\sqrt x 2 +y 2 +z 2

Если происходит ошибка диапазона из-за переполнения, +HUGE_VAL , +HUGE_VALF , или +HUGE_VALL возвращается.

Если происходит ошибка диапазона из-за потери значимости, возвращается корректный результат (после округления).

Обработка ошибок

Ошибки сообщаются, как указано в math_errhandling .

Если реализация поддерживает арифметику с плавающей запятой IEEE (IEC 60559),

std :: hypot ( x, y ) , std :: hypot ( y, x ) и std :: hypot ( x, - y ) эквивалентны.
если один из аргументов равен ±0, std :: hypot ( x, y ) эквивалентно вызову std::fabs с ненулевым аргументом.
если один из аргументов равен ±∞, std :: hypot ( x, y ) возвращает +∞ даже если другой аргумент является NaN.
в остальных случаях, если любой из аргументов является NaN, возвращается NaN.

Примечания

Реализации обычно гарантируют точность менее 1 ulp (Unit in the Last Place — Единица младшего разряда): GNU , BSD .

std :: hypot ( x, y ) эквивалентно std :: abs ( std:: complex < double > ( x, y ) ) .

POSIX определяет что исчерпание порядка (underflow) может происходить только тогда, когда оба аргумента являются субнормальными и правильный результат также субнормален (это запрещает наивные реализации).

Расстояние между двумя точками (x1, y1, z1) и (x2, y2, z2) в трёхмерном пространстве может быть вычислено с использованием трёхаргументной перегрузки std::hypot как std :: hypot ( x2 - x1, y2 - y1, z2 - z1 ) .

(since C++17)

Дополнительные перегрузки не обязаны быть предоставлены именно в виде (A,B) . Они должны быть достаточными для обеспечения того, чтобы для их первого аргумента num1 , второго аргумента num2 и опционального третьего аргумента num3 :

Если num1 , num2 или num3 имеют тип long double , тогда

std :: hypot ( num1, num2 ) имеет тот же эффект, что и std :: hypot ( static_cast < long double > ( num1 ) ,
static_cast < long double > ( num2 ) ) , и
std :: hypot ( num1, num2, num3 ) имеет тот же эффект, что и std :: hypot ( static_cast < long double > ( num1 ) ,
static_cast < long double > ( num2 ) ,
static_cast < long double > ( num3 ) ) .

В противном случае, если num1 , num2 и/или num3 имеют тип double или целочисленный тип, тогда

std :: hypot ( num1, num2 ) имеет тот же эффект, что и std :: hypot ( static_cast < double > ( num1 ) ,
static_cast < double > ( num2 ) ) , и
std :: hypot ( num1, num2, num3 ) имеет тот же эффект, что и std :: hypot ( static_cast < double > ( num1 ) ,
static_cast < double > ( num2 ) ,
static_cast < double > ( num3 ) ) .

В противном случае, если num1 , num2 или num3 имеет тип float , тогда

std :: hypot ( num1, num2 ) имеет тот же эффект, что и std :: hypot ( static_cast < float > ( num1 ) ,
static_cast < float > ( num2 ) ) , и
std :: hypot ( num1, num2, num3 ) имеет тот же эффект, что и std :: hypot ( static_cast < float > ( num1 ) ,
static_cast < float > ( num2 ) ,
static_cast < float > ( num3 ) ) .

(до C++23)

Если num1 , num2 и num3 имеют арифметические типы, тогда

std :: hypot ( num1, num2 ) имеет тот же эффект, что и std :: hypot ( static_cast < /*common-floating-point-type*/ > ( num1 ) ,
static_cast < /*common-floating-point-type*/ > ( num2 ) ) , и
std :: hypot ( num1, num2, num3 ) имеет тот же эффект, что и std :: hypot ( static_cast < /*common-floating-point-type*/ > ( num1 ) ,
static_cast < /*common-floating-point-type*/ > ( num2 ) ,
static_cast < /*common-floating-point-type*/ > ( num3 ) ) ,

где /*common-floating-point-type*/ - это тип с плавающей запятой с наибольшим рангом преобразования с плавающей запятой и наибольшим подрангом преобразования с плавающей запятой среди типов num1 , num2 и num3 , при этом аргументы целочисленного типа считаются имеющими тот же ранг преобразования с плавающей запятой, что и double .

Если такого типа с плавающей запятой с наибольшим рангом и подрангом не существует, тогда разрешение перегрузки не приводит к пригодному кандидату из предоставленных перегрузок.

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

Макрос тестирования возможностей	Значение	Стандарт	Возможность
`__cpp_lib_hypot`	`201603L`	(C++17)	Перегрузка с 3 аргументами для `std::hypot` (4,B)

Пример

Запустить этот код

#include <cerrno>
#include <cfenv>
#include <cfloat>
#include <cmath>
#include <cstring>
#include <iostream>
// #pragma STDC FENV_ACCESS ON
struct Point3D { float x, y, z; };
int main()
{
    // типичное использование
    std::cout << "(1,1) cartesian is (" << std::hypot(1, 1)
              << ',' << std::atan2(1,1) << ") polar\n";
    Point3D a{3.14, 2.71, 9.87}, b{1.14, 5.71, 3.87};
    // C++17 имеет перегрузку hypot с тремя аргументами:
    std::cout << "distance(a,b) = "
              << std::hypot(a.x - b.x, a.y - b.y, a.z - b.z) << '\n';
    // специальные значения
    std::cout << "hypot(NAN,INFINITY) = " << std::hypot(NAN, INFINITY) << '\n';
    // обработка ошибок
    errno = 0;
    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout << "hypot(DBL_MAX,DBL_MAX) = " << std::hypot(DBL_MAX, DBL_MAX) << '\n';
    if (errno == ERANGE)
        std::cout << "    errno = ERANGE " << std::strerror(errno) << '\n';
    if (std::fetestexcept(FE_OVERFLOW))
        std::cout << "    FE_OVERFLOW raised\n";
}

Вывод:

(1,1) cartesian is (1.41421,0.785398) polar
distance(a,b) = 7
hypot(NAN,INFINITY) = inf
hypot(DBL_MAX,DBL_MAX) = inf
    errno = ERANGE Numerical result out of range
    FE_OVERFLOW raised

Смотрите также

pow powf powl (C++11) (C++11)	возводит число в заданную степень ( $\small{x^y}$ $x y$ ) (функция)
sqrt sqrtf sqrtl (C++11) (C++11)	вычисляет квадратный корень ( $\sqrt x$ ) (функция)
cbrt cbrtf cbrtl (C++11) (C++11) (C++11)	вычисляет кубический корень ( $3 \sqrt x$ ) (функция)
abs (std::complex)	возвращает модуль комплексного числа (шаблон функции)
C documentation для hypot

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Diagnostics library
Memory management library
Metaprogramming library (C++11)
General utilities library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library (C++17)
Concurrency support library (C++11)
Execution control library (C++26)
Technical specifications
Symbols index
External libraries

ru.cppreference.net

Namespaces

Variants