Movatterモバイル変換

[0]ホーム
URL:

cppreference.com
Namespaces
Variants
    Actions

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

      From cppreference.com
      <cpp‎ |numeric‎ |math
       
       
       
      Common mathematical functions
      Nearest integer floating point operations
      (C++11)(C++11)(C++11)
      (C++11)
      (C++11)
      (C++11)(C++11)(C++11)
      Floating point manipulation functions
      (C++11)(C++11)
      (C++11)
      (C++11)
      Classification and comparison
      (C++11)
      (C++11)
      (C++11)
      (C++11)
      (C++11)
      (C++11)
      Types
      (C++11)
      (C++11)
      (C++11)
      Macro constants
       
      Defined in header<cmath>
      (1)
      float       hypot(float x,float y);

      double      hypot(double x,double y);

      longdouble hypot(longdouble x,longdouble y);
      		(since C++11)
      (until C++23)
      /*floating-point-type*/

                  hypot(/*floating-point-type*/ x,

                         /*floating-point-type*/ y);
      		(since C++23)
      (constexpr since C++26)
      float       hypotf(float x,float y);
      		 (2)(since C++11)
      (constexpr since C++26)
      longdouble hypotl(longdouble x,longdouble y);
      		 (3)(since C++11)
      (constexpr since C++26)
      (4)
      float       hypot(float x,float y,float z);

      double      hypot(double x,double y,double z);

      longdouble hypot(longdouble x,longdouble y,longdouble z);
      		(since C++17)
      (until C++23)
      /*floating-point-type*/

                  hypot(/*floating-point-type*/ x,
                         /*floating-point-type*/ y,

                         /*floating-point-type*/ z);
      		(since C++23)
      (constexpr since C++26)
      Defined in header<cmath>
      template<class Arithmetic1, Arithmetic2>

      /*common-floating-point-type*/

                  hypot( Arithmetic1 x, Arithmetic2 y);
      		 (A)(since C++11)
      (constexpr since C++26)
      template<class Arithmetic1, Arithmetic2, Arithmetic3>

      /*common-floating-point-type*/

                  hypot( Arithmetic1 x, Arithmetic2 y, Arithmetic3 z);
      		 (B)(since C++17)
      1-3) Computes the square root of the sum of the squares ofx andy, without undue overflow or underflow at intermediate stages of the computation.The library provides overloads ofstd::hypot for all cv-unqualified floating-point types as the type of the parametersx andy.(since C++23)
      4) Computes the square root of the sum of the squares ofx,y, andz, without undue overflow or underflow at intermediate stages of the computation.The library provides overloads ofstd::hypot for all cv-unqualified floating-point types as the type of the parametersx,y andz.(since C++23)
      A,B) Additional overloads are provided for all other combinations of arithmetic types.

      The value computed by the two-argument version of this function is the length of the hypotenuse of a right-angled triangle with sides of lengthx andy, or the distance of the point(x,y) from the origin(0,0), or the magnitude of a complex numberx+iy.

      The value computed by the three-argument version of this function is the distance of the point(x,y,z) from the origin(0,0,0).

      Contents

      [edit]Parameters

      x, y, z - floating-point or integer values

      [edit]Return value

      1-3,A) If no errors occur, the hypotenuse of a right-angled triangle,\(\scriptsize{\sqrt{x^2+y^2} }\)√x2
      +y2
      , is returned.
      4,B) If no errors occur, the distance from origin in 3D space,\(\scriptsize{\sqrt{x^2+y^2+z^2} }\)√x2
      +y2
      +z2
      , is returned.

      If a range error due to overflow occurs,+HUGE_VAL,+HUGE_VALF, or+HUGE_VALL is returned.

      If a range error due to underflow occurs, the correct result (after rounding) is returned.

      [edit]Error handling

      Errors are reported as specified inmath_errhandling.

      If the implementation supports IEEE floating-point arithmetic (IEC 60559),

      • std::hypot(x, y),std::hypot(y, x), andstd::hypot(x,-y) are equivalent.
      • if one of the arguments is ±0,std::hypot(x, y) is equivalent tostd::fabs called with the non-zero argument.
      • if one of the arguments is ±∞,std::hypot(x, y) returns +∞ even if the other argument is NaN.
      • otherwise, if any of the arguments is NaN, NaN is returned.

      [edit]Notes

      Implementations usually guarantee precision of less than 1ulp (Unit in the Last Place — Unit of Least Precision):GNU,BSD.

      std::hypot(x, y) is equivalent tostd::abs(std::complex<double>(x, y)).

      POSIX specifies that underflow may only occur when both arguments are subnormal and the correct result is also subnormal (this forbids naive implementations).

      Distance between two points(x1, y1, z1) and(x2, y2, z2) on 3D space can be calculated using 3-argument overload ofstd::hypot asstd::hypot(x2- x1, y2- y1, z2- z1).

      		(since C++17)

      The additional overloads are not required to be provided exactly as(A,B). They only need to be sufficient to ensure that for their first argumentnum1, second argumentnum2 and the optional third argumentnum3:

      • Ifnum1,num2 ornum3 has typelongdouble, then
      • std::hypot(num1, num2) has the same effect asstd::hypot(static_cast<longdouble>(num1),
                   static_cast<longdouble>(num2))        , and
      • std::hypot(num1, num2, num3) has the same effect asstd::hypot(static_cast<longdouble>(num1),
                   static_cast<longdouble>(num2),
                   static_cast<longdouble>(num3))        .
      • Otherwise, ifnum1,num2 and/ornum3 has typedouble or an integer type, then
      • std::hypot(num1, num2) has the same effect asstd::hypot(static_cast<double>(num1),
                   static_cast<double>(num2))        , and
      • std::hypot(num1, num2, num3) has the same effect asstd::hypot(static_cast<double>(num1),
                   static_cast<double>(num2),
                   static_cast<double>(num3))        .
      • Otherwise, ifnum1,num2 ornum3 has typefloat, then
      • std::hypot(num1, num2) has the same effect asstd::hypot(static_cast<float>(num1),
                   static_cast<float>(num2))        , and
      • std::hypot(num1, num2, num3) has the same effect asstd::hypot(static_cast<float>(num1),
                   static_cast<float>(num2),
                   static_cast<float>(num3))        .
      		(until C++23)

      Ifnum1,num2 andnum3 have arithmetic types, then

      • std::hypot(num1, num2) has the same effect asstd::hypot(static_cast</*common-floating-point-type*/>(num1),
                   static_cast</*common-floating-point-type*/>(num2))        , and
      • std::hypot(num1, num2, num3) has the same effect asstd::hypot(static_cast</*common-floating-point-type*/>(num1),
                   static_cast</*common-floating-point-type*/>(num2),
                   static_cast</*common-floating-point-type*/>(num3))        ,

      where/*common-floating-point-type*/ is the floating-point type with the greatestfloating-point conversion rank and greatestfloating-point conversion subrank among the types ofnum1,num2 andnum3, arguments of integer type are considered to have the same floating-point conversion rank asdouble.

      If no such floating-point type with the greatest rank and subrank exists, thenoverload resolution does not result in a usable candidate from the overloads provided.

      		(since C++23)
      Feature-test macroValueStdFeature
      __cpp_lib_hypot201603L(C++17)3-argument overload ofstd::hypot(4,B)

      [edit]Example

      Run this code
      #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(){// typical usagestd::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 has 3-argument hypot overload:std::cout<<"distance(a,b) = "<< std::hypot(a.x- b.x, a.y- b.y, a.z- b.z)<<'\n'; // special valuesstd::cout<<"hypot(NAN,INFINITY) = "<< std::hypot(NAN,INFINITY)<<'\n'; // error handlingerrno=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";}

      Output:

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

      [edit]See also

      (C++11)(C++11)
      		 raises a number to the given power (\(\small{x^y}\)xy)
      (function)[edit]
      (C++11)(C++11)
      		 computes square root (\(\small{\sqrt{x}}\)√x)
      (function)[edit]
      (C++11)(C++11)(C++11)
      		 computes cube root (\(\small{\sqrt[3]{x}}\)3√x)
      (function)[edit]
      returns the magnitude of a complex number
      (function template)[edit]
      Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/numeric/math/hypot&oldid=180162"
      [8]ページ先頭
      ©2009-2025 Movatter.jp