resueltos - Operación de módulo de punto flotante

representacion punto flotante ieee 754

Question

Estoy tratando de implementar la operación de reducción de rango para la trigonometría. Pero en cambio, creo que podría ser mejor simplemente realizar una operación de módulo pi / 2 en los datos entrantes. Me preguntaba qué algoritmos existen y son eficientes para esta operación para el punto flotante IEEE 754 de 32 bits.

Tengo que implementar esto en ensamblado, por lo que no tengo disponible un solo comando, división, multiplicación, etc. Mi procesador usa palabras de 16 bits y he implementado la suma, resta, multiplicación, división, raíz cuadrada, coseno y seno de punto flotante de 32 bits. Solo necesito reducción de rango (módulo) para ingresar valores al coseno y al seno.

Answer 1

El algoritmo que desea, para limitar un value punto flotante entre 0 y algún módulo n :

Double fmod(Double value, Double modulus)
{
    return value - Trunc(value/modulus)*modulus;
}

por ejemplo pi mod e (3.14159265358979 mod 2.718281828459045)

3.14159265358979 / 2.718281828459045 
   = 1.1557273497909217179

Trunc(1.1557273497909217179)
   = 1

1.1557273497909217179 - 1
   = 0.1557273497909217179

0.1557273497909217179 * e
   = 0.1557273497909217179 * 2.718281828459045
   = 0.42331082513074800

pi mod e = 0.42331082513074800

Answer 2

Tal vez me esté perdiendo el punto aquí, pero ¿tienes algo en contra simplemente de usar fmod ?

double theta = 10.4;
const double HALF_PI = 2 * atan(1);
double result = fmod(theta, HALF_PI);

Answer 3

Creo que fmod() la biblioteca estándar será la mejor opción en la mayoría de los casos. Aquí hay un link a una discusión de varios algoritmos simples.

En mi máquina, fmod() utiliza un código de ensamblaje en línea optimizado ( /usr/include/bits/mathinline.h ):

#if defined __FAST_MATH__ && !__GNUC_PREREQ (3, 5)
__inline_mathcodeNP2 (fmod, __x, __y, /
  register long double __value;                           /
  __asm __volatile__                                  /
    ("1:    fprem/n/t"                            /
     "fnstsw    %%ax/n/t"                             /
     "sahf/n/t"                                   /
     "jp    1b"                               /
     : "=t" (__value) : "0" (__x), "u" (__y) : "ax", "cc");           /
  return __value)
#endif

Así que en realidad usa una instrucción de CPU dedicada (fprem) para el cálculo.