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
Definiert im Header <cmath>
(1)
float fmin ( float x, float y ) ;

double fmin ( double x, double y ) ;

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

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

/*floating-point-type*/ y ) ;
(seit C++23)
float fminf ( float x, float y ) ;
(2) (seit C++11)
(constexpr seit C++23)
long double fminl ( long double x, long double y ) ;
(3) (seit C++11)
(constexpr seit C++23)
SIMD-Überladung (seit C++26)
Definiert im Header <simd>
template < class V0, class V1 >

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

fmin ( const V0 & v_x, const V1 & v_y ) ;
(S) (seit C++26)
Definiert im Header <cmath>
template < class Integer >
double fmin ( Integer x, Integer y ) ;
(A) (constexpr seit C++23)
1-3) Gibt das kleinere der beiden Gleitkomma-Argumente zurück, wobei NaNs als fehlende Daten behandelt werden (zwischen einem NaN und einem numerischen Wert wird der numerische Wert gewählt). Die Bibliothek stellt Überladungen von std::fmin für alle cv-unqualifizierten Gleitkommatypen als Parametertyp bereit. (since C++23)
S) Die SIMD-Überladung führt eine elementweise std::fmin Operation auf v_x und v_y durch.
(Siehe math-common-simd-t für deren Definition.)
(seit C++26)
A) Zusätzliche Überladungen werden für alle Ganzzahltypen bereitgestellt, die als double behandelt werden.
(since C++11)

Inhaltsverzeichnis

Parameter

x, y - Gleitkomma- oder Ganzzahlwerte

Rückgabewert

Bei Erfolg wird der kleinere von zwei Gleitkommawerten zurückgegeben. Der zurückgegebene Wert ist exakt und hängt nicht von Rundungsmodi ab.

Fehlerbehandlung

Diese Funktion unterliegt keinen der in math_errhandling spezifizierten Fehlerbedingungen.

Wenn die Implementierung IEEE-Gleitkommaarithmetik (IEC 60559) unterstützt,

  • Wenn eines der beiden Argumente NaN ist, wird der Wert des anderen Arguments zurückgegeben.
  • Nur wenn beide Argumente NaN sind, wird NaN zurückgegeben.

Hinweise

Diese Funktion muss nicht auf das Vorzeichen von Null reagieren, obwohl einige Implementierungen zusätzlich erzwingen, dass wenn ein Argument + 0 und das andere - 0 ist, dann - 0 zurückgegeben wird.

Die zusätzlichen Überladungen müssen nicht exakt wie (A) bereitgestellt werden. Sie müssen lediglich sicherstellen, dass für ihr erstes Argument num1 und zweites Argument num2 :

  • Falls num1 oder num2 den Typ long double hat, dann hat std :: fmin ( num1, num2 ) denselben Effekt wie std :: fmin ( static_cast < long double > ( num1 ) ,
    static_cast < long double > ( num2 ) )     .
  • Andernfalls, falls num1 und/oder num2 den Typ double oder einen Ganzzahltyp hat, dann hat std :: fmin ( num1, num2 ) denselben Effekt wie std :: fmin ( static_cast < double > ( num1 ) ,
    static_cast < double > ( num2 ) )     .
  • Andernfalls, falls num1 oder num2 den Typ float hat, dann hat std :: fmin ( num1, num2 ) denselben Effekt wie std :: fmin ( static_cast < float > ( num1 ) ,
    static_cast < float > ( num2 ) )     .
(bis C++23)

Falls num1 und num2 arithmetische Typen haben, dann hat std :: fmin ( num1, num2 ) denselben Effekt wie std :: fmin ( static_cast < /*common-floating-point-type*/ > ( num1 ) ,
static_cast < /*common-floating-point-type*/ > ( num2 ) ) , wobei /*common-floating-point-type*/ der Gleitkommatyp mit dem höchsten Gleitkomma-Konvertierungsrang und dem höchsten Gleitkomma-Konvertierungsunterrang zwischen den Typen von num1 und num2 ist; Argumente vom Ganzzahltyp werden als mit demselben Gleitkomma-Konvertierungsrang wie double betrachtet.

Falls kein solcher Gleitkommatyp mit dem höchsten Rang und Unterrang existiert, dann führt die Überladungsauflösung nicht zu einem verwendbaren Kandidaten aus den bereitgestellten Überladungen.

(seit C++23)

Beispiel

Diesen Code ausführen 
#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';
}

Mögliche Ausgabe: 

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

Siehe auch

(C++11)
prüft, ob das erste Gleitkomma-Argument kleiner als das zweite ist
(Funktion)
(C++11) (C++11) (C++11)
größerer von zwei Gleitkommawerten
(Funktion)
gibt den kleineren der gegebenen Werte zurück
(Funktions-Template)
gibt das kleinste Element in einem Bereich zurück
(Funktions-Template)
(C++11)
gibt das kleinere und größere von zwei Elementen zurück
(Funktions-Template)
(C++11)
gibt die kleinsten und größten Elemente in einem Bereich zurück
(Funktions-Template)
C-Dokumentation für fmin