Movatterモバイル変換

[0]ホーム
URL:

cppreference.com
Namespaces
Variants
    Actions

      std::fmin,std::fminf,std::fminl

      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       fmin(float x,float y);

      double      fmin(double x,double y);

      longdouble fmin(longdouble x,longdouble y);
      		(until C++23)
      constexpr/*floating-point-type*/

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

                         /*floating-point-type*/ y);
      		(since C++23)
      float       fminf(float x,float y);
      		 (2)(since C++11)
      (constexpr since C++23)
      longdouble fminl(longdouble x,longdouble y);
      		 (3)(since C++11)
      (constexpr since C++23)
      SIMD overload(since C++26)
      Defined in header<simd>
      template<class V0,class V1>

      constexpr/*math-common-simd-t*/<V0, V1>

                  fmin(const V0& v_x,const V1& v_y);
      		 (S)(since C++26)
      Defined in header<cmath>
      template<class Integer>
      double      fmin( Integer x, Integer y);
      		 (A)(constexpr since C++23)
      1-3) Returns the smaller of two floating point arguments, treating NaNs as missing data (between a NaN and a numeric value, the numeric value is chosen). The library provides overloads ofstd::fmin for all cv-unqualified floating-point types as the type of the parameters.(since C++23)
      S) The SIMD overload performs an element-wisestd::fmin onv_xandv_y.
      (Seemath-common-simd-t for its definition.)
      		(since C++26)
      A) Additional overloads are provided for all integer types, which are treated asdouble.
      		(since C++11)

      Contents

      [edit]Parameters

      x, y - floating-point or integer values

      [edit]Return value

      If successful, returns the smaller of two floating point values. The value returned is exact and does not depend on any rounding modes.

      [edit]Error handling

      This function is not subject to any of the error conditions specified inmath_errhandling.

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

      • If one of the two arguments is NaN, the value of the other argument is returned.
      • Only if both arguments are NaN, NaN is returned.

      [edit]Notes

      This function is not required to be sensitive to the sign of zero, although some implementations additionally enforce that if one argument is+0 and the other is-0, then-0 is returned.

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

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

      Ifnum1 andnum2 have arithmetic types, thenstd::fmin(num1, num2) has the same effect asstd::fmin(static_cast</*common-floating-point-type*/>(num1),
               static_cast</*common-floating-point-type*/>(num2))      , where/*common-floating-point-type*/ is the floating-point type with the greatestfloating-point conversion rank and greatestfloating-point conversion subrank between the types ofnum1 andnum2, 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)

      [edit]Example

      Run this code
      #include <cmath>#include <iostream> int main(){std::cout<<"fmin(2,1)    = "<< std::fmin(2,1)<<'\n'<<"fmin(-Inf,0) = "<< std::fmin(-INFINITY,0)<<'\n'<<"fmin(NaN,-1) = "<< std::fmin(NAN,-1)<<'\n';}

      Possible output:

      fmin(2,1)    = 1fmin(-Inf,0) = -inffmin(NaN,-1) = -1

      [edit]See also

      (C++11)
      		 checks if the first floating-point argument is less than the second
      (function)[edit]
      (C++11)(C++11)(C++11)
      		 larger of two floating-point values
      (function)[edit]
      returns the smaller of the given values
      (function template)[edit]
      returns the smallest element in a range
      (function template)[edit]
      (C++11)
      		 returns the smaller and larger of two elements
      (function template)[edit]
      returns the smallest and the largest elements in a range
      (function template)[edit]
      Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/numeric/math/fmin&oldid=160734"
      [8]ページ先頭
      ©2009-2025 Movatter.jp