Qual é a melhor opção para dividir um número inteiro por 2?

Qual das seguintes técnicas é a melhor opção para dividir um número inteiro por 2 e por quê?

Técnica 1:

x = x >> 1;

Técnica 2:

x = x / 2;

Aqui xestá um número inteiro.

Use a operação que melhor descreve o que você está tentando fazer.

• Se você estiver tratando o número como uma sequência de bits, use deslocamento de bits.
• Se você o estiver tratando como um valor numérico, use a divisão.

Observe que eles não são exatamente equivalentes. Eles podem fornecer resultados diferentes para números inteiros negativos. Por exemplo:

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

(ideona)

O primeiro parece dividir? Não. Se você deseja dividir, use x / 2. O compilador pode otimizá-lo para usar a troca de bits, se possível (é chamado de redução de força), o que torna uma micro-otimização inútil se você fizer isso por conta própria.

Para empilhar: há muitas razões para favorecer o uso x = x / 2; Aqui estão algumas:

• expressa sua intenção com mais clareza (supondo que você não esteja lidando com bits de registro de twiddling ou algo assim)

• o compilador reduzirá isso para uma operação de turno de qualquer maneira

• mesmo que o compilador não o reduza e escolha uma operação mais lenta que a mudança, a probabilidade de que isso acabe afetando o desempenho do seu programa de uma maneira mensurável é muito pequena (e se isso o afetar de forma mensurável, você terá uma experiência real). razão para usar um turno)

• se a divisão fizer parte de uma expressão maior, é mais provável que você tenha a precedência correta se usar o operador de divisão:

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

• aritmética assinada pode complicar ainda mais o problema de precedência mencionado acima

• para reiterar - o compilador já fará isso por você de qualquer maneira. De fato, ele converterá a divisão por uma constante em uma série de turnos, somas e multiplicações para todos os tipos de números, não apenas para potências de dois. Veja esta pergunta para obter links para mais informações sobre isso.

Em resumo, você não compra nada codificando uma mudança quando realmente pretende multiplicar ou dividir, exceto, talvez, uma maior possibilidade de introduzir um bug. Faz uma vida desde que os compiladores não eram inteligentes o suficiente para otimizar esse tipo de coisa para uma mudança quando apropriado.

Qual é a melhor opção e por que dividir o número inteiro por 2?

Depende do que você quer dizer com melhor .

Se você deseja que seus colegas o odeiem ou dificulte a leitura do código, eu definitivamente aceitaria a primeira opção.

Se você deseja dividir um número por 2, vá com o segundo.

Os dois não são equivalentes, eles não se comportam da mesma forma se o número for negativo ou dentro de expressões maiores - o deslocamento de bits tem precedência menor que +ou -, a divisão tem precedência mais alta.

Você deve escrever seu código para expressar qual é sua intenção. Se o desempenho é sua preocupação, não se preocupe, o otimizador faz um bom trabalho nesse tipo de micro-otimização.

Basta usar o split ( /), presumindo que seja mais claro. O compilador otimizará adequadamente.

Concordo com outras respostas que você deve favorecer x / 2porque sua intenção é mais clara e o compilador deve otimizá-lo para você.

No entanto, outro motivo para preferir o x / 2excesso x >> 1é que o comportamento de >>depende da implementação se xfor assinado inte for negativo.

Na seção 6.5.7, ponto 5 da norma ISO C99:

O resultado E1 >> E2é posições de bits E1deslocadas à direita E2. Se E1tiver um tipo não assinado ou E1um tipo assinado e um valor não negativo, o valor do resultado é parte integrante do quociente de E1/ 2 ^E2. Se E1tiver um tipo assinado e um valor negativo, o valor resultante será definido pela implementação.

x / 2é mais claro e x >> 1não é muito mais rápido (de acordo com uma micro-referência, cerca de 30% mais rápido para uma Java JVM). Como outros observaram, para números negativos o arredondamento é um pouco diferente; portanto, você deve considerar isso quando quiser processar números negativos. Alguns compiladores podem converter automaticamente x / 2para x >> 1se souberem que o número não pode ser negativo (mesmo que eu não pudesse verificar isso).

Even x / 2pode não usar a instrução da CPU de divisão (lenta), porque alguns atalhos são possíveis , mas ainda é mais lento que x >> 1.

(Este é um C / C ++ pergunta, outras linguagens de programação têm mais operadores. Para Java, há também o deslocamento para a direita sem sinal, x >>> 1que é novamente diferente. Ele permite calcular corretamente o valor médio (média) de dois valores, de modo que (a + b) >>> 1a vontade retorne o valor médio mesmo para valores muito grandes de ae bIsso é necessário, por exemplo, para pesquisa binária se os índices da matriz puderem ser muito grandes. Houve um erro em muitas versões da pesquisa binária , porque eles costumavam (a + b) / 2calcular a média. A solução correta é usar em seu (a + b) >>> 1lugar.)

Knuth disse:

Otimização prematura é a raiz de todo o mal.

Então eu sugiro usar x /= 2;

Dessa forma, o código é fácil de entender e também acho que a otimização dessa operação dessa forma, não significa uma grande diferença para o processador.

Dê uma olhada na saída do compilador para ajudá-lo a decidir. Eu executei este teste no x86-64 com o
gcc (GCC) 4.2.1 20070719 [FreeBSD]

Veja também as saídas do compilador online no godbolt .

O que você vê é que o compilador usa uma sarlinstrução (desvio aritmético para a direita) em ambos os casos, portanto reconhece a semelhança entre as duas expressões. Se você usar a divisão, o compilador também precisará ajustar os números negativos. Para fazer isso, ele muda o bit de sinal para o bit de menor ordem e o adiciona ao resultado. Isso corrige a questão de um por um ao mudar números negativos, em comparação com o que uma divisão faria.
Como o caso de divisão faz 2 turnos, enquanto o caso explícito de turno apenas um, podemos agora explicar algumas das diferenças de desempenho medidas por outras respostas aqui.

Código C com saída de montagem:

Para dividir, sua entrada seria

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

e isso compila para

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

Da mesma forma para o turno

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

com saída:

    sarl    %edi
    movl    %edi, %eax
    ret

Apenas uma nota adicional -

x * = 0,5 geralmente será mais rápido em alguns idiomas baseados em VM - principalmente actionscript, pois a variável não precisará ser verificada quanto à divisão por 0.

Use x = x / 2; OR x /= 2;Porque é possível que um novo programador trabalhe nele no futuro. Portanto, será mais fácil descobrir o que está acontecendo na linha de código. Todos podem não estar cientes dessas otimizações.

Estou dizendo com o objetivo de programar competições. Geralmente eles têm entradas muito grandes, onde a divisão por 2 ocorre muitas vezes e sabe-se que a entrada é positiva ou negativa.

x >> 1 será melhor que x / 2. Eu verifiquei no ideone.com executando um programa em que ocorreram mais de 10 ^ 10 divisões por 2 operações. x / 2 levou quase 5,5s enquanto x >> 1 levou quase 2,6s para o mesmo programa.

Eu diria que há várias coisas a considerar.

1. O deslocamento de bits deve ser mais rápido, pois não é realmente necessário um cálculo especial para mudar os bits; no entanto, como apontado, existem problemas em potencial com números negativos. Se você tiver números positivos e estiver procurando velocidade, eu recomendaria o deslocamento de bits.

2. O operador de divisão é muito fácil para os humanos lerem. Portanto, se você estiver procurando legibilidade de código, poderá usá-lo. Observe que o campo da otimização do compilador já percorreu um longo caminho, facilitando a leitura e compreensão do código, é uma boa prática.

3. Dependendo do hardware subjacente, as operações podem ter velocidades diferentes. A lei de Amdal é tornar o caso comum rápido. Portanto, você pode ter um hardware que pode executar operações diferentes mais rapidamente do que outros. Por exemplo, multiplicar por 0,5 pode ser mais rápido que dividir por 2. (Concedido, você pode precisar usar o piso da multiplicação se desejar impor a divisão inteira).

Se você busca desempenho puro, eu recomendaria a criação de alguns testes que poderiam executar as operações milhões de vezes. Faça a amostra da execução várias vezes (o tamanho da amostra) para determinar qual é estatisticamente melhor com seu SO / Hardware / Compilador / Código.

No que diz respeito à CPU, as operações de troca de bits são mais rápidas que as operações de divisão. No entanto, o compilador sabe disso e otimizará apropriadamente na medida do possível, para que você possa codificar da maneira que fizer mais sentido e ficar mais tranquilo sabendo que seu código está sendo executado com eficiência. Mas lembre-se de que um unsigned int(em alguns casos) pode ser otimizado melhor do que um intpor razões apontadas anteriormente. Se você não precisar de aritmética assinada, não inclua o bit de sinal.

x = x / 2; é o código adequado para uso .. mas uma operação depende do seu próprio programa de como a saída que você deseja produzir.

Torne suas intenções mais claras ... por exemplo, se você deseja dividir, use x / 2 e deixe o compilador otimizá-lo para mudar de operador (ou qualquer outra coisa).

Os processadores de hoje não permitem que essas otimizações tenham impacto no desempenho de seus programas.

A resposta para isso dependerá do ambiente em que você estiver trabalhando.

• Se você está trabalhando em um microcontrolador de 8 bits ou qualquer coisa sem suporte de hardware para multiplicação, pouco deslocamento é esperado e comum, e enquanto o compilador irá quase certamente transformar x /= 2em x >>= 1, a presença de um símbolo de divisão vai aumentar mais as sobrancelhas naquele ambiente de usando uma mudança para efetuar uma divisão.
• Se você estiver trabalhando em um ambiente crítico de desempenho ou em uma seção de código, ou se seu código puder ser compilado com a otimização do compilador desativada, x >>= 1um comentário explicando seu raciocínio provavelmente será o melhor apenas para fins de clareza de propósito.
• Se você não estiver em uma das condições acima, torne seu código mais legível simplesmente usando x /= 2. É melhor salvar o próximo programador que, por acaso, examinar seu código nos 10 segundos de operação dupla, do que provar desnecessariamente que sabia que o turno era mais eficiente na otimização do compilador.

Todos estes assumem números inteiros não assinados. A mudança simples provavelmente não é o que você deseja assinar. Além disso, DanielH traz um bom argumento sobre o uso x *= 0.5de determinadas linguagens como o ActionScript.

mod 2, teste para = 1. não sei a sintaxe em c. mas isso pode ser mais rápido.

geralmente o turno certo divide:

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

isso às vezes é usado para acelerar os programas à custa da clareza. Eu não acho que você deveria fazer isso. O compilador é inteligente o suficiente para executar a aceleração automaticamente. Isso significa que fazer uma mudança não ganha nada à custa da clareza .

Dê uma olhada nesta página da Practical C ++ Programming.

Obviamente, se você estiver escrevendo seu código para o próximo usuário que o lê, procure a clareza de "x / 2".

No entanto, se a velocidade é seu objetivo, tente de duas maneiras e cronometrar os resultados. Alguns meses atrás, trabalhei em uma rotina de convolução de bitmap que envolvia percorrer uma matriz de números inteiros e dividir cada elemento por 2. Fiz todo o tipo de coisas para otimizá-lo, incluindo o velho truque de substituir "x >> 1" por "x" / 2 ".

Quando cronometrei os dois sentidos, descobri, para minha surpresa, que x / 2 era mais rápido que x >> 1

Isso estava usando o Microsoft VS2008 C ++ com as otimizações padrão ativadas.

Em termos de desempenho. As operações de turno da CPU são significativamente mais rápidas que os códigos operacionais divididos. Assim, dividir por dois ou multiplicar por 2 etc, todos se beneficiam das operações de turno.

Quanto à aparência. Como engenheiros, quando nos tornamos tão apegados aos cosméticos que nem mesmo as mulheres bonitas usam! :)

X / Y é o correto ... e ">>" operador de deslocamento .. se queremos dois dividir um número inteiro, podemos usar (/) operador de dividendos. O operador shift é usado para mudar os bits.

x = x / 2; x / = 2; podemos usar assim ..

Enquanto x >> 1 é mais rápido que x / 2, o uso adequado de >> ao lidar com valores negativos é um pouco mais complicado. Requer algo semelhante ao seguinte:

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