Namespaces
Variants

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

    From ru.cppreference.net
    C++
    Numerics library
    Common mathematical functions
    Nearest integer floating point operations
    (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
    Определено в заголовочном файле <cmath>
    (1)
    float fmin ( float x, float y ) ;

    double fmin ( double x, double y ) ;

    long double fmin ( long double x, long double y ) ;
    		(до C++23)
    constexpr /*floating-point-type*/

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

    /*floating-point-type*/ y ) ;
    		(начиная с C++23)
    float fminf ( float x, float y ) ;
    		(2) (начиная с C++11)
    (constexpr начиная с C++23)
    long double fminl ( long double x, long double y ) ;
    		(3) (начиная с C++11)
    (constexpr начиная с C++23)
    SIMD перегрузка (начиная с C++26)
    Определено в заголовочном файле <simd>
    template < class V0, class V1 >

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

    fmin ( const V0 & v_x, const V1 & v_y ) ;
    		(S) (начиная с C++26)
    Определено в заголовочном файле <cmath>
    template < class Integer >
    double fmin ( Integer x, Integer y ) ;
    		(A) (constexpr начиная с C++23)
    1-3) Возвращает меньший из двух аргументов с плавающей точкой, трактуя NaN как отсутствующие данные (между NaN и числовым значением выбирается числовое значение). Библиотека предоставляет перегрузки std::fmin для всех неквалифицированных cv типов с плавающей точкой в качестве типа параметров. (since C++23)
    S) SIMD перегрузка выполняет поэлементное вычисление std::fmin для v_x и v_y .
    (См. math-common-simd-t для его определения.)
    		(since C++26)
    A) Дополнительные перегрузки предоставляются для всех целочисленных типов, которые трактуются как double .
    		(since C++11)

    Содержание

    Параметры

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

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

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

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

    Эта функция не подвержена ни одному из условий ошибок, указанных в math_errhandling .

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

    • Если один из двух аргументов является NaN, возвращается значение другого аргумента.
    • Только если оба аргумента являются NaN, возвращается NaN.

    Примечания

    Эта функция не обязана быть чувствительной к знаку нуля, хотя некоторые реализации дополнительно обеспечивают, что если один аргумент + 0 , а другой - 0 , то возвращается - 0 .

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

    • Если num1 или num2 имеет тип long double , то std :: fmin ( num1, num2 ) имеет тот же эффект, что и std :: fmin ( static_cast < long double > ( num1 ) ,
      static_cast < long double > ( num2 ) )       .
    • В противном случае, если num1 и/или num2 имеет тип double или целочисленный тип, то std :: fmin ( num1, num2 ) имеет тот же эффект, что и std :: fmin ( static_cast < double > ( num1 ) ,
      static_cast < double > ( num2 ) )       .
    • В противном случае, если num1 или num2 имеет тип float , то std :: fmin ( num1, num2 ) имеет тот же эффект, что и std :: fmin ( static_cast < float > ( num1 ) ,
      static_cast < float > ( num2 ) )       .
    		(до C++23)

    Если num1 и num2 имеют арифметические типы, то std :: fmin ( num1, num2 ) имеет тот же эффект, что и std :: fmin ( static_cast < /*common-floating-point-type*/ > ( num1 ) ,
    static_cast < /*common-floating-point-type*/ > ( num2 ) )     , где /*common-floating-point-type*/ - это тип с плавающей запятой с наибольшим рангом преобразования с плавающей запятой и наибольшим подрангом преобразования с плавающей запятой среди типов num1 и num2 , при этом аргументы целочисленного типа считаются имеющими тот же ранг преобразования с плавающей запятой, что и double .

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

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

    Пример

    Запустить этот код 
    #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';
}

    Возможный вывод: 

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

    См. также

    (C++11)
    		 проверяет, меньше ли первый аргумент с плавающей запятой второго
    (функция)
    (C++11)(C++11)(C++11)
    		 большее из двух значений с плавающей запятой
    (функция)
    		возвращает меньшее из заданных значений
    (шаблон функции & алгоритм функциональный объект)
    (C++20)
    		возвращает наименьший элемент в диапазоне
    (шаблон функции & алгоритм функциональный объект)
    (C++20)
    (C++11)
    		 возвращает меньшее и большее из двух элементов
    (шаблон функции & алгоритм функциональный объект)
    (C++20)
    (C++11)
    		 возвращает наименьший и наибольший элементы в диапазоне
    (шаблон функции & алгоритм функциональный объект)
    (C++20)
    Документация по C для fmin