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 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 míst pomocí zadané konvence zaokrouhlení.

Round(Double, MidpointRounding)

Zaokrouhlí hodnotu s plovoucí desetinnou čárkou s dvojitou přesností na celé číslo pomocí zadané konvence zaokrouhlení.

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žší číslo s plovoucí desetinnou čárkou.

Round(Decimal, Int32)

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

Round(Double)

Zaokrouhlí hodnotu s plovoucí desetinnou čárkou s dvojitou přesností na nejbližší celočíselnou hodnotu a zaokrouhlí střední hodnoty na nejbližší číslo s plovoucí desetinnou čárkou.

Round(Decimal)

Zaokrouhlí desítkovou hodnotu na nejbližší celočíselnou hodnotu a zaokrouhlí střední hodnoty na nejbližší číslo.

Round(Decimal, MidpointRounding)

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

Příklady

Kromě příkladů v části Poznámky tento článek obsahuje příklady, které ilustrují následující přetížení Math.Round 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?

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

Záměr Call
Zaokrouhlí číslo na celé číslo pomocí konvence zaokrouhlení na nejbližší. Round(Decimal)

-nebo-

Round(Double)
Zaokrouhlí číslo na celé číslo pomocí zadané konvence zaokrouhlení. Round(Decimal, MidpointRounding)

-nebo-

Round(Double, MidpointRounding)
Zaokrouhlí číslo na zadaný počet desetinných míst pomocí zaokrouhlení na nejbližší konvenci. Round(Decimal, Int32)

-nebo-

Round(Double, Int32)
Zaokrouhlí číslo na zadaný počet desetinných míst pomocí zadané konvence zaokrouhlení. Round(Decimal, Int32, MidpointRounding)

-nebo-

Round(Double, Int32, MidpointRounding)
Zaokrouhlí hodnotu na zadaný počet desetinných míst pomocí zadané konvence zaokrouhlení a minimalizuje Single ztrátu přesnosti. SinglePřeveďte na a Decimal zavolejte Round(Decimal, Int32, MidpointRounding) .
Zaokrouhlí číslo na zadaný počet desetinných míst a současně minimalizuje problémy přesnosti při zaokrouhlení středních hodnot. Volání metody zaokrouhlení, která implementuje porovnání "větší než nebo přibližně rovno". Viz Zaokrouhlení a přesnost.
Zaokrouhlí zlomkovou hodnotu na celé číslo, které je větší než desetinná hodnota. Například zaokrouhlete 3,1 na 4. Ceiling
Zaokrouhlí zlomkovou hodnotu na celé číslo, které je menší než desetinná hodnota. Například zaokrouhlete 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í. Můžete například použít metodu k zaokrouhlení hodnoty 3,4 na 3,0 a metodu k zaokrouhlení hodnoty Round(Double) Round(Double, Int32) 3,579 na 3,58.

V hodnotě středního bodu je hodnota za nejméně významnou číslicí ve výsledku přesně polovičním rozdílem 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 má být zaokrouhleno na celé číslo. Pokud se v těchto případech použije strategie zaokrouhlení na nejbližší, nelze nejbližší hodnotu snadno identifikovat bez konvence zaokrouhlení.

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

  • Zaokrouhlení od nuly

    Střední hodnoty jsou zaokrouhleny na další číslo 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. Tento tvar zaokrouhlení je reprezentován MidpointRounding.AwayFromZero členem výčtu.

  • Zaokrouhlení na nejbližší rovnoměrně nebo zaokrouhlení bankéra

    Střední hodnoty jsou zaokrouhleny na nejbližší číslo součástku. Například 3,75 i 3,85 se zaokrouhlí na 3,8 a obě –3,75 i -3,85 se zaokrouhlí na -3,8. Tento tvar zaokrouhlení je reprezentován MidpointRounding.ToEven členem výčtu.

Poznámka

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

Zaokrouhlení od nuly je nejčastěji známou formou zaokrouhlení, zatímco zaokrouhlení na nejbližší je standard ve finančních a statistických operacích. Odpovídá standardu IEEE 754, oddíl 4. Při použití ve více operacích zaokrouhlení se zaokrouhlení na nejbližší sníží i chyba zaokrouhlení, která je způsobena konzistentním zaokrouhlením středních 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ředsudky, které mohou být výsledkem konzistentně zaokrouhlující střední hodnoty v jednom směru. Příklad vypočítá skutečnou střední hodnotu pole hodnot a pak vypočítá střední hodnotu, když se hodnoty v poli zaokrouhlí pomocí Decimal dvou konvencí. V tomto příkladu je skutečná střední hodnota a průměr, který je výsledkem zaokrouhlení na nejbližší, stejné. Průměr, který je výsledkem zaokrouhlení od nuly, se ale od skutečné střední hodnoty liší o 0,05 (nebo o 3,6 %).

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

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

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

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

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

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

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

// The example displays the following output:
//       True mean:     1.40
//       AwayFromZero:  1.45
//       ToEven:        1.40
Dim values() As Decimal = {1.15D, 1.25D, 1.35D, 1.45D, 1.55D, 1.65D}
Dim sum As Decimal

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

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

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

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

Ve výchozím nastavení Round metoda používá zaokrouhlení na nejbližší konvenci even. Následující tabulka uvádí přetížení metody a konvenci zaokrouhlení, Round kterou každá z nich 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 se mode parametrem.
Round(Double, MidpointRounding) Určeno mode parametrem
Round(Decimal, Int32, MidpointRounding) Určeno mode parametrem
Round(Double, Int32, MidpointRounding) Určeno mode parametrem

Zaokrouhlování a přesnost

Aby bylo možné určit, zda operace zaokrouhlení zahrnuje hodnotu středního bodu, vynásobí metoda původní hodnotu zaokrouhlením o 10 n , kde n je požadovaný počet desetinných číslic ve vrácené hodnotě, a poté určí, zda je zbývající desetinná část hodnoty větší nebo rovna Round 0,5. Jedná se o drobnou variaci na test rovnosti a jak je popsáno v části Testování rovnosti v referenčním tématu, testy rovnosti s hodnotami s plovoucí desetinnou čárkou jsou problematické kvůli problémům s binární reprezentací a přesností ve formátu s plovoucí desetinnou Double čárkou. To znamená, že jakákoli desetinná část čísla, která je mírně menší než 0,5 (kvůli ztrátě přesnosti), nebude zaokrouhlena směrem nahoru.

Následující příklad ukazuje tento problém. Opakovaně přidá .1 k 11.0 a zaokrouhlí výsledek na nejbližší celé číslo. Hodnota 11,5 by se měla zaokrouhlit na 12 pomocí jedné ze konvencí středního zaokrouhlení ( ToEven nebo AwayFromZero ). Jak ale ukazuje výstup z příkladu, není to tak. Tento 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á zaokrouhlit, má během opakovaných sčítání ztracenou přesnost a její hodnota je ve skutečnosti 11,4999999999999998. Vzhledem k 499999999999998,že .499999999999998 menší než 0,5, nezačnou se hrát konvence středního zaokrouhlení a hodnota se zaokrouhlí dolů. Jak 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
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í středních hodnot se s největší pravděpodobností objeví za následujících podmínek:

  • Pokud desetinnou hodnotu nelze vyjádřit přesně v binárním formátu typu s plovoucí desetinnou čárkou.

  • Pokud se hodnota, která se má zaokrouhlit, vypočítá z jedné nebo více operací s plovoucí desetinnou čárkou.

  • Pokud je hodnota, která se má Single zaokrouhlit, spíše než nebo Double Decimal . Další informace najdete v další části Zaokrouhlení a hodnoty s plovoucí desetinnou čárkou s přesností na jednu desetinnou čárku.

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

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

  • Definujte vlastní algoritmus zaokrouhlení, který provede "téměř stejný" test, aby se zjistilo, jestli je hodnota, která se má zaokrouhlit, přijatelně blízko střední hodnoty. Následující příklad definuje metodu, která zkoumá, zda je desetinná hodnota dostatečně blízko střední hodnoty, aby byla předmětem zaokrouhlení RoundApproximate středního bodu. Jak ukazuje výstup z příkladu, opravuje problém zaokrouhlení 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
    
    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é zaokrouhlovat hodnoty typu Single . Pokud předáte hodnotu jednomu z přetížení metody, přetypuje se Single Round (v jazyce C#) nebo převede (v Visual Basic) na a je voláno odpovídající přetížení s Double Round Double parametrem . I když se jedná o rozšiřující převod, často se jedná o ztrátu přesnosti, jak ukazuje následující příklad. Když se metodě předá hodnota 16,325 a zaokrouhlí se na dvě desetinná místa pomocí zaokrouhlení na nejbližší konvenci, výsledek je Single Round 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
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 Double . Vzhledem k tomu, že výsledná hodnota Double 16,325000762939453 není střední hodnota a je větší než 16,325, vždy se zaokrouhlí směrem nahoru.

V mnoha případech, jak ukazuje příklad, lze ztrátu přesnosti minimalizovat nebo eliminovat přetypování 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)

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

Návraty

Double

Číslo, které má digits desetinné číslice value zaokrouhlené na Pokud value má menší počet desetinných míst než , vrátí se digits value beze změny.

Výjimky

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

mode není platná hodnota MidpointRounding .

Poznámky

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

Informace o zaokrouhlení čísel s hodnotami midpoint najdete v tématu Střední hodnoty a konvence zaokrouhlení.

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 hodnota value argumentu Double.NaN , metoda vrátí Double.NaN . Pokud value je nebo , metoda vrátí nebo Double.PositiveInfinity Double.NegativeInfinity Double.PositiveInfinity Double.NegativeInfinity .

Příklad

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


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

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

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

// The example displays the following output:

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

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

//         -3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
//         -3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)
//         -3.4 = Math.Round(-3.47, 1, MidpointRounding.ToZero)
Dim posValue As Double = 3.45
Dim negValue As Double = -3.45

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

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

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

'This code example produces the following results:

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

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

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

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 zdát, že metoda zaokrouhlí střední hodnoty podle Round(Double, Int32, MidpointRounding) mode parametru . To je znázorněno v následujícím příkladu, kde se 2,135 zaokrouhlí na 2,13 místo na 2,14. K tomu dochází, protože metoda se interně vynásobí 10 číslicemi a operace násobení v tomto případě trpí ztrátou value 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

Viz také

Platí pro

Round(Decimal, Int32, MidpointRounding)

Zaokrouhlí desetinnou hodnotu na zadaný počet desetinných míst 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 vrácené hodnotě

mode
MidpointRounding

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

Návraty

Decimal

Číslo s decimals desetinnou číslicí d zaokrouhlenou na Pokud d má menší počet desetinných míst než , vrátí se decimals d beze změny.

Výjimky

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

mode není platná hodnota MidpointRounding .

Výsledek je mimo rozsah Decimal .

Poznámky

Informace o zaokrouhlení čísel s hodnotami midpoint najdete v tématu Střední hodnoty a konvence zaokrouhlení.

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 decimals může být v rozsahu od 0 do 28.

Příklad

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

decimal result;

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

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

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

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

/*
This code example produces the following results:

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

-3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
-3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)
-3.4 = Math.Round(-3.47, 1, MidpointRounding.ToZero)
*/
Dim result As Decimal = 0D
Dim posValue As Decimal = 3.45D
Dim negValue As Decimal = -3.45D

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

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

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

Viz také

Platí pro

Round(Double, MidpointRounding)

Zaokrouhlí hodnotu s plovoucí desetinnou čárkou s dvojitou přesností na celé číslo pomocí zadané konvence zaokrouhlení.

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

Návraty

Double

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

Výjimky

mode není platná hodnota MidpointRounding .

Poznámky

Informace o zaokrouhlení čísel s hodnotami midpoint najdete v tématu Střední hodnoty a konvence zaokrouhlení.

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 hodnota value argumentu Double.NaN , metoda vrátí Double.NaN . Pokud value je nebo , metoda vrátí nebo Double.PositiveInfinity Double.NegativeInfinity Double.PositiveInfinity Double.NegativeInfinity .

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
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 zdát, že metoda zaokrouhlí hodnoty středních bodů na nejbližší rovnoměrně celé Round(Double, MidpointRounding) číslo. Vzhledem k tomu, že v následujícím příkladu má hodnota s plovoucí desetinnou čárkou .1 žádnou konečnou binární reprezentaci, vrátí první volání metody s hodnotou Round(Double) 11,5 místo hodnoty 12 hodnotu 11.

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

Viz také

Platí pro

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žší číslo s plovoucí desetinnou čárkou.

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

Nejbližší číslo, value které obsahuje počet desetinných číslic, které se rovnají digits .

Výjimky

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

Poznámky

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

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

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 hodnota value argumentu Double.NaN , metoda vrátí Double.NaN . Pokud value je nebo , metoda vrátí nebo Double.PositiveInfinity Double.NegativeInfinity Double.PositiveInfinity Double.NegativeInfinity .

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
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 zdát, že metoda zaokrouhlí střední hodnoty na nejbližší rovnoměrně nejbližší hodnotu na desetinné Round(Double, Int32) digits pozici. To je znázorněno v následujícím příkladu, kde se 2,135 zaokrouhlí na 2,13 místo na 2,14. K tomu dochází, protože metoda se interně vynásobí 10 číslicemi a operace násobení v tomto případě trpí ztrátou value 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

Viz také

Platí pro

Round(Decimal, Int32)

Zaokrouhlí desetinnou hodnotu na zadaný počet desetinných míst a zaokrouhlí střední hodnoty na nejbližší čí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 vrácené hodnotě

Návraty

Decimal

Nejbližší číslo, d které obsahuje počet desetinných číslic, které se rovnají decimals .

Výjimky

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

Výsledek je mimo rozsah Decimal .

Poznámky

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

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

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
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í desetinnou čárkou s dvojitou přesností na nejbližší celočíselnou hodnotu a zaokrouhlí střední hodnoty na nejbližší číslo s plovoucí desetinnou čárkou.

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 desetinná komponenta v polovině mezi dvěma celými čísly, z nichž jedno je sudé a druhé a liché, vrátí se sudé číslo. Všimněte si, že tato metoda Double vrátí místo celočíselného typu.

Poznámky

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

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 hodnota a argumentu Double.NaN , metoda vrátí Double.NaN . Pokud a je nebo , metoda vrátí nebo Double.PositiveInfinity Double.NegativeInfinity Double.PositiveInfinity Double.NegativeInfinity .

Počínaje Visual Basic 15.8 je výkon převodu typu Double na celé číslo optimalizován, pokud předáte hodnotu vrácenou metodou jakékoli celočíselné funkce převodu nebo pokud je hodnota Double vrácená funkcí automaticky převedena na celé číslo s parametrem Option Strict nastaveným Round na hodnotu Round Off. Díky této optimalizaci může kód běžet rychleji – až dvakrát rychleji u kódu, který udělá 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
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 zdát, že metoda zaokrouhlí hodnoty středních bodů na nejbližší rovnoměrně celé Round(Double) číslo. Vzhledem k tomu, že v následujícím příkladu má hodnota s plovoucí desetinnou čárkou .1 žádnou konečnou binární reprezentaci, vrátí první volání metody s hodnotou Round(Double) 11,5 místo hodnoty 12 hodnotu 11.

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

Viz také

Platí pro

Round(Decimal)

Zaokrouhlí desítkovou hodnotu na nejbližší celočíselnou hodnotu a zaokrouhlí střední hodnoty na nejbližší čí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 nejbližší d parametru. Pokud je desetinná komponenta v polovině mezi dvěma celými čísly, z nichž jedno je sudé a druhé d liché, vrátí se sudé číslo. Všimněte si, že tato metoda Decimal vrátí místo celočíselného typu.

Výjimky

Výsledek je mimo rozsah Decimal .

Příklady

Následující příklad ukazuje Round(Decimal) metodu . Hodnota 4,5 se zaokrouhlí na 4 místo 5, protože toto přetížení Decimal 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
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 zaokrouhlení MidpointRounding.ToEven . Informace o zaokrouhlení čísel s hodnotami středního bodu najdete v tématu Střední hodnoty a konvence zaokrouhlení.

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

Návraty

Decimal

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

Výjimky

mode není platná hodnota MidpointRounding .

Výsledek je mimo rozsah Decimal .

Poznámky

Informace o zaokrouhlení čísel s hodnotami středního bodu najdete v tématu Střední hodnoty a konvence zaokrouhlení.

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