conversion de virgule flottante en point fixe 32 bits en Java

Fixe-nombre de point est une représentation d'un nombre réel à l'aide d'un certain nombre de bits d'un type pour la partie entière, et les bits restants du type pour la partie fractionnaire. Le nombre de bits représentant chaque partie est fixe (d'où le nom, point fixe). Un type entier est généralement utilisé pour stocker des valeurs à point fixe.

Les nombres à virgule fixe sont généralement utilisés dans les systèmes qui n'ont pas de support en virgule flottante, ou qui ont besoin de plus de vitesse que la virgule flottante ne peut fournir. Point fixe les calculs peuvent être effectués à l'aide des instructions entières de la CPU.

Un nombre à point fixe de 32 bits serait stocké dans un type de 32 bits tel que int.

Normalement, chaque bit d'un type entier (non signé dans ce cas) représenterait une valeur entière 2^n comme suit:

 1    0    1    1    0    0    1    0       = 2^7 + 2^5 + 2^4 + 2^1 = 178
2^7  2^6  2^5  2^4  2^3  2^2  2^1  2^0

Mais si le type est utilisé pour stocker une valeur à point fixe, les bits sont interprétés légèrement différemment:

 1    0    1    1    0    0    1    0       = 2^3 + 2^1 + 2^0 + 2^-3 = 11.125
2^3  2^2  2^1  2^0  2^-1 2^-2 2^-3 2^-4

Le nombre de points fixes dans l'exemple ci-dessus est appelé un nombre de points fixes 4.4, depuis il y a 4 bits dans la partie entière et les 4 bits de la partie fractionnaire du nombre. Dans un type 32 bits, la valeur à point fixe serait généralement au format 16.16, mais pourrait également être 24.8, 28.4 ou toute autre combinaison.

La conversion d'une valeur à virgule flottante en une valeur à virgule fixe implique les étapes suivantes:

1. Multipliez le float par 2^(nombre de bits fractionnaires pour le type), par exemple. 2^8 pour 24.8
2. Arrondir le résultat (il suffit d'ajouter 0,5) si nécessaire, et le plancher (ou cast à un type entier) laissant une valeur entière.
3. Attribuez cette valeur au type à point fixe.

Évidemment, vous pouvez perdre une certaine précision dans la partie fractionnaire du nombre. Si la précision de la partie fractionnaire est importante, le choix du format à point fixe peut refléter cela-par exemple. utilisez 16.16 ou 8.24 au lieu de 24.8.

Les valeurs négatives peuvent également être traitées de la même manière si votre numéro à point fixe doit être signé.

Si mon Java était plus fort J'essayerais du code, mais j'écris généralement de telles choses en C, donc je ne tenterai pas une version Java. De plus, la version de stacker me semble bonne, à la petite exception qu'elle n'offre pas la possibilité d'arrondir. Il vous montre même comment effectuer une multiplication (le décalage est important!)

Un exemple très simple pour convertir en point fixe, il montre comment convertir et multiplie PI par2. Le résultat est converti en double pour démontrer que la mantisse n'a pas été perdue lors du calcul avec des entiers.

Vous pouvez développer cela facilement avec les tables de recherche sin() et cos (), etc. Je recommanderais si vous prévoyez d'utiliser un point fixe pour rechercher une bibliothèque de points fixes java.

public class Fix {

    public static final int FIXED_POINT = 16;
    public static final int ONE = 1 << FIXED_POINT;

    public static int mul(int a, int b) {
        return (int) ((long) a * (long) b >> FIXED_POINT);
    }

    public static int toFix( double val ) {
        return (int) (val * ONE);
    }

    public static int intVal( int fix ) {
        return fix >> FIXED_POINT;
    }

    public static double doubleVal( int fix ) {
        return ((double) fix) / ONE;
    }

    public static void main(String[] args) {
        int f1 = toFix( Math.PI );
        int f2 = toFix( 2 );

        int result = mul( f1, f2 );
        System.out.println( "f1:" + f1 + "," + intVal( f1 ) );
        System.out.println( "f2:" + f2 + "," + intVal( f2 ) );
        System.out.println( "r:" + result +"," + intVal( result));
        System.out.println( "double: " + doubleVal( result ));

    }
}

SORTIE

f1:205887,3
f2:131072,2
r:411774,6
double: 6.283172607421875

Un type à point fixe est un type qui a un nombre fixe de lieux décimaux/binaires après le point radix. Ou plus généralement, un type qui peut stocker des multiples de 1 / N pour un entier positif N.

En interne, les nombres à point fixe sont stockés en tant que valeur multipliée par le facteur d'échelle. Par exemple, 123.45 avec un facteur d'échelle de 100 est stocké comme s'il s'agissait de l'entier 12345.

Pour convertir la valeur interne d'un nombre à virgule fixe en virgule flottante, il suffit de diviser par facteur d'échelle. Pour convertir dans l'autre sens, multipliez par le facteur d'échelle et arrondissez à l'entier le plus proche.

La définition du point fixe 32 bits peut varier. L'idée générale du point fixe est que vous avez un certain nombre fixe de bits avant et un autre nombre fixe de bits après le point décimal (ou point binaire). Pour un 32 bits, la division la plus courante est probablement égale (16 avant, 16 après), mais selon le but, il n'y a aucune garantie de cela.

En ce qui concerne la conversion, encore une fois, il est ouvert à une certaine variation-par exemple, si le numéro d'entrée est en dehors de la plage de cible, vous voudrez peut-être faire un certain nombre de choses différentes (par exemple, dans certains cas, wraparound pourrait avoir du sens, mais dans d'autres, la saturation pourrait être préférée).