OK - es ist mir fast peinlich, dies hier zu posten (und ich werde es löschen, wenn jemand zum Schließen stimmt), da es wie eine grundlegende Frage erscheint.

Ist dies der richtige Weg, um in C ++ auf ein Vielfaches einer Zahl aufzurunden?

Ich weiß, dass es andere Fragen dazu gibt, aber ich bin besonders daran interessiert zu wissen, wie dies in C ++ am besten funktioniert:

int roundUp(int numToRound, int multiple)
{
 if(multiple == 0)
 {
  return numToRound;
 }

 int roundDown = ( (int) (numToRound) / multiple) * multiple;
 int roundUp = roundDown + multiple; 
 int roundCalc = roundUp;
 return (roundCalc);
}

Update: Entschuldigung, ich habe die Absicht wahrscheinlich nicht klargestellt. Hier sind einige Beispiele:

roundUp(7, 100)
//return 100

roundUp(117, 100)
//return 200

roundUp(477, 100)
//return 500

roundUp(1077, 100)
//return 1100

roundUp(52, 20)
//return 60

roundUp(74, 30)
//return 90

Dies funktioniert für positive Zahlen, nicht sicher über negative. Es wird nur ganzzahlige Mathematik verwendet.

int roundUp(int numToRound, int multiple)
{
    if (multiple == 0)
        return numToRound;

    int remainder = numToRound % multiple;
    if (remainder == 0)
        return numToRound;

    return numToRound + multiple - remainder;
}

Bearbeiten: Hier ist eine Version, die mit negativen Zahlen arbeitet, wenn Sie mit "up" ein Ergebnis meinen, das immer> = die Eingabe ist.

int roundUp(int numToRound, int multiple)
{
    if (multiple == 0)
        return numToRound;

    int remainder = abs(numToRound) % multiple;
    if (remainder == 0)
        return numToRound;

    if (numToRound < 0)
        return -(abs(numToRound) - remainder);
    else
        return numToRound + multiple - remainder;
}

Ohne Bedingungen:

int roundUp(int numToRound, int multiple) 
{
    assert(multiple);
    return ((numToRound + multiple - 1) / multiple) * multiple;
}

Dies funktioniert wie das Abrunden von Null für negative Zahlen

EDIT: Version, die auch für negative Zahlen funktioniert

int roundUp(int numToRound, int multiple) 
{
    assert(multiple);
    int isPositive = (int)(numToRound >= 0);
    return ((numToRound + isPositive * (multiple - 1)) / multiple) * multiple;
}

Tests

Wenn multipleist eine Potenz von 2 (schneller in ~ 3,7 mal http://quick-bench.com/sgPEZV9AUDqtx2uujRSa3-eTE80 )

int roundUp(int numToRound, int multiple) 
{
    assert(multiple && ((multiple & (multiple - 1)) == 0));
    return (numToRound + multiple - 1) & -multiple;
}

Tests

Dies funktioniert, wenn der Faktor immer positiv ist:

int round_up(int num, int factor)
{
    return num + factor - 1 - (num - 1) % factor;
}

Bearbeiten: Dies kehrt zurück round_up(0,100)=100. In Pauls Kommentar unten finden Sie eine Lösung, die zurückkehrt round_up(0,100)=0.

Dies ist eine Verallgemeinerung des Problems "Wie finde ich heraus, wie viele Bytes n Bits benötigt werden?" (A: (n Bits + 7) / 8).

int RoundUp(int n, int roundTo)
{
    // fails on negative?  What does that mean?
    if (roundTo == 0) return 0;
    return ((n + roundTo - 1) / roundTo) * roundTo; // edit - fixed error
}

int roundUp(int numToRound, int multiple)
{
 if(multiple == 0)
 {
  return 0;
 }
 return ((numToRound - 1) / multiple + 1) * multiple;  
}

Und Sie müssen nicht mit den Bedingungen herumspielen

Für alle, die eine kurze und süße Antwort suchen. Das habe ich benutzt. Keine Berücksichtigung von Negativen.

n - (n % r)

Das gibt den vorherigen Faktor zurück.

(n + r) - (n % r)

Ich werde am nächsten zurückkehren. Hoffe das hilft jemandem. :) :)

float roundUp(float number, float fixedBase) {
    if (fixedBase != 0 && number != 0) {
        float sign = number > 0 ? 1 : -1;
        number *= sign;
        number /= fixedBase;
        int fixedPoint = (int) ceil(number);
        number = fixedPoint * fixedBase;
        number *= sign;
    }
    return number;
}

Dies funktioniert für jede Float-Nummer oder Basis (z. B. können Sie -4 auf 6,75 runden). Im Wesentlichen wird in einen festen Punkt konvertiert, dort gerundet und dann zurück konvertiert. Es behandelt Negative, indem es AWAY von 0 rundet. Es behandelt auch eine negative Runde auf Wert, indem die Funktion im Wesentlichen in roundDown umgewandelt wird.

Eine int-spezifische Version sieht folgendermaßen aus:

int roundUp(int number, int fixedBase) {
    if (fixedBase != 0 && number != 0) {
        int sign = number > 0 ? 1 : -1;
        int baseSign = fixedBase > 0 ? 1 : 0;
        number *= sign;
        int fixedPoint = (number + baseSign * (fixedBase - 1)) / fixedBase;
        number = fixedPoint * fixedBase;
        number *= sign;
    }
    return number;
}

Das ist mehr oder weniger die Antwort von Sockel mit der zusätzlichen Unterstützung für negative Eingaben.

Dies ist der moderne c ++ - Ansatz, der eine Vorlagenfunktion verwendet, die für float, double, long, int und short funktioniert (jedoch nicht für long long und long double aufgrund der verwendeten double-Werte).

#include <cmath>
#include <iostream>

template<typename T>
T roundMultiple( T value, T multiple )
{
    if (multiple == 0) return value;
    return static_cast<T>(std::round(static_cast<double>(value)/static_cast<double>(multiple))*static_cast<double>(multiple));
}

int main()
{
    std::cout << roundMultiple(39298.0, 100.0) << std::endl;
    std::cout << roundMultiple(20930.0f, 1000.0f) << std::endl;
    std::cout << roundMultiple(287399, 10) << std::endl;
}

Sie können jedoch problemlos Unterstützung für long longund long doublemit Vorlagenspezialisierung hinzufügen, wie unten gezeigt:

template<>
long double roundMultiple<long double>( long double value, long double multiple)
{
    if (multiple == 0.0l) return value;
    return std::round(value/multiple)*multiple;
}

template<>
long long roundMultiple<long long>( long long value, long long multiple)
{
    if (multiple == 0.0l) return value;
    return static_cast<long long>(std::round(static_cast<long double>(value)/static_cast<long double>(multiple))*static_cast<long double>(multiple));
}

Um Funktionen zum Aufrunden zu erstellen, verwenden Sie std::ceilund um die Verwendung immer abzurunden std::floor. Mein Beispiel von oben ist das Runden mitstd::round .

Erstellen Sie die Vorlagenfunktion "Aufrunden" oder besser bekannt als "Runde Decke" wie unten gezeigt:

template<typename T>
T roundCeilMultiple( T value, T multiple )
{
    if (multiple == 0) return value;
    return static_cast<T>(std::ceil(static_cast<double>(value)/static_cast<double>(multiple))*static_cast<double>(multiple));
}

Erstellen Sie die Vorlagenfunktion "Abrunden" oder besser bekannt als "Abgerundeter Boden" wie unten gezeigt:

template<typename T>
T roundFloorMultiple( T value, T multiple )
{
    if (multiple == 0) return value;
    return static_cast<T>(std::floor(static_cast<double>(value)/static_cast<double>(multiple))*static_cast<double>(multiple));
}

Zunächst einmal sollte Ihre Fehlerbedingung (multiple == 0) wahrscheinlich einen Rückgabewert haben. Was? Ich weiß es nicht. Vielleicht möchten Sie eine Ausnahme auslösen, das liegt bei Ihnen. Aber nichts zurückzugeben ist gefährlich.

Zweitens sollten Sie überprüfen, ob numToRound noch kein Vielfaches ist. Andernfalls , wenn Sie hinzufügen multiplezuroundDown , haben Sie die falsche Antwort bekommen.

Drittens sind Ihre Darsteller falsch. Du hast gegossennumToRound in eine Ganzzahl umgewandelt, aber es ist bereits eine Ganzzahl. Sie müssen vor der Division auf Double und nach der Multiplikation auf Int zurücksetzen.

Was möchten Sie zum Schluss für negative Zahlen? Aufrunden "aufrunden" kann auf Null runden (in die gleiche Richtung wie positive Zahlen runden) oder von Null weg (eine "größere" negative Zahl). Oder vielleicht ist es dir egal.

Hier ist eine Version mit den ersten drei Korrekturen, aber ich beschäftige mich nicht mit dem negativen Problem:

int roundUp(int numToRound, int multiple)
{
 if(multiple == 0)
 {
  return 0;
 }
 else if(numToRound % multiple == 0)
 {
  return numToRound
 }

 int roundDown = (int) (( (double) numToRound / multiple ) * multiple);
 int roundUp = roundDown + multiple; 
 int roundCalc = roundUp;
 return (roundCalc);
}

Runde zur Zweierpotenz:

Nur für den Fall, dass jemand eine Lösung für positive Zahlen benötigt, die auf das nächste Vielfache einer Zweierpotenz gerundet sind (denn so bin ich hier gelandet):

// number: the number to be rounded (ex: 5, 123, 98345, etc.)
// pow2:   the power to be rounded to (ex: to round to 16, use '4')
int roundPow2 (int number, int pow2) {
    pow2--;                     // because (2 exp x) == (1 << (x -1))
    pow2 = 0x01 << pow2;

    pow2--;                     // because for any
                                //
                                // (x = 2 exp x)
                                //
                                // subtracting one will
                                // yield a field of ones
                                // which we can use in a
                                // bitwise OR

    number--;                   // yield a similar field for
                                // bitwise OR
    number = number | pow2;
    number++;                   // restore value by adding one back

    return number;
}

Die eingegebene Nummer bleibt gleich, wenn es sich bereits um ein Vielfaches handelt.

Hier ist die x86_64-Ausgabe, die GCC mit -O2oder gibt -Os(9Sep2013 Build - godbolt GCC online):

roundPow2(int, int):
    lea ecx, [rsi-1]
    mov eax, 1
    sub edi, 1
    sal eax, cl
    sub eax, 1
    or  eax, edi
    add eax, 1
    ret

Jede C-Codezeile entspricht perfekt der Zeile in der Assembly: http://goo.gl/DZigfX

Jede dieser Anweisungen ist extrem schnell , daher ist die Funktion auch extrem schnell. Da der Code so klein und schnell ist, kann er für inlinedie Funktion bei der Verwendung hilfreich sein .

Anerkennung:

• Algorithmus: Hagen von Eitzen @ Math.SE
• Godbolt Interactive Compiler : @ mattgodbolt / gcc-explorer auf GitHub

Ich benutze:

template <class _Ty>
inline _Ty n_Align_Up(_Ty n_x, _Ty n_alignment)
{
    assert(n_alignment > 0);
    //n_x += (n_x >= 0)? n_alignment - 1 : 1 - n_alignment; // causes to round away from zero (greatest absolute value)
    n_x += (n_x >= 0)? n_alignment - 1 : -1; // causes to round up (towards positive infinity)
    //n_x += (_Ty(-(n_x >= 0)) & n_alignment) - 1; // the same as above, avoids branch and integer multiplication
    //n_x += n_alignment - 1; // only works for positive numbers (fastest)
    return n_x - n_x % n_alignment; // rounds negative towards zero
}

und für Zweierkräfte:

template <class _Ty>
bool b_Is_POT(_Ty n_x)
{
    return !(n_x & (n_x - 1));
}

template <class _Ty>
inline _Ty n_Align_Up_POT(_Ty n_x, _Ty n_pot_alignment)
{
    assert(n_pot_alignment > 0);
    assert(b_Is_POT(n_pot_alignment)); // alignment must be power of two
    -- n_pot_alignment;
    return (n_x + n_pot_alignment) & ~n_pot_alignment; // rounds towards positive infinity (i.e. negative towards zero)
}

Beachten Sie, dass beide negativen Werte gegen Null runden (dh für alle Werte auf unendlich runden). Keiner von beiden basiert auf einem vorzeichenbehafteten Überlauf (der in C / C ++ undefiniert ist).

Das gibt:

n_Align_Up(10, 100) = 100
n_Align_Up(110, 100) = 200
n_Align_Up(0, 100) = 0
n_Align_Up(-10, 100) = 0
n_Align_Up(-110, 100) = -100
n_Align_Up(-210, 100) = -200
n_Align_Up_POT(10, 128) = 128
n_Align_Up_POT(130, 128) = 256
n_Align_Up_POT(0, 128) = 0
n_Align_Up_POT(-10, 128) = 0
n_Align_Up_POT(-130, 128) = -128
n_Align_Up_POT(-260, 128) = -256

Wahrscheinlich sicherer in Floats umzuwandeln und Ceil () zu verwenden - es sei denn, Sie wissen, dass die Int-Division das richtige Ergebnis liefert.

int noOfMultiples = int((numToRound / multiple)+0.5);
return noOfMultiples*multiple

C ++ rundet jede Zahl ab. Wenn Sie also 0,5 hinzufügen (wenn es 1,5 ist, ist es 2), aber 1,49 ist 1,99, also 1.

BEARBEITEN - Entschuldigung, Sie haben nicht gesehen, dass Sie aufrunden möchten. Ich würde vorschlagen, anstelle von +0.5 eine Ceil () -Methode zu verwenden

Zum einen, da ich nicht wirklich verstehe, was Sie tun wollen, die Zeilen

int roundUp = roundDown + multiple;
int roundCalc = roundUp;
return (roundCalc); 

könnte definitiv verkürzt werden

int roundUp = roundDown + multiple;
return roundUp;

Vielleicht kann dies helfen:

int RoundUpToNearestMultOfNumber(int val, int num)
{
  assert(0 != num);
  return (floor((val + num) / num) * num);
}

Immer abrunden

int alwaysRoundUp(int n, int multiple)
{
    if (n % multiple != 0) {
        n = ((n + multiple) / multiple) * multiple;

        // Another way
        //n = n - n % multiple + multiple;
    }

    return n;
}

alwaysRoundUp (1, 10) -> 10

alwaysRoundUp (5, 10) -> 10

alwaysRoundUp (10, 10) -> 10

Immer abrunden

int alwaysRoundDown(int n, int multiple)
{
    n = (n / multiple) * multiple;

    return n;
}

alwaysRoundDown (1, 10) -> 0

alwaysRoundDown (5, 10) -> 0

alwaysRoundDown (10, 10) -> 10

Den normalen Weg abrunden

int normalRound(int n, int multiple)
{
    n = ((n + multiple/2)/multiple) * multiple;

    return n;
}

normalRound (1, 10) -> 0

normalRound (5, 10) -> 10

normalRound (10, 10) -> 10

Auf das nächste Vielfache runden, das zufällig eine Potenz von 2 ist

unsigned int round(unsigned int value, unsigned int multiple){
    return ((value-1u) & ~(multiple-1u)) + multiple;
}

Dies kann nützlich sein, wenn Sie entlang von Junggesellen zuordnen, bei denen das gewünschte Rundungsinkrement eine Zweierpotenz ist, der resultierende Wert jedoch nur ein Vielfaches davon sein muss. Auf gccdem Körper dieser Funktion werden 8 Montageanweisungen ohne Unterteilung oder Verzweigungen generiert.

round(  0,  16) ->   0
round(  1,  16) ->  16
round( 16,  16) ->  16
round(257, 128) -> 384 (128 * 3)
round(333,   2) -> 334

Ich habe einen Algorithmus gefunden, der dem oben beschriebenen etwas ähnlich ist:

int [(| x | + n-1) / n] * [(nx) / | x |], wobei x ein Benutzereingabewert und n das verwendete Vielfache ist.

Es funktioniert für alle Werte x, wobei x eine ganze Zahl ist (positiv oder negativ, einschließlich Null). Ich habe es speziell für ein C ++ - Programm geschrieben, aber dies kann grundsätzlich in jeder Sprache implementiert werden.

Für negative numToRound:

Es sollte wirklich einfach sein, dies zu tun, aber der Standard-Modulo% -Operator verarbeitet negative Zahlen nicht wie erwartet. Zum Beispiel -14% 12 = -2 und nicht 10. Als erstes müssen Sie einen Modulo-Operator erhalten, der niemals negative Zahlen zurückgibt. Dann ist roundUp wirklich einfach.

public static int mod(int x, int n) 
{
    return ((x % n) + n) % n;
}

public static int roundUp(int numToRound, int multiple) 
{
    return numRound + mod(-numToRound, multiple);
}

Das würde ich tun:

#include <cmath>

int roundUp(int numToRound, int multiple)
{
    // if our number is zero, return immediately
   if (numToRound == 0)
        return multiple;

    // if multiplier is zero, return immediately
    if (multiple == 0)
        return numToRound;

    // how many times are number greater than multiple
    float rounds = static_cast<float>(numToRound) / static_cast<float>(multiple);

    // determine, whether if number is multiplier of multiple
    int floorRounds = static_cast<int>(floor(rounds));

    if (rounds - floorRounds > 0)
        // multiple is not multiplier of number -> advance to the next multiplier
        return (floorRounds+1) * multiple;
    else
        // multiple is multiplier of number -> return actual multiplier
        return (floorRounds) * multiple;
}

Der Code ist möglicherweise nicht optimal, aber ich bevorzuge sauberen Code gegenüber trockener Leistung.

int roundUp (int numToRound, int multiple)
{
  return multiple * ((numToRound + multiple - 1) / multiple);
}

obwohl:

• funktioniert nicht für negative Zahlen
• funktioniert nicht, wenn numRound + mehrere Überläufe

würde vorschlagen, stattdessen vorzeichenlose Ganzzahlen zu verwenden, die das Überlaufverhalten definiert haben.

Sie erhalten eine Ausnahme von multiplen == 0, aber in diesem Fall ist dies ohnehin kein genau definiertes Problem.

c:

int roundUp(int numToRound, int multiple)
{
  return (multiple ? (((numToRound+multiple-1) / multiple) * multiple) : numToRound);
}

und für dein ~ / .bashrc:

roundup()
{
  echo $(( ${2} ? ((${1}+${2}-1)/${2})*${2} : ${1} ))
}

Ich verwende eine Kombination von Modulen, um die Addition des Restes aufzuheben, wenn xes sich bereits um ein Vielfaches handelt:

int round_up(int x, int div)
{
    return x + (div - x % div) % div;
}

Wir finden die Umkehrung des Rest-dann-Moduls, die mit dem Divisor erneut aufgehoben wird, wenn es sich um den Divisor selbst handelt, und fügen dann hinzu x.

round_up(19, 3) = 21

Hier ist meine Lösung basierend auf dem Vorschlag des OP und den Beispielen aller anderen. Da fast jeder danach suchte, negative Zahlen zu verarbeiten, macht diese Lösung genau das, ohne die Verwendung spezieller Funktionen, dh abs und dergleichen.

Wenn Sie den Modul vermeiden und stattdessen die Division verwenden, ist die negative Zahl ein natürliches Ergebnis, obwohl sie abgerundet ist. Nachdem die abgerundete Version berechnet wurde, führt sie die erforderliche Berechnung durch, um entweder in negativer oder positiver Richtung aufzurunden.

Beachten Sie auch, dass keine speziellen Funktionen zum Berechnen verwendet werden, sodass dort ein kleiner Geschwindigkeitsschub erfolgt.

int RoundUp(int n, int multiple)
{
    // prevent divide by 0 by returning n
    if (multiple == 0) return n;

    // calculate the rounded down version
    int roundedDown = n / multiple * multiple;

    // if the rounded version and original are the same, then return the original
    if (roundedDown == n) return n;

    // handle negative number and round up according to the sign
    // NOTE: if n is < 0 then subtract the multiple, otherwise add it
    return (n < 0) ? roundedDown - multiple : roundedDown + multiple;
}

Ich denke, das sollte dir helfen. Ich habe das folgende Programm in C geschrieben.

# include <stdio.h>
int main()
{
  int i, j;
  printf("\nEnter Two Integers i and j...");
  scanf("%d %d", &i, &j);
  int Round_Off=i+j-i%j;
  printf("The Rounded Off Integer Is...%d\n", Round_Off);
  return 0;
}

/// Rounding up 'n' to the nearest multiple of number 'b'.
/// - Not tested for negative numbers.
/// \see http://stackoverflow.com/questions/3407012/
#define roundUp(n,b) ( (b)==0 ? (n) : ( ((n)+(b)-1) - (((n)-1)%(b)) ) )

/// \c test->roundUp().
void test_roundUp() {   
    // yes_roundUp(n,b) ( (b)==0 ? (n) : ( (n)%(b)==0 ? n : (n)+(b)-(n)%(b) ) )
    // yes_roundUp(n,b) ( (b)==0 ? (n) : ( ((n + b - 1) / b) * b ) )

    // no_roundUp(n,b) ( (n)%(b)==0 ? n : (b)*( (n)/(b) )+(b) )
    // no_roundUp(n,b) ( (n)+(b) - (n)%(b) )

if (true) // couldn't make it work without (?:)
{{  // test::roundUp()
    unsigned m;
                { m = roundUp(17,8); } ++m;
    assertTrue( 24 == roundUp(17,8) );
                { m = roundUp(24,8); }
    assertTrue( 24 == roundUp(24,8) );

    assertTrue( 24 == roundUp(24,4) );
    assertTrue( 24 == roundUp(23,4) );
                { m = roundUp(23,4); }
    assertTrue( 24 == roundUp(21,4) );

    assertTrue( 20 == roundUp(20,4) );
    assertTrue( 20 == roundUp(19,4) );
    assertTrue( 20 == roundUp(18,4) );
    assertTrue( 20 == roundUp(17,4) );

    assertTrue( 17 == roundUp(17,0) );
    assertTrue( 20 == roundUp(20,0) );
}}
}

Dadurch erhalten Sie die gewünschten Ergebnisse für positive Ganzzahlen:

#include <iostream>
using namespace std;

int roundUp(int numToRound, int multiple);

int main() {
    cout << "answer is: " << roundUp(7, 100) << endl;
    cout << "answer is: " << roundUp(117, 100) << endl;
    cout << "answer is: " << roundUp(477, 100) << endl;
    cout << "answer is: " << roundUp(1077, 100) << endl;
    cout << "answer is: " << roundUp(52,20) << endl;
    cout << "answer is: " << roundUp(74,30) << endl;
    return 0;
}

int roundUp(int numToRound, int multiple) {
    if (multiple == 0) {
        return 0;
    }
    int result = (int) (numToRound / multiple) * multiple;
    if (numToRound % multiple) {
        result += multiple;
    } 
    return result;
}

Und hier sind die Ausgaben:

answer is: 100
answer is: 200
answer is: 500
answer is: 1100
answer is: 60
answer is: 90

Dies funktioniert bei mir, hat aber nicht versucht, mit Negativen umzugehen

public static int roundUp(int numToRound, int multiple) {
    if (multiple == 0) {
        return 0;
    } else if (numToRound % multiple == 0) {
    return numToRound;
    }

    int mod = numToRound % multiple;
    int diff = multiple - mod;
    return numToRound + diff;
}

Hier ist eine super einfache Lösung, um das Konzept der Eleganz zu zeigen. Es ist im Grunde für Grid-Snaps.

(Pseudocode)

nearestPos = Math.Ceil( numberToRound / multiple ) * multiple;