Math.Round Metoda

Definice

Zaokrouhlí hodnotu na nejbližší celé číslo nebo na zadaný počet desetinných číslic.

Přetížení

Round(Double, Int32, MidpointRounding)

Zaokrouhlí hodnotu s dvojitou přesností na zadaný počet desetinných číslic pomocí zadané konvence zaokrouhlování.

Round(Decimal, Int32, MidpointRounding)

Zaokrouhlí desetinnou hodnotu na zadaný počet desetinných číslic pomocí zadané konvence zaokrouhlování.

Round(Double, MidpointRounding)

Zaokrouhlí hodnotu s dvojitou přesností na celé číslo pomocí zadané konvence zaokrouhlování.

Round(Double, Int32)

Zaokrouhlí hodnotu s plovoucí desetinnou čárkou na zadaný počet desetinných číslic a zaokrouhlí střední hodnoty na nejbližší sudé číslo.

Round(Decimal, Int32)

Zaokrouhlí desetinnou hodnotu na zadaný počet desetinných číslic a zaokrouhlí střední hodnoty na nejbližší sudé číslo.

Round(Double)

Zaokrouhlí hodnotu s plovoucí desetinou čárkou na nejbližší celočíselnou hodnotu a zaokrouhlí střední hodnoty na nejbližší sudé číslo.

Round(Decimal)

Zaokrouhlí desetinnou hodnotu na nejbližší celočíselnou hodnotu a zaokrouhlí střední hodnoty na nejbližší sudé číslo.

Round(Decimal, MidpointRounding)

Zaokrouhlí desetinnou hodnotu celé číslo pomocí zadané konvence zaokrouhlování.

Příklady

Kromě příkladů v části Poznámky obsahuje tento článek příklady, které ilustrují následující přetížení Math.Round metody:

Math.Round(Desetinné číslo)
Math.Round(Double)
Math.Round(Desetinné číslo; Int32)
Math.Round(Desetinné číslo, Střední bodRounding)
Math.Round(Double, Int32)
Math.Round(Double, MidpointRounding)
Math.Round(Desetinné číslo, Int32, Střední bodRounding)
Math.Round(Double, Int32, MidpointRounding)

Poznámky

V této části:

Jakou metodu mám volat?

Pomocí následující tabulky můžete vybrat odpovídající metodu zaokrouhlování. Kromě Math.Round metod zahrnuje Math.Ceiling také a Math.Floor.

Záměr Call
Číslo zaokrouhlíte na celé číslo pomocí konvence zaokrouhlení na nejbližší. Round(Decimal)
-nebo-
Round(Double)
Číslo zaokrouhlíte na celé číslo pomocí zadané konvence zaokrouhlování. Round(Decimal, MidpointRounding)
-nebo-
Round(Double, MidpointRounding)
Zaokrouhlí číslo na zadaný počet desetinných číslic pomocí zaokrouhlení na nejbližší konvenci. Round(Decimal, Int32)
-nebo-
Round(Double, Int32)
Zaokrouhlí číslo na zadaný počet desetinných číslic pomocí zadané konvence zaokrouhlování. Round(Decimal, Int32, MidpointRounding)
-nebo-
Round(Double, Int32, MidpointRounding)
Zaokrouhlí hodnotu Single na zadaný počet desetinných číslic pomocí zadané konvence zaokrouhlování a minimalizuje ztrátu přesnosti. Převeďte na Single Decimal a zavolejte Round(Decimal, Int32, MidpointRounding).
Zaokrouhlí číslo na zadaný počet desetinných číslic a současně minimalizuje problémy s přesností při zaokrouhlení hodnot středního bodu. Volání metody zaokrouhlení, která implementuje porovnání "větší než nebo přibližně rovno" Viz zaokrouhlení a přesnost.
Zaokrouhlí desetinnou hodnotu na celé číslo, které je větší než desetinná hodnota. Například zaokrouhlí číslo 3,1 na 4. Ceiling
Zaokrouhlí desetinnou hodnotu na celé číslo, které je menší než desetinná hodnota. Například zaokrouhlí číslo 3,9 na 3. Floor

Střední hodnoty a konvence zaokrouhlování

Zaokrouhlení zahrnuje převod číselné hodnoty s zadanou přesností na hodnotu s menší přesností. Pomocí metody můžete Round(Double) například zaokrouhlit hodnotu 3,4 na 3,0 a Round(Double, Int32) metodu zaokrouhlit hodnotu 3,579 na 3,58.

Ve střední hodnotě je hodnota za nejmenším významným číslem ve výsledku přesně napůl mezi dvěma čísly. Například 3,47500 je střední hodnota, pokud se má zaokrouhlit na dvě desetinná místa, a 7,500 je střední hodnota, pokud se má zaokrouhlit na celé číslo. V těchto případech, pokud se použije strategie zaokrouhlení na nejbližší, není možné snadno identifikovat bez konvence zaokrouhlování.

Metoda Round podporuje dvě konvence zaokrouhlování pro zpracování hodnot středního bodu:

  • Zaokrouhlování od nuly

    Střední hodnoty jsou zaokrouhleny na další číslo směrem od nuly. Například 3,75 zaokrouhlí na 3,8, 3,85 zaokrouhlí na 3,9, -3,75 zaokrouhlí na -3,8 a -3,85 zaokrouhlí na -3,9. Tato forma zaokrouhlení je reprezentována členem výčtu MidpointRounding.AwayFromZero .

  • Zaokrouhlování na nejbližší sudé nebo bankovní zaokrouhlování

    Střední hodnoty jsou zaokrouhleny na nejbližší sudé číslo. Například 3,75 i 3,85 zaokrouhlení na 3,8 a -3,75 i -3,85 zaokrouhlení na -3,8. Tato forma zaokrouhlení je reprezentována členem výčtu MidpointRounding.ToEven .

Poznámka

V .NET Core 3.0 a novějších verzích jsou prostřednictvím výčtu MidpointRounding k dispozici tři další strategie zaokrouhlování. Tyto strategie se používají ve všech případech, nejen pro hodnoty střední body, jako MidpointRounding.ToEven jsou a MidpointRounding.AwayFromZero jsou.

Zaokrouhlení směrem od nuly je nejrozšířenější formou zaokrouhlení, zatímco zaokrouhlování na nejbližší i je standardem ve finančních a statistických operacích. Odpovídá standardu IEEE Standard 754, oddílu 4. Při použití v několika operacích zaokrouhlení se zaokrouhlení na nejbližší dokonce sníží chyba zaokrouhlení, která je způsobená konzistentně zaokrouhlováním hodnot střední body jedním směrem. V některých případech může být tato chyba zaokrouhlení důležitá.

Následující příklad znázorňuje předsudky, které můžou mít za následek konzistentně zaokrouhlování hodnot středních bodů jedním směrem. Příklad vypočítá skutečnou střední hodnotu pole Decimal hodnot a pak vypočítá průměr, když jsou hodnoty v poli zaokrouhleny pomocí dvou konvencí. V tomto příkladu je pravdivá střední hodnota a průměr, že výsledky při zaokrouhlování na nejbližší jsou stejné. Průměr, který se však při zaokrouhlování od nuly liší o 05 (nebo o 3,6 %) od skutečné střední hodnoty.

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

Ve výchozím nastavení Round metoda používá kruhové kolo k nejbližší sudé konvenci. Následující tabulka uvádí přetížení Round metody a konvence zaokrouhlování, které jednotlivé používají.

Přetížení Konvence zaokrouhlování
Round(Decimal) ToEven
Round(Double) ToEven
Round(Decimal, Int32) ToEven
Round(Double, Int32) ToEven
Round(Decimal, MidpointRounding) Určuje parametr mode .
Round(Double, MidpointRounding) Určeno parametrem mode
Round(Decimal, Int32, MidpointRounding) Určeno parametrem mode
Round(Double, Int32, MidpointRounding) Určeno parametrem mode

Zaokrouhlování a přesnost

Aby bylo možné určit, zda operace zaokrouhlování zahrnuje střední hodnotu, metoda vynásobí původní hodnotu zaokrouhlenou o 10n, kde n je požadovaný počet desetinných číslic v návratové hodnotě a pak určí, Round zda zbývající zlomková část hodnoty je větší nebo rovna .5. Jedná se o mírné variace testu rovnosti a jak je popsáno v části Double Testování rovnosti v referenčním tématu, testy rovnosti s hodnotami s plovoucí desetinou čárkou jsou problematické kvůli problémům s binární reprezentací a přesností formátu s plovoucí desetinou čárkou. To znamená, že jakákoli zlomková část čísla, která je mírně menší než 5 (kvůli ztrátě přesnosti), se nezaokrouhlí směrem nahoru.

Následující příklad ukazuje tento problém. Opakovaně přidává hodnotu 1 do 11,0 a zaokrouhlí výsledek na nejbližší celé číslo. 11,5 by mělo zaokrouhlit na 12 pomocí konvencí středního bodu (ToEven nebo AwayFromZero). Jak ale ukazuje výstup z příkladu, nejedná se o to. Příklad používá standardní řetězec číselného formátu "R" k zobrazení úplné přesnosti hodnoty s plovoucí desetinnou čárkou a ukazuje, že hodnota, která se má zaokrouhlit, ztratila přesnost během opakovaných sčítání a její hodnota je ve skutečnosti 11,4999999999999999998. Vzhledem k tomu, že hodnota .499999999999998 je menší než 5, nezahrávají se konvence zaokrouhlování středních bodů a hodnota se zaokrouhlí dolů. Jak ukazuje příklad také, k tomuto problému nedojde, pokud přiřadíte konstantní hodnotu 11,5 proměnné Double .

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

Problémy s přesností při zaokrouhlení hodnot střední body se s největší pravděpodobností objeví v následujících podmínkách:

V případech, kdy je nedostatek přesnosti v operacích zaokrouhlení problematický, můžete provést následující:

  • Pokud operace zaokrouhlování volá přetížení, které zaokrouhlí Double hodnotu, můžete změnit Double hodnotu Decimal a volat přetížení, které místo toho zaokrouhlí Decimal hodnotu. Decimal I když datový typ má problémy s reprezentací a ztrátou přesnosti, jsou tyto problémy mnohem méně časté.

  • Definujte vlastní algoritmus zaokrouhlení, který provádí test "téměř rovná se", abyste zjistili, jestli je hodnota, která se má zaokrouhlit, přijatelně blízko střední hodnoty. Následující příklad definuje metodu RoundApproximate , která zkoumá, zda je desetinná hodnota dostatečně blízko k střední hodnotě, aby byla předmětem zaokrouhlení střední bod. Jak ukazuje výstup z příkladu, opraví problém se zaokrouhlováním zobrazeným v předchozím příkladu.

    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
    

Zaokrouhlování a hodnoty s pohyblivou desetinnou čárkou s přesností na jedno desetinné číslo

Metoda Round zahrnuje přetížení, které přijímají argumenty typu Decimal a Double. Neexistují žádné metody, které zaokrouhlují hodnoty typu Single. Pokud předáte Single hodnotu jednomu z přetížení Round metody, přetypuje se (v jazyce C#) nebo převede (v Visual Basic) na Doublea odpovídající Round přetížení s parametrem Double se volá. I když se jedná o rozšiřující převod, často zahrnuje ztrátu přesnosti, jak ukazuje následující příklad. Single Při předání hodnoty 16,325 metodě Round a zaokrouhlení na dvě desetinná místa pomocí zaokrouhlení na nejbližší konvenci je výsledek 16,33 a ne očekávaný výsledek 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

Tento neočekávaný výsledek je způsoben ztrátou přesnosti při převodu Single hodnoty na Doublehodnotu . Vzhledem k tomu, že výsledná Double hodnota 16,325000762939453 není střední hodnotou a je větší než 16,325, je vždy zaokrouhleno nahoru.

V mnoha případech lze ztrátu přesnosti minimalizovat nebo eliminovat přetypováním Single nebo převodem hodnoty na Decimalhodnotu . Všimněte si, že protože se jedná o zúžení převodu, vyžaduje použití operátoru přetypování nebo volání metody převodu.

Round(Double, Int32, MidpointRounding)

Zaokrouhlí hodnotu s dvojitou přesností na zadaný počet desetinných číslic pomocí zadané konvence zaokrouhlování.

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

Parametry

value
Double

Zaokrouhlované číslo dvojité přesnosti s plovoucí desetinnou čárkou.

digits
Int32

Počet desetinných číslic ve vrácené hodnotě.

mode
MidpointRounding

Jedna z hodnot výčtu, která určuje, kterou strategii zaokrouhlování se má použít.

Návraty

Double

Číslo s digits desetinnými číslicemi, na které value se zaokrouhlí. Pokud value má méně desetinných číslic, než digitsje , value vrátí se beze změny.

Výjimky

digits je menší než 0 nebo větší než 15.

modenení platná hodnota .MidpointRounding

Poznámky

Hodnota argumentu může být v rozsahu digits od 0 do 15. Maximální počet integrálních a zlomkových číslic podporovaných typem Double je 15.

Informace o zaokrouhlování čísel středními hodnotami středními hodnotami najdete v konvencích zaokrouhlení střední body a konvence zaokrouhlování .

Důležité

Při zaokrouhlování hodnot středního bodu provede algoritmus zaokrouhlení test rovnosti. Z důvodu problémů binární reprezentace a přesnosti ve formátu s plovoucí desetinnou čárkou může být hodnota vrácená metodou neočekávaná. Další informace naleznete v tématu zaokrouhlení a přesnost.

Pokud je Double.NaNhodnota argumentu value , vrátí Double.NaNmetoda . Pokud value je Double.PositiveInfinity nebo Double.NegativeInfinity, metoda vrátí Double.PositiveInfinity nebo Double.NegativeInfinity, v uvedeném pořadí.

Příklad

Následující příklad ukazuje, jak použít metodu Round(Double, Int32, MidpointRounding) s výčtem MidpointRounding .


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

Poznámky pro volající

Vzhledem ke ztrátě přesnosti, která může mít za následek reprezentaci desetinných hodnot jako čísel s plovoucí desetinnou čárkou nebo provádění aritmetických operací s hodnotami s plovoucí desetinnou čárkou, se v některých případech Round(Double, Int32, MidpointRounding) nemusí metoda zdát zaokrouhlená jako střední hodnoty zadaná parametrem mode . To je znázorněno v následujícím příkladu, kde je 2,135 zaokrouhleno na 2,13 místo 2.14. K tomu dochází, protože interně metoda vynásobí value10digits a operace násobení v tomto případě trpí ztrátou přesnosti.

Viz také

Platí pro

Round(Decimal, Int32, MidpointRounding)

Zaokrouhlí desetinnou hodnotu na zadaný počet desetinných číslic pomocí zadané konvence zaokrouhlování.

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

Parametry

d
Decimal

Zaokrouhlované desetinné číslo.

decimals
Int32

Počet desetinných míst v návratové hodnotě.

mode
MidpointRounding

Jedna z hodnot výčtu, která určuje, kterou strategii zaokrouhlování se má použít.

Návraty

Decimal

Číslo s decimals desetinnými číslicemi, na které d se zaokrouhlí. Pokud d má méně desetinných číslic, než decimalsje , d vrátí se beze změny.

Výjimky

decimals je menší než 0 nebo větší než 28.

modenení platná hodnota .MidpointRounding

Výsledek je mimo rozsah řady Decimal.

Poznámky

Informace o zaokrouhlování čísel středními hodnotami středními hodnotami najdete v konvencích zaokrouhlení střední body a konvence zaokrouhlování .

Důležité

Při zaokrouhlování hodnot středního bodu provede algoritmus zaokrouhlení test rovnosti. Z důvodu problémů binární reprezentace a přesnosti ve formátu s plovoucí desetinnou čárkou může být hodnota vrácená metodou neočekávaná. Další informace naleznete v tématu zaokrouhlení a přesnost.

Hodnota argumentu může být v rozsahu decimals od 0 do 28.

Příklad

Následující příklad ukazuje, jak použít metodu Round s výčtem MidpointRounding .

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

Viz také

Platí pro

Round(Double, MidpointRounding)

Zaokrouhlí hodnotu s dvojitou přesností na celé číslo pomocí zadané konvence zaokrouhlování.

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

Parametry

value
Double

Zaokrouhlované číslo dvojité přesnosti s plovoucí desetinnou čárkou.

mode
MidpointRounding

Jedna z hodnot výčtu, která určuje, kterou strategii zaokrouhlování se má použít.

Návraty

Double

Celé číslo, na které value je zaokrouhleno. Tato metoda vrátí Double místo celočíselného typu.

Výjimky

modenení platná hodnota .MidpointRounding

Poznámky

Informace o zaokrouhlování čísel středními hodnotami středními hodnotami najdete v konvencích zaokrouhlení střední body a konvence zaokrouhlování .

Důležité

Při zaokrouhlování hodnot středního bodu provede algoritmus zaokrouhlení test rovnosti. Z důvodu problémů binární reprezentace a přesnosti ve formátu s plovoucí desetinnou čárkou může být hodnota vrácená metodou neočekávaná. Další informace naleznete v tématu zaokrouhlení a přesnost.

Pokud je Double.NaNhodnota argumentu value , vrátí Double.NaNmetoda . Pokud value je Double.PositiveInfinity nebo Double.NegativeInfinity, metoda vrátí Double.PositiveInfinity nebo Double.NegativeInfinity, v uvedeném pořadí.

Příklad

Následující příklad zobrazuje hodnoty vrácené metodou Round(Double, MidpointRounding) s různými mode hodnotami.

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

Poznámky pro volající

Vzhledem ke ztrátě přesnosti, která může mít za následek reprezentaci desetinných hodnot jako čísel s plovoucí desetinnou čárkou nebo provádění aritmetických operací s hodnotami s plovoucí desetinnou čárkou, se v některých případech Round(Double, MidpointRounding) nemusí metoda zdát zaokrouhlená na nejbližší sudé celé číslo. V následujícím příkladu, protože hodnota s plovoucí desetinou čárkou ,1 nemá žádné konečné binární reprezentace, první volání Round(Double) metody s hodnotou 11,5 vrátí místo 12 hodnotu 11.

Viz také

Platí pro

Round(Double, Int32)

Zaokrouhlí hodnotu s plovoucí desetinnou čárkou na zadaný počet desetinných číslic a zaokrouhlí střední hodnoty na nejbližší sudé číslo.

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

Parametry

value
Double

Zaokrouhlované číslo dvojité přesnosti s plovoucí desetinnou čárkou.

digits
Int32

Počet desetinných číslic ve vrácené hodnotě.

Návraty

Double

Číslo nejbližší value k číslu, které obsahuje počet desetinných číslic rovnajících se digits.

Výjimky

digits je menší než 0 nebo větší než 15.

Poznámky

Hodnota argumentu může být v rozsahu digits od 0 do 15. Maximální počet integrálních a zlomkových číslic podporovaných typem Double je 15.

Tato metoda používá výchozí konvenci zaokrouhlování .MidpointRounding.ToEven Informace o zaokrouhlování čísel středními hodnotami středními hodnotami najdete v konvencích zaokrouhlení střední body a konvence zaokrouhlování .

Důležité

Při zaokrouhlování hodnot středního bodu provede algoritmus zaokrouhlení test rovnosti. Z důvodu problémů binární reprezentace a přesnosti ve formátu s plovoucí desetinnou čárkou může být hodnota vrácená metodou neočekávaná. Další informace naleznete v tématu zaokrouhlení a přesnost.

Pokud je Double.NaNhodnota argumentu value , vrátí Double.NaNmetoda . Pokud value je Double.PositiveInfinity nebo Double.NegativeInfinity, metoda vrátí Double.PositiveInfinity nebo Double.NegativeInfinity, v uvedeném pořadí.

Příklad

Následující příklad zaokrouhlí dvojité hodnoty se dvěma desetinnými číslicemi na dvojité hodnoty, které mají jednu desetinnou číslici.

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

Poznámky pro volající

Vzhledem ke ztrátě přesnosti, která může mít za následek reprezentaci desetinných hodnot jako čísel s plovoucí desetinnou čárkou nebo provádění aritmetických operací s hodnotami s plovoucí desetinnou čárkou, se v některých případech Round(Double, Int32) nemusí metoda zdát zaokrouhlit střední hodnoty na nejbližší sudou hodnotu v digits desetinné pozici. To je znázorněno v následujícím příkladu, kde je 2,135 zaokrouhleno na 2,13 místo 2.14. K tomu dochází, protože interně metoda vynásobí value10digits a operace násobení v tomto případě trpí ztrátou přesnosti.

Viz také

Platí pro

Round(Decimal, Int32)

Zaokrouhlí desetinnou hodnotu na zadaný počet desetinných číslic a zaokrouhlí střední hodnoty na nejbližší sudé číslo.

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

Parametry

d
Decimal

Zaokrouhlované desetinné číslo.

decimals
Int32

Počet desetinných míst v návratové hodnotě.

Návraty

Decimal

Číslo nejbližší d k číslu, které obsahuje počet desetinných číslic rovnajících se decimals.

Výjimky

decimals je menší než 0 nebo větší než 28.

Výsledek je mimo rozsah řady Decimal.

Poznámky

Hodnota argumentu může být v rozsahu decimals od 0 do 28.

Tato metoda používá výchozí konvenci zaokrouhlování .MidpointRounding.ToEven Informace o zaokrouhlování čísel středními hodnotami najdete v tématu Střední hodnoty a konvence zaokrouhlování.

Důležité

Při zaokrouhlování hodnot středního bodu provede algoritmus zaokrouhlení test rovnosti. Z důvodu problémů binární reprezentace a přesnosti ve formátu s plovoucí desetinnou čárkou může být hodnota vrácená metodou neočekávaná. Další informace naleznete v tématu zaokrouhlení a přesnost.

Příklad

Následující příklad zaokrouhlí desetinné hodnoty se dvěma desetinnými číslicemi na hodnoty, které mají jednu desetinnou číslici.

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

Viz také

Platí pro

Round(Double)

Zaokrouhlí hodnotu s plovoucí desetinou čárkou na nejbližší celočíselnou hodnotu a zaokrouhlí střední hodnoty na nejbližší sudé číslo.

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

Parametry

a
Double

Zaokrouhlované číslo dvojité přesnosti s plovoucí desetinnou čárkou.

Návraty

Double

Celé číslo nejbližší a. Pokud je zlomková komponenta a mezi dvěma celými čísly poloviční, jedna z nich je sudá a druhá lichá, vrátí se sudé číslo. Všimněte si, že tato metoda vrátí Double místo celočíselného typu.

Poznámky

Tato metoda používá výchozí konvenci zaokrouhlování .MidpointRounding.ToEven Informace o zaokrouhlování čísel středními hodnotami najdete v tématu Střední hodnoty a konvence zaokrouhlování.

Důležité

Při zaokrouhlování hodnot středního bodu provede algoritmus zaokrouhlení test rovnosti. Z důvodu problémů binární reprezentace a přesnosti ve formátu s plovoucí desetinnou čárkou může být hodnota vrácená metodou neočekávaná. Další informace naleznete v tématu zaokrouhlení a přesnost.

Pokud je Double.NaNhodnota argumentu a , vrátí Double.NaNmetoda . Pokud a je Double.PositiveInfinity nebo Double.NegativeInfinity, metoda vrátí Double.PositiveInfinity nebo Double.NegativeInfinity, v uvedeném pořadí.

Počínaje Visual Basic 15.8 je výkon převodu typu Double-to-integer optimalizovaný, pokud předáte hodnotu vrácenou Round metodou do jakékoli celočíselné funkce převodu, nebo pokud je hodnota Double vrácená Round automaticky převedena na celé číslo s parametrem Strict nastaveným na Vypnuto. Tato optimalizace umožňuje rychlejší spouštění kódu – až dvakrát tak rychle pro kód, který provede velký počet převodů na celočíselné typy. Následující příklad znázorňuje takové optimalizované převody:

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

Příklad

Následující příklad ukazuje zaokrouhlení na nejbližší celočíselnou hodnotu.

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

Poznámky pro volající

Vzhledem ke ztrátě přesnosti, která může mít za následek reprezentaci desetinných hodnot jako čísel s plovoucí desetinnou čárkou nebo provádění aritmetických operací s hodnotami s plovoucí desetinnou čárkou, se v některých případech Round(Double) nemusí metoda zdát zaokrouhlená na nejbližší sudé celé číslo. V následujícím příkladu, protože hodnota s plovoucí desetinou čárkou ,1 nemá žádné konečné binární reprezentace, první volání Round(Double) metody s hodnotou 11,5 vrátí místo 12 hodnotu 11.

Viz také

Platí pro

Round(Decimal)

Zaokrouhlí desetinnou hodnotu na nejbližší celočíselnou hodnotu a zaokrouhlí střední hodnoty na nejbližší sudé číslo.

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

Parametry

d
Decimal

Zaokrouhlované desetinné číslo.

Návraty

Decimal

Celé číslo nejblíže parametru d . Pokud je zlomková komponenta d mezi dvěma celými čísly poloviční, jedna z nich je sudá a druhá lichá, vrátí se sudé číslo. Všimněte si, že tato metoda vrátí Decimal místo celočíselného typu.

Výjimky

Výsledek je mimo rozsah řady Decimal.

Příklady

Následující příklad ukazuje metodu Round(Decimal) . Hodnota Decimal 4,5 se zaokrouhlí na 4 místo 5, protože toto přetížení používá výchozí ToEven konvenci.

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

Poznámky

Tato metoda používá výchozí konvenci zaokrouhlování .MidpointRounding.ToEven Informace o zaokrouhlování čísel středními hodnotami najdete v tématu Střední hodnoty a konvence zaokrouhlování.

Důležité

Při zaokrouhlování hodnot středního bodu provede algoritmus zaokrouhlení test rovnosti. Z důvodu problémů binární reprezentace a přesnosti ve formátu s plovoucí desetinnou čárkou může být hodnota vrácená metodou neočekávaná. Další informace naleznete v tématu zaokrouhlení a přesnost.

Viz také

Platí pro

Round(Decimal, MidpointRounding)

Zaokrouhlí desetinnou hodnotu celé číslo pomocí zadané konvence zaokrouhlování.

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

Parametry

d
Decimal

Zaokrouhlované desetinné číslo.

mode
MidpointRounding

Jedna z hodnot výčtu, která určuje, kterou strategii zaokrouhlování se má použít.

Návraty

Decimal

Celé číslo, na které d je zaokrouhleno. Tato metoda vrátí Decimal místo celočíselného typu.

Výjimky

modenení platná hodnota .MidpointRounding

Výsledek je mimo rozsah řady Decimal.

Poznámky

Informace o zaokrouhlování čísel středními hodnotami najdete v tématu Střední hodnoty a konvence zaokrouhlování.

Důležité

Při zaokrouhlování hodnot středního bodu provede algoritmus zaokrouhlení test rovnosti. Z důvodu problémů binární reprezentace a přesnosti ve formátu s plovoucí desetinnou čárkou může být hodnota vrácená metodou neočekávaná. Další informace naleznete v tématu zaokrouhlení a přesnost.

Příklad

Následující příklad zobrazuje hodnoty vrácené metodou Round(Decimal, MidpointRounding) s různými mode hodnotami.

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

Viz také

Platí pro