Math.pow vs operador multiplicar (rendimiento)

Question

Cualquier persona sabe si el operador se multiplican es más rápido que utilizando el método Math.pow? Como:

n * n * n

vs

Math.Pow ( n, 3 )

Answer 1

Básicamente, usted debe referencia para ver.

Educado conjeturas (no fiable):

En caso de que no se optimiza a lo mismo por algún compilador ...

Es muy probable que x * x * x es más rápido que Math.Pow(x, 3) como Math.Pow tiene que lidiar con el problema en su caso general, se trata de potencias fraccionarias y otros temas, mientras que x * x * x acaba de tomar un par de instrucciones se multiplican, así que es muy probable que sea más rápido .

Answer 2

I acaba de instalar ventanas de estudio de manera visual no está instalado y el código es feo

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

Los resultados: Read csc / o test.cs

test.exe

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

exponenciación binaria (ver https://stackoverflow.com/questions/101439/the-most-efficient-way-to-implement-an-integer-based-power-function-powint-int ) es mucho más rápido que el de matemáticas. Pow en mi prueba (mi CPU es un Pentium T3200 a 2 GHz)

EDIT:. NET versión 3.5 SP1 está, el sistema operativo es Vista SP1 y plan de energía es alto rendimiento

Answer 3

Algunas reglas de oro de 10 años de optimización en el procesamiento de imágenes y la computación científica:

Las optimizaciones a nivel algorítmico superan cualquier cantidad de optimización en un nivel bajo. A pesar de la "Escribir lo obvio, luego optimizar" la sabiduría convencional esto debe hacerse al inicio. No después.

codificado a mano las operaciones matemáticas (especialmente SIMD SSE + tipos) generalmente superar el error totalmente verificados, generalizar los incorporadas.

Cualquier operación en la que el compilador sabe de antemano lo que hay que hacer son optimizados por el compilador. Éstos incluyen: 1. Las operaciones de memoria tales como Array.Copy () 2. Para bucles más de matrices donde se indica la longitud de la matriz. Como en para (..; i<array.Length;..)

Siempre ponga metas poco realistas (si quieres).

Answer 4

Me acaba de pasar a haber probado esto ayer, luego vio a su pregunta ahora.

En mi máquina, un Core 2 Duo corriendo 1 hilo de prueba, es más rápido de usar multiplican hasta un factor de 9. En 10, Math.pow (b, e) es más rápido.

Sin embargo, incluso en un factor de 2, los resultados a menudo no son idénticos. Hay errores de redondeo.

Algunos algoritmos son muy sensibles a los errores de redondeo. Tuve que correr, literalmente, más de un millón de pruebas aleatorias hasta que descubrí esto.

Answer 5

he comprobado, y Math.Pow() se define a tomar dos dobles. Esto significa que no puede hacer multiplicaciones repetidas, pero tiene que utilizar un enfoque más general. Si hubiera un Math.Pow(double, int), podría probablemente ser más eficiente.

Una vez dicho esto, la diferencia de rendimiento es casi seguro que absolutamente trivial, y lo que debe utilizar el que sea más clara. Micro-optimizaciones de este tipo son casi siempre inútil, puede ser introducido prácticamente en cualquier momento, y deben dejarse para el final del proceso de desarrollo. En ese punto, se puede comprobar si el software es demasiado lento, donde están los puntos calientes, y pasa su esfuerzo micro-optimización donde se hará realmente una diferencia.

Answer 6

Esto es tan micro que probablemente debería referencia para plataformas específicas, no creo que los resultados para un Pentium Pro serán necesariamente los mismos que para un brazo o Pentium II.

Con todo, es más probable que sea totalmente irrelevante.

Answer 7

Vamos a usar la convención x ^ n. Vamos a suponer que n es siempre un número entero.

Para valores pequeños de n, aburrido multiplicación será más rápido, porque Math.pow (probable, dependiente de la implementación) utiliza algoritmos de lujo para permitir n sea no integral y / o negativo.

Para grandes valores de n, Math.pow es probable que haya más rápido, pero si su biblioteca no es muy inteligente que va a utilizar el mismo algoritmo, que no es ideal si usted sabe que n es siempre un número entero. Para que usted podría codificar hasta una implementación de href="http://en.wikipedia.org/wiki/Exponentiation_by_squaring" elevando al cuadrado o algún otro algoritmo de fantasía.

Por supuesto los ordenadores modernos son muy rápidos y probablemente debe pegarse a la más simple, más fácil de leer, y mucho menos probable que sea el método con errores hasta que punto de referencia de su programa y está seguro de que obtendrá una aceleración significativa mediante el uso de un algoritmo diferente.

Answer 8

No estoy de acuerdo que las funciones handbuilt son siempre más rápido. Las funciones coseno son la forma más rápida y precisa que cualquier cosa que podría escribir. En cuanto a pow (). Hice una prueba rápida para ver lo lento Math.pow () era en javascript, porque Mehrdad advirtió contra las conjeturas

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

aquí están los resultados:

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

Si no está de acuerdo probar el programa en http: //www.m0ose. com / javascript / speedtests / powSpeedTest.html

Answer 9

Math.Pow(x, y) se calcula típicamente internamente como Math.Exp(Math.Log(x) * y). ecuación de poder evey requiere la búsqueda de un logaritmo natural, una multiplicación, y elevar a una potencia e.

Como ya he mencionado en mi respuesta anterior, sólo que a una potencia de 10 Math.Pow() hace ser más rápido, pero la precisión se verá comprometida si se utiliza una serie de multiplicaciones.