# Mehr Nachkommastellen mit double



## kilopack15 (10. Nov 2016)

Hallo!
Double ist ja schon sehr genau, gibt mit System.out.println(double soundso); aber nur einen Bruchteil seines Potenzials preis. Kann man das ändern? Sodass man z.B. 50 Nackommatsellen einer double ausgeben kann?


----------



## JStein52 (10. Nov 2016)

nein. Dazu brauchst du dann z.B. BigDecimal. Damit ist die Zahl der Nachkommastellen mehr oder weniger nur durch den verfügbaren Speicher begrenzt.


----------



## kilopack15 (10. Nov 2016)

Was ist denn BigDecimal? Eine andere Programmiersprache?


----------



## Viktim (10. Nov 2016)

https://docs.oracle.com/javase/7/docs/api/java/math/BigDecimal.html Das 
Kannst du einfach so Erstellen:

```
import java.math.BigDecimal;

public class BigDecimalTest {
  public static void main(String[] args) {
    BigDecimal zahl = new BigDecimal("2.5555555555555555555555555555555555555");
    System.out.println(zahl);
  }
}
```


----------



## prise1993 (14. Nov 2016)

Gerechnet wird mit mehr Stellen als ausgegeben werden. Die Genauigkeit ist bei double sowieso ein eigenes Thema wegen der Speicherungsart! So werden sehr große Zahlen ungenauer wobei kleiner Zahlen genauer abgebildet werden können. Es ist auch wichtig zu beachten das auch wenn mehr Stellen ausgegeben werden die Ausgabe nicht genauer wird!

```
double c = 1.0/3.0;
        BigDecimal bc = new BigDecimal(c);
        System.out.println("bc = " + bc);
        System.out.println("c = " + c);
```
produziert die Ausgabe :
	
	
	
	





```
bc = 0.333333333333333314829616256247390992939472198486328125
c = 0.3333333333333333
```


----------



## JStein52 (14. Nov 2016)

Und was ist nun die Erkenntnis für den TE ?


----------



## prise1993 (14. Nov 2016)

Wollte nur mal darauf hinweisen das die double nicht genauer wird nur, weil man mehr Stellen ausgibt.
War ja in der Frage explizit gefordert das mehr Stellen von einem double ausgegeben werden sollen.
Hab mir gedacht das Beispiel veranschaulicht das ganz schön.


----------



## JCODA (14. Nov 2016)

prise1993 hat gesagt.:


> Wollte nur mal darauf hinweisen das die double nicht genauer wird nur, weil man mehr Stellen ausgibt.
> War ja in der Frage explizit gefordert das mehr Stellen von einem double ausgegeben werden sollen.
> Hab mir gedacht das Beispiel veranschaulicht das ganz schön.


Naja, ein BigDecimal kann nicht genauer als ein double sein, wenn du ihm den "double-Wert" 1.0/3.0 gibst. Da wurde ja zuerst in double gerechnet.
Richtig geht es so:


```
import java.math.*;
class Main {
  public static void main(String[] args) {
    
     MathContext precision = new MathContext(100);
     BigDecimal bc = BigDecimal.ONE.divide(new BigDecimal("3"),precision);
     System.out.println("bc = " + bc);
   
     double c = 1.0/3.0;
     System.out.println("c = " + c);
  }
}
```


----------



## prise1993 (14. Nov 2016)

> Naja, ein BigDecimal kann nicht genauer als ein double sein, wenn du ihm den "double-Wert" 1.0/3.0 gibst. Da wurde ja zuerst in double gerechnet.


Das ist mir schon klar wollte eigentlich nur zum Ausdruck bringen das es nicht genauer wird, wenn man sich mehr Nachkommastellen anzeigen lässt beim Rechnen mit double. 
Hab mich anscheinend nicht klar genug ausgedrückt sry.


----------



## Xyz1 (15. Nov 2016)

Die Aussage, double wird genauer, je kleiner er/sie/es ist, ist sowieso mit Vorsicht zu genießen - stimmt sie doch im Allgemeinen nicht


----------



## prise1993 (15. Nov 2016)

DerWissende hat gesagt.:


> Die Aussage, double wird genauer, je kleiner er/sie/es ist, ist sowieso mit Vorsicht zu genießen - stimmt sie doch im Allgemeinen nicht


Bei vielen führenden Nullen auf jedenfall und wenn die Zahl  sehr groß wird, wird auch der absolute Fehler größer werden! Wobei mir auch klar ist das auch manche sehr große Zahlen genau dargestellt werden.


----------



## Xyz1 (15. Nov 2016)

prise1993 hat gesagt.:


> Bei vielen führenden Nullen auf jedenfall und wenn die Zahl  sehr groß wird, wird auch der absolute Fehler größer werden! Wobei mir auch klar ist das auch manche sehr große Zahlen genau dargestellt werden.


Nein, ich kann gerne ein paar Gegenbeispiele bringen.

Manche tun schon wieder so, als seien sie wissend.

Bearbeitung: Es gibt eigentlich nur eine führende Null - und das ist


----------



## prise1993 (15. Nov 2016)

DerWissende hat gesagt.:


> Nein, ich kann gerne ein paar Gegenbeispiele bringen.
> 
> Manche tun schon wieder so, als seien sie wissend.
> 
> Bearbeitung: Es gibt eigentlich nur eine führende Null - und das ist


Bitte Gegenbeispiel!


----------



## InfectedBytes (15. Nov 2016)

Ein double hat eine Genauigkeit von etwa 15-16 Dezimalstellen. Wo dabei nun das Komma steht ist egal, das kannste nach belieben um bis zu 308 Stellen nach links oder rechts schieben.

Und nun noch simple Beispiele:
1.000000000000000001 kannste schon nicht mehr mit double darstellen

Und hier mit absoluten Fehlern zu argumentieren ist etwas unsinnig, da klar ist das der Fehler bei großen Zahlen größer wird...
Bei solchen Dingen einfach mal die Norm ansehen: https://de.wikipedia.org/wiki/IEEE_754


----------



## Xyz1 (15. Nov 2016)

double dbl1 = 1.0 / 6.0 * 100.0;
double dbl2 = 1.0 * 100.0 / 6.0;

Wir sind uns alle einig, dass 1.0 / 6.0 kleiner ist als 1.0 * 100.0 ... trotzdem ist dbl2 genauer als dbl1.

Es gibt noch mehr solcher Beispiele, zu finden auf StackOverflow! Nur, weil der double kleiner ist [0, 1] z. B., heißt das nicht IN JEDEM FALL, dass er auch genauer ist.

Sonst mag ich nicht so gerne diskutieren, weil, wie @InfectedBytes schon sagt, double ist genau spezifiziert. Auch das betreffende Fehler oder Abweichungen sind genau spezifiziert, musst du schon sagen, um welchen Fehler es sich handelt.


----------

