Namespaces
Variants

    std:: fmax, std:: fmaxf, std:: fmaxl

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

    double fmax ( double x, double y ) ;

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

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

    /*floating-point-type*/ y ) ;
    		(depuis C++23)
    float fmaxf ( float x, float y ) ;
    		(2) (depuis C++11)
    (constexpr depuis C++23)
    long double fmaxl ( 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 >

    fmax ( const V0 & v_x, const V1 & v_y ) ;
    		(S) (depuis C++26)
    Défini dans l'en-tête <cmath>
    template < class Integer >
    double fmax ( Integer x, Integer y ) ;
    		(A) (constexpr depuis C++23)
    1-3) Retourne le plus grand de deux arguments à virgule flottante, en traitant les NaN 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::fmax 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::fmax é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 grande 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 :: fmax ( num1, num2 ) a le même effet que std :: fmax ( 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 :: fmax ( num1, num2 ) a le même effet que std :: fmax ( static_cast < double > ( num1 ) ,
      static_cast < double > ( num2 ) )       .
    • Sinon, si num1 ou num2 a le type float , alors std :: fmax ( num1, num2 ) a le même effet que std :: fmax ( static_cast < float > ( num1 ) ,
      static_cast < float > ( num2 ) )       .
    		(jusqu'en C++23)

    Si num1 et num2 ont des types arithmétiques, alors std :: fmax ( num1, num2 ) a le même effet que std :: fmax ( 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 produit aucun candidat utilisable parmi les surcharges fournies.

    		(depuis C++23)

    Exemple

    Exécuter ce code 
    #include <cmath>
#include <iostream>
int main()
{
    std::cout << "fmax(2,1)    = " << std::fmax(2, 1) << '\n'
              << "fmax(-Inf,0) = " << std::fmax(-INFINITY, 0) << '\n'
              << "fmax(NaN,-1) = " << std::fmax(NAN, -1) << '\n';
}

    Sortie : 

    fmax(2,1)    = 2
fmax(-Inf,0) = 0
fmax(NaN,-1) = -1

    Voir aussi

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