¿Cuál es la mejor opción para dividir un número entero por 2?

¿Cuál de las siguientes técnicas es la mejor opción para dividir un número entero entre 2 y por qué?

Técnica 1:

x = x >> 1;

Técnica 2:

x = x / 2;

Aquí xhay un número entero.

Use la operación que mejor describa lo que está tratando de hacer.

• Si está tratando el número como una secuencia de bits, use el desplazamiento de bits.
• Si lo trata como un valor numérico, use la división.

Tenga en cuenta que no son exactamente equivalentes. Pueden dar diferentes resultados para enteros negativos. Por ejemplo:

-5 / 2  = -2
-5 >> 1 = -3

(ideona)

¿El primero parece dividir? No. Si quieres dividir, úsalo x / 2. El compilador puede optimizarlo para usar bit-shift si es posible (se llama reducción de fuerza), lo que lo convierte en una microoptimización inútil si lo hace por su cuenta.

Para agregar: hay muchas razones para favorecer el uso. x = x / 2; Aquí hay algunas:

• expresa su intención más claramente (suponiendo que no esté tratando con bits de registro de giro de bits o algo así)

• el compilador reducirá esto a una operación de turno de todos modos

• incluso si el compilador no lo redujo y eligió una operación más lenta que el cambio, la probabilidad de que esto termine afectando el rendimiento de su programa de una manera mensurable es en sí misma muy pequeña (y si lo afecta de manera medible, entonces tiene un valor real razón para usar un turno)

• Si la división va a ser parte de una expresión más grande, es más probable que obtenga la prioridad correcta si usa el operador de división:

  x = x / 2 + 5;
  x = x >> 1 + 5;  // not the same as above

• la aritmética firmada podría complicar las cosas aún más que el problema de precedencia mencionado anteriormente

• para reiterar: el compilador ya lo hará por usted de todos modos. De hecho, convertirá la división por una constante en una serie de cambios, sumas y multiplicaciones para todo tipo de números, no solo potencias de dos. Vea esta pregunta para obtener enlaces a más información sobre esto.

En resumen, no compra nada codificando un turno cuando realmente quiere multiplicar o dividir, excepto tal vez una mayor posibilidad de introducir un error. Ha pasado toda una vida desde que los compiladores no eran lo suficientemente inteligentes como para optimizar este tipo de cosas a un cambio cuando era apropiado.

¿Cuál es la mejor opción y por qué dividir el número entero por 2?

Depende de lo que entiendas por mejor .

Si quieres que tus colegas te odien, o que tu código sea difícil de leer, definitivamente elegiría la primera opción.

Si quieres dividir un número entre 2, ve con el segundo.

Los dos no son equivalentes, no se comportan igual si el número es negativo o dentro de expresiones más grandes: el desplazamiento de bits tiene menor prioridad que +o -, la división tiene mayor prioridad.

Debe escribir su código para expresar cuál es su intención. Si le preocupa el rendimiento, no se preocupe, el optimizador hace un buen trabajo en este tipo de micro optimizaciones.

Simplemente use divide ( /), suponiendo que sea más claro. El compilador se optimizará en consecuencia.

Estoy de acuerdo con otras respuestas que debe favorecer x / 2porque su intención es más clara y el compilador debe optimizarlo para usted.

Sin embargo, otra razón para preferir x / 2más x >> 1es que el comportamiento de >>depende de la implementación, si xes firmado, inty es negativo.

De la sección 6.5.7, viñeta 5 del estándar ISO C99:

El resultado de E1 >> E2es posiciones de bit E1desplazadas a la derecha E2. Si E1tiene un tipo sin signo o si E1tiene un tipo con signo y un valor no negativo, el valor del resultado es la parte integral del cociente de E1/ 2 ^E2. Si E1tiene un tipo con signo y un valor negativo, el valor resultante está definido por la implementación.

x / 2es más claro y x >> 1no es mucho más rápido (según un micro-benchmark, aproximadamente un 30% más rápido para una JVM de Java). Como otros han señalado, para los números negativos, el redondeo es ligeramente diferente, por lo que debe tener esto en cuenta cuando desee procesar números negativos. Algunos compiladores pueden convertir automáticamente x / 2a x >> 1si conocen el número no puede ser negativo (incluso pensó que no podía verificar esto).

Incluso x / 2puede no usar la instrucción de CPU de división (lenta), porque algunos atajos son posibles , pero aún es más lento que x >> 1.

(Esta es una C / C ++ cuestión, otros lenguajes de programación tienen más operadores. Para Java también es el desplazamiento sin signo de la derecha, x >>> 1que es de nuevo diferente. Permite calcular correctamente el valor medio (promedio) de dos valores, por lo que (a + b) >>> 1la voluntad devuelve el valor medio incluso para valores muy grandes de ay b. Esto es necesario, por ejemplo, para la búsqueda binaria si los índices de la matriz pueden ser muy grandes. Hubo un error en muchas versiones de la búsqueda binaria , porque solían (a + b) / 2calcular el promedio. no funciona correctamente. La solución correcta es usar (a + b) >>> 1en su lugar.)

Knuth dijo:

La optimización prematura es la fuente de todos los males.

Entonces sugiero usar x /= 2;

De esta manera, el código es fácil de entender y también creo que la optimización de esta operación en esa forma, no significa una gran diferencia para el procesador.

Echa un vistazo a la salida del compilador para ayudarte a decidir.
Ejecuté esta prueba en x86-64 con gcc (GCC) 4.2.1 20070719 [FreeBSD]

También vea las salidas del compilador en línea en godbolt .

Lo que ve es que el compilador utiliza una sarlinstrucción (aritmética de desplazamiento a la derecha) en ambos casos, por lo que reconoce la similitud entre las dos expresiones. Si usa la división, el compilador también necesita ajustar los números negativos. Para hacerlo, desplaza el bit de signo hacia abajo al bit de orden más bajo y lo agrega al resultado. Esto soluciona el problema de uno por uno al cambiar los números negativos, en comparación con lo que haría una división.
Dado que el caso de división hace 2 turnos, mientras que el caso de cambio explícito solo hace uno, ahora podemos explicar algunas de las diferencias de rendimiento medidas por otras respuestas aquí.

Código C con salida de ensamblaje:

Para dividir, su entrada sería

int div2signed(int a) {
  return a / 2;
}

y esto compila a

    movl    %edi, %eax
    shrl    $31, %eax
    addl    %edi, %eax
    sarl    %eax
    ret

de manera similar para turno

int shr2signed(int a) {
  return a >> 1;
}

con salida:

    sarl    %edi
    movl    %edi, %eax
    ret

Solo una nota adicional:

x * = 0.5 a menudo será más rápido en algunos lenguajes basados ​​en VM, especialmente actionscript, ya que la variable no tendrá que verificarse para dividir por 0.

Use x = x / 2; O x /= 2;Porque es posible que un nuevo programador trabaje en él en el futuro. Entonces será más fácil para él descubrir qué está pasando en la línea de código. Es posible que todos no estén al tanto de tales optimizaciones.

Lo digo con el propósito de programar competencias. Generalmente tienen entradas muy grandes donde la división por 2 tiene lugar muchas veces y se sabe que la entrada es positiva o negativa.

x >> 1 será mejor que x / 2. Revisé ideone.com ejecutando un programa donde se llevaron a cabo más de 10 ^ 10 divisiones por 2 operaciones. x / 2 tomó casi 5.5s mientras que x >> 1 tomó casi 2.6s para el mismo programa.

Yo diría que hay varias cosas a considerar.

1. Bitshift debería ser más rápido, ya que realmente no se necesita un cálculo especial para cambiar los bits, sin embargo, como se señaló, existen posibles problemas con los números negativos. Si tiene la seguridad de tener números positivos y está buscando velocidad, le recomendaría bitshift.

2. El operador de división es muy fácil de leer para los humanos. Entonces, si está buscando legibilidad de código, podría usar esto. Tenga en cuenta que el campo de la optimización del compilador ha recorrido un largo camino, por lo que hacer que el código sea fácil de leer y comprender es una buena práctica.

3. Dependiendo del hardware subyacente, las operaciones pueden tener diferentes velocidades. La ley de Amdal es hacer que el caso común sea rápido. Por lo tanto, puede tener hardware que puede realizar diferentes operaciones más rápido que otros. Por ejemplo, multiplicar por 0.5 puede ser más rápido que dividir por 2. (De acuerdo, es posible que deba tomar el piso de la multiplicación si desea forzar la división de enteros).

Si buscas un rendimiento puro, recomendaría crear algunas pruebas que podrían hacer las operaciones millones de veces. Pruebe la ejecución varias veces (su tamaño de muestra) para determinar cuál es estadísticamente mejor con su sistema operativo / hardware / compilador / código.

En lo que respecta a la CPU, las operaciones de desplazamiento de bits son más rápidas que las operaciones de división. Sin embargo, el compilador lo sabe y se optimizará adecuadamente en la medida de lo posible, para que pueda codificar de la manera que tenga más sentido y estar tranquilo sabiendo que su código se ejecuta de manera eficiente. Pero recuerde que una unsigned intlata (en algunos casos) puede optimizarse mejor que una intpor las razones previamente señaladas. Si no necesita aritmética con signo, no incluya el bit de signo.

x = x / 2; es el código adecuado para usar ... pero una operación depende de su propio programa de cómo la salida que desea producir.

Haga sus intenciones más claras ... por ejemplo, si desea dividir, use x / 2 y deje que el compilador lo optimice para cambiar de operador (o cualquier otra cosa).

Los procesadores de hoy no permitirán que estas optimizaciones tengan ningún impacto en el rendimiento de sus programas.

La respuesta a esto dependerá del entorno en el que esté trabajando.

• Si está trabajando en un microcontrolador de 8 bits o nada sin soporte de hardware para la multiplicación, se espera desplazamiento de bits y común, y mientras el compilador es casi seguro que gire x /= 2en x >>= 1la presencia de un símbolo de división elevará más las cejas en ese ambiente de usando un cambio para efectuar una división.
• Si está trabajando en un entorno de rendimiento crítico o en una sección de código, o su código podría compilarse con la optimización del compilador desactivada, x >>= 1con un comentario que explique que su razonamiento probablemente sea mejor solo por claridad de propósito.
• Si no se encuentra en una de las condiciones anteriores, haga que su código sea más legible simplemente usando x /= 2. Es mejor salvar al siguiente programador que mira su código en la doble toma de 10 segundos en su operación de turno que demostrar innecesariamente que sabía que el cambio era más eficiente sin la optimización del compilador.

Todos estos suponen enteros sin signo. El cambio simple probablemente no sea lo que desea para firmar. Además, DanielH plantea un buen punto sobre el uso x *= 0.5de ciertos lenguajes como ActionScript.

mod 2, prueba para = 1. no sé la sintaxis en c. Pero esto puede ser más rápido.

generalmente el desplazamiento a la derecha divide:

q = i >> n; is the same as: q = i / 2**n;

esto a veces se usa para acelerar los programas a costa de la claridad. No creo que debas hacerlo. El compilador es lo suficientemente inteligente como para realizar la aceleración automáticamente. Esto significa que poner un turno no te aporta nada a costa de la claridad .

Echa un vistazo a esta página desde la programación práctica de C ++.

Obviamente, si está escribiendo su código para el próximo tipo que lo lea, busque la claridad de "x / 2".

Sin embargo, si la velocidad es su objetivo, pruébelo en ambos sentidos y cronometra los resultados. Hace unos meses trabajé en una rutina de convolución de mapa de bits que consistía en recorrer una serie de enteros y dividir cada elemento entre 2. Hice todo tipo de cosas para optimizarlo, incluido el viejo truco de sustituir "x >> 1" por "x / 2 ".

Cuando realmente cronometré en ambos sentidos, descubrí para mi sorpresa que x / 2 era más rápido que x >> 1

Esto estaba usando Microsoft VS2008 C ++ con las optimizaciones predeterminadas activadas.

En términos de rendimiento. Las operaciones de cambio de la CPU son significativamente más rápidas que los códigos de operación divididos. Entonces, dividir entre dos o multiplicar por 2, etc., se beneficia de las operaciones de turno.

En cuanto a la apariencia. Como ingenieros, ¿cuándo nos apegamos tanto a los cosméticos que incluso las mujeres hermosas no usan! :)

X / Y es el correcto ... y el operador de desplazamiento ">>" ... si queremos que dos dividan un entero, podemos usar el operador de dividendo (/). El operador shift se usa para cambiar los bits.

x = x / 2; x / = 2; podemos usar así ...

Si bien x >> 1 es más rápido que x / 2, el uso adecuado de >> cuando se trata de valores negativos es un poco más complicado. Requiere algo similar a lo siguiente:

// Extension Method
public static class Global {
    public static int ShiftDivBy2(this int x) {
        return (x < 0 ? x + 1 : x) >> 1;
    }
}