Zehnerpotenzen, Sorry für diese Frage

10 soll 1 ergeben
100 soll 2 ergeben
1000 soll 3 ergeben
usw.

Bitte schlagt mich nicht, aber wie rechnet man das? Ich hätte es mit dem log zur Basis 10 oder mit einer Schleife versucht, aber was ist richtig?

firefly

Nach den Beispielen zu urteile soll das ergebnis sein wie oft der Wert durch 10 geteilt werden kann.
Also gibt es als input immer nur zahlen, welche mit einer 1 beginnt und dann 1-x anzahl von Nullen hat?

Leon0402

Manchmal verstehe ich deine Frage wirklich nicht. Du hast sie dir noch selber beantwortet. Mit log zur Basis 10 kriegst du das relativ einfach hin (musst nur noch abrunden & +1 rechnen wegen der limited floating precission). Wozu also deine Frage?

Bist du dir nicht sicher welche Methode du nehmen sollst? Richtig und Nicht Richtig definiert man anhand von Kriterien. Da musst du uns schon sagen, was du genau vor hast. Ich würde mal behaupten: In deinem use case tun es alle Varianten. Die Variante mit log10 ist easy, also nutz die doch.

hustbaer

@Leon0402 sagte in Sorry für diese Frage:

musst nur noch abrunden & +1 rechnen wegen der limited floating precission)

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.

hustbaer

@Fragender
Und was soll für 90 bzw. 110 rauskommen? Was für 1, 0 oder -10?
Oder können nur zehnerpotenzen > 1 als Input vorkommen?

Leon0402

@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?

Leon0402

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

It0101

@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.

DirkB

@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

wob

@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 = \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/5$ -> 5 ist keiner 2er Potenz, lässt sich nicht exakt darstellen
$0.25 = 1/4 = 1/(2\cdot 2)$ -> geht also auf.
$0.375 = 3/8 = 3/2^3$ -> geht auch auf.