Namensräume
Varianten
Aktionen

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

Von cppreference.com
< cpp‎ | numeric‎ | math
 
C++
 
Numerik-Bibliothek
 
Allgemeine mathematische Funktionen
Rundungsoperationen für Gleitkommazahlen
(C++11)(C++11)(C++11)
(C++11)
(C++11)
(C++11)(C++11)(C++11)
Gleitkomma-Manipulationsfunktionen
(C++11)(C++11)
(C++11)
(C++11)
(C++11)(C++11)
(C++11)
Klassifizierung und Vergleich
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Typen
(C++11)
(C++11)
(C++11)
Makrokonstanten
 
Definiert in der Header-Datei <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 /*Gleitkommazahl-Typ*/

            fmod ( /*Gleitkommazahl-Typ*/ x,

                   /* Gleitkommazahl-Typ */ 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 im 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 der Header-Datei <cmath>
template< class Integer >
double      fmod ( Integer x, Integer y );
 (A) (constexpr seit C++23)
1-3) Berechnet den Gleitkomma-Rest der Divisionoperation x / y. Die Bibliothek stellt Überladungen von std::fmod für alle cv-unqualifizierten Gleitkommatypen als Parametertypen bereit.(seit C++23)
S) Die SIMD-Überladung führt ein elementweises std::fmod auf v_xund v_ydurch.
(Siehe math-common-simd-t für dessen Definition.)
(seit C++26)
A) Zusätzliche Überladungen werden für alle ganzzahligen Typen bereitgestellt, die als double behandelt werden.
 (seit C++11)

Der durch diese Funktion berechnete Gleitkomma-Rest der Divisionoperation x / yist exakt der Wert x - iquot * y, wobei iquot der um seinen gebrochenen Teil gekürzte Wert von x / yist.

Der zurückgegebene Wert hat dasselbe Vorzeichen wie x und ist betragsmäßig kleiner als y.

Inhalt

[edit] Parameter

x, y - Gleitkomma- oder Ganzzahlwerte

[edit] Rückgabewert

Im Erfolgsfall wird der Gleitkomma-Rest der Division x / y wie oben definiert zurückgegeben.

Wenn ein Domänenfehler auftritt, wird ein implementierungsabhängiger Wert zurückgegeben (NaN, wo unterstützt).

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

[edit] Fehlerbehandlung

Fehler werden wie in math_errhandling beschrieben gemeldet.

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

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

  • Wenn x ±0 ist und y nicht null ist, wird ±0 zurückgegeben.
  • Wenn x ±∞ ist und y keine NaN ist, wird NaN zurückgegeben und FE_INVALID ausgelöst.
  • Wenn y ±0 ist und x keine 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.

[edit] Hinweise

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

std::fmod, aber nicht std::remainder ist nützlich, um Gleitkommatypen lautlos auf vorzeichenlose Ganzzahltypen abzubilden: (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 so, 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 das Runden 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) angegeben werden. Sie müssen nur ausreichen, um sicherzustellen, dass für ihr erstes Argument num1 und ihr zweites Argument num2

  • Wenn num1 oder num2 vom Typ long double ist, dann hat std::fmod(num1, num2) denselben Effekt wie std::fmod(static_cast<long double>(num1),
              static_cast<long double>(num2))    .
  • Andernfalls, wenn num1 und/oder num2 vom Typ double oder einem Ganzzahltyp ist, dann hat std::fmod(num1, num2) denselben Effekt wie std::fmod(static_cast<double>(num1),
              static_cast<double>(num2))    .
  • Andernfalls, wenn num1 oder num2 vom Typ float ist, dann hat std::fmod(num1, num2) denselben Effekt wie std::fmod(static_cast<float>(num1),
              static_cast<float>(num2))    .
 (bis C++23)

Wenn num1 und num2 arithmetische Typen haben, dann hat std::fmod(num1, num2) denselben Effekt wie std::fmod(static_cast</*gemeinsamer-Gleitkomma-Typ*/>(num1),
          static_cast</*gemeinsamer-Gleitkomma-Typ*/>(num2)), wobei /*gemeinsamer-Gleitkomma-Typ*/ der Gleitkommatyp mit dem höchsten Gleitkomma-Konvertierungsrang und dem höchsten Gleitkomma-Konvertierungs-Subrang zwischen den Typen von num1 und num2 ist. Argumente vom Ganzzahltyp werden so behandelt, als hätten sie denselben Gleitkomma-Konvertierungsrang wie double.

Wenn kein solcher Gleitkommazahltyp mit dem höchsten Rang und Subrang existiert, dann führt die Überladungsauflösung nicht zu einem nutzbaren Kandidaten aus den bereitgestellten Überladungen.

 (seit C++23)

[edit] Beispiel

Führen Sie diesen Code aus
#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

[edit] Siehe auch

(C++11)
 berechnet Quotient und Rest der ganzzahligen Division
(Funktion) [bearbeiten]
(C++11)(C++11)(C++11)
 Vorzeichenbehafteter Rest der Divisionsoperation
(Funktion) [bearbeiten]
(C++11)(C++11)(C++11)
 vorzeichenbehafteter Rest sowie die letzten drei Bits der Divisionsoperation
(Funktion) [bearbeiten]
C-Dokumentation für fmod
Abgerufen von "https://cppreference.de/mwiki/index.php?title=cpp/numeric/math/fmod&oldid=175785"