Schnelle Obergrenze einer Ganzzahldivision in C / C ++

Gegebene ganzzahlige Werte x und geben sowohl yC als auch C ++ als Quotient q = x/yden Boden des Gleitkommaäquivalents zurück. Ich bin an einer Methode interessiert, stattdessen die Decke zurückzugeben. Zum Beispiel ceil(10/5)=2und ceil(11/5)=3.

Der offensichtliche Ansatz beinhaltet etwas wie:

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

Dies erfordert einen zusätzlichen Vergleich und eine zusätzliche Multiplikation. und andere Methoden, die ich gesehen habe (tatsächlich verwendet), beinhalten das Casting als floatoderdouble . Gibt es eine direktere Methode, die die zusätzliche Multiplikation (oder eine zweite Division) und Verzweigung vermeidet und die auch das Casting als Gleitkommazahl vermeidet?

Für positive Zahlen

unsigned int x, y, q;

Aufrunden ...

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

oder (Vermeidung eines Überlaufs in x + y)

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

Für positive Zahlen:

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

Die Antwort von Sparky ist ein Standardweg, um dieses Problem zu lösen, aber wie ich auch in meinem Kommentar geschrieben habe, laufen Sie Gefahr, überzulaufen. Dies kann durch Verwendung eines breiteren Typs gelöst werden, aber was ist, wenn Sie teilen möchten?long long s ?

Die Antwort von Nathan Ernst bietet eine Lösung, beinhaltet jedoch einen Funktionsaufruf, eine Variablendeklaration und eine Bedingung, wodurch sie nicht kürzer als der OP-Code und wahrscheinlich sogar langsamer ist, da die Optimierung schwieriger ist.

Meine Lösung lautet:

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

Es ist etwas schneller als der OPs-Code, da das Modulo und die Division mit derselben Anweisung auf dem Prozessor ausgeführt werden, da der Compiler erkennen kann, dass sie äquivalent sind. Mindestens gcc 4.4.1 führt diese Optimierung mit dem Flag -O2 auf x86 durch.

Theoretisch könnte der Compiler den Funktionsaufruf in Nathan Ernsts Code einbinden und dasselbe ausgeben, aber gcc hat das nicht getan, als ich ihn getestet habe. Dies könnte daran liegen, dass der kompilierte Code an eine einzelne Version der Standardbibliothek gebunden wird.

Abschließend ist nichts davon auf einem modernen Computer von Bedeutung, es sei denn, Sie befinden sich in einer extrem engen Schleife und alle Ihre Daten befinden sich in Registern oder im L1-Cache. Andernfalls sind alle diese Lösungen gleich schnell, mit Ausnahme von Nathan Ernsts, der möglicherweise erheblich langsamer ist, wenn die Funktion aus dem Hauptspeicher abgerufen werden muss.

Sie können die divFunktion in cstdlib verwenden, um den Quotienten und den Rest in einem einzigen Aufruf abzurufen und dann die Obergrenze wie unten beschrieben separat zu behandeln

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

Wie wäre es damit? (erfordert y nicht negativ, verwenden Sie dies also nicht in dem seltenen Fall, in dem y eine Variable ohne Nicht-Negativitätsgarantie ist)

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

Ich reduzierte mich auf y/yeins, eliminierte den Begriff x + y - 1und damit jede Möglichkeit eines Überlaufs.

Ich vermeide es, x - 1herumzuwickeln, wenn xes sich um einen vorzeichenlosen Typ handelt, der Null enthält.

Bei Vorzeichen xwerden Negativ und Null immer noch zu einem einzigen Fall zusammengefasst.

Wahrscheinlich kein großer Vorteil für eine moderne Allzweck-CPU, aber dies wäre in einem eingebetteten System weitaus schneller als jede andere richtige Antwort.

Es gibt eine Lösung für positiv und negativ, xaber nur für positiv ymit nur 1 Division und ohne Zweige:

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

Beachten Sie, wenn xpositiv ist , ist die Division in Richtung Null, und wir sollten 1 hinzufügen, wenn die Erinnerung nicht Null ist.

Wenn xnegativ ist, dann ist die Division gegen Null, das ist es, was wir brauchen, und wir werden nichts hinzufügen, weil x % yes nicht positiv ist

Dies funktioniert für positive oder negative Zahlen:

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

Wenn es einen Rest gibt, prüft, ob xund yhaben das gleiche Vorzeichen und fügt 1entsprechend hinzu .

Ich hätte es lieber kommentiert, aber ich habe nicht genügend Wiederholungen.

Soweit mir bekannt ist, ist dies für positive Argumente und einen Divisor mit einer Potenz von 2 der schnellste Weg (getestet in CUDA):

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

Nur für generische positive Argumente mache ich das eher so:

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

vereinfachte generische Form,

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)

Für eine allgemeinere Antwort bietet C ++ Funktionen für die Ganzzahldivision mit genau definierter Rundungsstrategie

Mit O3 kompilieren. Der Compiler führt die Optimierung gut durch.

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