La façon la plus rapide pour la fixation d'un réel (fixe et virgule flottante) de la valeur?

Pour la 16.16 représentation, le simple ternaire est peu susceptible d'être amélioré en termes de vitesse.

Et pour les doubles, parce que vous en avez besoin standard/C portable, peu-manipulation de tout type finira mal.

Même si un peu de violon était possible (ce dont je doute), vous pourriez être en s'appuyant sur la représentation binaire de doubles. CE (et leur taille) EST DÉPENDANT de l'IMPLÉMENTATION.

Vous pourriez "deviner" ce en utilisant sizeof(double), puis en comparant la mise en page de divers double des valeurs à leurs représentations binaires, mais je pense que vous êtes sur une cachette pour rien.

La meilleure règle est de DIRE AU COMPILATEUR CE que VOUS VOULEZ (c'est à dire ternaire), et il l'optimiser pour vous.

EDIT: tarte Humble temps. Je viens de tester quinmars idée (ci-dessous), et il fonctionne - si vous avez IEEE-754 flotteurs. Cela a donné un gain d'environ 20% sur le code ci-dessous. IObviously non-portable, mais je pense qu'il y a peut-être une façon standardisée de demander à votre compilateur, s'il utilise des float IEEE754 formats avec un #IF...?

  double FMIN = 3.13;
  double FMAX = 300.44;

  double FVAL[10] = { -100, 0.23, 1.24, 3.00, 3.5, 30.5, 50 ,100.22 ,200.22, 30000};
  uint64  Lfmin = *(uint64 *)&FMIN;
  uint64  Lfmax = *(uint64 *)&FMAX;

    DWORD start = GetTickCount();

    for (int j=0; j<10000000; ++j)
    {
        uint64 * pfvalue = (uint64 *)&FVAL[0];
        for (int i=0; i<10; ++i)
            *pfvalue++ = (*pfvalue < Lfmin) ? Lfmin : (*pfvalue > Lfmax) ? Lfmax : *pfvalue;
    }

    volatile DWORD hacktime = GetTickCount() - start;

    for (int j=0; j<10000000; ++j)
    {
        double * pfvalue = &FVAL[0];
        for (int i=0; i<10; ++i)
            *pfvalue++ = (*pfvalue < FMIN) ? FMIN : (*pfvalue > FMAX) ? FMAX : *pfvalue;
    }

    volatile DWORD normaltime = GetTickCount() - (start + hacktime);

GCC et clang générer beau montage pour la suivante, simple, simple, portable code:

double clamp(double d, double min, double max) {
  const double t = d < min ? min : d;
  return t > max ? max : t;
}

> gcc -O3 -march=native -Wall -Wextra -Wc++-compat -S -fverbose-asm clamp_ternary_operator.c

GCC-assembly généré:

maxsd   %xmm0, %xmm1    # d, min
movapd  %xmm2, %xmm0    # max, max
minsd   %xmm1, %xmm0    # min, max
ret

> clang -O3 -march=native -Wall -Wextra -Wc++-compat -S -fverbose-asm clamp_ternary_operator.c

Bruit généré par l'assemblée:

maxsd   %xmm0, %xmm1
minsd   %xmm1, %xmm2
movaps  %xmm2, %xmm0
ret

Trois instructions (sans compter le ret), pas de branches. Excellent.

Cela a été testé avec GCC 4.7 et clang 3.2 sur Ubuntu 13.04 avec un Core i3 M 350.
Sur une note côté, le simple code C++ appel std::min et std::max généré de la même assemblée.

C'est pour les doubles. Et pour les int, GCC et clang générer de l'assemblée avec cinq instructions (sans compter le ret) et pas de branches. Aussi excellent.

Je ne suis pas actuellement l'utilisation de la virgule fixe, donc je ne vais pas donner un avis sur un point fixe.

Opérateur ternaire est vraiment la voie à suivre, parce que la plupart des compilateurs sont capables de les compiler en natif le fonctionnement matériel qui utilise un conditionnel déplacer au lieu d'une branche (et évite donc le mispredict peine et du pipeline de bulles et ainsi de suite). De manipulation de bits est susceptible de causer une charge-hit-magasin.

En particulier, PPC et x86 avec SSE2 matériel op qui pourrait être exprimée comme une valeur intrinsèque de quelque chose comme ceci:

double fsel( double a, double b, double c ) {
  return a >= 0 ? b : c; 
}

L'avantage est qu'il n'est présent à l'intérieur de la canalisation, sans provoquer une branche. En fait, si votre compilateur utilise la valeur intrinsèque, vous pouvez l'utiliser pour mettre en œuvre votre pince directement:

inline double clamp ( double a, double min, double max ) 
{
   a = fsel( a - min , a, min );
   return fsel( a - max, max, a );
}

Je vous suggère fortement de éviter de manipulation de bits en double en utilisant les opérations sur entiers. Sur la plupart des Processeurs modernes il n'y a aucun moyen direct de déplacement de données entre le double et int registres autres que de prendre un aller-retour à la dcache. Ce sera la cause d'une des données de danger appelé une charge-hit-store qui, en gros, vide le PROCESSEUR pipeline jusqu'à ce que la mémoire d'écriture est terminée (généralement autour de 40 cycles ou plus).

La seule exception est si le double des valeurs sont déjà en mémoire et non pas dans un registre: dans ce cas, il n'y a aucun danger d'une charge-hit-store. Toutefois, votre exemple indique que vous avez juste calculé le double et l'a retourné à partir d'une fonction qui signifie qu'il est probablement encore en XMM1.

Plutôt que de tester et de branchement, j'ai l'habitude d'utiliser ce format pour le serrage:

clampedA = fmin(fmax(a,MY_MIN),MY_MAX);

Bien que je n'ai jamais fait aucune analyse de la performance sur le code compilé.

Ici est peut-être plus rapidement la mise en œuvre similaire à @Roddy réponse:

typedef int64_t i_t;
typedef double  f_t;

static inline
i_t i_tmin(i_t x, i_t y) {
  return (y + ((x - y) & -(x < y))); //min(x, y)
}

static inline
i_t i_tmax(i_t x, i_t y) {
  return (x - ((x - y) & -(x < y))); //max(x, y)
}

f_t clip_f_t(f_t f, f_t fmin, f_t fmax)
{
#ifndef TERNARY
  assert(sizeof(i_t) == sizeof(f_t));
  //assert(not (fmin < 0 and (f < 0 or is_negative_zero(f))));
  //XXX assume IEEE-754 compliant system (lexicographically ordered floats)
  //XXX break strict-aliasing rules
  const i_t imin = *(i_t*)&fmin;
  const i_t imax = *(i_t*)&fmax;
  const i_t i    = *(i_t*)&f;
  const i_t iclipped = i_tmin(imax, i_tmax(i, imin));

#ifndef INT_TERNARY
  return *(f_t *)&iclipped;
#else /* INT_TERNARY */
  return i < imin ? fmin : (i > imax ? fmax : f); 
#endif /* INT_TERNARY */

#else /* TERNARY */
  return fmin > f ? fmin : (fmax < f ? fmax : f);
#endif /* TERNARY */
}

Voir Calculer le minimum (min) et maximum (max) de deux entiers sans ramification et La comparaison des nombres à virgule flottante

L'IEEE float et double de supports de
conçu de sorte que les nombres sont
“lexicographiquement ordonné”, qui –
dans les mots de l'architecte William IEEE
Kahan signifie “si deux virgule flottante
les numéros dans le même format sont commandés
( par exemple x < y ), alors qu'ils sont commandés
de la même manière lors de leurs morceaux sont
réinterprété comme Signe de Magnitude
les nombres entiers.”

Un programme de test:

/** gcc -std=c99 -fno-strict-aliasing -O2 -lm -Wall *.c -o clip_double && clip_double */
#include <assert.h> 
#include <iso646.h>  //not, and
#include <math.h>    //isnan()
#include <stdbool.h> //bool
#include <stdint.h>  //int64_t
#include <stdio.h>
static 
bool is_negative_zero(f_t x) 
{
return x == 0 and 1/x < 0;
}
static inline 
f_t range(f_t low, f_t f, f_t hi) 
{
return fmax(low, fmin(f, hi));
}
static const f_t END = 0./0.;
#define TOSTR(f, fmin, fmax, ff) ((f) == (fmin) ? "min" :       \
((f) == (fmax) ? "max" :      \
(is_negative_zero(ff) ? "-0.":   \
((f) == (ff) ? "f" : #f))))
static int test(f_t p[], f_t fmin, f_t fmax, f_t (*fun)(f_t, f_t, f_t)) 
{
assert(isnan(END));
int failed_count = 0;
for ( ; ; ++p) {
const f_t clipped  = fun(*p, fmin, fmax), expected = range(fmin, *p, fmax);
if(clipped != expected and not (isnan(clipped) and isnan(expected))) {
failed_count++;
fprintf(stderr, "error: got: %s, expected: %s\t(min=%g, max=%g, f=%g)\n", 
TOSTR(clipped,  fmin, fmax, *p), 
TOSTR(expected, fmin, fmax, *p), fmin, fmax, *p);
}
if (isnan(*p))
break;
}
return failed_count;
}  
int main(void)
{
int failed_count = 0;
f_t arr[] = { -0., -1./0., 0., 1./0., 1., -1., 2, 
2.1, -2.1, -0.1, END};
f_t minmax[][2] = { -1, 1,  //min, max
0, 2, };
for (int i = 0; i < (sizeof(minmax) / sizeof(*minmax)); ++i) 
failed_count += test(arr, minmax[i][0], minmax[i][1], clip_f_t);      
return failed_count & 0xFF;
}

Dans la console:

$ gcc -std=c99 -fno-strict-aliasing -O2 -lm *.c -o clip_double && ./clip_double 

Il imprime:

error: got: min, expected: -0.  (min=-1, max=1, f=0)
error: got: f, expected: min    (min=-1, max=1, f=-1.#INF)
error: got: f, expected: min    (min=-1, max=1, f=-2.1)
error: got: min, expected: f    (min=-1, max=1, f=-0.1)

Si je comprends bien, vous voulez limiter la valeur de "a" à une fourchette entre MY_MIN et MY_MAX. Le type de "a" est un double. Vous n'avez pas spécifié le type de MY_MIN ou MY_MAX.

La simple expression:

clampedA = (a > MY_MAX)? MY_MAX : (a < MY_MIN)? MY_MIN : a;

devrait faire l'affaire.

Je pense qu'il y a peut-être une petite optimisation si MY_MAX et MY_MIN arriver à être des entiers:

int b = (int)a;
clampedA = (b > MY_MAX)? (double)MY_MAX : (b < MY_MIN)? (double)MY_MIN : a;

En changeant entier comparaisons, il est possible que vous pourriez obtenir un léger avantage en termes de vitesse.

Comme l'a souligné ci-dessus, fmin/fmax fonctions fonctionnent bien (dans gcc, avec -ffast-math). Bien que gfortran a des modèles à utiliser IA instructions correspondant à max/min, g++ ne prend pas. Dans la cpi on doit utiliser au lieu de std::min/max, parce que la cpi n'autorise pas à court de la coupe de la spécification de la façon dont fmin/fmax travailler avec des non-finis opérandes.