Soffitto veloce di una divisione intera in C / C ++

Dati i valori interi xe y, C e C ++ restituiscono entrambi come quoziente q = x/yil piano dell'equivalente in virgola mobile. Sono invece interessato a un metodo per restituire il soffitto. Ad esempio, ceil(10/5)=2e ceil(11/5)=3.

L'approccio ovvio prevede qualcosa di simile:

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

Ciò richiede un ulteriore confronto e moltiplicazione; e altri metodi che ho visto (usato in effetti) prevedono il casting come a floato double. Esiste un metodo più diretto che evita la moltiplicazione aggiuntiva (o una seconda divisione) e il ramo e che evita anche il casting come numero in virgola mobile?

Per numeri positivi

unsigned int x, y, q;

Per arrotondare ...

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

o (evitando l'overflow in x + y)

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

Per numeri positivi:

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

La risposta di Sparky è un modo standard per risolvere questo problema, ma come ho scritto anche nel mio commento, corri il rischio di overflow. Questo può essere risolto utilizzando un tipo più ampio, ma cosa succede se si desidera dividere long longs?

La risposta di Nathan Ernst fornisce una soluzione, ma comporta una chiamata di funzione, una dichiarazione di variabile e un condizionale, che non lo rende più breve del codice OP e probabilmente anche più lento, perché è più difficile da ottimizzare.

La mia soluzione è questa:

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

Sarà leggermente più veloce del codice OP, perché il modulo e la divisione vengono eseguiti usando le stesse istruzioni sul processore, perché il compilatore può vedere che sono equivalenti. Almeno gcc 4.4.1 esegue questa ottimizzazione con -O2 flag su x86.

In teoria il compilatore potrebbe includere la funzione chiamata nel codice di Nathan Ernst ed emettere la stessa cosa, ma gcc non l'ha fatto quando l'ho provato. Ciò potrebbe essere dovuto al fatto che legherebbe il codice compilato a una singola versione della libreria standard.

Come nota finale, nulla di tutto ciò conta su una macchina moderna, tranne se si è in un ciclo estremamente stretto e tutti i dati sono nei registri o nella cache L1. Altrimenti tutte queste soluzioni saranno ugualmente veloci, ad eccezione di quelle di Nathan Ernst, che potrebbero essere significativamente più lente se la funzione debba essere recuperata dalla memoria principale.

È possibile utilizzare la divfunzione in cstdlib per ottenere il quoziente e il resto in una singola chiamata e quindi gestire il soffitto separatamente, come nel seguito

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

Cosa ne pensi di questo? (richiede y non negativo, quindi non usarlo nel raro caso in cui y sia una variabile senza garanzia di non negatività)

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

Ho ridotto y/ya uno, eliminando il termine x + y - 1e con esso ogni possibilità di overflow.

Evito di x - 1concludere quando xè un tipo senza segno e contiene zero.

Per firmato x, negativo e zero si combinano ancora in un singolo caso.

Probabilmente non è un enorme vantaggio su una moderna CPU per uso generico, ma questo sarebbe molto più veloce in un sistema incorporato rispetto a qualsiasi altra risposta corretta.

C'è una soluzione sia per positivo che per negativo, xma solo per positivo ycon solo 1 divisione e senza rami:

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

Nota, se xè positivo, la divisione è verso zero e dovremmo aggiungere 1 se il promemoria non è zero.

Se xè negativo, allora la divisione è verso zero, questo è ciò di cui abbiamo bisogno e non aggiungeremo nulla perché x % ynon è positivo

Funziona con numeri positivi o negativi:

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

Se c'è un resto, controlla se xe yhanno lo stesso segno e aggiunge di 1conseguenza.

Avrei preferito commentare ma non ho un rappresentante abbastanza alto.

Per quanto ne so, per argomenti positivi e un divisore che è un potere di 2, questo è il modo più veloce (testato in CUDA):

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

Solo per argomenti positivi generici, tendo a farlo in questo modo:

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

forma generica semplificata,

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)

Per una risposta più generica, C ++ funziona per la divisione di numeri interi con una strategia di arrotondamento ben definita

Compilare con O3, il compilatore esegue bene l'ottimizzazione.

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