Namespaces
Variants

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

    From fr.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
    Défini dans l'en-tête <cmath>
    (1)
    float fmin ( float x, float y ) ;

    double fmin ( double x, double y ) ;

    long double fmin ( long double x, long double y ) ;
    		(jusqu'à C++23)
    constexpr /*floating-point-type*/

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

    /*floating-point-type*/ y ) ;
    		(depuis C++23)
    float fminf ( float x, float y ) ;
    		(2) (depuis C++11)
    (constexpr depuis C++23)
    long double fminl ( long double x, long double y ) ;
    		(3) (depuis C++11)
    (constexpr depuis C++23)
    Surcharge SIMD (depuis C++26)
    Défini dans l'en-tête <simd>
    template < class V0, class V1 >

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

    fmin ( const V0 & v_x, const V1 & v_y ) ;
    		(S) (depuis C++26)
    Défini dans l'en-tête <cmath>
    template < class Integer >
    double fmin ( Integer x, Integer y ) ;
    		(A) (constexpr depuis C++23)
    1-3) Retourne le plus petit des deux arguments à virgule flottante, en traitant les NaNs comme des données manquantes (entre un NaN et une valeur numérique, la valeur numérique est choisie). La bibliothèque fournit des surcharges de std::fmin pour tous les types à virgule flottante non qualifiés cv comme type des paramètres. (depuis C++23)
    S) La surcharge SIMD effectue un std::fmin élément par élément sur v_x et v_y .
    (Voir math-common-simd-t pour sa définition.)
    		(depuis C++26)
    A) Des surcharges supplémentaires sont fournies pour tous les types entiers, qui sont traités comme double .
    		(depuis C++11)

    Contenu

    Paramètres

    x, y - valeurs à virgule flottante ou entières

    Valeur de retour

    En cas de succès, retourne la plus petite de deux valeurs à virgule flottante. La valeur retournée est exacte et ne dépend d'aucun mode d'arrondi.

    Gestion des erreurs

    Cette fonction n'est soumise à aucune des conditions d'erreur spécifiées dans math_errhandling .

    Si l'implémentation prend en charge l'arithmétique à virgule flottante IEEE (IEC 60559),

    • Si l'un des deux arguments est NaN, la valeur de l'autre argument est retournée.
    • C'est seulement si les deux arguments sont NaN que NaN est retourné.

    Notes

    Cette fonction n'est pas tenue d'être sensible au signe de zéro, bien que certaines implémentations imposent en outre que si un argument est + 0 et l'autre est - 0 , alors - 0 soit retourné.

    Les surcharges supplémentaires ne sont pas tenues d'être fournies exactement comme (A) . Elles doivent seulement être suffisantes pour garantir que pour leur premier argument num1 et second argument num2 :

    • Si num1 ou num2 a le type long double , alors std :: fmin ( num1, num2 ) a le même effet que std :: fmin ( static_cast < long double > ( num1 ) ,
      static_cast < long double > ( num2 ) )       .
    • Sinon, si num1 et/ou num2 a le type double ou un type entier, alors std :: fmin ( num1, num2 ) a le même effet que std :: fmin ( static_cast < double > ( num1 ) ,
      static_cast < double > ( num2 ) )       .
    • Sinon, si num1 ou num2 a le type float , alors std :: fmin ( num1, num2 ) a le même effet que std :: fmin ( static_cast < float > ( num1 ) ,
      static_cast < float > ( num2 ) )       .
    		(jusqu'en C++23)

    Si num1 et num2 ont des types arithmétiques, alors std :: fmin ( num1, num2 ) a le même effet que std :: fmin ( static_cast < /*common-floating-point-type*/ > ( num1 ) ,
    static_cast < /*common-floating-point-type*/ > ( num2 ) )     , où /*common-floating-point-type*/ est le type à virgule flottante ayant le plus grand rang de conversion en virgule flottante et la plus grande sous-catégorie de conversion en virgule flottante entre les types de num1 et num2 , les arguments de type entier sont considérés comme ayant le même rang de conversion en virgule flottante que double .

    Si aucun tel type à virgule flottante avec le plus grand rang et la plus grande sous-catégorie n'existe, alors la résolution de surcharge ne résulte pas en un candidat utilisable parmi les surcharges fournies.

    		(depuis C++23)

    Exemple

    Exécuter ce 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';
}

    Sortie possible : 

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

    Voir aussi

    (C++11)
    		 vérifie si le premier argument à virgule flottante est inférieur au second
    (fonction)
    (C++11)(C++11)(C++11)
    		 plus grand de deux valeurs à virgule flottante
    (fonction)
    		retourne la plus petite des valeurs données
    (modèle de fonction & objet fonction d'algorithme)
    (C++20)
    		retourne le plus petit élément d'une plage
    (modèle de fonction & objet fonction d'algorithme)
    (C++20)
    (C++11)
    		 retourne le plus petit et le plus grand de deux éléments
    (modèle de fonction & objet fonction d'algorithme)
    (C++20)
    (C++11)
    		 retourne les plus petit et plus grand éléments d'une plage
    (modèle de fonction & objet fonction d'algorithme)
    (C++20)
    Documentation C pour fmin