Namespaces
Variants

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

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

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