Runden



  • Daniel E. hat folgende Funktion gepostet um Zahlen zu Runden:

    int d2i(double d)
    {
      return d<0?d-.5:d+.5;
    }
    

    Das ist sehr kompakt und bedient sich dem Trick, dass bei double to int alle nachkommastellen einfach abgeschnitten werden!

    Wenn wir nun
    10.3
    auf Ganze runden wollen, dann machen wir das so:

    10.3 + 0.5 == 10.8
    Nachkommastellen weg: 10
    und das passt.

    und jetzt bei 10.9
    10.9 + 0.5 == 11.4
    Nachkommastellen weg: 11
    passt auch!

    Jetzt noch bei negativen Zahlen:
    -5.7 - 0.5 == - 6.2
    Nachkommastellen weg: -6
    passt auch

    Dies ist aber eine eecht 'dirty' version.
    Viel eleganter kann man es machen, indem man sich der standard bibliothek bedient:

    double Round(double Zahl, unsigned int Stellen)
    {
        Zahl *= pow(10, Stellen);
        if (Zahl >= 0)
            floor(Zahl + 0.5)
        else
            ceil(Zahl - 0.5);
        Zahl /= pow(10, Stellen);
        return Zahl;
    }
    

    der Vorteil hierbei ist, dass man angeben kann auf wieviel Stellen man runden will.

    pow() dient zum berechnen einer Potenz (include math.h)
    Der Trick der hier angewendet wird ist einfacher als bei der 1. Loesung.

    durch
    Zahl*=pow(10,stellen)
    'verschiebt' man die Stellen einfach um <stellen> nach 'rechts'
    danach rundet man aehnlich wie beim 1. Beispiel und am ende werden die Stellen wieder 'zurueck geschoben'

    alles in allem etwas mehr aufwand, dafuer eine schoenere und funktionalere Loesung.

    ReneGs Loesung, fuer Leute denen die oben genannten zu primitiv sind.
    Die Folgenden Codes beschreiben die Umformung der original Funktion in eine hochoptimierte:

    double Round(double Zahl, unsigned int Stellen)
    {
        Zahl *= pow(10, Stellen);
        if (Zahl >= 0)
            floor(Zahl + 0.5)
        else
            ceil(Zahl - 0.5);
        Zahl /= pow(10, Stellen);
        return Zahl;
    }
    // 1. Änderung ohne Kommentar
    double Round(double Zahl, unsigned int Stellen)
    {
        Zahl *= pow(10, Stellen);
        if (Zahl >= 0)
            Zahl = floor(Zahl + 0.5)
        else
            Zahl = ceil(Zahl - 0.5);
        Zahl /= pow(10, Stellen);
        return Zahl;
    }
    // 2. Änderung: Einführen der Potenzgesetze
    double Round(double Zahl, int Stellen)
    {
        Zahl *= pow( 10, Stellen);
        if (Zahl >= 0)
            Zahl = floor(Zahl + 0.5)
        else
            Zahl = ceil(Zahl - 0.5);
        Zahl *= pow(10, -Stellen);
        return Zahl;
    }
    // 3. Änderung: Rundung überarbeitet
    double Round(double Zahl, int Stellen)
    {
        Zahl *= pow( 10, Stellen);
        Zahl = floor(Zahl + 0.5)
        Zahl *= pow(10, -Stellen);
        return Zahl;
    }
    // 4. Änderung: Zusammenfassen
    double Round(double Zahl, int Stellen)
    {
        return floor(Zahl * pow( 10, Stellen) + 0.5) * pow(10, -Stellen);
    }
    // 5. Änderung: Laufzeitverhalten verbessern
    double Round(double Zahl, int Stellen)
    {
        double v[] = { 1, 10, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8 };  // mgl. verlängern
        return floor(Zahl * v[Stellen] + 0.5) / v[Stellen];
    }
    

    [ Dieser Beitrag wurde am 20.06.2003 um 17:33 Uhr von Shade Of Mine editiert. ]


Anmelden zum Antworten