remquo, remquof, remquol

Parámetros

Valor de retorno

Si tiene éxito, retorna el resto en punto flotante de la división x / y como se define en remainder , y almacena, en * quo , el signo y al menos tres de los bits menos significativos de x / y (formalmente, almacena un valor cuyo signo es el signo de x / y y cuya magnitud es congruente módulo 2 n
con la magnitud del cociente integral de x / y , donde n es un entero definido por la implementación mayor o igual a 3 ).

Si y es cero, el valor almacenado en * quo no está especificado.

Si ocurre un error de dominio, se devuelve un valor definido por la implementación (NaN donde esté soportado).

Si ocurre un error de rango debido a desbordamiento inferior, se devuelve el resultado correcto si se admiten subnormales.

Si y es cero, pero no se produce el error de dominio, se devuelve cero.

Manejo de errores

Los errores se reportan como se especifica en math_errhandling .

Puede ocurrir un error de dominio si y es cero.

Si la implementación soporta aritmética de punto flotante IEEE (IEC 60559),

• El modo de redondeo actual rounding mode no tiene efecto.
• FE_INEXACT nunca se activa
• Si x es ±∞ y y no es NaN, se retorna NaN y FE_INVALID se activa
• Si y es ±0 y x no es NaN, se retorna NaN y FE_INVALID se activa
• Si cualquiera x o y es NaN, se retorna NaN

Notas

POSIX requiere que ocurra un error de dominio si x es infinito o y es cero.

Esta función es útil al implementar funciones periódicas con el período exactamente representable como un valor de punto flotante: al calcular sin(πx) para un x muy grande, llamar a sin directamente puede resultar en un gran error, pero si el argumento de la función se reduce primero con remquo , los bits de menor orden del cociente pueden usarse para determinar el signo y el octante del resultado dentro del período, mientras que el resto puede usarse para calcular el valor con alta precisión.

En algunas plataformas esta operación es soportada por hardware (y, por ejemplo, en CPU Intel, FPREM1 deja exactamente 3 bits de precisión en el cociente).

Ejemplo

#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);
}
// el período es 2, los valores son (0;0.5) positivos, (0.5;1.5) negativos, (1.5,2) positivos
double cos_pi_x_smart(double x)
{
    const double pi = acos(-1);
    int extremum;
    double rem = remquo(x, 1, &extremum);
    extremum = (unsigned)extremum % 2; // mantener 1 bit para determinar el extremo más cercano
    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));
    // manejo de errores
    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

Referencias

Véase también