VB kan niet rekenen???

[TlighT]

code:

Dim d As Double
d = 1 - 0.9
MsgBox d - 0.1

Daar komt bij mij dus -2.77555756156289E-17 uit. Eh???

[mbravenboer]

Welkom in de wereld van de floating point berekeningen .

Vrijwel alle programmeertalen gebruiken een niet decimale methode om floating point berekeningen te doen. Deze berekeningen zijn niet geheel exact omdat ze simpelweg niet exact gerepresenteerd kunnen worden op deze manier. Er zijn meestal aparte faciliteiten voor berekeningen die wel een hoge precisie nodig hebben. Wat dat voor VB is weet ik echter niet...

Stukje info van IBM over een Java implementatie:

Why BigDecimal: Computer systems must provide an arithmetic that gives the results that people expect. This is not available in Java today; a decimal floating point arithmetic is needed -- one which gives the same results as the arithmetic that people learn at school.

Why IBM is offering this trial version: IBM is looking for your evaluation and feedback on this technology. We want to know that this works for you and is, in fact, useful. If so, we will use your input through www.alphaworks.ibm.com/forums in our proposals to make this extension of Java commercially available to developers.

How it works: The BigDecimal class provides immutable arbitrary-precision decimal numbers. The methods of the BigDecimal class provide operations for fixed and floating point arithmetic, comparison, format conversions, and hashing. As the numbers are decimal, there is an exact correspondence between an instance of a BigDecimal object and its String representation; the BigDecimal class provides direct conversions to and from String and character array objects, and well as conversions to and from the Java primitive types (which may not be exact) and BigInteger. The internal representation of a decimal number is neither defined nor exposed, and is not permitted to affect the result of any operation. Operations on BigDecimal numbers are controlled by a MathContext object, which provides precision and other information. Default settings are used if no MathContext object is provided.

[Tsjipmanz]

Op dinsdag 25 september 2001 14:56 schreef TlighT het volgende:

code:

Dim d As Double
d = 1 - 0.9
MsgBox d - 0.1

Daar komt bij mij dus -2.77555756156289E-17 uit. Eh???

Ach, als je afrondt op 14 cijfers achter de komma is het afgeronde getal nog steeds 0

[Verwijderd]

Kort gezegt: een Double is niet gemaakt om 0 te zijn, als je nou een Currency neemt, doet ie het wel

[MrKoen]

Op dinsdag 25 september 2001 14:56 schreef TlighT het volgende:

code:

Dim d As Double
d = 1 - 0.9
MsgBox d - 0.1

Daar komt bij mij dus -2.77555756156289E-17 uit. Eh???

Hmm.. eens effies denken. Dat heb ik nog ooit opgevangen tussen het slapen door in een college Probeer eens:

code:

d = 1.0 - 0.9

Ik meen dat het iets met type casting te maken kan hebben. En omdat je met een integer (1) begint, cast ie d naar een integer. Ik weet dat je het in Java kan doen met:

code:

(float) d = 1.0 - 0.9

Denk nie dat dat in VB werkt. Probeer maar eens die 1.0.

Suc6

[D2k]

Op dinsdag 25 september 2001 14:56 schreef TlighT het volgende:

code:

Dim d As Double
d = 1 - 0.9
MsgBox d - 0.1

Daar komt bij mij dus -2.77555756156289E-17 uit. Eh???

kijk eens hoe dicht dit getal bij 0 ligt?

dat kan jij met een schaal zo groot als je huis nog niet eens tekenen
dus dit is nul

[tus]

Ik heb hetzelfde gedaan in VC++. Zie hier het verschil:

Resultaten van (1.0 - 0.9 - 0.1)
--------------------------------
VC++: -0.00000000000000002775557561562891400
VB : -0.00000000000000002775557561562890000

[TlighT]

Op dinsdag 25 september 2001 15:10 schreef mbravenboer het volgende:
Welkom in de wereld van de floating point berekeningen .

Vrijwel alle programmeertalen gebruiken een niet decimale methode om floating point berekeningen te doen. Deze berekeningen zijn niet geheel exact omdat ze simpelweg niet exact gerepresenteerd kunnen worden op deze manier. Er zijn meestal aparte faciliteiten voor berekeningen die wel een hoge precisie nodig hebben. Wat dat voor VB is weet ik echter niet...

Stukje info van IBM over een Java implementatie:

Ja, dom natuurlijk...
* TlighT slaat zichzelf voor zijn hoofd
terwijl ik in c gewoon

code:

if (abs(d2-d1) < DBL_EPSILON) { blaat; }

of zoiets had gedaan om twee doubles te vergelijken. Tja, als je een tijdje in VB programmeert ga je gelijk te simpel denken

Slotje?

[.oisyn]

Op dinsdag 25 september 2001 15:10 schreef mbravenboer het volgende:
Welkom in de wereld van de floating point berekeningen .

Vrijwel alle programmeertalen gebruiken een niet decimale methode om floating point berekeningen te doen. Deze berekeningen zijn niet geheel exact omdat ze simpelweg niet exact gerepresenteerd kunnen worden op deze manier. Er zijn meestal aparte faciliteiten voor berekeningen die wel een hoge precisie nodig hebben. Wat dat voor VB is weet ik echter niet...

floating point wordt gewoon door de cpu gedaan, en is dus niet programmeertaal afhankelijk. Tenzij je natuurlijk een soort van emulatie gebruikt, maar dat is hier niet ter sprake (of tenzij hier iemand nog op een 486 sx of langzamer code, maar dat kan ik me nauwelijks voorstellen )

[Tsjipmanz]

Op dinsdag 25 september 2001 16:10 schreef OiSyN het volgende:

[..]

floating point wordt gewoon door de cpu gedaan, en is dus niet programmeertaal afhankelijk.

Volgens mij wel afhankelijk van de implementatie van de verschillende compilers.

[.oisyn]

Op dinsdag 25 september 2001 16:17 schreef Tsjipmanz het volgende:

[..]

Volgens mij wel afhankelijk van de implementatie van de verschillende compilers.

niet dus

behalve dat je op de cpu de precizie min of meer kunt aangeven, dus als je bijvoorbeeld in gcc of vc++ compilet met de optie -O2, dan krijg je minder default precizie. In zo verre is het misschien compiler/distributie afhankelijk, maar dat heb je wel zelf in de hand

[Tsjipmanz]

Op dinsdag 25 september 2001 16:22 schreef OiSyN het volgende:

[..]

niet dus

behalve dat je op de cpu de precizie min of meer kunt aangeven, dus als je bijvoorbeeld in gcc of vc++ compilet met de optie -O2, dan krijg je minder default precizie. In zo verre is het misschien compiler/distributie afhankelijk, maar dat heb je wel zelf in de hand

Hmmm cool... Dus je kan in principe in QBasic berekeningen net zo nauwkeurig doen als in Fortran ofzo?

[Janoz]

Als je die getallen gewoon ff omschrijft naar binair, dan zie je precies wat er gebeurt..

Met binair bedoel ik ipv

0.14343 x 10³²¹

zo

0.1100110101 x 2¹⁰¹⁰¹

[edit in opdracht van Tsjipmanz]
Als je dus 1.0, 0.9 en 0.1 binair opschrijft zoals hierboven, vervolgens de berekening uitvoerd, dan zie je wel waar het bitje vandaan komt die er voor zorgt dat er niet precies 0 uit komt.
[/edit in opdracht van Tsjipmanz]

[.oisyn]

Op dinsdag 25 september 2001 16:24 schreef Tsjipmanz het volgende:

[..]

Hmmm cool... Dus je kan in principe in QBasic berekeningen net zo nauwkeurig doen als in Fortran ofzo?

uhm nee denk het niet, fortran en qbasic zijn zo oud, die stammen nog uit de tijd dat er geen coprocessors waren

dus daar is het nog wel compiler afhankelijk (maar dat zei ik dus al, alleen als je emulatie gebruikt )

[mbravenboer]

OiSyN: floating point wordt gewoon door de cpu gedaan, en is dus niet programmeertaal afhankelijk.

Klopt in de praktijk wel, maar in principe niet... Alle programmeer platformen bieden wel een methode om met correcte decimaal te werken. Deze zou ook als standaard implementatie van float en double berekeningen genomen kunnen worden. Ik ken geen talen/compilers/platformen die dit doen, maar daar gaat het niet om .