Math.Round Methode

Definitie

Naamruimte:: System

Assembly's:: mscorlib.dll, System.Runtime.Extensions.dll

Assembly's:: netstandard.dll, System.Runtime.dll

Assembly:: System.Runtime.Extensions.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Belangrijk

Bepaalde informatie heeft betrekking op een voorlopige productversie die aanzienlijk kan worden gewijzigd voordat deze wordt uitgebracht. Microsoft biedt geen enkele expliciete of impliciete garanties met betrekking tot de informatie die hier wordt verstrekt.

Rondt een waarde af op het dichtstbijzijnde gehele getal of op het opgegeven aantal fractionele cijfers.

Overloads

Name	Description
Round(Double, Int32, MidpointRounding)	Rondt een drijvendekommagetalwaarde met dubbele precisie af op een opgegeven aantal fractionele cijfers met behulp van de opgegeven afrondingsconventie.
Round(Decimal, Int32, MidpointRounding)	Rondt een decimale waarde af op een opgegeven aantal fractionele cijfers met behulp van de opgegeven afrondingsconventie.
Round(Double, MidpointRounding)	Rondt een drijvendekommagetalwaarde met dubbele precisie af op een geheel getal met behulp van de opgegeven afrondingsconventie.
Round(Double, Int32)	Rondt een drijvendekommagetalwaarde met dubbele precisie af op een opgegeven aantal fractionele cijfers en rondt middelpuntwaarden af op het dichtstbijzijnde even getal.
Round(Decimal, Int32)	Rondt een decimale waarde af op een opgegeven aantal fractionele cijfers en rondt de middelpuntwaarden af op het dichtstbijzijnde even getal.
Round(Double)	Rondt een drijvendekommagetalwaarde met dubbele precisie af op de dichtstbijzijnde integrale waarde en rondt de middelpuntwaarden af op het dichtstbijzijnde even getal.
Round(Decimal)	Rondt een decimale waarde af op de dichtstbijzijnde integrale waarde en rondt de middelpuntwaarden af op het dichtstbijzijnde even getal.
Round(Decimal, MidpointRounding)	Rondt een decimale waarde af op een geheel getal met behulp van de opgegeven afrondingsconventie.

Voorbeelden

Naast de voorbeelden in de sectie Opmerkingen bevat dit artikel voorbeelden die de volgende overbelastingen van de Math.Round methode illustreren:

Math.Round(Decimal)Math.Round(Double)Math.Round(Decimal, Int32)Math.Round(Decimal, MidpointRounding)Math.Round(Double, Int32)Math.Round(Double, MidpointRounding)Math.Round(Decimal, Int32, MidpointRounding)Math.Round(Double, Int32, MidpointRounding)

Opmerkingen

In deze sectie:

Welke methode roep ik aan?
Middelpuntwaarden en afrondingsconventies
Afronding en precisie
Drijvendekommawaarden met één precisie afronden en één precisie
Voorbeelden van individuele overbelastingen

Welke methode roep ik aan?

U kunt de volgende tabel gebruiken om een geschikte afrondingsmethode te selecteren. Naast de Math.Round methoden bevat Math.Ceiling het ook en Math.Floor.

Tot	Call
Rond een getal af op een geheel getal met behulp van de afrondings-naar-dichtstbijzijnde conventie.	Round(Decimal) – of – Round(Double)
Rond een getal af op een geheel getal met behulp van een opgegeven afrondingsconventie.	Round(Decimal, MidpointRounding) – of – Round(Double, MidpointRounding)
Rond een getal af op een opgegeven aantal fractionele cijfers met behulp van de afronding naar de dichtstbijzijnde conventie.	Round(Decimal, Int32) – of – Round(Double, Int32)
Rond een getal af op een opgegeven aantal fractionele cijfers met behulp van een opgegeven afrondingsconventie.	Round(Decimal, Int32, MidpointRounding) – of – Round(Double, Int32, MidpointRounding)
Rond een Single waarde af op een opgegeven aantal fractionele cijfers met behulp van een opgegeven afrondingsconventie en minimaliseer het verlies van precisie.	Converteer de Single naar een Decimal en oproep Round(Decimal, Int32, MidpointRounding).
Rond een getal af op een opgegeven aantal fractionele cijfers en minimaliseer problemen met precisie bij het afronden van middelpuntwaarden.	Roep een afrondingsmethode aan die een vergelijking 'groter dan of ongeveer gelijk aan' implementeert. Zie Afronding en precisie.
Rond een breukwaarde af op een geheel getal dat groter is dan de breukwaarde. Bijvoorbeeld ronde 3,1 tot en met 4.	Ceiling
Rond een breukwaarde af op een geheel getal dat kleiner is dan de breukwaarde. Bijvoorbeeld ronde 3,9 tot 3.	Floor

Middelpuntwaarden en afrondingsconventies

Afronding omvat het converteren van een numerieke waarde met een opgegeven precisie naar een waarde met minder precisie. U kunt bijvoorbeeld de Round(Double) methode gebruiken om een waarde van 3,4 tot 3,0 af te ronden en de Round(Double, Int32) methode om een waarde van 3,579 tot 3,58 af te ronden.

In een middelpuntwaarde is de waarde na het minst significante cijfer in het resultaat precies halverwege tussen twee getallen. 3,47500 is bijvoorbeeld een middelpuntwaarde als deze moet worden afgerond op twee decimalen en 7,500 een middelpuntwaarde is als deze moet worden afgerond op een geheel getal. Als de round-to-dichtstbijzijnde strategie wordt gebruikt, kan de dichtstbijzijnde waarde niet eenvoudig worden geïdentificeerd zonder een afrondingsconventie.

De Round methode ondersteunt twee afrondingsconventies voor het verwerken van middelpuntwaarden:

Afronden van nul

Middelpuntwaarden worden afgerond op het volgende getal weg van nul. 3,75 rondt bijvoorbeeld af op 3,8, 3,85 rondt af op 3,9, -3,75 rondt af op -3,8 en -3,85 rondt af op -3,9. Deze vorm van afronding wordt vertegenwoordigd door het MidpointRounding.AwayFromZero opsommingslid.
Afronden op het dichtstbijzijnde even of de afronding van bankiers

Middelpuntwaarden worden afgerond op het dichtstbijzijnde even getal. Bijvoorbeeld: zowel 3,75 als 3,85 afronden op 3,8, en zowel -3,75 als -3,85 afronden op -3,8. Deze vorm van afronding wordt vertegenwoordigd door het MidpointRounding.ToEven opsommingslid.

Note

In .NET Core 3.0 en latere versies zijn drie extra afrondingsstrategieën beschikbaar via de opsomming MidpointRounding. Deze strategieën worden in alle gevallen gebruikt, niet alleen voor middelpuntwaarden als MidpointRounding.ToEven en MidpointRounding.AwayFromZero wel.

Afronding van nul is de meest bekende vorm van afronding, terwijl afronding naar het dichtstbijzijnde zelfs de standaard is in financiële en statistische activiteiten. Het voldoet aan IEEE Standard 754, sectie 4. Bij gebruik in meerdere afrondingsbewerkingen vermindert afronding naar dichtstbijzijnde zelfs de afrondingsfout die wordt veroorzaakt door consistent afronden van middelpuntwaarden in één richting. In sommige gevallen kan deze afrondingsfout aanzienlijk zijn.

In het volgende voorbeeld ziet u de vooroordelen die kunnen voortvloeien uit het consistent afronden van middelpuntwaarden in één richting. Het voorbeeld berekent het werkelijke gemiddelde van een matrix met Decimal waarden en berekent vervolgens het gemiddelde wanneer de waarden in de matrix worden afgerond met behulp van de twee conventies. In dit voorbeeld zijn het werkelijke gemiddelde en het gemiddelde dat resulteert bij afronding op dichtstbijzijnde waarde hetzelfde. Het gemiddelde dat resulteert bij het afronden van nul verschilt echter met .05 (of met 3,6%) van het werkelijke gemiddelde.

decimal[] values = { 1.15m, 1.25m, 1.35m, 1.45m, 1.55m, 1.65m };
decimal sum = 0;

// Calculate true mean.
foreach (var value in values)
    sum += value;

Console.WriteLine("True mean:     {0:N2}", sum / values.Length);

// Calculate mean with rounding away from zero.
sum = 0;
foreach (var value in values)
    sum += Math.Round(value, 1, MidpointRounding.AwayFromZero);

Console.WriteLine("AwayFromZero:  {0:N2}", sum / values.Length);

// Calculate mean with rounding to nearest.
sum = 0;
foreach (var value in values)
    sum += Math.Round(value, 1, MidpointRounding.ToEven);

Console.WriteLine("ToEven:        {0:N2}", sum / values.Length);

// The example displays the following output:
//       True mean:     1.40
//       AwayFromZero:  1.45
//       ToEven:        1.40

open System

let values = [| 1.15m; 1.25m; 1.35m; 1.45m; 1.55m; 1.65m |]
let mutable sum = 0m

// Calculate true mean.
for value in values do
    sum <- sum + value

printfn $"True mean:     {sum / decimal values.Length:N2}"

// Calculate mean with rounding away from zero.
sum <- 0m
for value in values do
    sum <- sum + Math.Round(value, 1, MidpointRounding.AwayFromZero)

printfn $"AwayFromZero:  {sum / decimal values.Length:N2}"

// Calculate mean with rounding to nearest.
sum <- 0m
for value in values do
    sum <- sum + Math.Round(value, 1, MidpointRounding.ToEven)

printfn $"ToEven:        {sum / decimal values.Length:N2}"

// The example displays the following output:
//       True mean:     1.40
//       AwayFromZero:  1.45
//       ToEven:        1.40

Dim values() As Decimal = {1.15D, 1.25D, 1.35D, 1.45D, 1.55D, 1.65D}
Dim sum As Decimal

' Calculate true mean.
For Each value In values
    sum += value
Next
Console.WriteLine("True mean:     {0:N2}", sum / values.Length)

' Calculate mean with rounding away from zero.
sum = 0
For Each value In values
    sum += Math.Round(value, 1, MidpointRounding.AwayFromZero)
Next
Console.WriteLine("AwayFromZero:  {0:N2}", sum / values.Length)

' Calculate mean with rounding to nearest.
sum = 0
For Each value In values
    sum += Math.Round(value, 1, MidpointRounding.ToEven)
Next
Console.WriteLine("ToEven:        {0:N2}", sum / values.Length)

' The example displays the following output:
'       True mean:     1.40
'       AwayFromZero:  1.45
'       ToEven:        1.40

De methode gebruikt standaard Round de ronde naar dichtstbijzijnde even conventie. De volgende tabel bevat de overbelastingen van de Round methode en de afrondingsconventie die elk gebruikt.

Overload	Afrondingsconventie
Round(Decimal)	ToEven
Round(Double)	ToEven
Round(Decimal, Int32)	ToEven
Round(Double, Int32)	ToEven
Round(Decimal, MidpointRounding)	Bepaald door `mode` parameter.
Round(Double, MidpointRounding)	Bepaald door `mode` parameter
Round(Decimal, Int32, MidpointRounding)	Bepaald door `mode` parameter
Round(Double, Int32, MidpointRounding)	Bepaald door `mode` parameter

Afronding en precisie

Om te bepalen of een afrondingsbewerking een middelpuntwaarde omvat, vermenigvuldigt de Round methode de oorspronkelijke waarde die moet worden afgerond met 10ⁿ, waarbij n het gewenste aantal fractionele cijfers in de retourwaarde is en vervolgens bepaalt of het resterende breukgedeelte van de waarde groter is dan of gelijk is aan ,5. Dit is een kleine variatie op een gelijkheidstest, en zoals besproken in de sectie Testen op gelijkheid van het Double referentieonderwerp, zijn tests voor gelijkheid met drijvendekommagewaarden problematisch vanwege de problemen van de drijvendekommage-indeling met binaire representatie en precisie. Dit betekent dat elk breukgedeelte van een getal dat iets kleiner is dan ,5 (vanwege een verlies van precisie) niet naar boven wordt afgerond.

In het volgende voorbeeld ziet u het probleem. Het voegt herhaaldelijk .1 toe aan 11,0 en rondt het resultaat af op het dichtstbijzijnde gehele getal. 11,5 moet afronden op 12 met behulp van een van de conventies voor afronding van middelpunten (ToEven of AwayFromZero). Zoals in de uitvoer uit het voorbeeld wordt weergegeven, is dit echter niet het geval. In het voorbeeld wordt de standaardtekenreeks voor numerieke R-notatie gebruikt om de volledige precisie van de drijvendekommawaarde weer te geven en wordt aangegeven dat de waarde die moet worden afgerond, de precisie is verloren gegaan tijdens herhaalde toevoegingen, en de waarde is in feite 11,499999999999998. Omdat .499999999999998 kleiner is dan 0,5, komen de middelpuntafrondingsconventies niet in het spel en wordt de waarde naar beneden afgerond. Zoals in het voorbeeld ook wordt weergegeven, treedt dit probleem niet op als u de constante waarde 11,5 toewijst aan een Double variabele.

public static void Example()
{
    Console.WriteLine("{0,5} {1,20:R}  {2,12} {3,15}\n",
                      "Value", "Full Precision", "ToEven",
                      "AwayFromZero");
    double value = 11.1;
    for (int ctr = 0; ctr <= 5; ctr++)
        value = RoundValueAndAdd(value);

    Console.WriteLine();

    value = 11.5;
    RoundValueAndAdd(value);
}

private static double RoundValueAndAdd(double value)
{
    Console.WriteLine("{0,5:N1} {0,20:R}  {1,12} {2,15}",
                      value, Math.Round(value, MidpointRounding.ToEven),
                      Math.Round(value, MidpointRounding.AwayFromZero));
    return value + .1;
}

// The example displays the following output:
//       Value       Full Precision        ToEven    AwayFromZero
//
//        11.1                 11.1            11              11
//        11.2                 11.2            11              11
//        11.3   11.299999999999999            11              11
//        11.4   11.399999999999999            11              11
//        11.5   11.499999999999998            11              11
//        11.6   11.599999999999998            12              12
//
//        11.5                 11.5            12              12

open System

let roundValueAndAdd (value: double) =
    printfn $"{value,5:N1} {value,20:R}  {Math.Round(value, MidpointRounding.ToEven),12} {Math.Round(value, MidpointRounding.AwayFromZero),15}"
    value + 0.1

printfn "%5s %20s  %12s %15s\n" "Value" "Full Precision" "ToEven" "AwayFromZero"
let mutable value = 11.1
for _ = 0 to 5 do
    value <- roundValueAndAdd value

printfn ""

value <- 11.5
roundValueAndAdd value
|> ignore

// The example displays the following output:
//       Value       Full Precision        ToEven    AwayFromZero
//
//        11.1                 11.1            11              11
//        11.2                 11.2            11              11
//        11.3   11.299999999999999            11              11
//        11.4   11.399999999999999            11              11
//        11.5   11.499999999999998            11              11
//        11.6   11.599999999999998            12              12
//
//        11.5                 11.5            12              12

Public Sub Example()
    Dim value As Double = 11.1

    Console.WriteLine("{0,5} {1,20:R}  {2,12} {3,15}",
                    "Value", "Full Precision", "ToEven",
                    "AwayFromZero")
    Console.WriteLine()
    For ctr As Integer = 0 To 5
        value = RoundValueAndAdd(value)
    Next
    Console.WriteLine()

    value = 11.5
    RoundValueAndAdd(value)
End Sub

Private Function RoundValueAndAdd(value As Double) As Double
    Console.WriteLine("{0,5:N1} {0,20:R}  {1,12} {2,15}",
                    value, Math.Round(value, MidpointRounding.ToEven),
                    Math.Round(value, MidpointRounding.AwayFromZero))
    Return value + 0.1
End Function

' The example displays the following output:
'       Value       Full Precision        ToEven    AwayFromZero
'       
'        11.1                 11.1            11              11
'        11.2                 11.2            11              11
'        11.3   11.299999999999999            11              11
'        11.4   11.399999999999999            11              11
'        11.5   11.499999999999998            11              11
'        11.6   11.599999999999998            12              12
'       
'        11.5                 11.5            12              12

Problemen met precisie bij het afronden van middelpuntwaarden komen waarschijnlijk voor in de volgende omstandigheden:

Wanneer een breukwaarde niet nauwkeurig kan worden uitgedrukt in de binaire indeling van het type drijvende komma.
Wanneer de waarde die moet worden afgerond, wordt berekend op basis van een of meer drijvendekommabewerkingen.
Wanneer de waarde die moet worden afgerond, een in plaats van een Single Double of Decimalis. Zie de volgende sectie, Afronding en drijvendekommawaarden met één precisie voor meer informatie.

In gevallen waarin het ontbreken van precisie bij afrondingsbewerkingen problematisch is, kunt u het volgende doen:

Als de afrondingsbewerking een overbelasting aanroept waarmee een Double waarde wordt afgerond, kunt u de Double waarde wijzigen in een Decimal waarde en een overbelasting aanroepen die een Decimal waarde rondt. Hoewel het Decimal gegevenstype ook problemen heeft met weergave en verlies van precisie, zijn deze problemen veel minder gebruikelijk.

Definieer een aangepast afrondingsalgoritmen waarmee een 'bijna gelijk'-test wordt uitgevoerd om te bepalen of de waarde die moet worden afgerond acceptabel is ten opzichte van een middelpuntwaarde. In het volgende voorbeeld wordt een RoundApproximate methode gedefinieerd waarmee wordt onderzocht of een breukwaarde voldoende dicht bij een middelpuntwaarde ligt om te worden afgerond op middelpunten. Zoals in de uitvoer van het voorbeeld wordt weergegeven, wordt het afrondingsprobleem gecorrigeerd dat in het vorige voorbeeld wordt weergegeven.

public static void Example()
{
    Console.WriteLine("{0,5} {1,20:R}  {2,12} {3,15}\n",
                      "Value", "Full Precision", "ToEven",
                      "AwayFromZero");
    double value = 11.1;
    for (int ctr = 0; ctr <= 5; ctr++)
        value = RoundValueAndAdd(value);

    Console.WriteLine();

    value = 11.5;
    RoundValueAndAdd(value);
}

private static double RoundValueAndAdd(double value)
{
    const double tolerance = 8e-14;

    Console.WriteLine("{0,5:N1} {0,20:R}  {1,12} {2,15}",
                      value,
                      RoundApproximate(value, 0, tolerance, MidpointRounding.ToEven),
                      RoundApproximate(value, 0, tolerance, MidpointRounding.AwayFromZero));
    return value + .1;
}

private static double RoundApproximate(double dbl, int digits, double margin,
                                  MidpointRounding mode)
{
    double fraction = dbl * Math.Pow(10, digits);
    double value = Math.Truncate(fraction);
    fraction = fraction - value;
    if (fraction == 0)
        return dbl;

    double tolerance = margin * dbl;
    // Determine whether this is a midpoint value.
    if ((fraction >= .5 - tolerance) & (fraction <= .5 + tolerance))
    {
        if (mode == MidpointRounding.AwayFromZero)
            return (value + 1) / Math.Pow(10, digits);
        else
           if (value % 2 != 0)
            return (value + 1) / Math.Pow(10, digits);
        else
            return value / Math.Pow(10, digits);
    }
    // Any remaining fractional value greater than .5 is not a midpoint value.
    if (fraction > .5)
        return (value + 1) / Math.Pow(10, digits);
    else
        return value / Math.Pow(10, digits);
}

// The example displays the following output:
//       Value       Full Precision        ToEven    AwayFromZero
//
//        11.1                 11.1            11              11
//        11.2                 11.2            11              11
//        11.3   11.299999999999999            11              11
//        11.4   11.399999999999999            11              11
//        11.5   11.499999999999998            12              12
//        11.6   11.599999999999998            12              12
//
//        11.5                 11.5            12              12

open System

let roundApproximate dbl digits margin mode =
    let fraction = dbl * Math.Pow(10, digits)
    let value = Math.Truncate fraction
    let fraction = fraction - value
    if fraction = 0 then
        dbl
    else
        let tolerance = margin * dbl
        // Determine whether this is a midpoint value.
        if (fraction >= 0.5 - tolerance) && (fraction <= 0.5 + tolerance) then
            if mode = MidpointRounding.AwayFromZero then
                (value + 1.) / Math.Pow(10, digits)
            elif value % 2. <> 0 then
                (value + 1.) / Math.Pow(10, digits)
            else
                value / Math.Pow(10, digits)
        // Any remaining fractional value greater than .5 is not a midpoint value.
        elif fraction > 0.5 then
            (value + 1.) / Math.Pow(10, digits)
        else
            value / Math.Pow(10, digits)


let roundValueAndAdd value =
    let tolerance = 8e-14
    let round = roundApproximate value 0 tolerance

    printfn $"{value,5:N1} {value,20:R}  {round MidpointRounding.ToEven,12} {round MidpointRounding.AwayFromZero,15}"
    value + 0.1

printfn "%5s %20s  %12s %15s\n" "Value" "Full Precision" "ToEven" "AwayFromZero"
let mutable value = 11.1
for _ = 0 to 5 do
    value <- roundValueAndAdd value

printfn ""

value <- 11.5
roundValueAndAdd value 
|> ignore

// The example displays the following output:
//       Value       Full Precision        ToEven    AwayFromZero
//
//        11.1                 11.1            11              11
//        11.2                 11.2            11              11
//        11.3   11.299999999999999            11              11
//        11.4   11.399999999999999            11              11
//        11.5   11.499999999999998            12              12
//        11.6   11.599999999999998            12              12
//
//        11.5                 11.5            12              12

Public Sub Example()
    Dim value As Double = 11.1

    Console.WriteLine("{0,5} {1,20:R}  {2,12} {3,15}\n",
                    "Value", "Full Precision", "ToEven",
                    "AwayFromZero")
    For ctr As Integer = 0 To 5
        value = RoundValueAndAdd(value)
    Next
    Console.WriteLine()

    value = 11.5
    RoundValueAndAdd(value)
End Sub

Private Function RoundValueAndAdd(value As Double) As Double
    Const tolerance As Double = 0.00000000000008
    Console.WriteLine("{0,5:N1} {0,20:R}  {1,12} {2,15}",
                    value,
                    RoundApproximate(value, 0, tolerance, MidpointRounding.ToEven),
                    RoundApproximate(value, 0, tolerance, MidpointRounding.AwayFromZero))
    Return value + 0.1
End Function

Private Function RoundApproximate(dbl As Double, digits As Integer, margin As Double,
                                 mode As MidpointRounding) As Double
    Dim fraction As Double = dbl * Math.Pow(10, digits)
    Dim value As Double = Math.Truncate(fraction)
    fraction = fraction - value
    If fraction = 0 Then Return dbl

    Dim tolerance As Double = margin * dbl
    ' Determine whether this is a midpoint value.
    If (fraction >= 0.5 - tolerance) And (fraction <= 0.5 + tolerance) Then
        If mode = MidpointRounding.AwayFromZero Then
            Return (value + 1) / Math.Pow(10, digits)
        Else
            If value Mod 2 <> 0 Then
                Return (value + 1) / Math.Pow(10, digits)
            Else
                Return value / Math.Pow(10, digits)
            End If
        End If
    End If
    ' Any remaining fractional value greater than .5 is not a midpoint value.
    If fraction > 0.5 Then
        Return (value + 1) / Math.Pow(10, digits)
    Else
        Return value / Math.Pow(10, digits)
    End If
End Function

' The example displays the following output:
'       Value       Full Precision        ToEven    AwayFromZero
'       
'        11.1                 11.1            11              11
'        11.2                 11.2            11              11
'        11.3   11.299999999999999            11              11
'        11.4   11.399999999999999            11              11
'        11.5   11.499999999999998            12              12
'        11.6   11.599999999999998            12              12
'       
'        11.5                 11.5            12              12

Drijvendekommawaarden met één precisie afronden en één precisie

De Round methode bevat overbelastingen die argumenten van het type Decimal accepteren en Double. Er zijn geen methoden waarmee waarden van het type Singleworden afgerond. Als u een Single-waarde doorgeeft aan een van de overbelastingen van de methode Round, wordt deze cast (in C#) of geconverteerd (in Visual Basic) naar een Double en wordt de bijbehorende Round overbelasting met een parameter Double aangeroepen. Hoewel dit een verbrekingsconversie is, gaat het vaak om verlies van precisie, zoals in het volgende voorbeeld wordt geïllustreerd. Wanneer een Single waarde van 16,325 wordt doorgegeven aan de Round methode en wordt afgerond op twee decimalen met behulp van de afronding naar de dichtstbijzijnde conventie, is het resultaat 16,33 en niet het verwachte resultaat van 16,32.

Single value = 16.325f;
Console.WriteLine("Widening Conversion of {0:R} (type {1}) to {2:R} (type {3}): ",
                  value, value.GetType().Name, (double)value,
                  ((double)(value)).GetType().Name);
Console.WriteLine(Math.Round(value, 2));
Console.WriteLine(Math.Round(value, 2, MidpointRounding.AwayFromZero));
Console.WriteLine();

Decimal decValue = (decimal)value;
Console.WriteLine("Cast of {0:R} (type {1}) to {2} (type {3}): ",
                  value, value.GetType().Name, decValue,
                  decValue.GetType().Name);
Console.WriteLine(Math.Round(decValue, 2));
Console.WriteLine(Math.Round(decValue, 2, MidpointRounding.AwayFromZero));

// The example displays the following output:
//    Widening Conversion of 16.325 (type Single) to 16.325000762939453 (type Double):
//    16.33
//    16.33
//
//    Cast of 16.325 (type Single) to 16.325 (type Decimal):
//    16.32
//    16.33

// In F#, 'float', 'float64', and 'double' are aliases for System.Double...
// 'float32' and 'single' are aliases for System.Single
open System

let value = 16.325f
printfn $"Widening Conversion of {value:R} (type {value.GetType().Name}) to {double value:R} (type {(double value).GetType().Name}): "
printfn $"{Math.Round(decimal value, 2)}"
printfn $"{Math.Round(decimal value, 2, MidpointRounding.AwayFromZero)}"
printfn ""

let decValue = decimal value
printfn $"Cast of {value:R} (type {value.GetType().Name}) to {decValue} (type {decValue.GetType().Name}): "
printfn $"{Math.Round(decValue, 2)}"
printfn $"{Math.Round(decValue, 2, MidpointRounding.AwayFromZero)}"

// The example displays the following output:
//    Widening Conversion of 16.325 (type Single) to 16.325000762939453 (type Double):
//    16.33
//    16.33
//
//    Cast of 16.325 (type Single) to 16.325 (type Decimal):
//    16.32
//    16.33

Dim value As Single = 16.325
Console.WriteLine("Widening Conversion of {0:R} (type {1}) to {2:R} (type {3}): ",
                value, value.GetType().Name, CDbl(value),
                CDbl(value).GetType().Name)
Console.WriteLine(Math.Round(value, 2))
Console.WriteLine(Math.Round(value, 2, MidpointRounding.AwayFromZero))
Console.WriteLine()

Dim decValue As Decimal = CDec(value)
Console.WriteLine("Cast of {0:R} (type {1}) to {2} (type {3}): ",
                value, value.GetType().Name, decValue,
                decValue.GetType().Name)
Console.WriteLine(Math.Round(decValue, 2))
Console.WriteLine(Math.Round(decValue, 2, MidpointRounding.AwayFromZero))
Console.WriteLine()

' The example displays the following output:
'    Widening Conversion of 16.325 (type Single) to 16.325000762939453 (type Double):
'    16.33
'    16.33
'    
'    Cast of 16.325 (type Single) to 16.325 (type Decimal):
'    16.32
'    16.33

Dit onverwachte resultaat wordt veroorzaakt door een verlies van precisie in de conversie van de Single waarde naar een Double. Omdat de resulterende Double waarde van 16,325000762939453 geen middelpuntwaarde is en groter is dan 16,325, wordt deze altijd naar boven afgerond.

Zoals in het voorbeeld wordt geïllustreerd, kan het verlies van precisie worden geminimaliseerd of geëlimineerd door de Single waarde te casten of te converteren naar een Decimal. Houd er rekening mee dat, omdat dit een smalle conversie is, het vereist dat een cast-operator wordt gebruikt of een conversiemethode wordt aangeroepen.

Round(Double, Int32, MidpointRounding)

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Rondt een drijvendekommagetalwaarde met dubbele precisie af op een opgegeven aantal fractionele cijfers met behulp van de opgegeven afrondingsconventie.

public:
 static double Round(double value, int digits, MidpointRounding mode);

public static double Round(double value, int digits, MidpointRounding mode);

static member Round : double * int * MidpointRounding -> double

Public Shared Function Round (value As Double, digits As Integer, mode As MidpointRounding) As Double

Parameters

value: Double

Een drijvendekommagetal met dubbele precisie dat moet worden afgerond.

digits: Int32

Het aantal fractionele cijfers in de retourwaarde.

mode: MidpointRounding

Een van de opsommingswaarden die aangeeft welke afrondingsstrategie moet worden gebruikt.

Retouren

Double

Het getal met digits fractionele cijfers dat value wordt afgerond op. Als value er minder fractionele cijfers zijn dan digits, value wordt ongewijzigd geretourneerd.

Uitzonderingen

ArgumentOutOfRangeException

digits is kleiner dan 0 of groter dan 15.

ArgumentException

mode is geen geldige waarde van MidpointRounding.

Opmerkingen

De waarde van het digits argument kan variëren van 0 tot 15. Het maximum aantal integrale en fractionele cijfers dat door het Double type wordt ondersteund, is 15.

Zie middelpuntwaarden en afrondingsconventies voor informatie over het afronden van getallen met middelpuntwaarden.

Important

Bij het afronden van middelpuntwaarden voert het afrondingsalgoritmen een gelijkheidstest uit. Vanwege problemen met binaire weergave en precisie in de drijvendekommage-indeling, kan de waarde die door de methode wordt geretourneerd onverwacht zijn. Zie Afronding en precisie voor meer informatie.

Als de waarde van het value argument is Double.NaN, retourneert Double.NaNde methode . Als value dat het is Double.PositiveInfinity of Double.NegativeInfinity, wordt de methode geretourneerd Double.PositiveInfinity of Double.NegativeInfinityrespectievelijk.

Voorbeeld

In het volgende voorbeeld ziet u hoe u de Round(Double, Int32, MidpointRounding) methode gebruikt met de MidpointRounding opsomming.


// Round a positive and a negative value using the default.
double result = Math.Round(3.45, 1);
Console.WriteLine($"{result,4} = Math.Round({3.45,5}, 1)");
result = Math.Round(-3.45, 1);
Console.WriteLine($"{result,4} = Math.Round({-3.45,5}, 1)\n");

// Round a positive value using a MidpointRounding value.
result = Math.Round(3.45, 1, MidpointRounding.ToEven);
Console.WriteLine($"{result,4} = Math.Round({3.45,5}, 1, MidpointRounding.ToEven)");
result = Math.Round(3.45, 1, MidpointRounding.AwayFromZero);
Console.WriteLine($"{result,4} = Math.Round({3.45,5}, 1, MidpointRounding.AwayFromZero)");
result = Math.Round(3.47, 1, MidpointRounding.ToZero);
Console.WriteLine($"{result,4} = Math.Round({3.47,5}, 1, MidpointRounding.ToZero)\n");

// Round a negative value using a MidpointRounding value.
result = Math.Round(-3.45, 1, MidpointRounding.ToEven);
Console.WriteLine($"{result,4} = Math.Round({-3.45,5}, 1, MidpointRounding.ToEven)");
result = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero);
Console.WriteLine($"{result,4} = Math.Round({-3.45,5}, 1, MidpointRounding.AwayFromZero)");
result = Math.Round(-3.47, 1, MidpointRounding.ToZero);
Console.WriteLine($"{result,4} = Math.Round({-3.47,5}, 1, MidpointRounding.ToZero)\n");

// The example displays the following output:

//         3.4 = Math.Round( 3.45, 1)
//         -3.4 = Math.Round(-3.45, 1)

//         3.4 = Math.Round(3.45, 1, MidpointRounding.ToEven)
//         3.5 = Math.Round(3.45, 1, MidpointRounding.AwayFromZero)
//         3.4 = Math.Round(3.47, 1, MidpointRounding.ToZero)

//         -3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
//         -3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)
//         -3.4 = Math.Round(-3.47, 1, MidpointRounding.ToZero)

// Round a positive and a negative value using the default.
let result = Math.Round(3.45, 1)
printfn $"{result,4} = Math.Round({3.45,5}, 1)"
let result = Math.Round(-3.45, 1)
printfn $"{result,4} = Math.Round({-3.45,5}, 1)\n"

// Round a positive value using a MidpointRounding value.
let result = Math.Round(3.45, 1, MidpointRounding.ToEven)
printfn $"{result,4} = Math.Round({3.45,5}, 1, MidpointRounding.ToEven)"
let result = Math.Round(3.45, 1, MidpointRounding.AwayFromZero)
printfn $"{result,4} = Math.Round({3.45,5}, 1, MidpointRounding.AwayFromZero)"
let result = Math.Round(3.47, 1, MidpointRounding.ToZero)
printfn $"{result,4} = Math.Round({3.47,5}, 1, MidpointRounding.ToZero)\n"

// Round a negative value using a MidpointRounding value.
let result = Math.Round(-3.45, 1, MidpointRounding.ToEven)
printfn $"{result,4} = Math.Round({-3.45,5}, 1, MidpointRounding.ToEven)"
let result = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)
printfn $"{result,4} = Math.Round({-3.45,5}, 1, MidpointRounding.AwayFromZero)"
let result = Math.Round(-3.47, 1, MidpointRounding.ToZero)
printfn $"{result,4} = Math.Round({-3.47,5}, 1, MidpointRounding.ToZero)\n"

// The example displays the following output:

//         3.4 = Math.Round( 3.45, 1)
//         -3.4 = Math.Round(-3.45, 1)

//         3.4 = Math.Round(3.45, 1, MidpointRounding.ToEven)
//         3.5 = Math.Round(3.45, 1, MidpointRounding.AwayFromZero)
//         3.4 = Math.Round(3.47, 1, MidpointRounding.ToZero)

//         -3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
//         -3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)
//         -3.4 = Math.Round(-3.47, 1, MidpointRounding.ToZero)

Dim posValue As Double = 3.45
Dim negValue As Double = -3.45

' Round a positive and a negative value using the default.  
Dim result As Double = Math.Round(posValue, 1)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1)", result, posValue)
result = Math.Round(negValue, 1)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1)", result, negValue)
Console.WriteLine()

' Round a positive value using a MidpointRounding value. 
result = Math.Round(posValue, 1, MidpointRounding.ToEven)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)",
                   result, posValue)
result = Math.Round(posValue, 1, MidpointRounding.AwayFromZero)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)",
                   result, posValue)
Console.WriteLine()

' Round a positive value using a MidpointRounding value. 
result = Math.Round(negValue, 1, MidpointRounding.ToEven)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)",
                    result, negValue)
result = Math.Round(negValue, 1, MidpointRounding.AwayFromZero)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)",
                   result, negValue)
Console.WriteLine()

'This code example produces the following results:

'  3.4 = Math.Round( 3.45, 1)
' -3.4 = Math.Round(-3.45, 1)

' 3.4 = Math.Round( 3.45, 1, MidpointRounding.ToEven)
' 3.5 = Math.Round( 3.45, 1, MidpointRounding.AwayFromZero)

' -3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
' -3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)

Notities voor bellers

Vanwege het verlies van precisie dat kan resulteren uit het weergeven van decimale waarden als drijvendekommanummers of het uitvoeren van rekenkundige bewerkingen op drijvende-kommawaarden, lijkt de Round(Double, Int32, MidpointRounding) methode in sommige gevallen geen middelpuntwaarden af te ronden zoals opgegeven door de mode parameter. Dit wordt geïllustreerd in het volgende voorbeeld, waarbij 2.135 wordt afgerond op 2.13 in plaats van 2.14. Dit komt doordat de methode intern vermenigvuldigt value met 10^cijfers en de vermenigvuldigingsbewerking in dit geval lijdt aan een verlies van precisie.

double[] values = { 2.125, 2.135, 2.145, 3.125, 3.135, 3.145 };
foreach (double value in values)
   Console.WriteLine("{0} --> {1}", value,
                     Math.Round(value, 2, MidpointRounding.AwayFromZero));

// The example displays the following output:
//       2.125 --> 2.13
//       2.135 --> 2.13
//       2.145 --> 2.15
//       3.125 --> 3.13
//       3.135 --> 3.14
//       3.145 --> 3.15

open System

let values = [| 2.125; 2.135; 2.145; 3.125; 3.135; 3.145 |]
for value in values do
    printfn $"{value} --> {Math.Round(value, 2, MidpointRounding.AwayFromZero)}"
// The example displays the following output:
//       2.125 --> 2.13
//       2.135 --> 2.13
//       2.145 --> 2.15
//       3.125 --> 3.13
//       3.135 --> 3.14
//       3.145 --> 3.15

Module Example
   Public Sub Main()
      Dim values() As Double = { 2.125, 2.135, 2.145, 3.125, 3.135, 3.145 }
      For Each value As Double In values
         Console.WriteLine("{0} --> {1}", value, 
                           Math.Round(value, 2, MidpointRounding.AwayFromZero))
      Next
   End Sub
End Module
' The example displays the following output:
'       2.125 --> 2.13
'       2.135 --> 2.13
'       2.145 --> 2.15
'       3.125 --> 3.13
'       3.135 --> 3.14
'       3.145 --> 3.15

Zie ook

Van toepassing op

Round(Decimal, Int32, MidpointRounding)

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Rondt een decimale waarde af op een opgegeven aantal fractionele cijfers met behulp van de opgegeven afrondingsconventie.

public:
 static System::Decimal Round(System::Decimal d, int decimals, MidpointRounding mode);

public static decimal Round(decimal d, int decimals, MidpointRounding mode);

static member Round : decimal * int * MidpointRounding -> decimal

Public Shared Function Round (d As Decimal, decimals As Integer, mode As MidpointRounding) As Decimal

Parameters

d: Decimal

Een decimaal getal dat moet worden afgerond.

decimals: Int32

Het aantal decimalen in de retourwaarde.

mode: MidpointRounding

Een van de opsommingswaarden die aangeeft welke afrondingsstrategie moet worden gebruikt.

Retouren

Decimal

Het getal met decimals fractionele cijfers waarnaar d wordt afgerond. Als d er minder fractionele cijfers zijn dan decimals, d wordt ongewijzigd geretourneerd.

Uitzonderingen

ArgumentOutOfRangeException

decimals is kleiner dan 0 of groter dan 28.

ArgumentException

mode is geen geldige waarde van MidpointRounding.

OverflowException

Het resultaat valt buiten het bereik van een Decimal.

Opmerkingen

Zie middelpuntwaarden en afrondingsconventies voor informatie over het afronden van getallen met middelpuntwaarden.

Important

De waarde van het decimals argument kan variëren van 0 tot 28.

Voorbeeld

In het volgende voorbeeld ziet u hoe u de Round methode gebruikt met de MidpointRounding opsomming.

decimal result;

// Round a positive value using different strategies.
// The precision of the result is 1 decimal place.

result = Math.Round(3.45m, 1, MidpointRounding.ToEven);
Console.WriteLine($"{result} = Math.Round({3.45m}, 1, MidpointRounding.ToEven)");
result = Math.Round(3.45m, 1, MidpointRounding.AwayFromZero);
Console.WriteLine($"{result} = Math.Round({3.45m}, 1, MidpointRounding.AwayFromZero)");
result = Math.Round(3.47m, 1, MidpointRounding.ToZero);
Console.WriteLine($"{result} = Math.Round({3.47m}, 1, MidpointRounding.ToZero)\n");

// Round a negative value using different strategies.
// The precision of the result is 1 decimal place.

result = Math.Round(-3.45m, 1, MidpointRounding.ToEven);
Console.WriteLine($"{result} = Math.Round({-3.45m}, 1, MidpointRounding.ToEven)");
result = Math.Round(-3.45m, 1, MidpointRounding.AwayFromZero);
Console.WriteLine($"{result} = Math.Round({-3.45m}, 1, MidpointRounding.AwayFromZero)");
result = Math.Round(-3.47m, 1, MidpointRounding.ToZero);
Console.WriteLine($"{result} = Math.Round({-3.47m}, 1, MidpointRounding.ToZero)\n");

/*
This code example produces the following results:

3.4 = Math.Round(3.45, 1, MidpointRounding.ToEven)
3.5 = Math.Round(3.45, 1, MidpointRounding.AwayFromZero)
3.4 = Math.Round(3.47, 1, MidpointRounding.ToZero)

-3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
-3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)
-3.4 = Math.Round(-3.47, 1, MidpointRounding.ToZero)
*/

// Round a positive value using different strategies.
// The precision of the result is 1 decimal place.

let result = Math.Round(3.45m, 1, MidpointRounding.ToEven)
printfn $"{result} = Math.Round({3.45m}, 1, MidpointRounding.ToEven)"
let result = Math.Round(3.45m, 1, MidpointRounding.AwayFromZero)
printfn $"{result} = Math.Round({3.45m}, 1, MidpointRounding.AwayFromZero)"
let result = Math.Round(3.47m, 1, MidpointRounding.ToZero)
printfn $"{result} = Math.Round({3.47m}, 1, MidpointRounding.ToZero)\n"

// Round a negative value using different strategies.
// The precision of the result is 1 decimal place.

let result = Math.Round(-3.45m, 1, MidpointRounding.ToEven)
printfn $"{result} = Math.Round({-3.45m}, 1, MidpointRounding.ToEven)"
let result = Math.Round(-3.45m, 1, MidpointRounding.AwayFromZero)
printfn $"{result} = Math.Round({-3.45m}, 1, MidpointRounding.AwayFromZero)"
let result = Math.Round(-3.47m, 1, MidpointRounding.ToZero)
printfn $"{result} = Math.Round({-3.47m}, 1, MidpointRounding.ToZero)\n"

// This code example produces the following results:

// 3.4 = Math.Round(3.45, 1, MidpointRounding.ToEven)
// 3.5 = Math.Round(3.45, 1, MidpointRounding.AwayFromZero)
// 3.4 = Math.Round(3.47, 1, MidpointRounding.ToZero)

// -3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
// -3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)
// -3.4 = Math.Round(-3.47, 1, MidpointRounding.ToZero)

Dim result As Decimal = 0D
Dim posValue As Decimal = 3.45D
Dim negValue As Decimal = -3.45D

' Round a positive value using different strategies.
' The precision of the result is 1 decimal place.
result = Math.Round(posValue, 1, MidpointRounding.ToEven)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)",
                   result, posValue)
result = Math.Round(posValue, 1, MidpointRounding.AwayFromZero)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)",
                   result, posValue)
result = Math.Round(posValue, 1, MidpointRounding.ToZero)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToZero)",
                   result, posValue)
Console.WriteLine()

' Round a negative value using different strategies.
' The precision of the result is 1 decimal place.
result = Math.Round(negValue, 1, MidpointRounding.ToEven)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)",
                    result, negValue)
result = Math.Round(negValue, 1, MidpointRounding.AwayFromZero)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)",
                   result, negValue)
result = Math.Round(negValue, 1, MidpointRounding.ToZero)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToZero)",
                   result, negValue)
Console.WriteLine()

'This code example produces the following results:
'
'        3.4 = Math.Round(3.45, 1, MidpointRounding.ToEven)
'        3.5 = Math.Round(3.45, 1, MidpointRounding.AwayFromZero)
'        3.4 = Math.Round(3.45, 1, MidpointRounding.ToZero)
'
'        -3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
'        -3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)
'        -3.4 = Math.Round(-3.45, 1, MidpointRounding.ToZero)
'

Zie ook

Van toepassing op

Round(Double, MidpointRounding)

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Rondt een drijvendekommagetalwaarde met dubbele precisie af op een geheel getal met behulp van de opgegeven afrondingsconventie.

public:
 static double Round(double value, MidpointRounding mode);

public static double Round(double value, MidpointRounding mode);

static member Round : double * MidpointRounding -> double

Public Shared Function Round (value As Double, mode As MidpointRounding) As Double

Parameters

value: Double

Een drijvendekommagetal met dubbele precisie dat moet worden afgerond.

mode: MidpointRounding

Een van de opsommingswaarden die aangeeft welke afrondingsstrategie moet worden gebruikt.

Retouren

Double

Het gehele getal dat value wordt afgerond op. Deze methode retourneert een Double in plaats van een integraal type.

Uitzonderingen

ArgumentException

mode is geen geldige waarde van MidpointRounding.

Opmerkingen

Zie middelpuntwaarden en afrondingsconventies voor informatie over het afronden van getallen met middelpuntwaarden.

Important

Voorbeeld

In het volgende voorbeeld worden waarden weergegeven die worden geretourneerd door de Round(Double, MidpointRounding) methode met verschillende mode waarden.

Double[] values = { 12.0, 12.1, 12.2, 12.3, 12.4, 12.5, 12.6,
                  12.7, 12.8, 12.9, 13.0 };
Console.WriteLine($"{"Value",-10} {"Default",-10} {"ToEven",-10} {"AwayFromZero",-15} {"ToZero",-15}");

foreach (var value in values)
    Console.WriteLine($"{value,-10:R} {Math.Round(value),-10} " +
        $"{Math.Round(value, MidpointRounding.ToEven),-10} " +
        $"{Math.Round(value, MidpointRounding.AwayFromZero),-15} " +
        $"{Math.Round(value, MidpointRounding.ToZero),-15}");

// The example displays the following output:
//       Value      Default    ToEven     AwayFromZero    ToZero
//       12         12         12         12              12
//       12.1       12         12         12              12
//       12.2       12         12         12              12
//       12.3       12         12         12              12
//       12.4       12         12         12              12
//       12.5       12         12         13              12
//       12.6       13         13         13              12
//       12.7       13         13         13              12
//       12.8       13         13         13              12
//       12.9       13         13         13              12
//       13         13         13         13              13

open System

let values = 
    [| 12.; 12.1; 12.2; 12.3; 12.4; 12.5
       12.6; 12.7; 12.8; 12.9; 13. |]

printfn "%-10s %-10s %-10s %-15s %-15s" "Value" "Default" "ToEven" "AwayFromZero" "ToZero"

for value in values do
    $"{value,-10:R} {Math.Round(value),-10} " +
    $"{Math.Round(value, MidpointRounding.ToEven),-10} " +
    $"{Math.Round(value, MidpointRounding.AwayFromZero),-15} " +
    $"{Math.Round(value, MidpointRounding.ToZero),-15}"
    |> printfn "%s"
    
// The example displays the following output:
//       Value      Default    ToEven     AwayFromZero    ToZero
//       12         12         12         12              12
//       12.1       12         12         12              12
//       12.2       12         12         12              12
//       12.3       12         12         12              12
//       12.4       12         12         12              12
//       12.5       12         12         13              12
//       12.6       13         13         13              12
//       12.7       13         13         13              12
//       12.8       13         13         13              12
//       12.9       13         13         13              12
//       13         13         13         13              13

Dim values() As Double = {12.0, 12.1, 12.2, 12.3, 12.4, 12.5, 12.6,
                         12.7, 12.8, 12.9, 13.0}
Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15} {4,-15}", "Value", "Default",
                "ToEven", "AwayFromZero", "ToZero")
For Each value In values
    Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15} {4,-15}",
                   value, Math.Round(value),
                   Math.Round(value, MidpointRounding.ToEven),
                   Math.Round(value, MidpointRounding.AwayFromZero),
                   Math.Round(value, MidpointRounding.ToZero))
Next

' The example displays the following output:
'       Value      Default    ToEven     AwayFromZero     ToZero
'       12         12         12         12               12
'       12.1       12         12         12               12
'       12.2       12         12         12               12
'       12.3       12         12         12               12
'       12.4       12         12         12               12
'       12.5       12         12         13               12
'       12.6       13         13         13               12
'       12.7       13         13         13               12
'       12.8       13         13         13               12
'       12.9       13         13         13               12
'       13         13         13         13               13

Notities voor bellers

Vanwege het verlies van precisie dat kan resulteren uit het weergeven van decimale waarden als drijvendekommage getallen of het uitvoeren van rekenkundige bewerkingen op drijvendekommawaarden, lijkt de Round(Double, MidpointRounding) methode in sommige gevallen geen middelpuntwaarden af te ronden op het dichtstbijzijnde even gehele getal. In het volgende voorbeeld, omdat de drijvende-kommawaarde .1 geen eindige binaire weergave heeft, retourneert de eerste aanroep naar de Round(Double) methode met een waarde van 11,5 11 in plaats van 12.

using System;

public class Example
{
   public static void Main()
   {
      double value = 11.1;
      for (int ctr = 0; ctr <= 5; ctr++)
         value = RoundValueAndAdd(value);

      Console.WriteLine();

      value = 11.5;
      RoundValueAndAdd(value);
   }

   private static double RoundValueAndAdd(double value)
   {
      Console.WriteLine("{0} --> {1}", value, Math.Round(value,
                        MidpointRounding.AwayFromZero));
      return value + .1;
   }
}
// The example displays the following output:
//       11.1 --> 11
//       11.2 --> 11
//       11.3 --> 11
//       11.4 --> 11
//       11.5 --> 11
//       11.6 --> 12
//
//       11.5 --> 12

open System

let roundValueAndAdd (value: float) =
      printfn $"{value} --> {Math.Round(value, MidpointRounding.AwayFromZero)}"
      value + 0.1

let mutable value = 11.1
for _ = 0 to 5 do
    value <- roundValueAndAdd value

printfn ""

value <- 11.5
roundValueAndAdd value
|> ignore

// The example displays the following output:
//       11.1 --> 11
//       11.2 --> 11
//       11.3 --> 11
//       11.4 --> 11
//       11.5 --> 11
//       11.6 --> 12
//
//       11.5 --> 12

Module Example
   Public Sub Main()
      Dim value As Double = 11.1
      For ctr As Integer = 0 To 5    
         value = RoundValueAndAdd(value)
      Next
      Console.WriteLine()

      value = 11.5
      RoundValueAndAdd(value)
   End Sub
   
   Private Function RoundValueAndAdd(value As Double) As Double
      Console.WriteLine("{0} --> {1}", value, Math.Round(value, 
                        MidpointRounding.AwayFromZero))
      Return value + .1
   End Function   
End Module
' The example displays the following output:
'       11.1 --> 11
'       11.2 --> 11
'       11.3 --> 11
'       11.4 --> 11
'       11.5 --> 11
'       11.6 --> 12
'       
'       11.5 --> 12

Zie ook

Van toepassing op

Round(Double, Int32)

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Rondt een drijvendekommagetalwaarde met dubbele precisie af op een opgegeven aantal fractionele cijfers en rondt middelpuntwaarden af op het dichtstbijzijnde even getal.

public:
 static double Round(double value, int digits);

public static double Round(double value, int digits);

static member Round : double * int -> double

Public Shared Function Round (value As Double, digits As Integer) As Double

Parameters

value: Double

Een drijvendekommagetal met dubbele precisie dat moet worden afgerond.

digits: Int32

Het aantal fractionele cijfers in de retourwaarde.

Retouren

Double

Het getal dat het dichtst value bij het getal ligt dat een aantal fractionele cijfers bevat die gelijk zijn aan digits.

Uitzonderingen

ArgumentOutOfRangeException

digits is kleiner dan 0 of groter dan 15.

Opmerkingen

De waarde van het digits argument kan variëren van 0 tot 15. Het maximum aantal integrale en fractionele cijfers dat door het Double type wordt ondersteund, is 15.

Deze methode maakt gebruik van de standaard afrondingsconventie van MidpointRounding.ToEven. Zie middelpuntwaarden en afrondingsconventies voor informatie over het afronden van getallen met middelpuntwaarden.

Important

Voorbeeld

In het volgende voorbeeld worden dubbele waarden afgerond met twee fractionele cijfers om te verdubbelen met één breukcijfer.

Math.Round(3.44, 1); //Returns 3.4.
Math.Round(3.45, 1); //Returns 3.4.
Math.Round(3.46, 1); //Returns 3.5.

Math.Round(4.34, 1); // Returns 4.3
Math.Round(4.35, 1); // Returns 4.4
Math.Round(4.36, 1); // Returns 4.4

open System

printfn $"{Math.Round(3.44, 1)}" //Returns 3.4.
printfn $"{Math.Round(3.45, 1)}" //Returns 3.4.
printfn $"{Math.Round(3.46, 1)}" //Returns 3.5.

printfn $"{Math.Round(4.34, 1)}" // Returns 4.3
printfn $"{Math.Round(4.35, 1)}" // Returns 4.4
printfn $"{Math.Round(4.36, 1)}" // Returns 4.4

Math.Round(3.44, 1) 'Returns 3.4.
Math.Round(3.45, 1) 'Returns 3.4.
Math.Round(3.46, 1) 'Returns 3.5.

Math.Round(4.34, 1) ' Returns 4.3
Math.Round(4.35, 1) ' Returns 4.4
Math.Round(4.36, 1) ' Returns 4.4

Notities voor bellers

Vanwege het verlies van precisie dat kan voortvloeien uit het weergeven van decimale waarden als drijvendekommanummers of het uitvoeren van rekenkundige bewerkingen op drijvende-kommawaarden, lijkt de Round(Double, Int32) methode in sommige gevallen geen middelpuntwaarden af te ronden op de dichtstbijzijnde even waarde in de digits decimale positie. Dit wordt geïllustreerd in het volgende voorbeeld, waarbij 2.135 wordt afgerond op 2.13 in plaats van 2.14. Dit komt doordat de methode intern vermenigvuldigt value met 10^cijfers en de vermenigvuldigingsbewerking in dit geval lijdt aan een verlies van precisie.

using System;

public class Example
{
   public static void Main()
   {
      double[] values = { 2.125, 2.135, 2.145, 3.125, 3.135, 3.145 };
      foreach (double value in values)
         Console.WriteLine("{0} --> {1}", value, Math.Round(value, 2));
   }
}
// The example displays the following output:
//       2.125 --> 2.12
//       2.135 --> 2.13
//       2.145 --> 2.14
//       3.125 --> 3.12
//       3.135 --> 3.14
//       3.145 --> 3.14

open System

let values = [| 2.125; 2.135; 2.145; 3.125; 3.135; 3.145 |]
for value in values do
    printfn $"{value} --> {Math.Round(value, 2)}"
// The example displays the following output:
//       2.125 --> 2.12
//       2.135 --> 2.13
//       2.145 --> 2.14
//       3.125 --> 3.12
//       3.135 --> 3.14
//       3.145 --> 3.14

Module Example
   Public Sub Main()
      Dim values() As Double = { 2.125, 2.135, 2.145, 3.125, 3.135, 3.145 }
      For Each value As Double In values
         Console.WriteLine("{0} --> {1}", value, Math.Round(value, 2))
      Next
   End Sub
End Module
' The example displays the following output:
'       2.125 --> 2.12
'       2.135 --> 2.13
'       2.145 --> 2.14
'       3.125 --> 3.12
'       3.135 --> 3.14
'       3.145 --> 3.14

Zie ook

Van toepassing op

Round(Decimal, Int32)

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Rondt een decimale waarde af op een opgegeven aantal fractionele cijfers en rondt de middelpuntwaarden af op het dichtstbijzijnde even getal.

public:
 static System::Decimal Round(System::Decimal d, int decimals);

public static decimal Round(decimal d, int decimals);

static member Round : decimal * int -> decimal

Public Shared Function Round (d As Decimal, decimals As Integer) As Decimal

Parameters

d: Decimal

Een decimaal getal dat moet worden afgerond.

decimals: Int32

Het aantal decimalen in de retourwaarde.

Retouren

Decimal

Het getal dat het dichtst d bij het getal ligt dat een aantal fractionele cijfers bevat die gelijk zijn aan decimals.

Uitzonderingen

ArgumentOutOfRangeException

decimals is kleiner dan 0 of groter dan 28.

OverflowException

Het resultaat valt buiten het bereik van een Decimal.

Opmerkingen

De waarde van het decimals argument kan variëren van 0 tot 28.

Deze methode maakt gebruik van de standaard afrondingsconventie van MidpointRounding.ToEven. Zie Middelpuntwaarden en afrondingsconventies voor informatie over het afronden van getallen met middelpuntwaarden.

Important

Voorbeeld

In het volgende voorbeeld worden decimale waarden afgerond met twee decimalen op waarden met één breukcijfer.

Console.WriteLine(Math.Round(3.44m, 1));
Console.WriteLine(Math.Round(3.45m, 1));
Console.WriteLine(Math.Round(3.46m, 1));
Console.WriteLine();

Console.WriteLine(Math.Round(4.34m, 1));
Console.WriteLine(Math.Round(4.35m, 1));
Console.WriteLine(Math.Round(4.36m, 1));

// The example displays the following output:
//       3.4
//       3.4
//       3.5
//
//       4.3
//       4.4
//       4.4

open System

printfn 
    $"""{Math.Round(3.44m, 1)}
{Math.Round(3.45m, 1)}
{Math.Round(3.46m, 1)}

{Math.Round(4.34m, 1)}
{Math.Round(4.35m, 1)}
{Math.Round(4.36m, 1)}"""

// The example displays the following output:
//       3.4
//       3.4
//       3.5
//
//       4.3
//       4.4
//       4.4

Console.WriteLine(Math.Round(3.44, 1))
Console.WriteLine(Math.Round(3.45, 1))
Console.WriteLine(Math.Round(3.46, 1))
Console.WriteLine()

Console.WriteLine(Math.Round(4.34, 1))
Console.WriteLine(Math.Round(4.35, 1))
Console.WriteLine(Math.Round(4.36, 1))

' The example displays the following output:
'       3.4
'       3.4
'       3.5
'       
'       4.3
'       4.4
'       4.4

Zie ook

Van toepassing op

Round(Double)

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Rondt een drijvendekommagetalwaarde met dubbele precisie af op de dichtstbijzijnde integrale waarde en rondt de middelpuntwaarden af op het dichtstbijzijnde even getal.

public:
 static double Round(double a);

public static double Round(double a);

static member Round : double -> double

Public Shared Function Round (a As Double) As Double

Parameters

a: Double

Een drijvendekommagetal met dubbele precisie dat moet worden afgerond.

Retouren

Double

Het dichtstbijzijnde agehele getal. Als het breukgedeelte a halverwege twee gehele getallen is, waarvan één even is en de andere oneven, wordt het even getal als resultaat gegeven. Houd er rekening mee dat deze methode een Double in plaats van een integraal type retourneert.

Opmerkingen

Important

Als de waarde van het a argument is Double.NaN, retourneert Double.NaNde methode . Als a dat het is Double.PositiveInfinity of Double.NegativeInfinity, wordt de methode geretourneerd Double.PositiveInfinity of Double.NegativeInfinityrespectievelijk.

Vanaf Visual Basic 15,8 worden de prestaties van conversie van double-to-integer geoptimaliseerd als u de waarde die wordt geretourneerd door de methode Round doorgeeft aan een van de integrale conversiefuncties, of als de dubbele waarde die wordt geretourneerd door Round automatisch wordt geconverteerd naar een geheel getal met Option Strict ingesteld op Uit. Met deze optimalisatie kan code sneller worden uitgevoerd, tot twee keer zo snel voor code die een groot aantal conversies naar gehele getallen uitvoert. Het volgende voorbeeld illustreert dergelijke geoptimaliseerde conversies:

Dim d1 As Double = 1043.75133
Dim i1 As Integer = CInt(Math.Ceiling(d1))        ' Result: 1044

Dim d2 As Double = 7968.4136
Dim i2 As Integer = CInt(Math.Ceiling(d2))        ' Result: 7968

Voorbeeld

In het volgende voorbeeld wordt afgerond op de dichtstbijzijnde gehele waarde.

Console.WriteLine("Classic Math.Round in CSharp");
Console.WriteLine(Math.Round(4.4)); // 4
Console.WriteLine(Math.Round(4.5)); // 4
Console.WriteLine(Math.Round(4.6)); // 5
Console.WriteLine(Math.Round(5.5)); // 6

open System

printfn "Classic Math.Round in F#"
printfn $"{Math.Round(4.4)}" // 4
printfn $"{Math.Round(4.5)}" // 4
printfn $"{Math.Round(4.6)}" // 5
printfn $"{Math.Round(5.5)}" // 6

Module Module1

    Sub Main()
    Console.WriteLine("Classic Math.Round in Visual Basic")
    Console.WriteLine(Math.Round(4.4)) ' 4
    Console.WriteLine(Math.Round(4.5)) ' 4
    Console.WriteLine(Math.Round(4.6)) ' 5
    Console.WriteLine(Math.Round(5.5)) ' 6
    End Sub

End Module

Notities voor bellers

Vanwege het verlies van precisie dat kan resulteren uit het weergeven van decimale waarden als drijvendekommage getallen of het uitvoeren van rekenkundige bewerkingen op drijvendekommawaarden, lijkt de Round(Double) methode in sommige gevallen geen middelpuntwaarden af te ronden op het dichtstbijzijnde even gehele getal. In het volgende voorbeeld, omdat de drijvende-kommawaarde .1 geen eindige binaire weergave heeft, retourneert de eerste aanroep naar de Round(Double) methode met een waarde van 11,5 11 in plaats van 12.

using System;

public class Example
{
   public static void Main()
   {
      double value = 11.1;
      for (int ctr = 0; ctr <= 5; ctr++)
         value = RoundValueAndAdd(value);

      Console.WriteLine();

      value = 11.5;
      RoundValueAndAdd(value);
   }

   private static double RoundValueAndAdd(double value)
   {
      Console.WriteLine("{0} --> {1}", value, Math.Round(value));
      return value + .1;
   }
}
// The example displays the following output:
//       11.1 --> 11
//       11.2 --> 11
//       11.3 --> 11
//       11.4 --> 11
//       11.5 --> 11
//       11.6 --> 12
//
//       11.5 --> 12

open System

let roundValueAndAdd (value: float) =
    printfn $"{value} --> {Math.Round value}"
    value + 0.1

let mutable value = 11.1

for _ = 0 to 5 do
    value <- roundValueAndAdd value

printfn ""

value <- 11.5
roundValueAndAdd value
|> ignore

// The example displays the following output:
//       11.1 --> 11
//       11.2 --> 11
//       11.3 --> 11
//       11.4 --> 11
//       11.5 --> 11
//       11.6 --> 12
//
//       11.5 --> 12

Module Example
   Public Sub Main()
      Dim value As Double = 11.1
      For ctr As Integer = 0 To 5    
         value = RoundValueAndAdd(value)
      Next
      Console.WriteLine()

      value = 11.5
      RoundValueAndAdd(value)
   End Sub
   
   Private Function RoundValueAndAdd(value As Double) As Double
      Console.WriteLine("{0} --> {1}", value, Math.Round(value))
      Return value + .1
   End Function   
End Module
' The example displays the following output:
'       11.1 --> 11
'       11.2 --> 11
'       11.3 --> 11
'       11.4 --> 11
'       11.5 --> 11
'       11.6 --> 12
'       
'       11.5 --> 12

Zie ook

Van toepassing op

Round(Decimal)

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Rondt een decimale waarde af op de dichtstbijzijnde integrale waarde en rondt de middelpuntwaarden af op het dichtstbijzijnde even getal.

public:
 static System::Decimal Round(System::Decimal d);

public static decimal Round(decimal d);

static member Round : decimal -> decimal

Public Shared Function Round (d As Decimal) As Decimal

Parameters

d: Decimal

Een decimaal getal dat moet worden afgerond.

Retouren

Decimal

Het gehele getal dat het dichtst bij de d parameter ligt. Als het breukgedeelte d halverwege twee gehele getallen is, waarvan één even is en de andere oneven, wordt het even getal als resultaat gegeven. Houd er rekening mee dat deze methode een Decimal in plaats van een integraal type retourneert.

Uitzonderingen

OverflowException

Het resultaat valt buiten het bereik van een Decimal.

Voorbeelden

In het volgende voorbeeld ziet u de Round(Decimal) methode. De Decimal waarde van 4,5 wordt afgerond op 4 in plaats van 5, omdat deze overbelasting gebruikmaakt van de standaardconventie ToEven .

for (decimal value = 4.2m; value <= 4.8m; value+=.1m )
   Console.WriteLine("{0} --> {1}", value, Math.Round(value));
// The example displays the following output:
//       4.2 --> 4
//       4.3 --> 4
//       4.4 --> 4
//       4.5 --> 4
//       4.6 --> 5
//       4.7 --> 5
//       4.8 --> 5

open System

for value in 4.2m .. 0.1m .. 4.8m do
    printfn $"{value} --> {Math.Round value}"
// The example displays the following output:
//       4.2 --> 4
//       4.3 --> 4
//       4.4 --> 4
//       4.5 --> 4
//       4.6 --> 5
//       4.7 --> 5
//       4.8 --> 5

Module Example
   Public Sub Main()
      For value As Decimal = 4.2d To 4.8d Step .1d
         Console.WriteLine("{0} --> {1}", value, Math.Round(value))
      Next   
   End Sub                                                                 
End Module
' The example displays the following output:
'       4.2 --> 4
'       4.3 --> 4
'       4.4 --> 4
'       4.5 --> 4
'       4.6 --> 5
'       4.7 --> 5
'       4.8 --> 5

Opmerkingen

Important

Zie ook

Van toepassing op

Round(Decimal, MidpointRounding)

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Bron:: Math.cs

Rondt een decimale waarde af op een geheel getal met behulp van de opgegeven afrondingsconventie.

public:
 static System::Decimal Round(System::Decimal d, MidpointRounding mode);

public static decimal Round(decimal d, MidpointRounding mode);

static member Round : decimal * MidpointRounding -> decimal

Public Shared Function Round (d As Decimal, mode As MidpointRounding) As Decimal

Parameters

d: Decimal

Een decimaal getal dat moet worden afgerond.

mode: MidpointRounding

Een van de opsommingswaarden die aangeeft welke afrondingsstrategie moet worden gebruikt.

Retouren

Decimal

Het gehele getal dat d wordt afgerond op. Deze methode retourneert een Decimal in plaats van een integraal type.

Uitzonderingen

ArgumentException

mode is geen geldige waarde van MidpointRounding.

OverflowException

Het resultaat valt buiten het bereik van een Decimal.

Opmerkingen

Zie Middelpuntwaarden en afrondingsconventies voor informatie over het afronden van getallen met middelpuntwaarden.

Important

Voorbeeld

In het volgende voorbeeld worden waarden weergegeven die worden geretourneerd door de Round(Decimal, MidpointRounding) methode met verschillende mode waarden.

Console.WriteLine($"{"Value",-10} {"Default",-10} {"ToEven",-10} {"AwayFromZero",-15} {"ToZero",-15}");
for (decimal value = 12.0m; value <= 13.0m; value += 0.1m)
    Console.WriteLine($"{value,-10} {Math.Round(value),-10} " +
        $"{Math.Round(value, MidpointRounding.ToEven),-10} " +
        $"{Math.Round(value, MidpointRounding.AwayFromZero),-15} " +
        $"{Math.Round(value, MidpointRounding.ToZero),-15}");

// The example displays the following output:
//       Value      Default    ToEven     AwayFromZero    ToZero
//       12.0       12         12         12              12
//       12.1       12         12         12              12
//       12.2       12         12         12              12
//       12.3       12         12         12              12
//       12.4       12         12         12              12
//       12.5       12         12         13              12
//       12.6       13         13         13              12
//       12.7       13         13         13              12
//       12.8       13         13         13              12
//       12.9       13         13         13              12
//       13.0       13         13         13              13

printfn $"""{"Value",-10} {"Default",-10} {"ToEven",-10} {"AwayFromZero",-15} {"ToZero",-15}"""
for value in 12m .. 0.1m .. 13m do
    printfn "%-10O %-10O %-10O %-15O %-15O" 
        value
        (Math.Round value)
        (Math.Round(value, MidpointRounding.ToEven))
        (Math.Round(value, MidpointRounding.AwayFromZero))
        (Math.Round(value, MidpointRounding.ToZero))

// The example displays the following output:
//       Value      Default    ToEven     AwayFromZero    ToZero
//       12.0       12         12         12              12
//       12.1       12         12         12              12
//       12.2       12         12         12              12
//       12.3       12         12         12              12
//       12.4       12         12         12              12
//       12.5       12         12         13              12
//       12.6       13         13         13              12
//       12.7       13         13         13              12
//       12.8       13         13         13              12
//       12.9       13         13         13              12
//       13.0       13         13         13              13

Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15} {4,-15}", "Value", "Default",
                "ToEven", "AwayFromZero", "ToZero")
For value As Decimal = 12D To 13D Step 0.1D
    Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15} {4,-15}",
                   value, Math.Round(value),
                   Math.Round(value, MidpointRounding.ToEven),
                   Math.Round(value, MidpointRounding.AwayFromZero),
                   Math.Round(value, MidpointRounding.ToZero))
Next

' The example displays the following output:
'       Value      Default    ToEven     AwayFromZero     ToZero
'       12         12         12         12               12
'       12.1       12         12         12               12
'       12.2       12         12         12               12
'       12.3       12         12         12               12
'       12.4       12         12         12               12
'       12.5       12         12         13               12
'       12.6       13         13         13               12
'       12.7       13         13         13               12
'       12.8       13         13         13               12
'       12.9       13         13         13               12
'       13.0       13         13         13               13

Zie ook

Van toepassing op

Feedback

Is deze pagina nuttig?