Math.Round Metoda
Definice
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 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?
- Střední hodnoty a konvence zaokrouhlování
- Zaokrouhlování a přesnost
- Zaokrouhlení a hodnoty s plovoucí desetinnou čárkou s přesností na jednu desetinnou čárku
- 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ě 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í
RoundApproximatestř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 12Public 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 -> doublePublic Shared Function Round (value As Double, digits As Integer, mode As MidpointRounding) As DoubleParametry
- 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
Čí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 -> decimalPublic Shared Function Round (d As Decimal, decimals As Integer, mode As MidpointRounding) As DecimalParametry
- 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
Čí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 -> doublePublic Shared Function Round (value As Double, mode As MidpointRounding) As DoubleParametry
- 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
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 -> doublePublic Shared Function Round (value As Double, digits As Integer) As DoubleParametry
- value
- Double
Zaokrouhlované číslo dvojité přesnosti s plovoucí desetinnou čárkou.
- digits
- Int32
Počet desetinných číslic ve vrácené hodnotě.
Návraty
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 -> decimalPublic Shared Function Round (d As Decimal, decimals As Integer) As DecimalParametry
- d
- Decimal
Zaokrouhlované desetinné číslo.
- decimals
- Int32
Počet desetinných míst ve vrácené hodnotě
Návraty
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 -> doublePublic Shared Function Round (a As Double) As DoubleParametry
- a
- Double
Zaokrouhlované číslo dvojité přesnosti s plovoucí desetinnou čárkou.
Návraty
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 -> decimalPublic Shared Function Round (d As Decimal) As DecimalParametry
- d
- Decimal
Zaokrouhlované desetinné číslo.
Návraty
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 -> decimalPublic Shared Function Round (d As Decimal, mode As MidpointRounding) As DecimalParametry
- d
- Decimal
Zaokrouhlované desetinné číslo.
- mode
- MidpointRounding
Jedna z hodnot výčtu, která určuje, kterou strategii zaokrouhlení použít.
Návraty
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