Namensräume
Varianten
Aktionen

std::remainder, std::remainderf, std::remainderl

Von cppreference.com
< cpp‎ | numeric‎ | math
 
C++
 
Numerik-Bibliothek
 
Allgemeine mathematische Funktionen
Funktionen
Grundlegende Operationen
remainder
(C++11)  
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)(C++11)(C++11)
Exponentialfunktionen
(C++11)
(C++11)

(C++11)
(C++11)
Potenzfunktionen
(C++11)
(C++11)
Trigonometrische und
hyperbolische Funktionen
(C++11)
(C++11)
(C++11)

Fehler- und Gammafunktionen
(C++11)
(C++11)
(C++11)
(C++11)
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       remainder ( float x, float y );

double      remainder ( double x, double y );

long double remainder ( long double x, long double y );
 (bis C++23)
constexpr /*Gleitkommazahl-Typ*/

            remainder ( /*Gleitkomma-Typ*/ x,

                        /* Gleitkommazahl-Typ */ y );
 (seit C++23)
float       remainderf( float x, float y );
 (2) (seit C++11)
(constexpr seit C++23)
long double remainderl( 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>

            remainder ( const V0& v_x, const V1& v_y );
 (S) (seit C++26)
Definiert in der Header-Datei <cmath>
template< class Integer >
double      remainder ( Integer x, Integer y );
 (A) (constexpr seit C++23)
1-3) Berechnet den IEEE-Rest der Gleitkomma-Division x / y. Die Bibliothek stellt Überladungen von std::remainder für alle cv-unqualifizierten Gleitkommatypen als Parametertypen bereit.(seit C++23)
S) Die SIMD-Überladung führt eine elementweise std::remainder auf v_xund v_y durch.
(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 IEEE-Gleitkomma-Rest der Division x / y, der von dieser Funktion berechnet wird, ist exakt der Wert x - quo * y, wobei quo der ganzzahlige Wert ist, der am nächsten am exakten Wert x / y liegt. Wenn |quo - x / y| = ½ ist, wird quo so gewählt, dass er gerade ist.

Im Gegensatz zu std::fmod hat der zurückgegebene Wert nicht garantiert dasselbe Vorzeichen wie x.

Wenn der zurückgegebene Wert Null ist, hat er dasselbe Vorzeichen wie x.

Inhalt

[edit] Parameter

x, y - Gleitkomma- oder Ganzzahlwerte

[edit] Rückgabewert

Bei Erfolg wird der IEEE-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 von Unterlauf auftritt, wird das korrekte Ergebnis zurückgegeben.

Wenn y Null ist, aber kein Domänenfehler auftritt, wird Null 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,

  • Der aktuelle Rundungsmodus hat keinen Einfluss.
  • FE_INEXACT wird nie ausgelöst, das Ergebnis ist immer exakt.
  • 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 eines der Argumente NaN ist, wird NaN zurückgegeben.

[edit] Anmerkungen

POSIX schreibt vor, 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 Überlaufen von Gleitkommatypen zu vorzeichenlosen 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 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, hat std::remainder(num1, num2) denselben Effekt wie std::remainder(static_cast<long double>(num1),
                   static_cast<long double>(num2))    .
  • Andernfalls, wenn num1 und/oder num2 vom Typ double oder einem Ganzzahltyp ist, hat std::remainder(num1, num2) denselben Effekt wie std::remainder(static_cast<double>(num1),
                   static_cast<double>(num2))    .
  • Andernfalls, wenn num1 oder num2 vom Typ float ist, hat std::remainder(num1, num2) denselben Effekt wie std::remainder(static_cast<float>(num1),
                   static_cast<float>(num2))    .
 (bis C++23)

Wenn num1 und num2 arithmetische Typen haben, hat std::remainder(num1, num2) denselben Effekt wie std::remainder(static_cast</*gemeinsamer Gleitkomma-Typ*/>(num1),
               static_cast</*gemeinsamer Gleitkomma-Typ*/>(num2)), wobei /*gemeinsamer Gleitkomma-Typ*/ der Gleitkommatyp mit dem größten Gleitkomma-Konversionsrang und dem größten Gleitkomma-Konversions-Subrang zwischen den Typen von num1 und num2 ist. Argumente vom Ganzzahltyp werden so behandelt, als hätten sie denselben Gleitkomma-Konversionsrang 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 << "remainder(+5.1, +3.0) = " << std::remainder(5.1, 3) << '\n'
              << "remainder(-5.1, +3.0) = " << std::remainder(-5.1, 3) << '\n'
              << "remainder(+5.1, -3.0) = " << std::remainder(5.1, -3) << '\n'
              << "remainder(-5.1, -3.0) = " << std::remainder(-5.1, -3) << '\n';
 
    // special values
    std::cout << "remainder(-0.0, 1.0) = " << std::remainder(-0.0, 1) << '\n'
              << "remainder(5.1, Inf) = " << std::remainder(5.1, INFINITY) << '\n';
 
    // error handling
    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout << "remainder(+5.1, 0) = " << std::remainder(5.1, 0) << '\n';
    if (fetestexcept(FE_INVALID))
        std::cout << "    FE_INVALID raised\n";
}

Mögliche Ausgabe

remainder(+5.1, +3.0) = -0.9
remainder(-5.1, +3.0) = 0.9
remainder(+5.1, -3.0) = -0.9
remainder(-5.1, -3.0) = 0.9
remainder(-0.0, 1.0) = -0
remainder(5.1, Inf) = 5.1
remainder(+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)
 Rest der Gleitkommadivisionsoperation
(Funktion) [bearbeiten]
(C++11)(C++11)(C++11)
 vorzeichenbehafteter Rest sowie die letzten drei Bits der Divisionsoperation
(Funktion) [bearbeiten]
C-Dokumentation für remainder
Abgerufen von "https://cppreference.de/mwiki/index.php?title=cpp/numeric/math/remainder&oldid=180346"