remquo, remquof, remquol

Parameter

Rückgabewert

Bei Erfolg gibt es den Gleitkomma-Rest der Division x / y zurück, wie in remainder definiert, und speichert in * quo das Vorzeichen und mindestens drei der niederwertigsten Bits von x / y (formal: speichert einen Wert, dessen Vorzeichen dem Vorzeichen von x / y entspricht und dessen Betrag kongruent modulo 2 n
zum Betrag des ganzzahligen Quotienten von x / y ist, wobei n eine implementierungsdefinierte Ganzzahl größer oder gleich 3 ist).

Wenn y null ist, ist der in * quo gespeicherte Wert nicht spezifiziert.

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 Subnormale unterstützt werden.

Wenn y null ist, aber kein Domänenfehler auftritt, wird null zurückgegeben.

Fehlerbehandlung

Fehler werden gemeldet, wie in math_errhandling festgelegt.

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
• 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 entweder x oder y NaN ist, wird NaN zurückgegeben

Hinweise

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

Diese Funktion ist nützlich bei der Implementierung periodischer Funktionen mit einer exakt als Fließkommawert darstellbaren Periode: bei der Berechnung von sin(πx) für ein sehr großes x kann der direkte Aufruf von sin zu einem großen Fehler führen, aber wenn das Funktionsargument zuerst mit remquo reduziert wird, können die niederwertigen Bits des Quotienten verwendet werden, um das Vorzeichen und die Oktante des Ergebnisses innerhalb der Periode zu bestimmen, während der Rest zur Berechnung des Werts mit hoher Genauigkeit verwendet werden kann.

Auf einigen Plattformen wird dieser Vorgang durch Hardware unterstützt (und zum Beispiel auf Intel-CPUs FPREM1 belässt genau 3 Bits Genauigkeit im Quotienten).

Beispiel

#include <fenv.h>
#include <math.h>
#include <stdio.h>
#ifndef __GNUC__
#pragma STDC FENV_ACCESS ON
#endif
double cos_pi_x_naive(double x)
{
    const double pi = acos(-1);
    return cos(pi * x);
}
// the period is 2, values are (0;0.5) positive, (0.5;1.5) negative, (1.5,2) positive
double cos_pi_x_smart(double x)
{
    const double pi = acos(-1);
    int extremum;
    double rem = remquo(x, 1, &extremum);
    extremum = (unsigned)extremum % 2; // keep 1 bit to determine nearest extremum
    return extremum ? -cos(pi * rem) : cos(pi * rem);
}
int main(void)
{
    printf("cos(pi * 0.25) = %f\n", cos_pi_x_naive(0.25));
    printf("cos(pi * 1.25) = %f\n", cos_pi_x_naive(1.25));
    printf("cos(pi * 1000000000000.25) = %f\n", cos_pi_x_naive(1000000000000.25));
    printf("cos(pi * 1000000000001.25) = %f\n", cos_pi_x_naive(1000000000001.25));
    printf("cos(pi * 1000000000000.25) = %f\n", cos_pi_x_smart(1000000000000.25));
    printf("cos(pi * 1000000000001.25) = %f\n", cos_pi_x_smart(1000000000001.25));
    // error handling
    feclearexcept(FE_ALL_EXCEPT);
    int quo;
    printf("remquo(+Inf, 1) = %.1f\n", remquo(INFINITY, 1, &quo));
    if (fetestexcept(FE_INVALID))
        puts("    FE_INVALID raised");
}

cos(pi * 0.25) = 0.707107
cos(pi * 1.25) = -0.707107
cos(pi * 1000000000000.25) = 0.707123
cos(pi * 1000000000001.25) = -0.707117
cos(pi * 1000000000000.25) = 0.707107
cos(pi * 1000000000001.25) = -0.707107 
remquo(+Inf, 1) = -nan
    FE_INVALID raised

Referenzen

Siehe auch