0
votes

Comment créer un flotteur avec la valeur après la rencontre de Mantissa?

Utilisation de C ou C ++ Quel est le moyen le plus rapide de créer un flotteur d'un entier où l'entier est après la mantisse?

Par exemple, je voudrais créer le flotteur 0.12345F à partir de 12345.

Une manière lente qui a fonctionné pour moi était de créer une chaîne de l'entier et de passer à Atof. Cependant, il doit y avoir beaucoup de moyens plus rapides de le résoudre au moyen d'un débit?

1 commentaires

Assigner l'int à un flotteur; Continuez à diviser de 10 jusqu'à ce que vous obteniez une valeur <1.

3 Réponses :

1
votes

L'opération réelle que vous essayez de faire est X / 10 ^ D où X est votre numéro et D est le nombre de chiffres de x. Cela rend un peu plus facile. Tout ce que vous avez à faire est de compter les chiffres.

Il existe de nombreuses façons de compter les chiffres. La voie Naieve serait p> xxx pré>

mais si vous voulez vite .... p>

Si vos numéros sont des entiers 32 bits, vous pouvez utiliser ce truc de BIT Twiddling Hacks P>

static const char LogTable256[256] = 
{
#define LT(n) n, n, n, n, n, n, n, n, n, n, n, n, n, n, n, n
    -1, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
    LT(4), LT(5), LT(5), LT(6), LT(6), LT(6), LT(6),
    LT(7), LT(7), LT(7), LT(7), LT(7), LT(7), LT(7), LT(7)
};

unsigned int v; // 32-bit word to find the log of
unsigned r;     // r will be lg(v)
register unsigned int t, tt; // temporaries

if (tt = v >> 16)
{
  r = (t = tt >> 8) ? 24 + LogTable256[t] : 16 + LogTable256[tt];
}
else 
{
  r = (t = v >> 8) ? 8 + LogTable256[t] : LogTable256[v];
}

0 commentaires

0
votes

Eh bien, vous pouvez simplement utiliser une boucle:

int ival = 12345;
float fval = ival;
while (fabs(fval) >= 1) fval /= 10;

0 commentaires

0
votes

Ce sera un peu plus rapide que la "Division de 10 jusqu'à ce que le nombre soit mis à l'échelle" des solutions, car la multiplication est plus rapide que la division. Mais la principale raison que j'utiliserais, c'est parce qu'elle est plus précise: la division de 10 perd de précision sur chaque division, alors que la multiplication de 10 ne le fait pas (jusqu'à ce que vous le fassiez 23 fois, ce qui est bien plus que vous n'avez besoin de gérer un entier long). Donc, seule la dernière division ici est imprécise: xxx

0 commentaires