Conversion double pour flotter sans compter sur le mode d'arrondi FPU

Question

Quelqu'un at-il à portée de main les extraits de code pour convertir un IEEE 754 double la immédiatement inférieure (resp. Supérieure) float, sans changer ou en supposant quoi que ce soit au sujet de l'arrondissement actuel du FPU mode?

Remarque: cette contrainte implique probablement de ne pas utiliser du tout la FPU. Je m'attends à ce que la façon la plus simple de le faire dans ces conditions soit de lire les bits du double en 64 bits et de travailler avec ça.

Vous pouvez supposer le boutisme de votre choix pour la simplicité, et que la double en question est disponible à travers le champ d de l'union ci-dessous:

union double_bits 
{ 
    long i; 
    double d; 
}; 

Je voudrais essayer de le faire moi-même mais je suis certain J'introduirais des bogues difficiles à remarquer pour les nombres dénormalisés ou négatifs.

Answer 1

Je pense que les travaux suivants, mais je dirai d'abord mes hypothèses :

• nombres à virgule flottante sont stockés au format IEEE-754 sur votre mise en œuvre,
• Aucun débordement,
• Vous avez nextafterf() disponible (cela est spécifié dans C99).

Aussi, très probablement, cette méthode n'est pas très efficace.

#include <stdio.h> 
#include <stdlib.h> 
#include <math.h> 

int main(int argc, char *argv[]) 
{ 
    /* Change to non-zero for superior, otherwise inferior */ 
    int superior = 0; 

    /* double value to convert */ 
    double d = 0.1; 

    float f; 
    double tmp = d; 

    if (argc > 1) 
     d = strtod(argv[1], NULL); 

    /* First, get an approximation of the double value */ 
    f = d; 

    /* Now, convert that back to double */ 
    tmp = f; 

    /* Print the numbers. %a is C99 */ 
    printf("Double: %.20f (%a)\n", d, d); 
    printf("Float: %.20f (%a)\n", f, f); 
    printf("tmp: %.20f (%a)\n", tmp, tmp); 

    if (superior) { 
     /* If we wanted superior, and got a smaller value, 
      get the next value */ 
     if (tmp < d) 
      f = nextafterf(f, INFINITY); 
    } else { 
     if (tmp > d) 
      f = nextafterf(f, -INFINITY); 
    } 
    printf("converted: %.20f (%a)\n", f, f); 

    return 0; 
} 

Sur ma machine, il imprime:

Double: 0.10000000000000000555 (0x1.999999999999ap-4) 
Float: 0.10000000149011611938 (0x1.99999ap-4) 
tmp: 0.10000000149011611938 (0x1.99999ap-4) 
converted: 0.09999999403953552246 (0x1.999998p-4) 

L'idée est que je suis en train de convertir la valeur double à une valeur float — cela pourrait être inférieure ou supérieure à la valeur double en fonction de la mode d'arrondi. Une fois reconverti en double, nous pouvons vérifier s'il est plus petit ou plus grand que la valeur originale. Ensuite, si la valeur du float n'est pas dans la bonne direction, nous regardons le prochain numéro float à partir du nombre converti dans la direction du numéro d'origine.

Answer 2

Pour faire ce travail avec plus de précision que de recombiner mantisse et chèque de bit exposant ceci:

http://www.mathworks.com/matlabcentral/fileexchange/23173

concernant

Answer 3

J'ai posté un code pour le faire ici: https://stackoverflow.com/q/19644895/364818 et copié ci-dessous pour votre commodité.

// d is IEEE double, but double is not natively supported. 
    static float ConvertDoubleToFloat(void* d) 
    { 
     unsigned long long x; 
     float f; // assumed to be IEEE float 
     unsigned long long sign ; 
     unsigned long long exponent; 
     unsigned long long mantissa; 

     memcpy(&x,d,8); 

     // IEEE binary64 format (unsupported) 
     sign  = (x >> 63) & 1; // 1 
     exponent = ((x >> 52) & 0x7FF); // 11 
     mantissa = (x >> 0) & 0x000FFFFFFFFFFFFFULL; // 52 
     exponent -= 1023; 

     // IEEE binary32 format (supported) 
     exponent += 127; // rebase 
     exponent &= 0xFF; 
     mantissa >>= (52-23); // left justify 

     x = mantissa | (exponent << 23) | (sign << 31); 
     memcpy(&f,&x,4); 

     return f; 
    }