Comment puis-je enregistrer un nombre à virgule flottante dans les 2 octets?

Oui, je suis conscient de la norme IEEE-754 demi-précision norme, et oui je suis conscient du travail accompli dans le domaine. Mettez tout simplement, j'essaie de sauver un simple nombre à virgule flottante (comme 52.1, ou 1.25) en seulement 2 octets.

J'ai essayé certaines implémentations dans Java et dans C# mais ils ruinent la valeur d'entrée par le décodage d'un nombre différent. Vous nourrissez dans 32.1 et après coder-décoder vous obtenez 32.0985.

Est-il possible que je peux stocker des nombres à virgule flottante en seulement 16-bits sans ruiner la valeur d'entrée?

Merci beaucoup.

Binaire floatingpoints ne pouvez pas encoder 32.1
Quel est l'éventail des numéros de avez-vous besoin de coder, et combien de chiffres significatifs ont-ils? Envisager virgule fixe ou flottante points.
Vous pouvez les stocker comme un unsigned short, avec quelques bits utilisés pour l'exponentielle de la partie? Vous pouvez ensuite convertir manuellement de retour de ce format régulier de simple précision float.
Ce CodeInChaos dit mot pour mot...
Qui ne permettent pas de résoudre le problème de la représentation.
Vous devez être plus précis avec votre énoncé du problème. Deux octets peut représenter au plus 65536 différentes valeurs à virgule flottante. Ceux qui sont celles que vous voulez? Pire des cas, vous pouvez avoir un tableau de "la 65536 valeurs à virgule flottante-je me soucier de" et de rendre les deux octets de la valeur d'une recherche.

InformationsquelleAutor Robinicks | 2012-05-02

binary c#floating-point ieee-754 numerical

8

Vous pouvez stocker à trois chiffres en BCD et utiliser le reste de quatre bits pour la position du point décimal:
```
52.1 = 521 * 10 ^ -1 => 0x1521
1.25 = 125 * 10 ^ -2 => 0x2125
```
Ce serait vous donner une gamme de 0.0000000000000001 à 999. Vous pouvez bien sûr ajouter un offset pour le point décimal pour obtenir par exemple la gamme 0.0000000001 à 999000000.

Simple de mise en œuvre de quatre bits utilisés pour le point décimal de placement, et le reste pour la valeur. Sans aucune vérification d'erreur, et de ne pas soigneusement vérifiée. (Peut avoir de la précision des problèmes avec certaines valeurs lors de l'utilisation de != de comparer doubles.)
```
public static short Encode(double value) {
  int cnt = 0;
  while (value != Math.Floor(value)) {
    value *= 10.0;
    cnt++;
  }
  return (short)((cnt << 12) + (int)value);
}

public static double Decode(short value) {
  int cnt = value >> 12;
  double result = value & 0xfff;
  while (cnt > 0) {
    result /= 10.0;
    cnt--;
  }
  return result;
}
```
Exemple:
```
Console.WriteLine(Encode(52.1));
Console.WriteLine(Decode(4617));
```
De sortie:
```
4617
52.1
```
- Vous pouvez insérer 4 chiffres en deux octets, mais vous n'avez alors qu'à deux bits à gauche pour la description d'où le point décimal est. Pour les nombres avec moins de chiffres que vous venez de remplir avec des zéros, c'est à dire 1.5 est le même que 001.5 ou 1.500.
- Pouvez-vous montrer des exemples de flotter binaire de codage/décodage fonctions? Je suis désolé mais je ne comprends pas vraiment ce qui est hapenning.
- J'ai ajouté une mise en œuvre simple ci-dessus.
- Merci très beaucoup, Guffa! Vraiment cool.
- Dépendent de la gamme nécessaire, 3 chiffres peuvent être emballés à 10 bits avec DPD et laisser 6 bits pour l'exposant (et signe - si nécessaire), la gamme sera plus grande que le code ci-dessus, mais bien sûr un peu plus difficile à coder/décoder. Si peu de gamme est nécessaire alors de 14 bits pour la mantisse donnera plus de précision
InformationsquelleAutor Guffa
7

C# n'a pas intégré dans les fonctionnalités, mais vous pouvez essayer un point fixe de l'approche.

Exemple de 8,8 point Fixe (8 avant la virgule, 8 après):
```
float value = 123.45;
ushort fixedIntValue = (ushort)(value * 256);
```
De cette façon, le nombre est stocké comme ceci:
XXXXXXXX XXXXXXXX

et vous pouvez récupérer le flotteur de nouveau l'utilisation de ce:
```
float value = fixedIntValue / 256f;
```
- Qui dispose également d'une précision limitée. 52.1 devient 52.09765625.
- Eh bien, vous ne pouvez pas tout avoir. Si vous en voulez plus, vous pouvez soit essayer de 6,10 point fixe ou 4 octets.
- L'op ne demande pas de tout, juste pour revenir exactement la même valeur. Ce n'est pas du tout déraisonnable, si une gamme limitée est acceptable. Vous avez juste à utiliser une approche différente d'une variable binaire/fixe le nombre de point.
InformationsquelleAutor bytecode77
5

Êtes-vous sûr que vous avez besoin d'une micro-optimisation, plus simplement, à l'aide d'un float ou double?

Vous serait mieux servi par le stockage d'un short et la compréhension que, par exemple, il est divisé par 100 pour faire le nombre réel? (E. g. vos exemples de 52,1 et 1,25 pourrait être stockées en tant que 5210 et 125) je pense que cela pourrait être la meilleure solution pour vous.

Si vous êtes fixés sur l'aide d'un nombre à virgule flottante, vous pouvez prendre le décodé nombre et autour d'elle à x chiffres significatifs, (à partir de votre exemple, 3), qui doit généralement vous obtenir de nouveau le même nombre de départ (notez que oui, c'est intentionnellement vague - vous ne pouvez pas garantir l'obtention de l'original, à moins que vous stockez l'original).

InformationsquelleAutor Tim S.
4

Le problème est que vous ne pouvez pas représenter 32.1 dans tout binaire à virgule flottante type.

En simple précision, le plus proche de la valeur représentable est 32.099998.
Dans la demi-précision, il est apparemment 32.0985.

Vous pourriez envisager un nombre décimal à virgule flottante type, mais cette solution n'est pas unique à la moitié de précision.
- Une demi-valeur de précision utilise 11 bits pour l'significande (le premier bit 1 est implicite). Dans l'intervalle [32,64), 6 de ces bits sont utilisés pour la partie entière, en laissant 5 bits pour la partie fractionnaire. Donc, dans ce domaine, [32,64), le représentable valeurs sont exactement les mulitples de 1/(2**5) = 1/32. Le plus proche de 32.1 sera 32+3/32 (un.k.un. 1027/32) qui est 32.09375. Donc votre "apparemment" n'est pas correct, après tout. Je ne sais pas où le demandeur a son exemple de. Pour une demi-valeur de précision, vous le feriez normalement, sortie seulement 3 chiffres après la virgule, donc "32.1" serait l'habitude de précision.
InformationsquelleAutor Oliver Charlesworth
2

Il y a 4,278,190,080 32 bits à virgule flottante valeurs, non compris les NaNs et infinis. Il y a de 65 536 valeurs de 16 bits sur deux octets. Clairement, il est impossible de bien coder toutes les valeurs à virgule flottante dans deux octets.

Quelles sont celles que vous souhaitez encoder?

Même pour une seule valeur de la signer et de l'exposant (par exemple, toutes les valeurs à virgule flottante de 4 à 8, pas 8), il y a 8,388,608 des valeurs à virgule flottante, de sorte que vous ne pouvez même pas coder dans deux octets.

Vous devez vous limiter à un petit sous-ensemble de valeurs à coder. Une fois que vous avez fait cela, les gens peuvent avoir des suggestions sur la façon de coder. Quel est le problème que vous essayez de résoudre?

InformationsquelleAutor Eric Postpischil
1

De vos exemples que vous souhaitez stocker 3 chiffres et point décimal. Il vous suffit d'encoder votre "alphabet" de 11 des symboles dans un 4 bits de code, et le magasin 4 x 4 bits 2 octets.
- oui, quelque chose comme décimale codée binaire marcherait bien
InformationsquelleAutor High Performance Mark

Vous devez vous connecter pour publier un commentaire.