Zehnerpotenzen, Sorry für diese Frage



  • @hustbaer sagte in Sorry für diese Frage:

    Huch?
    Wieso abrunden und dann +1? Je nachdem wie der Fehler ausfällt kommt dabei nicht das richtige raus. Wenn als Ergebnis ne ganze Zahl gewünscht ist, dann einfach ganz normal runden.

    Gute Frage, was mir grade dabei durch den Kopf gegangen ist 😃 Ich glaube, ich hatte im Kopf die Anzahl der digits zählen. Dann müsste man denke ich abrunden und +1. Bzw. in dem Fall oben dann ohne die +1, weil in den Beispielen oben ist es ja immer number of digits - 1



  • @firefly sagte in Sorry für diese Frage:

    Also gibt es als input immer nur zahlen, welche mit einer 1 beginnt und dann 1-x anzahl von Nullen hat?

    Ja genau.

    @firefly sagte in Sorry für diese Frage:

    soll das ergebnis sein wie oft der Wert durch 10 geteilt werden kann

    Ja genau auch ... ich suche nach dem einfachsten Verfahren, was auch schnell wäre.



  • @hustbaer sagte in Sorry für diese Frage:

    Und was soll für 90 bzw. 110 rauskommen? Was für 1, 0 oder -10?

    Es gibt nur dieses Muster für die Eingabe: 1, 10, 100, 1000, usw. Für 1 soll es 0 ergeben (also die Zahl 0 - nicht null ...)



  • Das ginge nicht, oder?

    precision = (int) Math.pow(precision, 0.1);



  • Habe es geschafft

        public static BigDecimal roundQty(final double qty, final String name, final Info info) {
            double precision = info.getAsDouble(name);
            System.out.println("precision = " + precision);
            int iPrecision = 0;
            if (precision != 0) {
                iPrecision = (int) Math.round(Math.log10(1.0 / precision));
            }
            System.out.println("iPrecision = " + iPrecision);
            return BigDecimal.valueOf(qty).setScale(iPrecision, RoundingMode.HALF_UP);
        }
    
    System.out.println(roundQty(1.23456789, "ABC", info));
    System.out.println(roundQty(1.23456789, "DEF", info));
    

    Und die Ausgabe:

    precision = 1.0
    iPrecision = 0
    1
    precision = 0.001
    iPrecision = 3
    1.235
    
    


  • Das Problem war glaube ich einfach, dass ich viel zu kompliziert gedacht hatte...

    Aber dennoch die Frage, wenn es um Präzisionsangaben geht (Wie viele Nachkommastellen darf ein Wert höchstens haben?), welche Darstellung wäre dann besser:

    a) 4
    b) 1000
    c) 0.0001

    also, jetzt bezogen auf Computersysteme?



  • Das eigentliche Problem ist, dass deine Fragen wirr sind. Warum stellst du nicht von Anfang an dein eigentliches Problem / aufgabenstellung vor. Dann kann man vlt. auch vernünftigere Antworten gaben.

    siehe auch: https://de.wikipedia.org/wiki/XY-Problem



  • @Fragender sagte in Zehnerpotenzen, Sorry für diese Frage:

    Das Problem war glaube ich einfach, dass ich viel zu kompliziert gedacht hatte...

    Aber dennoch die Frage, wenn es um Präzisionsangaben geht (Wie viele Nachkommastellen darf ein Wert höchstens haben?), welche Darstellung wäre dann besser:

    a) 4
    b) 1000
    c) 0.0001

    also, jetzt bezogen auf Computersysteme?

    Die Gleitkommadatentypen haben schlichtweg eine begrenzte "Genauigkeit". Die Anzahl der möglichen NKS hängt also mehr oder minder davon ab, wieviel Fehler du bereit bist zu akzeptieren.

    Selbst "0.1" kann mit den Gleitkommadatentypen nicht exakt abgebildet werden, wenn ich mich recht entsinne.



  • @It0101 sagte in Zehnerpotenzen, Sorry für diese Frage:

    Die Anzahl der möglichen NKS hängt also mehr oder minder davon ab, wieviel Fehler du bereit bist zu akzeptieren.

    Die Genauigkeit hängt nicht von den NKS, sondern von den signifikanten Stellen ab.
    Bzw. NKS nur bei der Exponentialdarstellung z.B. 1E-1



  • @It0101 sagte in Zehnerpotenzen, Sorry für diese Frage:

    Selbst "0.1" kann mit den Gleitkommadatentypen nicht exakt abgebildet werden, wenn ich mich recht entsinne.

    Korrekt. 0.1=110=1250.1 = \frac{1}{10} = \frac{1}{2\, \cdot \, 5} Da ist also eine 5 im Nenner. Du brauchst aber eine reine 2er-Potenz im Nenner, um die Zahl darstellen zu können.

    Das siehst du auch, wenn du dir die Bits anguckst:

    root [0] double d;
    root [1] d=0.1;std::bitset<64>(*reinterpret_cast<ULong64_t*>(&d)).to_string()
    (std::basic_string<char, std::char_traits<char>, std::allocator<char> >) "0011111110111001100110011001100110011001100110011001100110011010"
    root [2] d=0.2;std::bitset<64>(*reinterpret_cast<ULong64_t*>(&d)).to_string()
    (std::basic_string<char, std::char_traits<char>, std::allocator<char> >) "0011111111001001100110011001100110011001100110011001100110011010"
    root [3] d=0.25;std::bitset<64>(*reinterpret_cast<ULong64_t*>(&d)).to_string()
    (std::basic_string<char, std::char_traits<char>, std::allocator<char> >) "0011111111010000000000000000000000000000000000000000000000000000"
    root [4] d=0.375;std::bitset<64>(*reinterpret_cast<ULong64_t*>(&d)).to_string()
    (std::basic_string<char, std::char_traits<char>, std::allocator<char> >) "0011111111011000000000000000000000000000000000000000000000000000"
    

    0.2=2/10=1/50.2 = 2/10 = 1/5 -> 5 ist keiner 2er Potenz, lässt sich nicht exakt darstellen
    0.25=1/4=1/(22)0.25 = 1/4 = 1/(2\cdot 2) -> geht also auf.
    0.375=3/8=3/230.375 = 3/8 = 3/2^3 -> geht auch auf.


Anmelden zum Antworten