[VB 6.0] Fout in de Round functie?

[Verwijderd]

Fout in de Round functie

Round(2.5) levert bij mij 2 op. Round(2.51) levert wel netjes 3 op.

Ziet iemand hier de logica van?

[D2k]

Round(2.50) ?
wat doet dat?

[FitNiX]

Ja duh, dat is toch logisch.
Zo werkt die functie, als ie 2,5 is, rond ie hem af naar beneden, is ie 2,51 rond ie hem af omhoog

[edit]

D2k schreef op 13 november 2002 @ 10:40:
Round(2.50) ?
wat doet dat?

Die maakt een INT van een FLOAT
[/edit]

[gorgi_19]

En wat meer informatie:
http://www.xbeat.net/vbspeed/c_Round.htm

The native VB6 Round is problematic:
VB6 Round rounds 1/2 to nearest the even number (aka 'Banker's rounding')
Round(1.5) => 2
Round(2.5) => 2 !! should be 3 in 'Other people's rounding'
VB6 Round does *not* support numDecimalPlaces to be negative, eg:
Round(123.45, -1) => 120 !! run-time error 5 in VB6

Gevonden met Google

[D2k]

zuigerig
waarom zou je die functie zo implementeren?

[FitNiX]

In VB script werkt ie volgens mij wel goed hoor
http://www.devguru.com/..../round.html

[edit]
Zal eens ff testen.....
[/edit]

[gorgi_19]

D2k schreef op 13 november 2002 @ 10:46:
zuigerig
waarom zou je die functie zo implementeren?

* gorgi_19 blijft copy pasten..

code:

              ... some people think "Banker's rounding" is bad,
but it is not the case. This "Banker's" method uses the Gauss 
rule that if you are in an perfect half case, you must round to the 
nereast digit that can be divided by 2 (0,2,4,6,8). This rule is 
important to obtain more accurate results with rounded numbers after 
operation.

Now, an example :
                  2 digits                2 digits
Unrounded    "Standard" rounding    "Gaussian" rounding
  54.1754      54.18                  54.18
 343.2050     343.21                 343.20
+106.2038    +106.20                +106.20 
=========    =======                =======
 503.5842     503.59                 503.58

Which one is nearer from unrounded result ? The "Gaussian" one 
(Difference of 0.0042 with "Gaussian/Banker" and 0.0058 
with "Standard" rounding.)

Another example with half-round cases only:
                   1 digit                1 digit
Unrounded    "Standard" Rounding    "Gaussian rounding"
  27.25        27.3                   27.2
  27.45        27.5                   27.4  
+ 27.55      + 27.6                 + 27.6
=======      ======                 ======  
  82.25        82.4                   82.2

Again, the "Gaussian" rounding result is nearer from the unrounded 
result than the "Standard" one.

Dit schijnt de reden te zijn.. (Moet het zelf nog ff bestuderen.. )

[D2k]

mjah dat kan wel "de dichtsbijzijnde" zijn
maar waarom leer je dan dat
2.49999999999999999 -> 2
en
2.50000000000000000 -> 3
* D2k denkt dat VB zuigt _{op dit punt dan en imho enz enz}

[FitNiX]

Dat is stom, check ff m'n zojuist gemaakt ASP pagina:
ASP pagina

[gorgi_19]

Het voorbeeld gaat uit van tussentijds afronden, waarbij de fouten kunnen optreden. Op deze manier kan verklein je dus de foutkans..

In VB.Net hebben ze dit er wel uitgesloopt.. (Anders heb ik een klein probleempje met mijn pakket, denk ik.. )

Kermit schreef op 13 November 2002 @ 10:54:
Dat is stom, check ff m'n zojuist gemaakt ASP pagina:
ASP pagina

VB6 != VBscript; weet niet of ze hier een andere functie voor hebben geschreven...
Kan je ze anders ook proberen voor de waarden 3 en 4?

[D2k]

Kermit schreef op 13 november 2002 @ 10:54:
Dat is stom, check ff m'n zojuist gemaakt ASP pagina:
ASP pagina

zet even de acties erbij
het ene is VB round? en het andere?

[FitNiX]

D2k schreef op 13 November 2002 @ 10:55:

[...]

zet even de acties erbij
het ene is VB round? en het andere?

Het is allebei ROUND...
wacht...

ASP.NET Visual Basic:

<%
afrond1 = Round(1.5)
afrond2 = Round(2.5)
Response.write("1<B>.</B>5 wordt: " & afrond1 & "<BR>")
Response.write("2<B>.</B>5 wordt: " & afrond2 & "<P>")

afrond3 = Round(1,5)
afrond4 = Round(2,5)
Response.write("1<B>,</B>5 wordt: " & afrond3 & "<BR>")
Response.write("2<B>,</B>5 wordt: " & afrond4 & "<P>")
%>

[FitNiX]

Het werkt in VB precies hetzelfde hoor
Zal ff screenie maken van zojuist gebouwde proggie.....
Be Right Back.....

[edit]


Je moet dus gewoon een komma gebruiken...
[/edit]

[Verwijderd]

Wow, check nu pas weer. Best wat reacties teweeg gebracht zo

Best vaag dat Banker's algoritme, zie nog niet helemaal de logica in van het minimaliseren van afrondingsfouten, moet ik het wat beter bestuderen.

Komt banker trouwens van bankier? Dan maakt het geen zak uit, die applicatie die ik maak is toch bedoeld voor economen

[Crazy D]

In code moet je met een getal altijd een . als decimaalteken nemen... Doe je Round(1,2) dan ziet ie de int 1, die je op 2 posities achter de komma wilt afronden => gewoon 1 dus.

(o.a. met format(1.1, "0.0") kun je checken wat je decimaalteken is, bij mij geeft dit 1,1 => , dus Maar een hard gecodeerde float doe je altijd met een . )

De logica achter het afronden geloof ik direct. Ik heb niet voor niets een computer die dat voor me doet En hoe dat zoekt ie zelf maar uit...

[-bolio-]

Ik ben zoiets ook een keer tegen gekomen in een andere taaltje (weet alleen niet meer welke) wat ik toen deed was gewoon 0.5 bij het getal optellen en dan naar beneden laten afronden. Weet alleen niet of zo'n functie ook in vb zit

[Sponge]

Zo zijn er meer van die gevallen in VB, zoals bijv CInt() en Int()

[Verwijderd]

je moet ook niet vergeten dat floats nooit precies opgeslagen zijn, door de interne binaire representatie ervan

[Soultaker]

Verwijderd schreef op 13 november 2002 @ 20:43:
je moet ook niet vergeten dat floats nooit precies opgeslagen zijn, door de interne binaire representatie ervan

Zeg nooit nooit: 2.5 kan toevallig wél exact opgeslagen worden, als: (1 + (1/2) ^ 2) * (2 ^ 1). Dit geldt voor alle getallen die (binnen het redelijke) met een eindig aantal machten van 2 genoteerd kunnen worden. De exponenten daarvan moeten wel een beetje dicht bij elkaar liggen, though.

(Een meer gedetailleerde uitleg is wel een aantal keer gegeven, maar die is helaas vast niet te vinden met de search.)

[SA007]

In plaats van de Round functie kun je ook doen
<code>
Int(Getal +0.5)
</code>
Dat doet het wel goed

[D2k]

SA007 schreef op 13 november 2002 @ 22:03:
In plaats van de Round functie kun je ook doen
<code>
Int(Getal +0.5)
</code>
Dat doet het wel goed

das een ranzige oplossing imho

[vinnux]

Niks ranzigs aan hoor Word heeeel veel gebruikt hoe denk je dat een round dat zelf doet