Math.Round Methode

Definition

Rundet einen Wert auf die nächste Ganzzahl oder auf die angegebene Anzahl von Bruchstellen.

Überlädt

Round(Double, Int32, MidpointRounding)

Rundet einen Gleitkommawert mit doppelter Genauigkeit unter Verwendung der angegebenen Rundungskonvention auf eine angegebene Anzahl von Dezimalzahlen.

Round(Decimal, Int32, MidpointRounding)

Rundet einen Dezimalwert mithilfe der angegebenen Rundungskonvention auf eine angegebene Anzahl von Dezimalstellen.

Round(Double, MidpointRounding)

Rundet einen Gleitkommawert mit doppelter Genauigkeit unter Verwendung der angegebenen Rundungskonvention auf eine ganze Zahl.

Round(Double, Int32)

Rundet einen Gleitkommawert mit doppelter Genauigkeit auf eine angegebene Anzahl Dezimalstellen und Mittelpunktwerte auf die nächstgelegene gerade Zahl.

Round(Decimal, Int32)

Rundet einen Dezimalwert auf eine angegebene Anzahl Dezimalstellen und Mittelpunktwerte auf die nächstgelegene gerade Zahl.

Round(Double)

Rundet einen Gleitkommawert mit doppelter Genauigkeit auf den nächstgelegenen ganzzahligen Wert und Mittelpunktwerte auf die nächstgelegene gerade Zahl.

Round(Decimal)

Rundet einen Dezimalwert auf den nächstgelegenen ganzzahligen Wert und Mittelpunktwerte auf die nächstgelegene gerade Zahl.

Round(Decimal, MidpointRounding)

Rundet einen Dezimalwert mithilfe der angegebenen Rundungskonvention um eine ganze Zahl.

Beispiele

Zusätzlich zu den Beispielen im Abschnitt "Hinweise" enthält dieser Artikel Beispiele, die die folgenden Überladungen der -Methode Math.Round veranschaulichen:

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)

Hinweise

In diesem Abschnitt

Welche Methode rufe ich auf?

Sie können die folgende Tabelle verwenden, um eine geeignete Rundungsmethode auszuwählen. Zusätzlich zu den Math.Round -Methoden enthält sie auch Math.Ceiling und Math.Floor .

Beschreibung Aufruf
Runden Sie eine Zahl auf eine ganze Zahl, indem Sie die Konvention "Rounding to Nearest" verwenden. Round(Decimal)

- oder -

Round(Double)
Runden Sie eine Zahl mithilfe einer angegebenen Rundungskonvention auf eine ganze Zahl. Round(Decimal, MidpointRounding)

- oder -

Round(Double, MidpointRounding)
Runden Sie eine Zahl mithilfe der Rundung auf die nächste Konvention auf eine angegebene Anzahl von Dezimalstellen. Round(Decimal, Int32)

- oder -

Round(Double, Int32)
Runden Sie eine Zahl mithilfe einer angegebenen Rundungskonvention auf eine angegebene Anzahl von Dezimalstellen. Round(Decimal, Int32, MidpointRounding)

- oder -

Round(Double, Int32, MidpointRounding)
Runden Sie einen Single Wert auf eine angegebene Anzahl von Dezimalstellen, indem Sie eine angegebene Rundungskonvention verwenden und den Genauigkeitsverlust minimieren. Konvertieren Sie in Single einen , und rufen Sie Decimal Round(Decimal, Int32, MidpointRounding) auf.
Runden Sie eine Zahl auf eine angegebene Anzahl von Dezimalstellen, während Die Genauigkeitsprobleme beim Runden von Mittelpunktwerten minimiert werden. Rufen Sie eine Rundungsmethode auf, die einen Vergleich "größer als oder ungefähr gleich" implementiert. Weitere Informationen finden Sie unter Rundung und Genauigkeit.
Rundet einen Bruchwert auf eine ganze Zahl, die größer als der Bruchwert ist. Runden Sie beispielsweise 3,1 auf 4. Ceiling
Rundet einen Bruchwert auf eine ganze Zahl, die kleiner als der Bruchwert ist. Runden Sie beispielsweise 3,9 auf 3. Floor

Mittelpunktwerte und Rundungskonventionen

Beim Runden wird ein numerischer Wert mit einer angegebenen Genauigkeit in einen Wert mit geringerer Genauigkeit konvertiert. Beispielsweise können Sie die -Methode verwenden, Round(Double) um einen Wert von 3,4 auf 3,0 zu runden, und die Round(Double, Int32) -Methode, um einen Wert von 3,579 auf 3,58 zu runden.

In einem Mittelpunktwert liegt der Wert nach der am wenigsten signifikanten Ziffer im Ergebnis genau in der Mitte zwischen zwei Zahlen. Beispielsweise ist 3,47500 ein Mittelpunktwert, wenn er auf zwei Dezimalstellen gerundet werden soll, und 7,500 ist ein Mittelpunktwert, wenn er auf eine ganze Zahl gerundet werden soll. Wenn in diesen Fällen die Strategie "Round-to-Near" verwendet wird, kann der nächste Wert ohne Rundungskonvention nicht einfach identifiziert werden.

Die Round -Methode unterstützt zwei Rundungskonventionen für die Behandlung von Mittelpunktwerten:

  • Abrunden von 0 (null)

    Mittelpunktwerte werden auf die nächste Zahl gerundet, die von 0 (null) entfernt ist. Beispielsweise werden 3,75 auf 3,8, 3,85 auf 3,9, -3,75 auf -3,8 und -3,85 auf -3,9 gerundet. Diese Form der Rundung wird durch den MidpointRounding.AwayFromZero Enumerationsmember dargestellt.

  • Rundung auf nächste Gerade oder Rundung des Bankers

    Mittelpunktwerte werden auf die nächste gerade Zahl gerundet. Beispielsweise werden sowohl 3,75 als auch 3,85 auf 3,8 und -3,75 und -3,85 auf -3,8 gerundet. Diese Form der Rundung wird durch den MidpointRounding.ToEven Enumerationsmember dargestellt.

Hinweis

In .NET Core 3.0 und höher sind drei zusätzliche Rundungsstrategien über die MidpointRounding -Enumeration verfügbar. Diese Strategien werden in allen Fällen verwendet, nicht nur für Mittelpunktwerte wie MidpointRounding.ToEven und MidpointRounding.AwayFromZero .

Die Rundung von null ist die am häufigsten bekannte Form der Rundung, während das Runden auf die nächste gerade der Standard bei finanz- und statistischen Vorgängen ist. Es entspricht dem IEEE-Standard 754, Abschnitt 4. Bei Verwendung in mehreren Rundungsvorgängen reduziert das Runden auf den nächsten sogar den Rundungsfehler, der durch das konsistente Runden von Mittelpunktwerten in einer richtungenweise verursacht wird. In einigen Fällen kann dieser Rundungsfehler erheblich sein.

Das folgende Beispiel veranschaulicht die Voreingenommenheit, die sich aus der konsistenten Rundung von Mittelpunktwerten in einer einzelnen Richtung ergeben kann. Im Beispiel wird der tatsächliche Mittelwert eines Arrays von Decimal Werten berechnet, und anschließend wird der Mittelwert berechnet, wenn die Werte im Array mithilfe der beiden Konventionen gerundet werden. In diesem Beispiel sind der true-Mittelwert und der Mittelwert, mit dem ergebnisse beim Runden auf den nächsten identisch sind. Der Mittelwert, der beim Abrunden von null ergibt, unterscheidet sich jedoch um 0,05 (oder um 3,6 %) vom tatsächlichen Mittelwert.

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
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

Standardmäßig verwendet die Round -Methode die Rundung bis zur nächsten geraden Konvention. In der folgenden Tabelle sind die Überladungen der Round -Methode und die von den einzelnen verwendeten Rundungskonventionen aufgeführt.

Überladung Rundungskonvention
Round(Decimal) ToEven
Round(Double) ToEven
Round(Decimal, Int32) ToEven
Round(Double, Int32) ToEven
Round(Decimal, MidpointRounding) Wird durch mode den -Parameter bestimmt.
Round(Double, MidpointRounding) Bestimmt durch mode Parameter
Round(Decimal, Int32, MidpointRounding) Bestimmt durch mode Parameter
Round(Double, Int32, MidpointRounding) Bestimmt durch mode Parameter

Rundung und Genauigkeit

Um zu bestimmen, ob ein Rundungsvorgang einen Mittelpunktwert umfasst, multipliziert die Methode den ursprünglichen Wert mit Round 10 n,wobei n die gewünschte Anzahl von Dezimalstellen im Rückgabewert ist, und bestimmt dann, ob der verbleibende Bruchteil des Werts größer oder gleich .5 ist. Dies ist eine geringfügige Abweichung bei einem Gleichheitstest. Wie im Abschnitt "Testing for Equality" des Double Referenzthemas erläutert, sind Tests auf Gleichheit mit Gleitkommawerten aufgrund der Probleme des Gleitkommaformats mit binärer Darstellung und Genauigkeit problematisch. Dies bedeutet, dass jeder Bruchteil einer Zahl, der aufgrund eines Genauigkeitsverlusts etwas kleiner als 0,5 ist, nicht aufwärts gerundet wird.

Das Problem wird anhand des folgenden Beispiels veranschaulicht. Es fügt wiederholt .1 zu 11.0 hinzu und rundet das Ergebnis auf die nächste ganze Zahl. 11.5 sollte mit einer der Midpoint-Roundingkonventionen ( oder ) auf 12 gerundet ToEven AwayFromZero werden. Wie die Ausgabe des Beispiels zeigt, ist dies jedoch nicht der Gleiche. Im Beispiel wird die numerische Standardformatzeichenfolge "R" verwendet, um die vollständige Genauigkeit des Gleitkommawerts anzuzeigen, und es wird gezeigt, dass der wert, der gerundet werden soll, bei wiederholten Additionen an Genauigkeit verloren gegangen ist und sein Wert tatsächlich 11,49999999999998 ist. Da .499999999999998 kleiner als .5 ist, kommen die Midpoint-Roundingkonventionen nicht ins Spiel, und der Wert wird abgerundet. Wie das Beispiel zeigt, tritt dieses Problem nicht auf, wenn Sie einer Variablen den konstanten Wert 11,5 Double zuweisen.

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
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

Probleme mit der Genauigkeit beim Runden von Mittelpunktwerten treten am wahrscheinlichsten unter den folgenden Bedingungen auf:

  • Wenn ein Bruchwert nicht genau im Binärformat des Gleitkommatyps ausgedrückt werden kann.

  • Wenn der zu rundende Wert aus einer oder mehreren Gleitkommavorgängen berechnet wird.

  • Wenn der wert, der gerundet werden soll, ein Single anstelle von Double oder Decimal ist. Weitere Informationen finden Sie im nächsten Abschnitt Rundung und Gleitkommawerte mit einfacher Genauigkeit.

In Fällen, in denen die fehlende Genauigkeit bei Rundungsvorgängen problematisch ist, können Sie folgende Schritte ausführen:

  • Wenn der Rundungsvorgang eine Überladung aufruft, die einen Double Wert rundet, können Sie in einen Wert ändern und Double Decimal stattdessen eine Überladung aufrufen, die einen Decimal Wert rundet. Obwohl der Datentyp auch Probleme mit der Darstellung und dem Decimal Verlust der Genauigkeit auf sich hat, treten diese Probleme weitaus seltener auf.

  • Definieren Sie einen benutzerdefinierten Rundungsalgorithmus, der einen "fast gleichen" Test ausführt, um zu bestimmen, ob der wert, der gerundet werden soll, in der Nähe eines Mittelpunktwerts akzeptiert wird. Im folgenden Beispiel wird eine RoundApproximate Methode definiert, die überprüft, ob sich ein Bruchwert ausreichend nahe an einem Mittelpunktwert befindet, um einer Mittelpunktrunde unterzogen zu werden. Wie die Ausgabe des Beispiels zeigt, wird das im vorherigen Beispiel gezeigte Rundungsproblem behoben.

    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
    
    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
    

Gleitkommawerte mit einfacher Genauigkeit und Rundung

Die Round -Methode enthält Überladungen, die Argumente vom Typ Decimal und Double akzeptieren. Es gibt keine Methoden, die Werte vom Typ Single runden. Wenn Sie einen Single Wert an eine der Überladungen der Round -Methode übergeben, wird er (in C#) umgewandelt oder (in Visual Basic) in einen Double konvertiert, und die entsprechende Round Überladung mit einem Double -Parameter wird aufgerufen. Obwohl dies eine erweiternde Konvertierung ist, bedeutet dies häufig einen Genauigkeitsverlust, wie im folgenden Beispiel veranschaulicht. Wenn der Single Wert 16,325 an die Methode übergeben Round und mithilfe der Rundung auf die nächste Konvention auf zwei Dezimalstellen gerundet wird, ist das Ergebnis 16,33 und nicht das erwartete Ergebnis von 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
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

Dieses unerwartete Ergebnis ist auf einen Genauigkeitsverlust bei der Konvertierung des Single Werts in einen -Wert zurückgekommen. Double Da der resultierende Wert Double 16,325000762939453 kein Mittelpunktwert ist und größer als 16,325 ist, wird er immer nach oben gerundet.

In vielen Fällen kann, wie im Beispiel veranschaulicht, der Genauigkeitsverlust minimiert oder beseitigt werden, indem der Wert in einen konvertiert Single oder konvertiert Decimal wird. Beachten Sie, dass dies eine schmale Konvertierung ist, die Verwendung eines Umwandlungsoperator oder das Aufrufen einer Konvertierungsmethode erfordert.

Round(Double, Int32, MidpointRounding)

Rundet einen Gleitkommawert mit doppelter Genauigkeit unter Verwendung der angegebenen Rundungskonvention auf eine angegebene Anzahl von Dezimalzahlen.

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

Parameter

value
Double

Eine zu rundende Gleitkommazahl mit doppelter Genauigkeit.

digits
Int32

Die Anzahl der Bruchziffern im Rückgabewert.

mode
MidpointRounding

Einer der Enumerationswerte, der angibt, welche Rundungsstrategie verwendet werden soll.

Gibt zurück

Double

Die Zahl mit digits Dezimalzahlen, auf value die gerundet wird. Wenn value weniger Dezimalstellen als digits hat, wird value unverändert zurückgegeben.

Ausnahmen

digits ist kleiner als 0 (null) oder größer als 15.

mode ist kein gültiger Wert von MidpointRounding.

Hinweise

Der Wert des Arguments digits kann zwischen 0 und 15 liegen. Die maximale Anzahl von Ganzzahl- und Dezimalziffern, die vom Typ unterstützt Double werden, beträgt 15.

Informationen zum Runden von Zahlen mit Mittelpunktwerten finden Sie unter Midpointwerte und Rundungskonventionen.

Wichtig

Bei der Rundung von Mittelwerten führt der Rundungsalgorithmus einen Gleichheitstest durch. Aufgrund von Problemen bei der binären Darstellung und der Genauigkeit im Gleitkommaformat kann der von der Methode zurückgegebene Wert unerwartet sein. Weitere Informationen finden Sie unter Rundung und Genauigkeit.

Wenn der Wert des Arguments value Double.NaN ist, gibt die Methode Double.NaN zurück. Wenn value ist Double.PositiveInfinity oder Double.NegativeInfinity, gibt die Methode zurück Double.PositiveInfinity oder Double.NegativeInfinitybzw.

Beispiel

Im folgenden Beispiel wird veranschaulicht, wie die -Methode Round(Double, Int32, MidpointRounding) mit der -Enumeration verwendet MidpointRounding wird.


// 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)
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)

Hinweise für Aufrufer

Aufgrund des Genauigkeitsverlusts, der sich aus der Darstellung von Dezimalwerten als Gleitkommazahlen oder dem Ausführen arithmetischer Operationen für Gleitkommawerte ergeben kann, scheint die Methode in einigen Fällen nicht so zu sein, als ob die Mittelpunktwerte durch den -Parameter gerundet Round(Double, Int32, MidpointRounding) mode werden. Dies wird im folgenden Beispiel veranschaulicht, bei dem 2.135 auf 2,13 anstatt auf 2,14 gerundet wird. Dies liegt daran, dass die -Methode intern mit 10 Ziffern multipliziert wird und der Multiplikationsvorgang in diesem Fall zu einem value Genauigkeitsverlustkommt.

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

Siehe auch

Gilt für

Round(Decimal, Int32, MidpointRounding)

Rundet einen Dezimalwert mithilfe der angegebenen Rundungskonvention auf eine angegebene Anzahl von Dezimalstellen.

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

Parameter

d
Decimal

Eine zu rundende Dezimalzahl.

decimals
Int32

Die Anzahl von Dezimalstellen im Rückgabewert.

mode
MidpointRounding

Einer der Enumerationswerte, der angibt, welche Rundungsstrategie verwendet werden soll.

Gibt zurück

Decimal

Die Zahl mit decimals Dezimalzahlen, auf d die gerundet wird. Wenn d weniger Dezimalstellen als decimals hat, wird d unverändert zurückgegeben.

Ausnahmen

decimals ist kleiner als 0 (null) oder größer als 28.

mode ist kein gültiger Wert von MidpointRounding.

Das Ergebnis liegt außerhalb des Bereichs von Decimal.

Hinweise

Informationen zum Runden von Zahlen mit Mittelpunktwerten finden Sie unter Midpointwerte und Rundungskonventionen.

Wichtig

Bei der Rundung von Mittelwerten führt der Rundungsalgorithmus einen Gleichheitstest durch. Aufgrund von Problemen bei der binären Darstellung und der Genauigkeit im Gleitkommaformat kann der von der Methode zurückgegebene Wert unerwartet sein. Weitere Informationen finden Sie unter Rundung und Genauigkeit.

Der Wert des Arguments decimals kann zwischen 0 und 28 liegen.

Beispiel

Im folgenden Beispiel wird veranschaulicht, wie die -Methode Round mit der -Enumeration verwendet MidpointRounding wird.

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)
*/
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)
'

Siehe auch

Gilt für

Round(Double, MidpointRounding)

Rundet einen Gleitkommawert mit doppelter Genauigkeit unter Verwendung der angegebenen Rundungskonvention auf eine ganze Zahl.

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

Parameter

value
Double

Eine zu rundende Gleitkommazahl mit doppelter Genauigkeit.

mode
MidpointRounding

Einer der Enumerationswerte, der angibt, welche Rundungsstrategie verwendet werden soll.

Gibt zurück

Double

Die ganze value Zahl, auf die gerundet wird. Diese Methode gibt anstelle Double eines integralen Typs einen zurück.

Ausnahmen

mode ist kein gültiger Wert von MidpointRounding.

Hinweise

Informationen zum Runden von Zahlen mit Mittelpunktwerten finden Sie unter Midpointwerte und Rundungskonventionen.

Wichtig

Bei der Rundung von Mittelwerten führt der Rundungsalgorithmus einen Gleichheitstest durch. Aufgrund von Problemen bei der binären Darstellung und der Genauigkeit im Gleitkommaformat kann der von der Methode zurückgegebene Wert unerwartet sein. Weitere Informationen finden Sie unter Rundung und Genauigkeit.

Wenn der Wert des Arguments value Double.NaN ist, gibt die Methode Double.NaN zurück. Wenn value ist Double.PositiveInfinity oder Double.NegativeInfinity, gibt die Methode zurück Double.PositiveInfinity oder Double.NegativeInfinitybzw.

Beispiel

Im folgenden Beispiel werden werte angezeigt, die von der Round(Double, MidpointRounding) -Methode mit unterschiedlichen Werten mode zurückgegeben werden.

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
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

Hinweise für Aufrufer

Aufgrund des Genauigkeitsverlusts, der sich aus der Darstellung von Dezimalwerten als Gleitkommazahlen oder dem Ausführen arithmetischer Operationen für Gleitkommawerte ergeben kann, scheint die Methode in einigen Fällen keine Mittelpunktwerte auf die nächste gerade ganze Zahl zu Round(Double, MidpointRounding) runden. Da der Gleitkommawert .1 im folgenden Beispiel keine endliche binäre Darstellung hat, gibt der erste Aufruf der -Methode mit dem Wert Round(Double) 11,5 11 anstelle von 12 zurück.

Siehe auch

Gilt für

Round(Double, Int32)

Rundet einen Gleitkommawert mit doppelter Genauigkeit auf eine angegebene Anzahl Dezimalstellen und Mittelpunktwerte auf die nächstgelegene gerade Zahl.

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

Parameter

value
Double

Eine zu rundende Gleitkommazahl mit doppelter Genauigkeit.

digits
Int32

Die Anzahl von Dezimalstellen im Rückgabewert.

Gibt zurück

Double

Die Zahl, die value am nächsten liegt und deren Anzahl von Nachkommastellen gleich digits ist.

Ausnahmen

digits ist kleiner als 0 (null) oder größer als 15.

Hinweise

Der Wert des Arguments digits kann zwischen 0 und 15 liegen. Die maximale Anzahl von Ganzzahl- und Dezimalziffern, die vom Typ unterstützt Double werden, beträgt 15.

Diese Methode verwendet die Standardmäßige Rundungskonvention von MidpointRounding.ToEven . Informationen zum Runden von Zahlen mit Mittelpunktwerten finden Sie unter Midpointwerte und Rundungskonventionen.

Wichtig

Bei der Rundung von Mittelwerten führt der Rundungsalgorithmus einen Gleichheitstest durch. Aufgrund von Problemen bei der binären Darstellung und der Genauigkeit im Gleitkommaformat kann der von der Methode zurückgegebene Wert unerwartet sein. Weitere Informationen finden Sie unter Rundung und Genauigkeit.

Wenn der Wert des Arguments value Double.NaN ist, gibt die Methode Double.NaN zurück. Wenn value ist Double.PositiveInfinity oder Double.NegativeInfinity, gibt die Methode zurück Double.PositiveInfinity oder Double.NegativeInfinitybzw.

Beispiel

Im folgenden Beispiel werden doppelte Werte mit zwei Dezimalziffern auf Double-Werte gerundet, die eine einzelne Dezimalziffer haben.

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
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
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

Hinweise für Aufrufer

Aufgrund des Genauigkeitsverlusts, der sich aus der Darstellung von Dezimalwerten als Gleitkommazahlen oder dem Ausführen arithmetischer Operationen für Gleitkommawerte ergeben kann, scheint die Methode in einigen Fällen keine Mittelpunktwerte auf den nächsten geraden Wert in der Dezimalposition zu Round(Double, Int32) digits runden. Dies wird im folgenden Beispiel veranschaulicht, bei dem 2.135 auf 2,13 anstatt auf 2,14 gerundet wird. Dies liegt daran, dass die -Methode intern mit 10 Ziffern multipliziert wird und der Multiplikationsvorgang in diesem Fall zu einem value Genauigkeitsverlustkommt.

Siehe auch

Gilt für

Round(Decimal, Int32)

Rundet einen Dezimalwert auf eine angegebene Anzahl Dezimalstellen und Mittelpunktwerte auf die nächstgelegene gerade Zahl.

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

Parameter

d
Decimal

Eine zu rundende Dezimalzahl.

decimals
Int32

Die Anzahl der Dezimalstellen im Rückgabewert.

Gibt zurück

Decimal

Die Zahl, die d am nächsten liegt und deren Anzahl von Nachkommastellen gleich decimals ist.

Ausnahmen

decimals ist kleiner als 0 (null) oder größer als 28.

Das Ergebnis liegt außerhalb des Bereichs von Decimal.

Hinweise

Der Wert des Arguments decimals kann zwischen 0 und 28 liegen.

Diese Methode verwendet die Standardmäßige Rundungskonvention von MidpointRounding.ToEven . Informationen zum Runden von Zahlen mit Mittelpunktwerten finden Sie unter Midpointwerte und Rundungskonventionen.

Wichtig

Bei der Rundung von Mittelwerten führt der Rundungsalgorithmus einen Gleichheitstest durch. Aufgrund von Problemen bei der binären Darstellung und der Genauigkeit im Gleitkommaformat kann der von der Methode zurückgegebene Wert unerwartet sein. Weitere Informationen finden Sie unter Rundung und Genauigkeit.

Beispiel

Im folgenden Beispiel werden Dezimalwerte mit zwei Dezimalstellen auf Werte gerundet, die eine einzelne Dezimalstelle haben.

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
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

Siehe auch

Gilt für

Round(Double)

Rundet einen Gleitkommawert mit doppelter Genauigkeit auf den nächstgelegenen ganzzahligen Wert und Mittelpunktwerte auf die nächstgelegene gerade Zahl.

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

Parameter

a
Double

Eine zu rundende Gleitkommazahl mit doppelter Genauigkeit.

Gibt zurück

Double

Der der Ganzzahl am nächsten liegende a. Wenn der Nachkommawert von a genau in der Mitte zwischen zwei Ganzzahlen liegt, von denen eine gerade und die andere ungerade ist, wird die gerade Zahl zurückgegeben. Beachten Sie, dass diese Methode einen Double anstelle eines ganzzahligen Typs zurückgibt.

Hinweise

Diese Methode verwendet die Standardmäßige Rundungskonvention von MidpointRounding.ToEven . Informationen zum Runden von Zahlen mit Mittelpunktwerten finden Sie unter Midpointwerte und Rundungskonventionen.

Wichtig

Bei der Rundung von Mittelwerten führt der Rundungsalgorithmus einen Gleichheitstest durch. Aufgrund von Problemen bei der binären Darstellung und der Genauigkeit im Gleitkommaformat kann der von der Methode zurückgegebene Wert unerwartet sein. Weitere Informationen finden Sie unter Rundung und Genauigkeit.

Wenn der Wert des Arguments a Double.NaN ist, gibt die Methode Double.NaN zurück. Wenn a ist Double.PositiveInfinity oder Double.NegativeInfinity, gibt die Methode zurück Double.PositiveInfinity oder Double.NegativeInfinitybzw.

Ab Visual Basic 15.8 wird die Leistung der Konvertierung von Double in Integer optimiert, wenn Sie den von der -Methode zurückgegebenen Wert an eine der integralen Konvertierungsfunktionen übergeben oder wenn der von zurückgegebene Double-Wert automatisch in eine ganze Zahl konvertiert wird, bei der Option Strict auf Off festgelegt Round Round ist. Dank dieser Optimierung kann Code schneller ausgeführt werden. Code, der viele Ganzzahltypen konvertiert, wird bis zu doppelt so schnell ausgeführt. Im folgenden Beispiel werden solche optimierten Konvertierungen veranschaulicht:

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

Beispiel

Im folgenden Beispiel wird die Rundung auf den nächsten ganzzahligen Wert veranschaulicht.

using namespace System;

void main()
{
    Console::WriteLine("Classic Math.Round in CPP");
    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
}
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
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

Hinweise für Aufrufer

Aufgrund des Genauigkeitsverlusts, der sich aus der Darstellung von Dezimalwerten als Gleitkommazahlen oder dem Ausführen arithmetischer Operationen für Gleitkommawerte ergeben kann, scheint die Methode in einigen Fällen keine Mittelpunktwerte auf die nächste gerade ganze Zahl zu Round(Double) runden. Da der Gleitkommawert .1 im folgenden Beispiel keine endliche binäre Darstellung hat, gibt der erste Aufruf der -Methode mit dem Wert Round(Double) 11,5 11 anstelle von 12 zurück.

Siehe auch

Gilt für

Round(Decimal)

Rundet einen Dezimalwert auf den nächstgelegenen ganzzahligen Wert und Mittelpunktwerte auf die nächstgelegene gerade Zahl.

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

Parameter

d
Decimal

Eine zu rundende Dezimalzahl.

Gibt zurück

Decimal

Die dem d-Parameter nächstgelegene ganze Zahl. Wenn der Nachkommawert von d genau in der Mitte zwischen zwei Ganzzahlen liegt, von denen eine gerade und die andere ungerade ist, wird die gerade Zahl zurückgegeben. Beachten Sie, dass diese Methode einen Decimal anstelle eines ganzzahligen Typs zurückgibt.

Ausnahmen

Das Ergebnis liegt außerhalb des Bereichs von Decimal.

Beispiele

Das folgende Beispiel veranschaulicht die Round(Decimal) Methode. Der Wert von 4,5 wird auf 4 statt auf 5 gerundet, da diese Überladung Decimal die Standardkonvention ToEven verwendet.

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
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

Hinweise

Diese Methode verwendet die Standardmäßige Rundungskonvention von MidpointRounding.ToEven . Informationen zum Runden von Zahlen mit Mittelpunktwerten finden Sie unter Midpointwerte und Rundungskonventionen.

Wichtig

Bei der Rundung von Mittelwerten führt der Rundungsalgorithmus einen Gleichheitstest durch. Aufgrund von Problemen bei der binären Darstellung und der Genauigkeit im Gleitkommaformat kann der von der Methode zurückgegebene Wert unerwartet sein. Weitere Informationen finden Sie unter Rundung und Genauigkeit.

Siehe auch

Gilt für

Round(Decimal, MidpointRounding)

Rundet einen Dezimalwert mithilfe der angegebenen Rundungskonvention um eine ganze Zahl.

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

Parameter

d
Decimal

Eine zu rundende Dezimalzahl.

mode
MidpointRounding

Einer der Enumerationswerte, der angibt, welche Rundungsstrategie verwendet werden soll.

Gibt zurück

Decimal

Die ganze d Zahl, auf die gerundet wird. Diese Methode gibt anstelle Decimal eines integralen Typs einen zurück.

Ausnahmen

mode ist kein gültiger Wert von MidpointRounding.

Das Ergebnis liegt außerhalb des Bereichs von Decimal.

Hinweise

Informationen zum Runden von Zahlen mit Mittelpunktwerten finden Sie unter Midpointwerte und Rundungskonventionen.

Wichtig

Bei der Rundung von Mittelwerten führt der Rundungsalgorithmus einen Gleichheitstest durch. Aufgrund von Problemen bei der binären Darstellung und der Genauigkeit im Gleitkommaformat kann der von der Methode zurückgegebene Wert unerwartet sein. Weitere Informationen finden Sie unter Rundung und Genauigkeit.

Beispiel

Im folgenden Beispiel werden werte angezeigt, die von der Round(Decimal, MidpointRounding) -Methode mit unterschiedlichen Werten mode zurückgegeben werden.

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
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

Siehe auch

Gilt für