Namespaces
Variants

std:: fdim, std:: fdimf, std:: fdiml

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 in Header <cmath>
(1)
float fdim ( float x, float y ) ;

double fdim ( double x, double y ) ;

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

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

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

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

fdim ( const V0 & v_x, const V1 & v_y ) ;
(S) (seit C++26)
Definiert in Header <cmath>
template < class Integer >
double fdim ( Integer x, Integer y ) ;
(A) (constexpr seit C++23)
1-3) Gibt die positive Differenz zwischen x und y zurück, das heißt, wenn x > y , wird x - y zurückgegeben, andernfalls (d.h. wenn x <= y ) wird + 0 zurückgegeben. Die Bibliothek stellt Überladungen von std::fdim für alle cv-unqualifizierten Gleitkommatypen als Parametertyp bereit. (since C++23)
S) Die SIMD-Überladung führt eine elementweise std::fdim auf v_x und v_y aus.
(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 die positive Differenz zwischen x und y zurückgegeben.

Wenn ein Bereichsfehler aufgrund von Überlauf auftritt, +HUGE_VAL , +HUGE_VALF , oder +HUGE_VALL wird zurückgegeben.

Wenn ein Bereichsfehler aufgrund von Unterlauf auftritt, wird der korrekte Wert (nach Rundung) zurückgegeben.

Fehlerbehandlung

Fehler werden gemeldet, wie in math_errhandling spezifiziert.

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

  • Wenn eines der Argumente NaN ist, wird NaN zurückgegeben.

Hinweise

Entspricht std:: fmax ( x - y, 0 ) , abgesehen von den NaN-Behandlungsanforderungen.

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 :: fdim ( num1, num2 ) denselben Effekt wie std :: fdim ( 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 :: fdim ( num1, num2 ) denselben Effekt wie std :: fdim ( static_cast < double > ( num1 ) ,
    static_cast < double > ( num2 ) )     .
  • Andernfalls, falls num1 oder num2 den Typ float hat, dann hat std :: fdim ( num1, num2 ) denselben Effekt wie std :: fdim ( static_cast < float > ( num1 ) ,
    static_cast < float > ( num2 ) )     .
(bis C++23)

Falls num1 und num2 arithmetische Typen haben, dann hat std :: fdim ( num1, num2 ) denselben Effekt wie std :: fdim ( 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 <cerrno>
#include <cfenv>
#include <cmath>
#include <cstring>
#include <iostream>
#ifndef __GNUC__
#pragma STDC FENV_ACCESS ON
#endif
int main()
{
    std::cout << "fdim(4, 1) = " << std::fdim(4, 1) << '\n'
              << "fdim(1, 4) = " << std::fdim(1, 4) << '\n'
              << "fdim(4,-1) = " << std::fdim(4, -1) << '\n'
              << "fdim(1,-4) = " << std::fdim(1, -4) << '\n';
    // Fehlerbehandlung
    errno = 0;
    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout << "fdim(1e308, -1e308) = " << std::fdim(1e308, -1e308) << '\n';
    if (errno == ERANGE)
        std::cout << "    errno == ERANGE: " << std::strerror(errno) << '\n';
    if (std::fetestexcept(FE_OVERFLOW))
        std::cout << "    FE_OVERFLOW ausgelöst\n";
}

Ausgabe: 

fdim(4, 1) = 3
fdim(1, 4) = 0
fdim(4,-1) = 5
fdim(1,-4) = 5
fdim(1e308, -1e308) = inf
    errno == ERANGE: Numerical result out of range
    FE_OVERFLOW raised

Siehe auch

(C++11)
berechnet den absoluten Wert eines ganzzahligen Wertes ( |x| )
(Funktion)
(C++11) (C++11) (C++11)
größerer von zwei Gleitkommawerten
(Funktion)
C-Dokumentation für fdim