Math.Round Metoda

Reference

Definice

Obor názvů:: System

Sestavení:: System.Runtime.Extensions.dll

Sestavení:: System.Runtime.dll

Sestavení:: mscorlib.dll

Sestavení:: netstandard.dll

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

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

Přetížení

Round(Double, Int32, MidpointRounding)	Zaokrouhlí hodnotu s plovoucí desetinnou čárkou s dvojitou přesností na zadaný počet desetinných číslic pomocí zadané konvence zaokrouhlení.
Round(Decimal, Int32, MidpointRounding)	Zaokrouhlí desetinnou hodnotu na zadaný počet desetinných číslic pomocí zadané konvence zaokrouhlení.
Round(Double, MidpointRounding)	Zaokrouhlí hodnotu s plovoucí desetinou čárkou s dvojitou přesností na celé číslo pomocí zadané konvence zaokrouhlování.
Round(Double, Int32)	Zaokrouhlí hodnotu s plovoucí desetinnou čárkou s dvojitou přesností 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í hodnoty uprostřed na nejbližší sudé číslo.
Round(Double)	Zaokrouhlí hodnotu s plovoucí desetinou čárkou s dvojitou přesností 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 zaokrouhlení.

Příklady

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

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)

Poznámky

V této části:

Jakou metodu mám volat?
Střední hodnoty a konvence zaokrouhlování
Zaokrouhlování a přesnost
Zaokrouhlení a hodnoty s plovoucí desetinou čárkou s jednou přesností
Příklady jednotlivých přetížení

Jakou metodu mám volat?

K výběru vhodné metody zaokrouhlení můžete použít následující tabulku. Kromě Math.Round metod zahrnuje Math.Ceiling také a Math.Floor.

Záměr	Call
Zaokrouhlí číslo na celé číslo pomocí konvence zaokrouhlení na nejbližší.	Round(Decimal) -nebo- Round(Double)
Zaokrouhlení čísla na celé číslo pomocí zadané konvence zaokrouhlení.	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)
Zaokrouhlení čísla na zadaný počet desetinných číslic pomocí zadané konvence zaokrouhlení.	Round(Decimal, Int32, MidpointRounding) -nebo- Round(Double, Int32, MidpointRounding)
Zaokrouhlení Single hodnoty na zadaný počet desetinných číslic pomocí zadané konvence zaokrouhlení a minimalizace ztráty 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í 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 zaokrouhlit číslo 3,1 na 4.	Ceiling
Zaokrouhlí desetinnou hodnotu na celé číslo, které je menší než desetinná hodnota. Například zaokrouhlit číslo 3,9 na 3.	Floor

Střední hodnoty a konvence zaokrouhlování

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

Ve střední hodnotě je hodnota za nejméně významnou číslicí ve výsledku přesně napůl cesty mezi dvěma čísly. Například hodnota 3,47500 je střední bod, pokud se má zaokrouhlit na dvě desetinná místa, a 7,500 je hodnota střední bodu, pokud má být zaokrouhlená na celé číslo. Pokud se v těchto případech použije strategie zaokrouhlení na nejbližší, nejde nejbližší hodnotu snadno identifikovat bez konvence zaokrouhlování.

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

Zaokrouhlování směrem od nuly

Střední hodnoty se zaokrouhlují na další číslo směrem od nuly. Například 3,75 zaokrouhlí na 3,8, 3,85 na 3,9, -3,75 na -3,8 a -3,85 na -3,9. Tato forma zaokrouhlení je reprezentována členem výčtu MidpointRounding.AwayFromZero .
Zaokrouhlení na nejbližší sudé nebo zaokrouhlení banky

Střední hodnoty se zaokrouhlují na nejbližší sudé číslo. Například 3,75 a 3,85 zaokrouhlí na 3,8 a obě hodnoty -3,75 a -3,85 zaokrouhlí 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ího bodu, jako MidpointRounding.ToEven jsou a MidpointRounding.AwayFromZero jsou.

Zaokrouhlování směrem od nuly je nejčastěji známá forma zaokrouhlení, zatímco zaokrouhlení na nejbližší sudé je standardem ve finančních a statistických operacích. Je v souladu se standardem IEEE 754, oddíl 4. Při použití ve více operacích zaokrouhlení na nejbližší se dokonce sníží chyba zaokrouhlení, která je způsobená konzistentním zaokrouhlením hodnot v jednom směru. V některých případech může být tato chyba zaokrouhlení významná.

Následující příklad znázorňuje předpojatost, která může být výsledkem konzistentního zaokrouhlení hodnot středního bodu v jednom směru. Příklad vypočítá skutečnou střední hodnotu pole Decimal hodnot a pak vypočítá průměr při zaokrouhlení hodnot v matici pomocí dvou konvencí. V tomto příkladu jsou skutečná střední hodnota a střední hodnota, která se zobrazí při zaokrouhlení na nejbližší, stejné. Průměr, který je výsledkem zaokrouhlení směrem od nuly, se však liší o 05 (neboli 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á zaokrouhlení na nejbližší sudou konvenci. Následující tabulka uvádí přetížení Round metody a konvence zaokrouhlování, které každý používá.

Přetížení	Konvence zaokrouhlení
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 zaokrouhlení zahrnuje střední hodnotu, Round metoda vynásobí původní hodnotu, která má být zaokrouhlená 10ⁿ, kde n je požadovaný počet desetinných číslic ve návratové hodnotě a pak určí, zda je zbývající zlomková část hodnoty větší než nebo rovna 0,5. Jedná se o mírnou variaci testu rovnosti. Jak je popsáno v části Testování rovnosti v referenčním Double tématu, testy rovnosti s hodnotami s plovoucí desetinou čárkou jsou problematické kvůli problémům formátu s plovoucí desetinou čárkou s binární reprezentací a přesností. To znamená, že žádná zlomková část čísla, která je o něco menší než 0,5 (kvůli ztrátě přesnosti), nebude zaokrouhlená nahoru.

Následující příklad ukazuje tento problém. Opakovaně přidává hodnotu .1 na hodnotu 11.0 a výsledek zaokrouhlí na nejbližší celé číslo. 11.5 by se měl zaokrouhlit na číslo 12 s použitím některé z konvencí pro zaokrouhlování mezi body (ToEven nebo AwayFromZero). Jak ale ukazuje výstup z příkladu, ne. Příklad používá řetězec standardního číselného formátu "R" k zobrazení plné přesnosti hodnoty s plovoucí desetinnou čárkou a ukazuje, že hodnota, která se má zaokrouhlovat, ztratila přesnost při opakovaném sčítání a její hodnota je ve skutečnosti 11,49999999999998. Vzhledem k tomu, že hodnota .499999999999998 je menší než 0,5, nepřicházejí do hry konvence zaokrouhlení středního bodu a hodnota se zaokrouhlí dolů. Jak také ukazuje příklad, k tomuto problému nedojde, pokud proměnné přiřadíte konstantní hodnotu 11,5 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

K problémům s přesností při zaokrouhlení hodnot uprostřed je nejpravděpodobnější, že dojde k následujícím podmínkám:

Pokud desetinná hodnota nemůže být přesně vyjádřena v binárním formátu typu s plovoucí desetinnou čárkou.
Hodnota, která se má zaokrouhlit, se vypočítá z jedné nebo více operací s plovoucí desetinnou čárkou.
Pokud je hodnota, která se má zaokrouhlit, Single a ne nebo Double Decimal. Další informace najdete v další části Zaokrouhlování a hodnoty s plovoucí desetinou čárkou s jednou přesností.

V případech, kdy je nedostatečná přesnost operací zaokrouhlení problematická, můžete provést následující:

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

Definujte vlastní algoritmus zaokrouhlování, který provede test "téměř shodného" a určí, zda je hodnota, která se má zaokrouhlit, přijatelně blízko hodnoty střední bodu. Následující příklad definuje metodu RoundApproximate , která zkoumá, zda je desetinná hodnota dostatečně blízko ke střední hodnotě, aby byla předmětem zaokrouhlení střední bod. Jak ukazuje výstup z příkladu, opraví problém zaokrouhlování zobrazený 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é by zaokrouhlují hodnoty typu Single. Pokud předáte Single hodnotu některému z přetížení Round metody, je přetypována (v jazyce C#) nebo převedena (v jazyce Visual Basic) na Doublea odpovídající Round přetížení parametrem Double je voláno. I když se jedná o rozšiřující převod, často s sebou nese ztrátu přesnosti, jak ukazuje následující příklad. Single Pokud je metodě předána Round hodnota 16,325 a zaokrouhleno na dvě desetinná místa pomocí zaokrouhlení na nejbližší konvenci, výsledek je 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,3250007629393453 není střední hodnotou a je větší než 16,325, je vždy zaokrouhlená nahoru.

V mnoha případech, jak ukazuje příklad, lze ztrátu přesnosti minimalizovat nebo eliminovat přetypováním nebo převodem Single hodnoty na Decimal. Všimněte si, že vzhledem k tomu, že se jedná o zužující převod, vyžaduje použití operátoru přetypování nebo volání metody převodu.

Round(Double, Int32, MidpointRounding)

Source:: Math.cs

Source:: Math.cs

Source:: Math.cs

Zaokrouhlí hodnotu s plovoucí desetinnou čárkou s dvojitou přesností na zadaný počet desetinných číslic pomocí zadané konvence zaokrouhlení.

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í použít.

Návraty

Double

Číslo, které obsahuje digits desetinné číslice zaokrouhlené value na. Pokud value má méně desetinných číslic než digits, value vrátí se beze změny.

Výjimky

ArgumentOutOfRangeException

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

ArgumentException

mode není platná hodnota MidpointRounding.

Poznámky

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

Informace o zaokrouhlení čísel s hodnotami středních bodů najdete v tématu Hodnoty středních bodů a konvence zaokrouhlování .

Důležité

Při zaokrouhlení hodnot střední bodu algoritmus zaokrouhlování provede test rovnosti. Vzhledem k problémům s binární reprezentací a přesností ve formátu s plovoucí desetinou čárkou může být hodnota vrácená metodou neočekávaná. Další informace najdete v tématu Zaokrouhlení a přesnost.

Pokud je Double.NaNhodnota argumentu value , vrátí metoda hodnotu Double.NaN. Pokud value je Double.PositiveInfinity nebo Double.NegativeInfinity, vrátí Double.PositiveInfinity metoda 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 být výsledkem reprezentace 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í zdát, že metoda zaokrouhlí hodnoty střední bodu, jak je určeno parametrem mode . To je znázorněno v následujícím příkladu, kde 2,135 je zaokrouhleno na 2,13 místo na 2,14. K tomu dochází, protože interně se metoda vynásobí value 10^číslicemi a operace násobení v tomto případě trpí ztrátou přesnosti.

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

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

open System

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

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

Viz také

Platí pro

Round(Decimal, Int32, MidpointRounding)

Source:: Math.cs

Source:: Math.cs

Source:: Math.cs

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

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 ve návratové hodnotě.

mode: MidpointRounding

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

Návraty

Decimal

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

Výjimky

ArgumentOutOfRangeException

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

ArgumentException

mode není platná hodnota MidpointRounding.

OverflowException

Výsledek je mimo rozsah Decimal.

Poznámky

Informace o zaokrouhlení čísel s hodnotami středních bodů najdete v tématu Hodnoty středních bodů a konvence zaokrouhlování .

Důležité

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)

Source:: Math.cs

Source:: Math.cs

Source:: Math.cs

Zaokrouhlí hodnotu s plovoucí desetinou čárkou 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í použít.

Návraty

Double

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

Výjimky

ArgumentException

mode není platná hodnota MidpointRounding.

Poznámky

Informace o zaokrouhlení čísel s hodnotami středních bodů najdete v tématu Hodnoty středních bodů a konvence zaokrouhlování .

Důležité

Příklad

Následující příklad zobrazí 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 být výsledkem reprezentace desetinných hodnot jako čísel s plovoucí desetinnou čárkou nebo provádění aritmetických operací s hodnotami s plovoucí desetinnou čárkou, nemusí se v některých případech Round(Double, MidpointRounding) zdát, že metoda zaokrouhlí hodnoty střední bodu na nejbližší sudé celé číslo. V následujícím příkladu, protože hodnota .1 s plovoucí desetinou čárkou nemá žádné konečné binární vyjádření, první volání Round(Double) metody s hodnotou 11,5 vrátí hodnotu 11 místo 12.

using System;

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

      Console.WriteLine();

      value = 11.5;
      RoundValueAndAdd(value);
   }

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

open System

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

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

printfn ""

value <- 11.5
roundValueAndAdd value
|> ignore

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

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

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

Viz také

Platí pro

Round(Double, Int32)

Source:: Math.cs

Source:: Math.cs

Source:: Math.cs

Zaokrouhlí hodnotu s plovoucí desetinnou čárkou s dvojitou přesností 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, které je nejblíže k value číslu, obsahuje počet desetinných číslic rovnající se hodnotě digits.

Výjimky

ArgumentOutOfRangeException

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álů a desetinných číslic podporovaných typem Double je 15.

Tato metoda používá výchozí konvenci zaokrouhlení pro MidpointRounding.ToEven. Informace o zaokrouhlení čísel s hodnotami středních bodů najdete v tématu Hodnoty středních bodů a konvence zaokrouhlování .

Důležité

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 být výsledkem reprezentace desetinných hodnot jako čísel s plovoucí desetinnou čárkou nebo provádění aritmetických operací s hodnotami s plovoucí desetinnou čárkou, nemusí se v některých případech Round(Double, Int32) zdát, že metoda zaokrouhlí hodnoty střední bodu na nejbližší sudou hodnotu v digits desítkové pozici. To je znázorněno v následujícím příkladu, kde 2,135 je zaokrouhleno na 2,13 místo na 2,14. K tomu dochází, protože interně se metoda vynásobí value 10^číslicemi a operace násobení v tomto případě trpí ztrátou přesnosti.

using System;

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

open System

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

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

Viz také

Platí pro

Round(Decimal, Int32)

Source:: Math.cs

Source:: Math.cs

Source:: Math.cs

Zaokrouhlí desetinnou hodnotu na zadaný počet desetinných číslic a zaokrouhlí hodnoty uprostřed 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 ve návratové hodnotě.

Návraty

Decimal

Číslo, které je nejblíže k d číslu, obsahuje počet desetinných číslic rovnající se hodnotě decimals.

Výjimky

ArgumentOutOfRangeException

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

OverflowException

Výsledek je mimo rozsah Decimal.

Poznámky

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

Tato metoda používá výchozí konvenci zaokrouhlení pro MidpointRounding.ToEven. Informace o zaokrouhlení čísel pomocí hodnot středních bodů najdete v tématu Hodnoty středních bodů a konvence zaokrouhlování.

Důležité

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)

Source:: Math.cs

Source:: Math.cs

Source:: Math.cs

Zaokrouhlí hodnotu s plovoucí desetinou čárkou s dvojitou přesností 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á složka v a polovině cesty mezi dvěma celými čísly, z nichž jedno je sudé a druhé liché, vrátí se sudé číslo. Všimněte si, že tato metoda vrací Double místo celočíselného typu.

Poznámky

Důležité

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

Počínaje jazykem Visual Basic 15.8 je výkon převodu typu Double-to-integer optimalizovaný, pokud předáte hodnotu vrácenou metodou Round některé z integrálních funkcí převodu nebo pokud je hodnota Double vrácená Round automaticky převedena na celé číslo s parametrem Strict nastavenou na Vypnuto. Tato optimalizace umožňuje rychlejší spouštění kódu – až dvakrát rychleji 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 být výsledkem reprezentace desetinných hodnot jako čísel s plovoucí desetinnou čárkou nebo provádění aritmetických operací s hodnotami s plovoucí desetinnou čárkou, nemusí se v některých případech Round(Double) zdát, že metoda zaokrouhlí hodnoty střední bodu na nejbližší sudé celé číslo. V následujícím příkladu, protože hodnota .1 s plovoucí desetinou čárkou nemá žádné konečné binární vyjádření, první volání Round(Double) metody s hodnotou 11,5 vrátí hodnotu 11 místo 12.

using System;

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

      Console.WriteLine();

      value = 11.5;
      RoundValueAndAdd(value);
   }

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

open System

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

let mutable value = 11.1

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

printfn ""

value <- 11.5
roundValueAndAdd value
|> ignore

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

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

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

Viz také

Platí pro

Round(Decimal)

Source:: Math.cs

Source:: Math.cs

Source:: Math.cs

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, které je nejblíže parametru d . Pokud je desetinná komponenta d napůl cesty mezi dvěma celými čísly, z nichž jedno je sudé a druhé liché, vrátí se sudé číslo. Všimněte si, že tato metoda vrací Decimal místo celočíselného typu.

Výjimky

OverflowException

Výsledek je mimo rozsah Decimal.

Příklady

Následující příklad ukazuje metodu Round(Decimal) . Hodnota Decimal 4,5 zaokrouhlí na 4 místo na 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

Důležité

Viz také

Platí pro

Round(Decimal, MidpointRounding)

Source:: Math.cs

Source:: Math.cs

Source:: Math.cs

Zaokrouhlí desetinnou hodnotu celé číslo pomocí zadané konvence zaokrouhlení.

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í použít.

Návraty

Decimal

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

Výjimky

ArgumentException

mode není platná hodnota MidpointRounding.

OverflowException

Výsledek je mimo rozsah Decimal.

Poznámky

Informace o zaokrouhlení čísel pomocí hodnot středních bodů najdete v tématu Hodnoty středních bodů a konvence zaokrouhlování.

Důležité

Příklad

Následující příklad zobrazí 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

Math.Round Metoda

Definice

Přetížení

Příklady

Poznámky

Jakou metodu mám volat?

Střední hodnoty a konvence zaokrouhlování

Zaokrouhlování a přesnost

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

Round(Double, Int32, MidpointRounding)

Parametry

Návraty

Výjimky

Poznámky

Příklad

Poznámky pro volající

Viz také

Platí pro

Round(Decimal, Int32, MidpointRounding)

Parametry

Návraty

Výjimky

Poznámky

Příklad

Viz také

Platí pro

Round(Double, MidpointRounding)

Parametry

Návraty

Výjimky

Poznámky

Příklad

Poznámky pro volající

Viz také

Platí pro

Round(Double, Int32)

Parametry

Návraty

Výjimky

Poznámky

Příklad

Poznámky pro volající

Viz také

Platí pro

Round(Decimal, Int32)

Parametry

Návraty

Výjimky

Poznámky

Příklad

Viz také

Platí pro

Round(Double)

Parametry

Návraty

Poznámky

Příklad

Poznámky pro volající

Viz také

Platí pro

Round(Decimal)

Parametry

Návraty

Výjimky

Příklady

Poznámky

Viz také

Platí pro

Round(Decimal, MidpointRounding)

Parametry

Návraty

Výjimky

Poznámky

Příklad

Viz také

Platí pro

Váš názor

Další materiály