Teto rápido de uma divisão inteira em C / C ++

Dados os valores inteiros xe y, C e C ++ retornam como quociente q = x/yo piso do equivalente em ponto flutuante. Estou interessado em um método de devolver o teto. Por exemplo, ceil(10/5)=2e ceil(11/5)=3.

A abordagem óbvia envolve algo como:

q = x / y;
if (q * y < x) ++q;

Isso requer uma comparação e multiplicação extras; e outros métodos que eu vi (usados ​​de fato) envolvem a transmissão como um floatou double. Existe um método mais direto que evite a multiplicação adicional (ou uma segunda divisão) e ramificação, e também evite a conversão como um número de ponto flutuante?

Para números positivos

unsigned int x, y, q;

Para arredondar ...

q = (x + y - 1) / y;

ou (evitando o estouro em x + y)

q = 1 + ((x - 1) / y); // if x != 0

Para números positivos:

    q = x/y + (x % y != 0);

A resposta de Sparky é uma maneira padrão de resolver esse problema, mas como também escrevi no meu comentário, você corre o risco de estouros. Isso pode ser resolvido usando um tipo mais amplo, mas e se você quiser dividir long longs?

A resposta de Nathan Ernst fornece uma solução, mas envolve uma chamada de função, uma declaração de variável e uma condicional, o que o torna não mais curto que o código dos OPs e provavelmente ainda mais lento, porque é mais difícil de otimizar.

Minha solução é esta:

q = (x % y) ? x / y + 1 : x / y;

Será um pouco mais rápido que o código de OPs, porque o módulo e a divisão são executados usando a mesma instrução no processador, porque o compilador pode ver que eles são equivalentes. Pelo menos o gcc 4.4.1 executa essa otimização com o sinalizador -O2 em x86.

Em teoria, o compilador pode incorporar a chamada de função no código de Nathan Ernst e emitir a mesma coisa, mas o gcc não fez isso quando o testei. Isso pode ocorrer porque vincularia o código compilado a uma única versão da biblioteca padrão.

Como observação final, nada disso importa em uma máquina moderna, exceto se você estiver em um loop extremamente rígido e todos os seus dados estiverem em registradores ou no cache L1. Caso contrário, todas essas soluções serão igualmente rápidas, exceto, possivelmente, as de Nathan Ernst, que podem ser significativamente mais lentas se a função precisar ser buscada na memória principal.

Você pode usar a divfunção no cstdlib para obter o quociente e o restante em uma única chamada e, em seguida, manipular o teto separadamente, como abaixo

#include <cstdlib>
#include <iostream>

int div_ceil(int numerator, int denominator)
{
        std::div_t res = std::div(numerator, denominator);
        return res.rem ? (res.quot + 1) : res.quot;
}

int main(int, const char**)
{
        std::cout << "10 / 5 = " << div_ceil(10, 5) << std::endl;
        std::cout << "11 / 5 = " << div_ceil(11, 5) << std::endl;

        return 0;
}

Que tal agora? (requer y não negativo, portanto, não use isso em casos raros em que y é uma variável sem garantia de não negatividade)

q = (x > 0)? 1 + (x - 1)/y: (x / y);

Reduzi y/ya um, eliminando o termo x + y - 1e com ele qualquer chance de transbordar.

Evito x - 1envolver quando xé um tipo não assinado e contém zero.

Para assinado x, negativo e zero ainda combinam em um único caso.

Provavelmente não é um grande benefício para uma CPU moderna de uso geral, mas isso seria muito mais rápido em um sistema incorporado do que qualquer outra resposta correta.

Existe uma solução para positivo e negativo, xmas apenas para positivo ycom apenas 1 divisão e sem ramificações:

int ceil(int x, int y) {
    return x / y + (x % y > 0);
}

Observe que se xfor positivo, a divisão será em direção a zero e devemos adicionar 1 se o lembrete não for zero.

Se xfor negativo, a divisão é em direção a zero, é disso que precisamos e não adicionaremos nada porque x % ynão é positivo

Isso funciona para números positivos ou negativos:

q = x / y + ((x % y != 0) ? !((x > 0) ^ (y > 0)) : 0);

Se houver um restante, verifica se há xe ytem o mesmo sinal e adiciona de 1acordo.

Eu preferiria comentar, mas não tenho um representante suficientemente alto.

Tanto quanto sei, para argumentos positivos e um divisor que é uma potência de 2, esta é a maneira mais rápida (testada no CUDA):

//example y=8
q = (x >> 3) + !!(x & 7);

Apenas para argumentos positivos genéricos, costumo fazer o seguinte:

q = x/y + !!(x % y);

formulário genérico simplificado,

int div_up(int n, int d) {
    return n / d + (((n < 0) ^ (d > 0)) && (n % d));
} //i.e. +1 iff (not exact int && positive result)

Para uma resposta mais genérica, o C ++ funciona para divisão inteira com estratégia de arredondamento bem definida

Compilar com O3, O compilador executa bem a otimização.

q = x / y;
if (x % y)  ++q;