remquo, remquof, remquol

Paramètres

Valeur de retour

En cas de succès, retourne le reste en virgule flottante de la division x / y tel que défini dans remainder , et stocke, dans * quo , le signe et au moins trois des bits de poids faible de x / y (formellement, stocke une valeur dont le signe est le signe de x / y et dont la magnitude est congruente modulo 2 n
à la magnitude du quotient intégral de x / y , où n est un entier défini par l'implémentation supérieur ou égal à 3 ).

Si y est nul, la valeur stockée dans * quo n'est pas spécifiée.

Si une erreur de domaine se produit, une valeur définie par l'implémentation est retournée (NaN là où supporté).

Si une erreur de plage se produit en raison d'un dépassement inférieur, le résultat correct est renvoyé si les nombres sous-normaux sont pris en charge.

Si y est nul, mais que l'erreur de domaine ne se produit pas, zéro est retourné.

Gestion des erreurs

Les erreurs sont signalées comme spécifié dans math_errhandling .

Une erreur de domaine peut survenir si y est nul.

Si l'implémentation prend en charge l'arithmétique à virgule flottante IEEE (IEC 60559),

• Le mode d'arrondi actuel n'a aucun effet.
• FE_INEXACT n'est jamais déclenché
• Si x est ±∞ et y n'est pas NaN, NaN est retourné et FE_INVALID est déclenché
• Si y est ±0 et x n'est pas NaN, NaN est retourné et FE_INVALID est déclenché
• Si x ou y est NaN, NaN est retourné

Notes

POSIX exige qu'une erreur de domaine se produise si x est infini ou si y est nul.

Cette fonction est utile lors de l'implémentation de fonctions périodiques avec une période exactement représentable comme valeur à virgule flottante : lors du calcul de sin(πx) pour un x très grand, l'appel direct à sin peut entraîner une erreur importante, mais si l'argument de la fonction est d'abord réduit avec remquo , les bits de poids faible du quotient peuvent être utilisés pour déterminer le signe et l'octant du résultat dans la période, tandis que le reste peut être utilisé pour calculer la valeur avec une haute précision.

Sur certaines plateformes, cette opération est prise en charge par le matériel (et, par exemple, sur un processeur Intel, FPREM1 laisse exactement 3 bits de précision dans le quotient).

Exemple

#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);
}
// la période est 2, les valeurs sont (0;0.5) positives, (0.5;1.5) négatives, (1.5,2) positives
double cos_pi_x_smart(double x)
{
    const double pi = acos(-1);
    int extremum;
    double rem = remquo(x, 1, &extremum);
    extremum = (unsigned)extremum % 2; // garder 1 bit pour déterminer l'extremum le plus proche
    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));
    // gestion des erreurs
    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

Références

Voir aussi