[VB] Afronden naar boven

[phroze]

Iemand die weet hoe je bijvoorbeeld 1.4 kunt afronden naar 2?
is hier nog een handige functie voor in vb?

[Mischa_NL]

code:

variable = Abs(Int(-waarde))

typ voor de grap ook eens "ASP Rnd" in bij de zoekmachine

[phroze]

Dat had ik al geprobeerd, maar dan rond hij 1.4 af naar beneden (1). en het is juist de bedoeling dat hij alle getallen naar boven afrond

En met de Rnd functie precies hetzelfde. Ik dacht dat ik ergens in een boek gelezen had dat er een kleine functie voor in vb gebouwd zat. maar dat kan ik nu niet meer terugvinden

[Paul]

1/2 erbij optellen en het integer-deel nemen?

[Mischa_NL]

rond ie dan 4 niet naar 5 af?

edit: is het niet mogelijk elk NIET heel getal + 1 te doen en dan de decimalen eraf te halen?

[ Voor 63% gewijzigd door Mischa_NL op 02-08-2004 19:36 ]

[Wolfboy]

Math.Ceiling ?
of was dat alleen met .net

[phroze]

Paul Nieuwkamp schreef op 02 augustus 2004 @ 19:32:
1/2 erbij optellen en het integer-deel nemen?

Kijk daar moet je ook maar opkomen
Jeetje, binnen een minuut opgelost, dat gaat snel. Bedankt!

[phroze]

Wolfboy schreef op 02 augustus 2004 @ 19:35:
Math.Ceiling ?
of was dat alleen met .net

Dat is dotNET
maar heb het al voor elkaar nu

[Maasluip]

Fix(waarde)+1

[ Voor 3% gewijzigd door Maasluip op 02-08-2004 19:36 ]

[Paul]

Hmm, dat is alleen om 0.5 en hoger naar 1 af te ronden bendek ik net 0.4 wordt dan gewoon 0

Jij wilt dus blijkbaar ALTIJD het integer-deel + 1? Integerdeel nemen en 1 erbij optellen

[Lustucru]

Om er achter te komen dat 2 wordt afgerond naar 3.

code:

a: -sgn(x)*int(-sgn(x)*x)
b: -sgn(x)*int(-x)

a rondt 4,1 af op 5; -4,1 op -5
b rondt 4,1 af op 5; -4,1 op -4

[ Voor 34% gewijzigd door Lustucru op 02-08-2004 21:38 ]

[Mayco]

integerdeel plus een is niet helemaal correct, een 1 zal dan 2 worden, het moet dus groter zijn dan het integerdeel zelf.

zoiets dus:

if int(getal) != getal then
result = int(getal) +1
else
result = getal

[ Voor 29% gewijzigd door Mayco op 02-08-2004 21:37 ]

[Rac-On]

het getal is X, dan doe je:

code:

if(integer(x) == x){
 x = x ;
else{
 x = integer(x) + 1;
}

Maar er is vast wel een functie die dit voor je doet. (ik kan nauwelijks vb dus het is pseudo-code, maar het gaat om het idee)

[ Voor 19% gewijzigd door Rac-On op 02-08-2004 21:38 ]

[-DarkShadow-]

code:

'-----------------------------------------------------
'Author: Dr. John A. Nyhart
'work  : [e-mail]
'home  : [e-mail]
'web   : www.spessart.com/users/jnyhart/john1.htm
'Posted:7/22/97
'
'Here is a function to round a value up,down,or near 
'to another value.
'-----------------------------------------------------

Function doRound(value As Double, RStep As Double, Mode As String) As
Double
  ' ***********************
  ' Mode   function
  '  UP     RoundUp
  '  DN     RoundDN
  '  NE     Nearest
  '
  ' ***********************
  If Mode = "DN" Then
    doRound = (Int(value / RStep) * RStep)
    Exit Function
  End If
  
  ' **** mode up
  If Mode = "UP" Then
    If value Mod RStep > 0 Then
      doRound = ((Int(value / RStep) * RStep) + RStep)
    Else
      doRound = value
    End If
    Exit Function
  End If
  
  If Mode = "NE" Then
    value = value + (RStep / 2)
    doRound = (Int(value / RStep) * RStep)
    Exit Function
  End If
End Function

Zeker niet ideaal, maar een speciale functie schijnt er niet voor te zijn in visual basic 6. Als je heel vaak alleen naar boven moet afronden, dan zou ik er een speciale functie voor maken die alleen dat doet.
Heb het alvast voor je gedaan:

code:

Function RoundUp(ByVal val As Double)
        If Int(val) = val Then
            RoundUp = val
        Else
            RoundUp = Int(val) + 1
        End If
End Function

[ Voor 20% gewijzigd door -DarkShadow- op 02-08-2004 21:54 ]

[Paul]

Afhankelijk van het aantal decimalen dat je maximaal hebt kun je er natuurlijk ook 0.9(999) bij optellen en dan het integerdeel nemen

Ik weet alleen niet wat duurder is, 0.9(999) ergens bij optellen of die if-jes die hierboven staan

[phroze]

-DarkShadow- schreef op 02 augustus 2004 @ 21:50:
Zeker niet ideaal, maar een speciale functie schijnt er niet voor te zijn in visual basic 6. Als je heel vaak alleen naar boven moet afronden, dan zou ik er een speciale functie voor maken die alleen dat doet.
Heb het alvast voor je gedaan:

code:

Function RoundUp(ByVal val As Double)
        If Int(val) = val Then
            RoundUp = val
        Else
            RoundUp = Int(val) + 1
        End If
End Function

Simpel en effectief, mijn dank is groot
Dat 0.5 erbij optellen bleek namelijk ook voor geen meter te werken

[Paul]

phroze schreef op 03 augustus 2004 @ 18:32:

Dat 0.5 erbij optellen bleek namelijk ook voor geen meter te werken

Afhankelijk van je definitie van afronden Ik had de vraag eerst verkeerd geinterpeteerd

[Henk007]

-DarkShadow- schreef op 02 augustus 2004 @ 21:50:

code:

Function RoundUp(ByVal val As Double)
        If Int(val) = val Then

Ik heb ooit geleerd dat deze vergelijking 'if integer=real then' gevaarlijk kan zijn en in bepaalde gevallen foutieve antwoorden kan geven. De implementatie die erboven staat is robuuster door het gebruik van de mod funktie. Je zou dat overigens vrij eenvoudig kunnen testen door als input een waardes te geven als bv. 4-10^-12, 4, 4+10^-12.
Okee dat was destijds wel in een mierenn* setting van wiskundigen die er altijd iets van maakten als

code:

if a-b<epsilon then

[ Voor 30% gewijzigd door Henk007 op 03-08-2004 19:57 ]

[jan-marten]

Excuses voor de 'schop omhoog na een halfjaar' maar hier nog even mijn functies voor dit probleem. Op verschillende fora kwam ik de 'tel er 0.5 bij op' maar dit levert in sommige gevallen wat rare resultaten op.

Visual Basic:

' Functie   Floor
' Omschr.   Rond een gebroken getal af naar onderen
'           Floor( 1.6) = 1
'           Floor(-1.6) = -2
Public Function Floor(ByVal x As Double) As Long
    Floor = Sgn(x) * Abs(Int(x))
End Function

' Functie   Ceil
' Omschr    Rond af naar boven
Public Function Ceil(ByVal x As Double) As Long
    Ceil = Sgn(x) * Abs(Int(-x))
End Function

Ceil rond dus af naar +oneindig en Floor rond dus af naar -oneindig.

[.oisyn]

Je floor is een beetje raar aangezien Int(x) al precies doet wat floor ook doet. De Abs en Sgn zijn dus overbodig.

[RobIII]

Idem, maar nu met optioneel het aantal decimalen waarop je wil afronden (0 = hele getallen)

code:

Public Function Floor(ByVal x As Currency, Optional lDecimals As Long = 0) As Currency
    Floor = Int(x * (10 ^ lDecimals)) / 10 ^ lDecimals
End Function

Public Function Ceil(ByVal x As Currency, Optional lDecimals As Long = 0) As Currency
    Ceil = -Int(-x * (10 ^ lDecimals)) / 10 ^ lDecimals
End Function

Overigens wel redelijk "gevaarlijk" als je met erg grote getallen werkt
Disclaimer: Uit de losse pols, niet gechecked ...

[ Voor 17% gewijzigd door RobIII op 25-01-2005 12:42 ]

[angelina]

Visual Basic:

iVal = -Int(-dblVal)

En sign proof (bv -2.1 en 2.1):

Visual Basic:

iVal = IIf(dblVal < 0, Int(dblVal), -Int(-dblVal))

[ Voor 62% gewijzigd door angelina op 25-01-2005 15:20 ]