Namespaces
Variants

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

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

double remainder ( double x, double y ) ;

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

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

/*floating-point-type*/ 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 in 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 Header <cmath>
template < class Integer >
double remainder ( Integer x, Integer y ) ;
(A) (constexpr seit C++23)
1-3) Berechnet den IEEE-Rest der Gleitkomma-Divisionsoperation x / y . Die Bibliothek stellt Überladungen von std::remainder für alle cv-unqualifizierten Gleitkommatypen als Parametertyp bereit. (since C++23)
S) Die SIMD-Überladung führt eine elementweise std::remainder -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 IEEE-Gleitkomma-Rest der Divisionsoperation x / y , berechnet durch diese Funktion, ist exakt der Wert x - quo * y , wobei der Wert quo der nächstgelegene ganzzahlige Wert zum exakten Wert x / y ist. Wenn |quo - x / y| = ½ , wird der Wert quo als gerade gewählt.

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

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

Inhaltsverzeichnis

Parameter

x, y - Gleitkomma- oder Ganzzahlwerte

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 implementierungsdefinierter Wert zurückgegeben (NaN, sofern 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.

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,

  • Der aktuelle Rundungsmodus hat keine Auswirkung.
  • FE_INEXACT wird niemals ausgelöst, das Ergebnis ist stets exakt.
  • 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 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 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 :: remainder ( num1, num2 ) denselben Effekt wie std :: remainder ( 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 :: remainder ( num1, num2 ) denselben Effekt wie std :: remainder ( static_cast < double > ( num1 ) ,
    static_cast < double > ( num2 ) )     .
  • Andernfalls, falls num1 oder num2 den Typ float hat, dann hat std :: remainder ( num1, num2 ) denselben Effekt wie std :: remainder ( static_cast < float > ( num1 ) ,
    static_cast < float > ( num2 ) )     .
(bis C++23)

Falls num1 und num2 arithmetische Typen haben, dann hat std :: remainder ( num1, num2 ) denselben Effekt wie std :: remainder ( 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 <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

Siehe auch

(C++11)
berechnet Quotient und Rest der Ganzzahldivision
(Funktion)
(C++11) (C++11)
Rest der Gleitkomma-Divisionsoperation
(Funktion)
(C++11) (C++11) (C++11)
vorzeichenbehafteter Rest sowie die drei letzten Bits der Divisionsoperation
(Funktion)
C-Dokumentation für remainder