# Rechnen mit sehr kleinen Zahlen



## michaelb (11. Jun 2008)

Hallo,

ich muss in meinem Programm mit sehr kleinen Zahlen rechnen. Es geht um Physik. So kommt natürlich auch 1,602*10-19 vor. Damit das ganze genau wird verwende ich BigDecimal, da Double viele Rundungsfehler reingemacht hatte. Gibt es Alternativen zu BigDecimal? Kann man .add und so nicht als + und so schreiben, weil es bei komplexeren Formeln leicht übersichtlich wird? 

MfG, Michael


----------



## Gast (11. Jun 2008)

Doch, es gibt ein paar Bibliotheken, leider fallen mir die Namen gerade nicht ein. Musst mal googlen. Ab Java 7 werden auch + und - bei BigDecimal funktionieren.


----------



## michaelb (11. Jun 2008)

Hallo,

gegoogelt hab ich schon recht oft und hab wenig gefunden 
Es funktioniert zwar mit BigDecimal aber sieht halt nicht so toll aus...
Ist es richtig, dass Double nur auf 17 Stellen genau ist?

MfG, Michael


----------



## Gast (11. Jun 2008)

kleine faktoren machen eigentlich nichts. problematisch wirds nur, wenn sehr kleine faktoren mit sehr grossen kombiniert werden.

dafür gibts halt bigdecimal. sieht zwar nicht ganz so schön aus, aber dafür bleibt die genauigkeit erhalten. würd mir darüber keine gedanken machen.


----------



## Marco13 (11. Jun 2008)

"Auf 17 Stellen" klingt eben irreführend (und es scheint, als hätte es das bei dir auch bewirkt). Es geht nicht um die Anzahl der Nachkommastellen, sondern um die Anzahl der _signifikanten_ Stellen - und da ist bei 17 Schluss. Intern werden double-Werte ja immer (grob) gespeichert als
1.XXXXXXXXXXXXXXXX * 2^Y
(siehe http://en.wikipedia.org/wiki/IEEE_754)
D.h. man kann 17 Stellen speichern, aber es ist "egal, wo sie sind". Zur Verdeutlichung:

```
0.0000000000000000000000000123  ( = 1.23 * 10^-27 )
+ 0.0000000000000000000000000123  ( = 1.23 * 10^-27 )
= 0.0000000000000000000000000245  ( = 2.46 * 10^-27 )
```
- kein Problem, obwohl man bei >17 Nachkommastellen rumrechnet.

```
0.0000000000000000000000000123  ( = 1.23 * 10^-27 )
+ 1.0                             ( = 1.0 * 10^0 )
= 1.0                             ( = 1.0 * 10^0 )
```
Weil die Zahl
1.0000000000000000000000000123  
mehr als 17 signifikante Stellen hat.


----------



## Wildcard (11. Jun 2008)

Literatur dazu:
http://docs.sun.com/source/806-3568/ncg_goldberg.html


----------



## michaelb (12. Jun 2008)

Hey,

danke! werd mir mal den Link genauer anschauen bzw. den Inhalt der Seite, auf die gelinkt ist.

MfG, Michael


----------



## Marco13 (12. Jun 2008)

Aber ob man sowas wie 
sk = (sk - 1 + yk)(1 + k)
= [sk - 1 + (xk - ck - 1) (1 + k)](1 + k)
= [(sk - 1 - ck - 1) - kck - 1](1+k)
ck = [{sk - sk - 1}(1 + k) - yk](1 + k)
= [{((sk - 1 - ck - 1) - kck - 1)(1 + k) - sk - 1}(1 + k) + ck - 1(1 + k)](1 + k)
= [{(sk - 1 - ck - 1)k - kck-1(1 + k) - ck - 1}(1 + k) + ck - 1(1 + k)](1 + k)
= [(sk - 1 - ck - 1)k(1 + k) - ck - 1(k + k(k + k + kk))](1 + k),
sk - ck = ((sk - 1 - ck - 1) - kck - 1) (1 + k)
- [(sk - 1 - ck - 1)k(1 + k) - ck - 1(k + k(k + k + kk)](1 + k)
= (sk- 1 - ck - 1)((1 + k) - k(1 + k)(1 + k))
+ ck - 1(-k(1 + k) + (k + k(k + k + kk)) (1 + k))
= (s- 1 - ck - 1) (1 - k(k + k + kk))
+ ck - 1 - [k + k + k(k + kk) + (k + k(k + k + kk))k] 
wirklich nachvollziehen muss, um zur EInsicht zu gelangen, dass double nicht beliebig genau ist, sei mal dahingestellt :wink:


----------



## Wildcard (12. Jun 2008)

Aber der Link funktioniert erstaunlich gut um zu verdeutlichen, dass Gleitkommazahlen eine komplexe Thematik sind  :wink:


----------

