Runden von Double Werten

CHF 1.15 kommt da raus. Es gibt unterschiedliche Rundungsmodelle (abrunden, aufrunden usw.)
Aus "sicherer Quelle" :D weiß ich dass den Banken aufgerundete Cent- oder Rappenbeträge auch egal wären...

Aber wie kann xx5 gerundet werden? Das ist so ähnlich wie die Frage ob meine Kaffeetasse noch halbvoll oder schon halb leer ist...
ich frag mich auch immer wieder wieso manche Sachen so unnötig "kompliziert" gemacht werden :)
 
Hallo cyb0rg,
Java:
//Runden nach Schweizerwährung auf 0.05 genau
// 1,08 bis 1,12 sind 1.10
// 1,13 bis 1,17 sind 1,15
// Frage, sind 1,125 noch 1,10 oder schon 1,15? Antwort 1,15
public class Rappenrunden {
    double Betrag;
    Rappenrunden(double d) {
        double erhoehungbei=0.025;
        double epsilon=0.00000000001;
        if (d<0.0)
            epsilon=-epsilon;
        Betrag=Math.ceil((d-erhoehungbei+epsilon)*20.0)/20.0;
        // ceil rundet auf die nächste Ganzzahl mit double-Rückgabe: static double ceil(double a)
    }
}
Java:
class TestRappenrunden {
    public static void main(String [] args)
    {
        for (int i=0; i<=10; i++)
            System.out.printf("%.2f sind %.2f\n",52296.60+i*0.01,new Rappenrunden(52296.60+i*0.01).Betrag);
        System.out.printf("%.3f sind %.2f\n",1.124,new Rappenrunden(1.124).Betrag);
        System.out.printf("%.3f sind %.2f\n",1.125,new Rappenrunden(1.125).Betrag);
        System.out.printf("%.3f sind %.2f\n",1.129,new Rappenrunden(1.129).Betrag);
        System.out.printf("%.3f sind %.2f\n",1.130,new Rappenrunden(1.130).Betrag);
        System.out.printf("%.3f sind %.2f\n",-1.124,new Rappenrunden(-1.124).Betrag);
        System.out.printf("%.3f sind %.2f\n",-1.125,new Rappenrunden(-1.125).Betrag);
        System.out.printf("%.3f sind %.2f\n",-1.126,new Rappenrunden(-1.126).Betrag);
    }
}
/*
52296,60 sind 52296,60
52296,61 sind 52296,60
52296,62 sind 52296,60
52296,63 sind 52296,65
52296,64 sind 52296,65
52296,65 sind 52296,65
52296,66 sind 52296,65
52296,67 sind 52296,65
52296,68 sind 52296,70
52296,69 sind 52296,70
52296,69 sind 52296,70
52296,70 sind 52296,70
1,124 sind 1,10
1,125 sind 1,15
1,129 sind 1,15
1,130 sind 1,15
*/
@Tobias-nrw
ich brauchte für meine Version des Programm diese Konstante.
Zum Beispiel an der nächsten Tankstelle werden Literpreise mit 3 Nachkommastellen angegeben und im Devisenhandel sind es noch mehr Nachkommastellen. Außerdem können rechnerisch falsche Handelsrechnungen auch bei Cent, Rappen Differenzen zurück gewiesen werden.
Wer den Zentelrappen nicht ehrt, ist des Bitcoins nicht wert.
Gruß
 
@juergenkulow Das funktioniert auch mit Minus prima
Java:
public static String getRounded(double d) {
    return NumberFormat.getCurrencyInstance(new Locale("de", "CH")).format(Math.round(d * 20.0) / 20.0);
}

public static void main(String[] args) {
    System.out.println(getRounded(11.224));

    for (int i = 0; i <= 10; i++)
        System.out.println((-11.1 + 0.01 * i) + " => " + getRounded(-11.1 + 0.01 * i));
}

/*
CHF 11.20
-11.1 => CHF-11.10
-11.09 => CHF-11.10
-11.08 => CHF-11.10
-11.07 => CHF-11.05
-11.06 => CHF-11.05
-11.049999999999999 => CHF-11.05
-11.04 => CHF-11.05
-11.03 => CHF-11.05
-11.02 => CHF-11.00
-11.01 => CHF-11.00
-11.0 => CHF-11.00
*/

Ich würde mich nicht auf etwas Eigenes verlassen. Bitte auch daran denken dass double höhere Werte gestattet als long.
 
ich frag mich auch immer wieder wieso manche Sachen so unnötig "kompliziert" gemacht werden :)
Hallo Cyb0rg,
einfacher, aber nicht zu einfach:
Java:
// Runden von schweizer Rappen - einfacher.
public class Myround
{
    public static void main(String [] args)
    {
        System.out.println(Math.ceil((52296.63-0.02499999999)*20.0)/20.0); //Fehler z. B. bei -1.125, -1.175, ...
        System.out.println(myround(52296.63));
    }

    static double myround(double d) {
        if (d<0.0)
            return Math.ceil((d-0.025+0.00000000001)*20.0)/20.0;
        else
            return Math.ceil((d-0.025-0.00000000001)*20.0)/20.0;
                            // ceil rundet auf die nächste Ganzzahl mit double-Rückgabe: static double ceil(double a)
    }
}
/*Lösungsidee:     Was kann als Rappen rauskommen: 0 5 10 15 20 ... 95
                            Wieviele unterschiedliche Werte sind das: 20
                            Welchen Wert muß ich vom Betrag abziehen, wenn ich den Betrag mit 20 multizieren, um eins erhöhe,
                            die Kommasstellen abschneide und dann durch 20 teile : 0.025
                            Was hilft bei double Rechenfehler: Eine kleine Zahl abziehen oder addieren bei negativen Beträgen
/* Programmausgabe:
52296.65
52296.65
*/
 
//Fehler z. B. bei -1.125, -1.175, ...
@juergenkulow Danke, jetzt erst das Problem verstanden.... :(
So rundet er auch mit negativen Beträgen "richtig":
Java:
    public static String getRounded(double d) {
        if (d >= 0) {
            return NumberFormat.getCurrencyInstance(new Locale("de", "CH")).format(Math.round(d * 20.0) / 20.0);
        } else {
            d *= 20.0;
            double i = Math.floor(d);
            double f = d - i;
            if (f > 0.5) {
                i += 1.0;
            }
            return NumberFormat.getCurrencyInstance(new Locale("de", "CH")).format(i / 20.0);
        }
    }

    public static void main(String[] args) {
        System.out.println(getRounded(+1.125));
        System.out.println(getRounded(-1.125));
    }
 
Hallo Cyb0rg,
ein klitzekleines Update:
Java:
//Runden nach Schweizerwährung auf 0.05 genau
// 1,08 bis 1,12 sind 1.10
// 1,13 bis 1,17 sind 1,15
// Frage, sind 1,125 noch 1,10 oder schon 1,15? Antwort 1,15
public class Rappenrunden {
    double Betrag;

    Rappenrunden(double d) {
        if (d>=0)
            Betrag=Math.round(d*20.0)/20.0;
        else
            Betrag=Math.ceil((d-0.024999999999999998)*20.0)/20.0; //0.024999999999999998 ist double Zahl vor 0.025.
        // ceil rundet auf die nächste Ganzzahl mit double-Rückgabe: static double ceil(double a)
    }
    public static void main(String [] args)
    {
        System.out.println(new Rappenrunden(52296.67).Betrag);
    }
}
// 52296.65
// Erst im hochen dreistelligen Milliarden Franken Bereich wird es ungenau.
 
Hallo Cyb0rg,
ein klitzekleines Update:
Java:
//Runden nach Schweizerwährung auf 0.05 genau
// 1,08 bis 1,12 sind 1.10
// 1,13 bis 1,17 sind 1,15
// Frage, sind 1,125 noch 1,10 oder schon 1,15? Antwort 1,15
public class Rappenrunden {
    double Betrag;

    Rappenrunden(double d) {
        if (d>=0)
            Betrag=Math.round(d*20.0)/20.0;
        else
            Betrag=Math.ceil((d-0.024999999999999998)*20.0)/20.0; //0.024999999999999998 ist double Zahl vor 0.025.
        // ceil rundet auf die nächste Ganzzahl mit double-Rückgabe: static double ceil(double a)
    }
    public static void main(String [] args)
    {
        System.out.println(new Rappenrunden(52296.67).Betrag);
    }
}
// 52296.65
// Erst im hochen dreistelligen Milliarden Franken Bereich wird es ungenau.
danke :)
 
Passende Stellenanzeigen aus deiner Region:

Neue Themen

Oben