individuelles Runden

[tiek]

Hallo!
Ich suche eine Möglichkeit Zahlen so zu runden:
0.13 -> 0.2
0.16 -> 0.2
0.91 -> 1
1.3 -> 2
1.31 -> 2

11 -> 20
19 -> 20
111 -> 200
191 ->200
Ist irgendwie logarithmisch.
Irgendwelche Vorschläge?

 

[Landei]

public class Round {
    public static double round(double d) {
        int k = 0;
        while(d < 0.2) {
            d *= 10;
            k--;
        }
        while(d > 2) {
            d /= 10;
            k++;
        }
        return (d <= 1 ? 1 : 2) * Math.pow(10,k);
    }

    public static void main(String... args) {
        for(double d : new double[]{0.13, 0.16, 0.91, 1.3, 1.31, 11, 19, 111, 191} ) {
           System.out.println("" + d + " -> " + round(d));
        }
    }
}

 

[tiek]

Sieht super aus!
Leider verstehe ich den Code noch nicht komplett. Wie würde man ein passendes Abrunden realisieren?

 

[Landei]

Abrunden wäre

...
return (d < 1 ? 0.2 : 1) * Math.pow(10,k);
...

Der Code ist absolut simpel: Die beiden Schleifen sorgen durch Multiplikation oder Division durch 10 dafür, dass d in das "Fenster" von 0.2 bis 2 passt. Ist dann d kleiner als 1, wird es auf 1, ansonsten auf 2 aufgerundet. Nun muss man natürlich d wieder auf die ursprüngliche "Größenordnung" bringen. Deshalb merken sich die Schleifen die Anzahl der Multiplikationen/Divisionen in der Variable k, so dass man diese Aktionen am Ende durch Multiplikation mit 10^k sozusagen wieder rückgangig macht.

 

[tiek]

Ich war scheinbar etwas zu früh mit meiner Freude.
Ich gebe noch mal ein paar Beispiele damit etwas klarer wird, was ich mir wünsche:
-0.13 -> -0.2
-0.16 -> -0.2
-0.34 -> -0.4
-0.61 -> -0.7
-0.91 -> -1.0
-1.3 -> -2.0
-1.31 -> -2.0
-6.1 -> -7.0
-11.0 -> -20.0
-19.0 -> -20.0
-83.3 -> -90.0
-111.0 -> -200.0
-191.0 -> -200.0

0.13 -> 0.2
0.16 -> 0.2
0.34 -> 0.4
0.61 -> 0.7
0.91 -> 1.0
1.3 -> 2.0
1.31 -> 2.0
6.1 -> 7.0
11.0 -> 20.0
19.0 -> 20.0
83.3 -> 90.0
111.0 -> 200.0
191.0 -> 200.0

 

[SlaterB]

und was funktioniert davon noch nicht? wäre ja bisschen mühsam selber zu testen,
wenn es nur um die negativen geht: feststellen ob negativ, merken, evtl. positiv machen, runden, am Ende wenn nötig wieder negativ machen

 

[SlaterB]

hier mal ein Code von mir, nur für positive Zahlen,
findet mehrere Abstufungen, kann bisher auch verkleinern (11 -> 10),

auch für Zahlen zwischen 0 und 1 geeignet

    public static final int[] FACTOR =
        {1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000};

   /**
     * Findet einen Faktor, eine Potenz von 10, mit dem eine Zahl multipliziert v werden
     * muss, damit sie größergleich 1 und kleiner 10 ist. Bisher nur im begrenzten
     * int-Bereich.
     * 
     * @param value
     * @return int
     */
    public static double findFactor(double value)
    {
        if (value <= 0) throw new RuntimException();
        double k = Math.log10(_alue);
        if (k > 1)
        {
            int x = (int)Math.ceil(k - 1);
            return FACTOR[x];
        }
        if (k < 0)
        {
            int x = (int)Math.ceil(-k);
            return 1.0 / FACTOR[x];
        }
        return 1;
    }

    /**
     * Normiert eine Zahl, liefert einfachere Werte in der Nähe, z.B. 20.000 für 19.000,
     * 10 für 11 usw.
     * 
     * @param value
     * @return int
     */
    public static double normalize(double value)
    {
        double fac = findFactor(value);
        // value nun zwischen 1 und 10
        value /= fac;
        if (value < 1.25)
            value = 1;
        else if (value < 1.75)
            value = 1.5;
        else if (value < 2.25)
            value = 2;
        else if (value < 2.75)
            value = 2.5;
        else if (value < 3.5)
            value = 3;
        else if (value < 4.5)
            value = 4;
        else if (value < 6.25)
            value = 5;
        else if (value < 8.75)
            value = 7.5;
        else
            value = 10;
        value *= fac;
        return value;
    }

 

[Ariol]

@SlaterB: Ich hab mir mal grad deinen Code geklaut :wink:

@tiek:

public class Round {
    public static double round(double d) {

        if(d==0) {
        	return 0;
        }

        int k = 0;
        
        double abs = Math.abs(d);
        double prefix=d/abs;
        
        //Nur eine Stelle vor dem Komma
        while(abs < 1) {
        	abs *= 10;
            k--;
        }
        while(abs >= 10) {
        	abs /= 10;
            k++;
        }
        
        return prefix * Math.ceil(abs) * Math.pow(10,k);
    }
 
    public static void main(String... args) {
        for(double d : new double[]{-0.13, 0.16, 0.34, 0.91, 1.3, -1.31, 11, 19, 111, 191} ) {
           System.out.println("" + d + " -> " + round(d));
        }
    }
}

EDIT: Division durch 0 verhindert.