Runden von Zahlen

[redbomber]

hey, kann mir jemand einen Tip geben, wie ich effizient Zahlen runden kann?

Mein Problem:

Ich habe in Abhängigkeit der Größe eines JPanels eine Menge von Zahlen


Beispiel.:
value 1.9429999999999998
value 1.9430999999999998
value 1.9431999999999998
value 1.9432999999999998
value 1.9434
value 1.9435
value 1.9436
value 1.9437
value 1.9438
value 1.9439
value 1.944

Da ich diese Zahlen als String in das Panel schreiben möchte, formatiere ich diese Double-Werte, ich dem ich diese auf eine bestimmte ANzahl an Nachkommastellen reduziere.
Bisher werden diese auf zwei Nachkommastellen reduziert.
Bei diesen Zahlen oben habe ich dann das Problem, dass überall der String: 1.94 steht.
Das möchte ich natürlich nicht.

Wie bekomme ich also von dieser Menge an Zahlen heraus, auf wieviele Stellen nach dem Komma ich sie runden muss, damit sie alle unterschiedlich sind? (Also in diesem Beispiel 4 Nachkommastellen)

 

[SlaterB]

suche dir eine Startzahl aus, z.B. 8,
formatiere alle Zahlen als String mit 8 Stellen und suche den ersten Index, der nicht in allen Strings gleich ist
-> mit dem Index dann runden,
wenn bei 8 alles gleich ist, dann gehe auf 16,

oder fange mit einer Nachkommastelle an, dann 2, 3, 4, und wenn sich eine Stelle unterscheidet, dann bist du schon fertig

 

[Marco13]

Ja, ausprobieren ist eine Möglichkeit. Die andere ist... ausrechnen

Es geht ja vermutlich auch nicht um "effizient", sondern um "hübsch".

Eine Möglichkeit: Man berechnet die minimale (absolute) Differenz von irgendzwei Zahlen, und schaut, wie viele Stellen man braucht, um diese Zahl darstellen zu können. Was bei solchen Eingaben wie "0,0,0..." passieren soll, musst du dir überlegen (das Programm gibt in diesem Fall -1 zurück)

class FormatTest
{
    public static void main(String args[])
    {
        double input0[] = new double[] {
            1.9429999999999998,
            1.9430999999999998,
            1.9431999999999998,
            1.9432999999999998,
            1.9434,
            1.9435,
            1.9436,
            1.9437,
            1.9438,
            1.9439,
            1.944
        };
        System.out.println(computeDigits(input0));

        double input1[] = new double[] { 0, 0, 0 };
        System.out.println(computeDigits(input1));

        double input2[] = new double[] { 1000, 100000, 999999 };
        System.out.println(computeDigits(input2));

        double input3[] = new double[] { 0.1, 0.2, 0.9 };
        System.out.println(computeDigits(input3));

        double input4[] = new double[] { 0.01, 0.02, 0.09 };
        System.out.println(computeDigits(input4));

    }

    private static double computeMinAbsDifference(double data[])
    {
        double minAbsDifference = Double.MAX_VALUE;
        for (int i=0; i<data.length; i++)
        {
            for (int j=i+1; j<data.length; j++)
            {
                minAbsDifference = Math.min(minAbsDifference,
                    Math.abs(data[i]-data[j]));
            }
        }
        return minAbsDifference;
    }

    private static int computeDigits(double data[])
    {
        double minAbsDifference = computeMinAbsDifference(data);
        //System.out.println("minAbsDifference "+minAbsDifference);
        if (minAbsDifference < 1e-15)
        {
            return -1;
        }
        if (minAbsDifference >= 1)
        {
            return 0;
        }

        double log = Math.log10(minAbsDifference);
        //System.out.println("log "+log);
        return (int)Math.round(-log);
    }
}

 

[redbomber]

vielen Dank perfekt, genau sowas brauchte ich!!