Namespaces
Variants

std:: fmod, std:: fmodf, std:: fmodl

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

double fmod ( double x, double y ) ;

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

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

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

fmod ( const V0 & v_x, const V1 & v_y ) ;
(S) (seit C++26)
Definiert in Header <cmath>
template < class Integer >
double fmod ( Integer x, Integer y ) ;
(A) (constexpr seit C++23)
1-3) Berechnet den Gleitkomma-Rest der Divisionsoperation x / y . Die Bibliothek stellt Überladungen von std::fmod für alle cv-unqualifizierten Gleitkommatypen als Parametertyp bereit. (since C++23)
S) Die SIMD-Überladung führt eine elementweise std::fmod -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)

Der Gleitkomma-Rest der Divisionsoperation x / y , der von dieser Funktion berechnet wird, ist exakt der Wert x - iquot * y , wobei iquot gleich x / y mit abgeschnittenem Nachkommaanteil ist.

Der zurückgegebene Wert hat dasselbe Vorzeichen wie x und ist im Betrag kleiner als y .

Inhaltsverzeichnis

Parameter

x, y - Gleitkomma- oder Ganzzahlwerte

Rückgabewert

Bei Erfolg gibt es den Gleitkomma-Rest der Division x / y wie oben definiert zurück.

Wenn ein Domänenfehler auftritt, wird ein implementierungsdefinierter Wert zurückgegeben (NaN, sofern unterstützt).

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

Fehlerbehandlung

Fehler werden gemeldet, wie in math_errhandling spezifiziert.

Ein Domänenfehler kann auftreten, wenn y null ist.

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

  • Wenn x ±0 ist und y nicht null ist, wird ±0 zurückgegeben.
  • Wenn x ±∞ ist und y nicht NaN ist, wird NaN zurückgegeben und FE_INVALID ausgelöst.
  • Wenn y ±0 ist und x nicht NaN ist, wird NaN zurückgegeben und FE_INVALID ausgelöst.
  • Wenn y ±∞ ist und x endlich ist, wird x zurückgegeben.
  • Wenn eines der Argumente NaN ist, wird NaN zurückgegeben.

Hinweise

POSIX erfordert dass ein Domänenfehler auftritt, wenn x unendlich ist oder y null ist.

std::fmod , aber nicht std::remainder ist nützlich für das stille Umwandeln von Gleitkommatypen in vorzeichenlose Ganzzahltypen: ( 0.0 <= ( y = std :: fmod ( std:: rint ( x ) , 65536.0 ) ) ? y : 65536.0 + y ) liegt im Bereich [ - 0.0 , 65535.0 ] , was unsigned short entspricht, aber std:: remainder ( std:: rint ( x ) , 65536.0 liegt im Bereich [ - 32767.0 , + 32768.0 ] , was außerhalb des Bereichs von signed short liegt.

Die double -Version von std::fmod verhält sich, als wäre sie wie folgt implementiert: 

double fmod(double x, double y)
{
#pragma STDC FENV_ACCESS ON
    double result = std::remainder(std::fabs(x), y = std::fabs(y));
    if (std::signbit(result))
        result += y;
    return std::copysign(result, x);
}

Der Ausdruck x - std:: trunc ( x / y ) * y entspricht möglicherweise nicht std :: fmod ( x, y ) , wenn die Rundung von x / y zur Initialisierung des Arguments von std::trunc zu viel Präzision verliert (Beispiel: x = 30.508474576271183309 , y = 6.1016949152542370172 ).

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

Falls num1 und num2 arithmetische Typen haben, dann hat std :: fmod ( num1, num2 ) denselben Effekt wie std :: fmod ( 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 Überlagerungsauflösung nicht zu einem verwendbaren Kandidaten aus den bereitgestellten Überlagerungen.

(seit C++23)

Beispiel

Diesen Code ausführen 
#include <cfenv>
#include <cmath>
#include <iostream>
// #pragma STDC FENV_ACCESS ON
int main()
{
    std::cout << "fmod(+5.1, +3.0) = " << std::fmod(5.1, 3) << '\n'
              << "fmod(-5.1, +3.0) = " << std::fmod(-5.1, 3) << '\n'
              << "fmod(+5.1, -3.0) = " << std::fmod(5.1, -3) << '\n'
              << "fmod(-5.1, -3.0) = " << std::fmod(-5.1, -3) << '\n';
    // special values
    std::cout << "fmod(+0.0, 1.0) = " << std::fmod(0, 1) << '\n'
              << "fmod(-0.0, 1.0) = " << std::fmod(-0.0, 1) << '\n'
              << "fmod(5.1, Inf) = " << std::fmod(5.1, INFINITY) << '\n';
    // error handling
    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout << "fmod(+5.1, 0) = " << std::fmod(5.1, 0) << '\n';
    if (std::fetestexcept(FE_INVALID))
        std::cout << "    FE_INVALID raised\n";
}

Mögliche Ausgabe: 

fmod(+5.1, +3.0) = 2.1
fmod(-5.1, +3.0) = -2.1
fmod(+5.1, -3.0) = 2.1
fmod(-5.1, -3.0) = -2.1
fmod(+0.0, 1.0) = 0
fmod(-0.0, 1.0) = -0
fmod(5.1, Inf) = 5.1
fmod(+5.1, 0) = -nan
    FE_INVALID raised

Siehe auch

(C++11)
berechnet Quotient und Rest der ganzzahligen Division
(Funktion)
(C++11) (C++11) (C++11)
vorzeichenbehafteter Rest der Divisionsoperation
(Funktion)
(C++11) (C++11) (C++11)
vorzeichenbehafteter Rest sowie die drei letzten Bits der Divisionsoperation
(Funktion)
C-Dokumentation für fmod