Namespaces
Variants

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

From 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)

Table des matières

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)
plus petite de deux valeurs à virgule flottante
(fonction)
retourne la plus grande des valeurs données
(modèle de fonction)
retourne le plus grand élément dans une plage
(modèle de fonction)
(C++11)
retourne le plus petit et le plus grand de deux éléments
(modèle de fonction)
(C++11)
retourne les plus petits et les plus grands éléments dans une plage
(modèle de fonction)
Documentation C pour fmax