Plafond rapide d'une division entière en C / C ++

Étant donné les valeurs entières xet y, C et C ++ renvoient tous les deux comme quotient q = x/yle plancher de l'équivalent en virgule flottante. Je suis intéressé par une méthode de retour du plafond à la place. Par exemple, ceil(10/5)=2et ceil(11/5)=3.

L'approche évidente implique quelque chose comme:

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

Cela nécessite une comparaison et une multiplication supplémentaires; et d'autres méthodes que j'ai vues (utilisées en fait) impliquent le casting en tant que floatou double. Existe-t-il une méthode plus directe qui évite la multiplication supplémentaire (ou une deuxième division) et la branche, et qui évite également la conversion en nombre à virgule flottante?

Pour les nombres positifs

unsigned int x, y, q;

Pour arrondir ...

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

ou (en évitant le débordement en x + y)

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

Pour les nombres positifs:

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

La réponse de Sparky est un moyen standard de résoudre ce problème, mais comme je l'ai également écrit dans mon commentaire, vous courez le risque de débordements. Cela peut être résolu en utilisant un type plus large, mais que se passe-t-il si vous souhaitez diviser long longs?

La réponse de Nathan Ernst fournit une solution, mais elle implique un appel de fonction, une déclaration de variable et un conditionnel, ce qui le rend pas plus court que le code OP et probablement encore plus lent, car il est plus difficile à optimiser.

Ma solution est la suivante:

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

Il sera légèrement plus rapide que le code OP, car le modulo et la division sont effectués en utilisant la même instruction sur le processeur, car le compilateur peut voir qu'ils sont équivalents. Au moins gcc 4.4.1 effectue cette optimisation avec l'indicateur -O2 sur x86.

En théorie, le compilateur pourrait incorporer l'appel de fonction dans le code de Nathan Ernst et émettre la même chose, mais gcc ne l'a pas fait quand je l'ai testé. Cela peut être dû au fait qu'il lierait le code compilé à une seule version de la bibliothèque standard.

En conclusion, rien de tout cela n'a d'importance sur une machine moderne, sauf si vous êtes dans une boucle extrêmement serrée et que toutes vos données sont dans des registres ou dans le cache L1. Sinon, toutes ces solutions seront également rapides, à l'exception peut-être de Nathan Ernst, qui pourrait être considérablement plus lent si la fonction doit être récupérée de la mémoire principale.

Vous pouvez utiliser la divfonction dans cstdlib pour obtenir le quotient et le reste en un seul appel, puis gérer le plafond séparément, comme ci-dessous

#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 dis-tu de ça? (nécessite y non négatif, ne l'utilisez donc pas dans les rares cas où y est une variable sans garantie de non-négativité)

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

J'ai réduit y/yà un, éliminant le terme x + y - 1et avec lui toute possibilité de débordement.

J'évite de x - 1m'enrouler quand xest un type non signé et contient zéro.

Pour signé x, négatif et zéro se combinent toujours en un seul cas.

Probablement pas un énorme avantage sur un CPU polyvalent moderne, mais ce serait beaucoup plus rapide dans un système embarqué que n'importe quelle autre bonne réponse.

Il existe une solution à la fois positive et négative, xmais uniquement pour le positif yavec une seule division et sans branches:

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

Notez que si xest positif, la division est vers zéro et nous devons ajouter 1 si le rappel n'est pas nul.

Si xest négatif alors la division est vers zéro, c'est ce dont nous avons besoin, et nous n'ajouterons rien parce que ce x % yn'est pas positif

Cela fonctionne pour les nombres positifs ou négatifs:

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

S'il y a un reste, vérifie si xet ysont du même signe et ajoute en 1conséquence.

J'aurais plutôt commenté mais je n'ai pas de représentant suffisamment élevé.

Pour autant que je sache, pour les arguments positifs et un diviseur qui est une puissance de 2, c'est le moyen le plus rapide (testé dans CUDA):

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

Pour les arguments positifs génériques uniquement, j'ai tendance à le faire comme suit:

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

forme générique simplifiée,

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)

Pour une réponse plus générique, les fonctions C ++ pour la division entière avec une stratégie d'arrondi bien définie

Compiler avec O3, le compilateur effectue bien l'optimisation.

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