Math.Pow vs mehrfach Operator (Performance)

StackOverflow https://stackoverflow.com/questions/936541

  •  06-09-2019
  •  | 
  •  

Frage

weiß jemand, wenn mehrfach Operator ist schneller als die Math.Pow Methode? Wie: 

n * n * n

vs 

Math.Pow ( n, 3 )
War es hilfreich?

Lösung

Grundsätzlich sollten Sie Benchmark sehen.

Gebildete Rätselraten (unzuverlässige):

Falls es ist nicht dasselbe ist von einigen Compiler optimiert ...

Es ist sehr wahrscheinlich, dass x * x * x ist schneller als Math.Pow(x, 3) als Math.Pow hat mit dem Problem in seinem allgemeinen Fall zu behandeln, mit gebrochenen Potenzen und anderen Fragen beschäftigen, während x * x * x würde nur nehmen ein paar Multiplizierbefehle, so dass es sehr wahrscheinlich ist, schneller zu sein .

Andere Tipps

Ich habe gerade Windows neu installiert, so Visual Studio nicht installiert ist und der Code ist hässlich 

using System;
using System.Diagnostics;

public static class test{

public static void Main(string[] args){
    MyTest();
    PowTest();
}

static void PowTest(){
    var sw = Stopwatch.StartNew();
    double res = 0;
    for (int i = 0; i < 333333333; i++){
        res = Math.Pow(i,30); //pow(i,30)
    }
    Console.WriteLine("Math.Pow: " + sw.ElapsedMilliseconds + " ms:  " + res);
}

static void MyTest(){
    var sw = Stopwatch.StartNew();
    double res = 0;
    for (int i = 0; i < 333333333; i++){
        res = MyPow(i,30);
    }
    Console.WriteLine("MyPow: " + sw.ElapsedMilliseconds + " ms:  " + res);
}



static double MyPow(double num, int exp)
{
    double result = 1.0;
    while (exp > 0)
    {
        if (exp % 2 == 1)
            result *= num;
        exp >>= 1;
        num *= num;
    }

    return result;
}
}

Die Ergebnisse:
csc / o Test.cs

test.exe 

MyPow: 6224 ms:  4.8569351667866E+255  
Math.Pow: 43350 ms:  4.8569351667866E+255

Binäre Exponentiation (siehe

Ein paar Faustregeln von 10+ Jahren der Optimierung in der Bildverarbeitung und die wissenschaftliche Rechnen:

Optimierungen bei einer algorithmischen Ebene schlugen jede Menge Optimierung auf einem niedrigen Niveau. Trotz der konventionellen Weisheit „Schreiben Sie die Hand, dann optimieren“ dies muss zu Beginn erfolgen. Nicht nach.

Hand codierte mathematische Operationen (insbesondere SIMD SSE + Typen) wird im Allgemeinen übertrifft die voll Fehler checked, eingebaut diejenigen verallgemeinern.

Jede Operation, wo der Compiler vorher weiß, was durch den Compiler optimiert sind getan werden muss. Diese schließen ein: 1. Speicheroperationen wie Array.Copy () 2. Für Schleifen über Arrays, wo die Arraylänge gegeben ist. Wie in für (..; i<array.Length;..)

Immer unrealistische Ziele gesetzt (wenn Sie wollen).

Ich war zufällig gerade diese gestern getestet haben, dann jetzt sah Ihre Frage.

Auf meinem Rechner ein Core 2 Duo läuft 1 Test Thread, es schneller ist mehrfach zu verwenden, bis zu einem Faktor von 9. Bei 10 Math.Pow (b, e) ist schneller.

Doch selbst bei einem Faktor von 2, sind die Ergebnisse oft nicht identisch. Es gibt Rundungsfehler.

Einige Algorithmen sind sehr empfindlich Fehler Rundung. Ich musste buchstäblich über eine Million gelegentliche Tests laufen, bis ich diese entdeckt.

Ich habe, und Math.Pow() definiert zwei Doppelzimmer zu nehmen. Das bedeutet, dass es nicht wiederholt Multiplikationen tun können, aber hat einen allgemeineren Ansatz zu verwenden. Wenn es eine Math.Pow(double, int) war, könnte es wahrscheinlich effizienter sein.

Davon abgesehen, ist der Unterschied in der Leistung an Sicherheit grenzender Wahrscheinlichkeit absolut trivial, und so sollten Sie je nachdem, was klarer ist. Micro-Optimierungen wie diese sind fast immer sinnlos, kann praktisch jederzeit eingeführt werden und sollen für das Ende des Entwicklungsprozesses bleiben. An diesem Punkt können Sie überprüfen, ob die Software zu langsam ist, wo die Hot Spots ist, und verbringen Sie Ihre Mikro-Optimierung Anstrengungen, wo es tatsächlich einen Unterschied machen.

Das ist so, Mikro, dass Sie sollten es wahrscheinlich Benchmark für bestimmte Plattformen, ich glaube nicht, dass die Ergebnisse für einen Pentium Pro notwendig als für einen ARM oder Pentium II die gleiche sein wird.

Alles in allem ist es sehr wahrscheinlich völlig irrelevant sein.

Ich bin nicht einverstanden, dass handbuilt Funktionen sind immer schneller. Die Kosinus-Funktionen sind viel schneller und genauer als alles, was ich schreiben konnte. Wie für pow (). Ich habe einen schnellen Test, um zu sehen, wie langsam Math.pow () war in Javascript, weil Mehrdad gegen Mutmaßungen verwarnt 

    for (i3 = 0; i3 < 50000; ++i3) { 
      for(n=0; n < 9000;n++){ 
        x=x*Math.cos(i3);
      }
    }

Hier sind die Ergebnisse: 

Each function run 50000 times 

time for 50000 Math.cos(i) calls = 8 ms 
time for 50000 Math.pow(Math.cos(i),9000) calls = 21 ms 
time for 50000 Math.pow(Math.cos(i),9000000) calls = 16 ms 
time for 50000 homemade for loop calls 1065 ms

Wenn Sie nicht einverstanden sind, das Programm versuchen, unter http: //www.m0ose. com / Javascripts / Geschwindigkeitstests / powSpeedTest.html

Math.Pow(x, y) wird in der Regel intern als Math.Exp(Math.Log(x) * y) berechnet. Evey Leistungsgleichung erfordert einen natürlichen Logarithmus zu finden, eine Multiplikation und Erhöhung e zu einer Macht.

Wie ich in meiner vorherigen Antwort erwähnt, nur bei einer Leistung von 10 tut schneller Math.Pow() werden, aber der Genauigkeit wird bei Verwendung einer Reihe von Multiplikationen beeinträchtigt werden.

Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top