Fonction ABS intégrale rapide

int X = a-b;
int d = Math.Abs(X);

Je suis assez sûr que .NET ne fait pas l'in-lining. Alors, vais-je faire si(), ou est-il quelques autres moins connus truc?

source d'informationauteur Daniel Mošmondor

  1. 15

    L'équipe effectue inline dans certaines circonstances. Je ne sais pas si il inlines Math.Abs ou pas... mais avez-vous vérifié que c'est en fait un problème de performance pour vous? N'avez pas de micro-optimiser jusqu'à ce que vous savez que vous en avez besoin, et ensuite mesurer le gain de performance à partir de quelque chose comme:

    int d = X > 0 ? X : -X;

    pour vérifier qu'il vaut vraiment le coup.

    Comme indiqué par Anthony, le ci-dessus ne sont pas (normalement) travaillent pour int.MinValuecomme -int.MinValue == int.MinValuealors que Math.Abs va jeter un OverflowException. Vous pouvez forcer cette dans la ligne droite C# ainsi vérifié à l'aide de l'arithmétique:

    int d = X > 0 ? X : checked(-X);
  2. 17

    J'ai fait quelques tests de performance, pour savoir si vous pouvez réellement gagner du temps à l'aide de quelque chose en dehors de la norme de Mathématiques.Abs.

    Les résultats après l'exécution de l'ensemble de ces 2000000000 fois (avec i de -1000000000 à +1000000000, sans débordements):

    Math.Abs(i)                    5839 ms     Factor 1
i > 0 ? i : -i                 6395 ms     Factor 1.09
(i + (i >> 31)) ^ (i >> 31)    5053 ms     Factor 0.86

    (Ces chiffres varient un peu pour les différentes pistes)

    Fondamentalement, vous pouvez obtenir une très légère amélioration par rapport à Math.Absmais rien de spectaculaire.

    Avec le bit hack vous permet de vous raser un peu de temps requis pour les Mathématiques.Abs, mais la lisibilité souffre gravement.

    Avec la simple direction générale, vous pouvez effectivement être plus lent. Globalement ce n'est pas la peine à mon avis.

    Tous les tests où s'exécuter sur un OS 32 bits, Net 4.0, visual studio 2010, mode de Libération, pas de débogueur.

    Voici le code:

    class Program
{
public static int x; //public static field. 
//this way the JITer will not assume that it is  
//never used and optimize the wholeloop away
static void Main()
{
//warm up
for (int i = -1000000000; i < 1000000000; i++)
{
x = Math.Abs(i);
}
//start measuring
Stopwatch watch = Stopwatch.StartNew();
for (int i = -1000000000; i < 1000000000; i++)
{
x = Math.Abs(i);
}
Console.WriteLine(watch.ElapsedMilliseconds);
//warm up
for (int i = -1000000000; i < 1000000000; i++)
{
x = i > 0 ? i : -i;
}
//start measuring
watch = Stopwatch.StartNew();
for (int i = -1000000000; i < 1000000000; i++)
{
x = i > 0 ? i : -i;
}
Console.WriteLine(watch.ElapsedMilliseconds);
//warm up
for (int i = -1000000000; i < 1000000000; i++)
{
x = (i + (i >> 31)) ^ (i >> 31);
}
//start measuring
watch = Stopwatch.StartNew();
for (int i = -1000000000; i < 1000000000; i++)
{
x = (i + (i >> 31)) ^ (i >> 31);
}
Console.WriteLine(watch.ElapsedMilliseconds);
Console.ReadLine();
}
}
  3. 6

    Pour ce que ça vaut, la valeur absolue de 32 bits signé, complément de 2 format int est généralement mis en œuvre comme ceci:

    abs(x) = (x^(x>>31))-(x>>31)

  4. 1

    Je viens de voir si elle est inférieure à zéro et de le multiplier par -1

    int d = (X < 0) ? (-X) : X;
  5. 1

    Voir http://graphics.stanford.edu/~seander/bithacks.html#IntegerAbs pour savoir comment calculer la valeur absolue sans ramification.

    Tandis que .Net prend en charge l'in-lining, je doute que Math.Abs() serait considéré comme un candidat pour un alignement par le compilateur. Voici la mise en œuvre de la int surcharge, avec l'aimable autorisation de Réflecteur.

    public static int Abs(int value)
{
if (value >= 0)
{
return value;
}
return AbsHelper(value);
}
private static int AbsHelper(int value)
{
if (value == -2147483648)
{
throw new OverflowException(Environment.GetResourceString("Overflow_NegateTwosCompNum"));
}
return -value;
}

    Les surcharges pour les autres types intégraux sont similaires. Le float et double surcharges sont les appels externes, tandis que la decimal surcharge utilise sa propre mise en œuvre, qui construit une nouvelle instance. Ouch!

  6. 0

    C# ne inline Mathématiques.Abs. Cela fonctionne:

    int x = 12;
int y = 17;
int z = Math.Abs(x - y);
Console.WriteLine(z); //outputs 5