Math.pow vs operatore di moltiplicazione (performance)

Question

Qualcuno sa se l'operatore si moltiplicano è più veloce utilizzando il metodo Math.pow? Come:

n * n * n

vs

Math.Pow ( n, 3 )

Answer 1

In sostanza, si dovrebbe punto di riferimento per vedere.

congetture (inaffidabile):

Nel caso in cui non è ottimizzato per la stessa cosa da qualche compilatore ...

E 'molto probabile che x * x * x è più veloce di Math.Pow(x, 3) come Math.Pow deve affrontare il problema nel suo caso generale, si tratta di potenze frazionarie e di altre questioni, mentre x * x * x sarebbe solo prendere un paio di istruzioni si moltiplicano, quindi è molto probabile che sia più veloce .

Answer 2

I finestre appena reinstallato in studio in modo visivo non è installato e il codice è brutto

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;
}
}

I risultati:
csc / o Test.cs

test.exe

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

Elevamento elevando al quadrato (vedi https://stackoverflow.com/questions/101439/the-most-efficient-way-to-implement-an-integer-based-power-function-powint-int ) è molto più veloce di matematica. Pow nel mio test (il mio CPU è un Pentium T3200 a 2 GHz)

EDIT:. Versione di .NET è 3.5 SP1, sistema operativo è Vista SP1 e il risparmio di energia è alto rendimento

Answer 3

Alcune regole di pollice da 10 anni di ottimizzazione di elaborazione delle immagini e il calcolo scientifico:

Le ottimizzazioni a livello algoritmico battere qualsiasi quantità di ottimizzazione a un livello basso. Nonostante la "Scrivere l'ovvio, quindi ottimizzare" saggezza convenzionale questo deve essere fatto all'inizio. Non dopo.

codificati a mano le operazioni matematiche (soprattutto SIMD SSE + tipi) generalmente sovraperformare il completamente di errore spuntate, generalizzata quelli insiti.

Qualsiasi operazione in cui il compilatore sa in anticipo che cosa deve essere fatto sono ottimizzati dal compilatore. Questi includono: 1. Le operazioni di memoria, come Array.Copy () 2. Per cicli più matrici in cui viene dato la lunghezza della matrice. Come in for (..; i<array.Length;..)

Impostare sempre obiettivi irrealistici (se si desidera).

Answer 4

Mi è capitato di aver testato questo ieri, poi ha visto la tua domanda ora.

Sulla mia macchina, un Core 2 Duo 1 filo di prova, è più veloce da usare si moltiplicano fino a un fattore di 9. A 10, Math.pow (b, e) è più veloce.

Tuttavia, anche ad un fattore 2, i risultati non sono spesso identici. Ci sono errori di arrotondamento.

Alcuni algoritmi sono molto sensibili a errori di arrotondamento. Ho dovuto correre letteralmente oltre un milione di test casuali fino a quando ho scoperto questo.

Answer 5

Ho controllato, e Math.Pow() definito per prendere due doppie. Ciò significa che non può fare moltiplicazioni ripetute, ma deve utilizzare un approccio più generale. Se ci fosse un Math.Pow(double, int), potrebbe probabilmente essere più efficiente.

Detto questo, la differenza di prestazioni è quasi certamente assolutamente banale, e così si dovrebbe usare a seconda di quale è più chiaro. Micro-ottimizzazioni come questo sono quasi sempre inutile, può essere introdotto in qualsiasi momento, e dovrebbe essere lasciato per la fine del processo di sviluppo. A quel punto, è possibile verificare se il software è troppo lento, in cui i punti caldi sono, e trascorrere il vostro sforzo micro-ottimizzazione in cui sarà effettivamente fare la differenza.

Answer 6

Questo è così micro che probabilmente si dovrebbe punto di riferimento per piattaforme specifiche, non credo che i risultati di un Pentium Pro sarà necessariamente lo stesso di un braccio o Pentium II.

Tutto sommato, è più probabile che sia del tutto irrilevante.

Answer 7

Usiamo la convenzione x ^ n. Supponiamo che n è sempre un numero intero.

Per piccoli valori di n, noioso moltiplicazione sarà più veloce, perché Math.pow (probabilmente, dipende dall'implementazione) utilizza algoritmi di fantasia per consentire n sia non integrale e / o negative.

Per grandi valori di n, Math.pow sarà probabilmente più veloce, ma se la libreria non è molto intelligente userà lo stesso algoritmo, che non è l'ideale se si sa che n è sempre un numero intero. Per questo è possibile codificare fino un'implementazione di elevando al quadrato o qualche altro algoritmo di fantasia.

Naturalmente i computer moderni sono molto veloci e, probabilmente, si dovrebbero usare per il più semplice, più facile da leggere, meno probabilità di essere metodo buggy fino a punto di riferimento il programma e sono certo che si otterrà un aumento di velocità significativo utilizzando un algoritmo diverso.

Answer 8

Non sono d'accordo che le funzioni handbuilt sono sempre più veloci. Le funzioni coseno sono il modo più veloce e più preciso di qualsiasi cosa potrei scrivere. Per quanto riguarda il pow (). Ho fatto un rapido test per vedere come lento Math.pow () era in javascript, perché Mehrdad guardia contro congetture

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

ecco i risultati:

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

Se non sei d'accordo provare il programma a http: //www.m0ose. com / javascript / speedtests / powSpeedTest.html

Answer 9

Math.Pow(x, y) è tipicamente calcolata internamente come Math.Exp(Math.Log(x) * y). equazione potere Evey è necessario trovare un logaritmo naturale, una moltiplicazione, e alzando e a una potenza.

Come ho detto nella mia risposta precedente, solo in caso di una potenza di 10 fa Math.Pow() diventare più veloce, ma la precisione sarà compromessa se si utilizza una serie di moltiplicazioni.