Extrait de partie fractionnaire de la double *efficace* en C

Je suis à la recherche de prendre un IEEE double et enlever toute la partie entière de la manière la plus efficace possible.

Je veux

1035 ->0
1045.23->0.23
253e-23=253e-23

Je ne se soucient pas correctement la manipulation de la denormals, infinis, ou de NaNs. Je n'ai pas l'esprit à peu se tourner, car je sais que je suis en train de travailler avec la norme IEEE double, donc, il faut travailler sur des machines.

Sans branches code serait bien préférable.

Ma première pensée est (en pseudo code)

char exp=d.exponent;
(set the last bit of the exponent to 1)
d<<=exp*(exp>0);
(& mask the last 52 bits of d)
(shift d left until the last bit of the exponent is zero, decrementing exp each time)
d.exponent=exp;

Mais le problème est que je ne peux pas penser à un moyen efficace de changement d à gauche jusqu'à ce que le dernier bit de l'exposant est égal à zéro, et en plus il semble qu'il aurait besoin à la sortie de zéro si tous les derniers morceaux n'étaient pas définis. Cela semble être liée à la base 2 logarithme problème.

Aider avec cet algorithme, ou mieux serait très apprécié.

Je devrais sans doute remarque que la raison pour laquelle je veux sans branches code est parce que je le veux efficacement vectoriser.

InformationsquelleAutor Jeremy Salwen | 2011-04-08
  1. 34

    Comment parler de quelque chose de simple?

    double fraction = whole - ((long)whole);

    Ce juste soustrait la partie entière du double de la valeur elle-même, le reste devrait être la fraction de la composante. Il est possible, bien sûr, cela pourrait avoir quelques problèmes de représentation.

    • Pas sûr de savoir comment la vitesse compare, mais vous pouvez également faire un double fraction = ensemble%1;
    • Voir ma réponse. % ne fonctionne pas.
    • vous pouvez faire fmod (% est entier uniquement), et je suis presque sûr que c'est plus lent depuis % implique une division.
    • yup, vous êtes à la fois à droite... :-X
    • Le problème est qu'il ne sera pas nécessairement s'insérer dans un flotteur. Ma limite supérieure. Je suis à la recherche pour traiter deux cas différents, l'un avec les numéros de |x|<2^60, ce qui va travailler pour, mais d'autres 2^60<|x|<2^128. Un long temps ne peut contenir jusqu'à 2^65. Alors peut-être que je vais l'utiliser pour le premier cas, mais j'ai encore besoin de quelque chose d'efficace pour la deuxième.
    • dans ce cas fmod est le chemin à parcourir.
    • Je ne suis pas sûr que c'est un vectorizable appel, mais je vais regarder.
    • En fait, bah, c'est la réponse. Si c'est trop gros pour une longue, j'ai peut détecter et vient de mettre la partie fractionnaire à zéro. Accepté.
    • En effet, toute la valeur que les grosses ne peuvent pas avoir une partie décimale. Mais vous devez utiliser int64_t, pas long. long peut-être seulement 32 bits, auquel cas les valeurs que vous avez besoin de ne pas s'adapter.
    • serait un meilleur choix qu'un cast en entier ici, je pense, au moins pour les Processeurs modernes (x86 avec SSE4 roundpd). La mise en œuvre de cette méthode exige le compilateur afin de rendre le code qui va échouer si le double est en dehors de la plage de représentable valeurs longues. Un aller-retour à partir de la FP en entier et à l'arrière peut être plus lent que l'arrondissement. J'ai essayé les deux versions sur le Godbolt compilateur explorer. floor n'est pas en ligne avec juste -fno-math-errno, malheureusement, j'ai donc utilisé -ffast-math. Si vous ne pouvez pas le faire, et ne pouvez pas assumer SSE4, le casting a l'air bon.
    • Une conversion de double à long a UB pour les valeurs en dehors de la plage de long, de sorte que le compilateur doit être en mesure de l'optimiser en supposant que la valeur est dans la gamme (et donc d'éviter toute conversion de type entier).

    InformationsquelleAutor Mark Elliot
  2. 12

    La mise en œuvre optimale dépend entièrement de l'architecture cible.

    Sur les récents processeurs Intel, ce qui peut être réalisé avec deux instructions: roundsd et subsd, mais qui ne peuvent pas être exprimées dans portable code C.

    Sur certains processeurs, le moyen le plus rapide de le faire est avec les opérations sur entiers sur la représentation à virgule flottante. Début de l'Atome et de nombreux Processeurs ARM viennent à l'esprit.

    Sur d'autres processeurs, le plus rapide c'est de cast en entier et à l'arrière, puis de soustraire, branchement pour protéger les grandes valeurs.

    Si vous allez à la manipulation de beaucoup de valeurs, vous pouvez définir le mode d'arrondi à la ronde-à-zéro, puis ajouter et soustraire +/-2^52 le nombre tronqué en entier, puis soustraire la valeur d'origine pour obtenir la fraction. Si vous n'avez pas SSE4.1, mais ne avoir un moderne type de PROCESSEUR Intel et souhaitez vectoriser, c'est généralement le meilleur que vous pouvez faire. Il n'a de sens que si vous avez beaucoup de valeurs à traiter, cependant, parce que changer le mode d'arrondi est un peu cher.

    Sur d'autres architectures, d'autres implémentations sont optimales. En général, il n'a pas de sens à parler de "l'efficacité" des programmes C; seule l'efficacité d'une mise en œuvre spécifique sur une architecture spécifique.

    • Peut-être que j'aurais dû être plus précis à propos de l'efficacité. Je veux dire efficace portable C99 code qui mettra vectoriser. Dans le sens de la moyenne des carrés des temps d'exécution sur des processeurs pondérée par la popularité de PC de modèle de la propriété.
    • Je me suis trouvé d'ajouter/soustraire 2^52 (avec une bonne copysign) et round à zéro en mode, original et soigné.
    • Ne pouvez pas vous exprimer le désiré de la sémantique avec floor() et la - opérateur? Puis un compilateur de ciblage SSE4 pouvez utiliser roundsd / roundpd pour mettre en œuvre ces sémantique. (Mais je suppose que vous pourriez avoir besoin -fno-math-errno ou peut-être la pleine -ffast-math de le laisser en fait vectoriser floor() à roundpd.)
    InformationsquelleAutor Stephen Canon
  3. 10
    #include <math.h>
double fraction = fmod(d, 1.0);
    • Je suis venu demander parce que c'est pas assez efficace pour mes fins. Évidemment, je pourrais bande NaN, l'infini de la manipulation, et la partie entière de calcul de certains de la mise en œuvre de fmod, mais il a encore plus de ramification dans ce que j'aime.
    • la prochaine fois nous dire que l'information en question.
    • Ah, je vois... comment à propos de la soustraction de la floor? Ne nécessite pas de branchement.
    • C'est un bon point. Le plancher peut être vectorizable. Je vais regarder à cela.
    • pourrait aider.
    • Hmm... Il semble que GCC ne vectoriser il.
    • C'est une instruction SSE4 malheureusement, de sorte que votre PROCESSEUR peut le supporte pas... avez-vous importer smmintrin.h et compiler avec le drapeau de l'ESS?
    • J'ai compilé avec gcc -march=native -mtune=native -ftree-vectorizer-verbose=4 -O3-std=c99 -lm principal.c. Je pense que aucun de mes ordinateurs soutien SSE4, même si on ne l'appui SSE4a. Est-il un moyen de faire quelque chose de similaire sans SSE4?
    • Compiler avec -msse4. Mais si votre PROCESSEUR ne prend pas en charge, alors il ne fonctionnera pas; dans ce cas, vous ne pouvez pas vraiment utiliser SIMD pour vectoriser ce calcul particulier. :\

    InformationsquelleAutor Mehrdad
  4. 7

    Proposition

    La fonction reste calcule le reste, mais pas la partie entière comme modf n':

    #include <math.h>

double fracpart(double input)
{
    return remainder(input, 1.);
}

    C'est le plus efficace (et portable), comme il n'est pas inutile de calculer les valeurs de la tâche (cf. modf, (long), fmod, etc.)

    De référence

    Que Mattew suggéré dans les commentaires, j'ai écrit quelques référence code de comparer cette solution à tous les autres proposés sur cette page.

    Veuillez trouver ci-dessous les mesures de temps de 65536 calculs (compilé avec Clang avec les optimisations désactivé):

    method 1 took 0.002389 seconds (using remainder)
method 2 took 0.000193 seconds (casting to long)
method 3 took 0.000209 seconds (using floor)
method 4 took 0.000257 seconds (using modf)
method 5 took 0.010178 seconds (using fmod)

    De nouveau avec Clang, en utilisant cette fois les -O3 drapeau:

    method 1 took 0.002222 seconds (using remainder)
method 2 took 0.000000 seconds (casting to long)
method 3 took 0.000000 seconds (using floor)
method 4 took 0.000223 seconds (using modf)
method 5 took 0.010131 seconds (using fmod)

    S'avère la solution la plus simple semble donner les meilleurs résultats sur la plupart des plates-formes et les méthodes spécifiques à effectuer cette tâche (fmod, modf, remainder) sont en fait des super lent!

    • Ce ne sera pas un problème puisque le reste() arrondit à la plus proche valeur intégrale? fmod() serait ok si.
    • Je serais intéressé de voir comment cette efficacité se compare à d'autres.
    • excellente question, je suis d'analyse comparative en ce moment 🙂
    • compiled with Clang with optimizations turned off. Vos résultats sont vides de sens. L'optimisation n'a pas d'accélérer le tout par le même pourcentage. Voir ma réponse sur cette question au sujet d'une mission où ils ont eu à optimiser pour -O0.
    • Les résultats sont très similaires avec les optimisations activée (voir édité réponse).
    • 0.000000 seconds. Sonne comme vos performances optimisées à l'écart. Je n'attends que floor ou de la conversion en long vont être très efficace, basé sur le fait qu'ils ne prennent une couple de rapide asm instructions x86 (vs lent FP division), mais ce n'est pas de démontrer quoi que ce soit.
    • Si il y avait un cas pour la fusion des réponses ce serait elle.

    InformationsquelleAutor Mathieu Rodic
  5. 3

    De la bibliothèque Standard de la fonction modf résout ce problème assez facilement.

    #include <math.h>
/*...*/
double somenumber;
double integralPart;
double fractionalPart = modf(somenumber, &integralPart);

    Cela devrait faire ce que vous avez demandé, est portable, et raisonnablement efficace.

    Un sans-papiers détail est de savoir si le deuxième argument peut être NULL et éviter la partie intégrante temporaire, qui serait pourtant souhaitable utilise comme celle que vous avez décrite.

    Malheureusement il coutures de nombreuses implémentations ne supportent pas la valeur NULL pour le deuxième argument, nous allons donc utiliser un temporaire de savoir si ou non vous utilisez cette valeur.

    InformationsquelleAutor user1555418
  6. 3

    Certains de profilage et d'expérimentation à l'aide de C++ dans Visual Studio 2015 indique que la meilleure méthode pour les nombres positifs est:

    double n;
//...
double fractional_part = n - floor(n);

    Il est plus rapide que modf, et, comme il a déjà été mentionné, le reste de la fonction arrondit à l'entier le plus proche, et n'est donc pas de l'utiliser.

    InformationsquelleAutor Graham Asher