Math.Round Metoda

Definice

Obor názvů:

System

Sestavení:

netstandard.dll, System.Runtime.dll

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

Přetížení

Name	Description
Round(Double, Int32, MidpointRounding)	Zaokrouhlí hodnotu s plovoucí desetinnou čárkou s dvojitou přesností na zadaný počet desetinných číslic pomocí zadané konvence zaokrouhlování.
Round(Decimal, Int32, MidpointRounding)	Zaokrouhlí desetinnou hodnotu na zadaný počet desetinných číslic pomocí zadané konvence zaokrouhlování.
Round(Double, MidpointRounding)	Zaokrouhlí hodnotu s plovoucí desetinnou čárkou s dvojitou přesností na celé číslo pomocí zadané konvence zaokrouhlování.
Round(Double, Int32)	Zaokrouhlí hodnotu s plovoucí desetinnou čárkou s dvojitou přesností na zadaný počet desetinných míst a zaokrouhlí střední hodnoty na nejbližší sudé číslo.
Round(Decimal, Int32)	Zaokrouhlí desetinnou hodnotu na zadaný počet desetinných číslic a zaokrouhlí střední hodnoty na nejbližší sudé číslo.
Round(Double)	Zaokrouhlí hodnotu s plovoucí desetinnou čárkou s dvojitou přesností na nejbližší celočíselnou hodnotu a zaokrouhlí střední hodnoty na nejbližší sudé číslo.
Round(Decimal)	Zaokrouhlí desetinnou hodnotu na nejbližší celočíselnou hodnotu a zaokrouhlí střední hodnoty na nejbližší sudé číslo.
Round(Decimal, MidpointRounding)	Zaokrouhlí desetinnou hodnotu celé číslo pomocí zadané konvence zaokrouhlování.

Příklady

Kromě příkladů v části Poznámky existují příklady v každém přetížení Math.Round metody.

Poznámky

V této části:

• Jakou metodu zavolám?
• Střední hodnoty a konvence zaokrouhlování
• Zaokrouhlování a přesnost
• Zaokrouhlování a hodnoty s plovoucí desetinnou čárkou s jednoduchou přesností

Jakou metodu zavolám?

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

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

Střední hodnoty a konvence zaokrouhlování

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

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

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

• Zaokrouhlování směrem od nuly

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

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

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

Note

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

Zaokrouhlování směrem od nuly je nejobsáhlejší formou zaokrouhlování, zatímco zaokrouhlování na nejbližší i je standardem finančních a statistických operací. Je v souladu se standardem IEEE 754, oddílem 4. Při použití v několika operacích zaokrouhlení se zaokrouhlování na nejbližší i sníží zaokrouhlování chyby, která je způsobena konzistentně zaokrouhlováním středních hodnot v jednom směru. V některých případech může být tato chyba zaokrouhlování významná.

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

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

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

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

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

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

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

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

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

open System

let values = [| 1.15m; 1.25m; 1.35m; 1.45m; 1.55m; 1.65m |]
let mutable sum = 0m

// Calculate true mean.
for value in values do
    sum <- sum + value

printfn $"True mean:     {sum / decimal values.Length:N2}"

// Calculate mean with rounding away from zero.
sum <- 0m
for value in values do
    sum <- sum + Math.Round(value, 1, MidpointRounding.AwayFromZero)

printfn $"AwayFromZero:  {sum / decimal values.Length:N2}"

// Calculate mean with rounding to nearest.
sum <- 0m
for value in values do
    sum <- sum + Math.Round(value, 1, MidpointRounding.ToEven)

printfn $"ToEven:        {sum / decimal values.Length:N2}"

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

Dim values() As Decimal = {1.15D, 1.25D, 1.35D, 1.45D, 1.55D, 1.65D}
Dim sum As Decimal

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

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

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

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

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

Overload	Konvence zaokrouhlování
Round(Decimal)	ToEven
Round(Double)	ToEven
Round(Decimal, Int32)	ToEven
Round(Double, Int32)	ToEven
Round(Decimal, MidpointRounding)	Určuje parametr mode .
Round(Double, MidpointRounding)	Určeno parametrem mode
Round(Decimal, Int32, MidpointRounding)	Určeno parametrem mode
Round(Double, Int32, MidpointRounding)	Určeno parametrem mode

Zaokrouhlování a přesnost

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

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

public static void Example()
{
    Console.WriteLine("{0,5} {1,20:R}  {2,12} {3,15}\n",
                      "Value", "Full Precision", "ToEven",
                      "AwayFromZero");
    double value = 11.1;
    for (int ctr = 0; ctr <= 5; ctr++)
        value = RoundValueAndAdd(value);

    Console.WriteLine();

    value = 11.5;
    RoundValueAndAdd(value);
}

private static double RoundValueAndAdd(double value)
{
    Console.WriteLine("{0,5:N1} {0,20:R}  {1,12} {2,15}",
                      value, Math.Round(value, MidpointRounding.ToEven),
                      Math.Round(value, MidpointRounding.AwayFromZero));
    return value + .1;
}

// The example displays the following output:
//       Value       Full Precision        ToEven    AwayFromZero
//
//        11.1                 11.1            11              11
//        11.2                 11.2            11              11
//        11.3   11.299999999999999            11              11
//        11.4   11.399999999999999            11              11
//        11.5   11.499999999999998            11              11
//        11.6   11.599999999999998            12              12
//
//        11.5                 11.5            12              12

open System

let roundValueAndAdd (value: double) =
    printfn $"{value,5:N1} {value,20:R}  {Math.Round(value, MidpointRounding.ToEven),12} {Math.Round(value, MidpointRounding.AwayFromZero),15}"
    value + 0.1

printfn "%5s %20s  %12s %15s\n" "Value" "Full Precision" "ToEven" "AwayFromZero"
let mutable value = 11.1
for _ = 0 to 5 do
    value <- roundValueAndAdd value

printfn ""

value <- 11.5
roundValueAndAdd value
|> ignore

// The example displays the following output:
//       Value       Full Precision        ToEven    AwayFromZero
//
//        11.1                 11.1            11              11
//        11.2                 11.2            11              11
//        11.3   11.299999999999999            11              11
//        11.4   11.399999999999999            11              11
//        11.5   11.499999999999998            11              11
//        11.6   11.599999999999998            12              12
//
//        11.5                 11.5            12              12

Public Sub Example()
    Dim value As Double = 11.1

    Console.WriteLine("{0,5} {1,20:R}  {2,12} {3,15}",
                    "Value", "Full Precision", "ToEven",
                    "AwayFromZero")
    Console.WriteLine()
    For ctr As Integer = 0 To 5
        value = RoundValueAndAdd(value)
    Next
    Console.WriteLine()

    value = 11.5
    RoundValueAndAdd(value)
End Sub

Private Function RoundValueAndAdd(value As Double) As Double
    Console.WriteLine("{0,5:N1} {0,20:R}  {1,12} {2,15}",
                    value, Math.Round(value, MidpointRounding.ToEven),
                    Math.Round(value, MidpointRounding.AwayFromZero))
    Return value + 0.1
End Function

' The example displays the following output:
'       Value       Full Precision        ToEven    AwayFromZero
'       
'        11.1                 11.1            11              11
'        11.2                 11.2            11              11
'        11.3   11.299999999999999            11              11
'        11.4   11.399999999999999            11              11
'        11.5   11.499999999999998            11              11
'        11.6   11.599999999999998            12              12
'       
'        11.5                 11.5            12              12

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

• Pokud desetinnou hodnotu nelze vyjádřit přesně v binárním formátu typu s plovoucí desetinnou čárkou.
• Při zaokrouhlení hodnoty se vypočítá z jedné nebo více operací s plovoucí desetinnou čárkou.
• Pokud je hodnota, která má být zaokrouhlená, Single spíše než Double a nebo Decimal. Další informace najdete v další části, zaokrouhlování a hodnoty s plovoucí desetinnou čárkou s jednoduchou přesností.

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

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

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

  open System
  
  let roundApproximate dbl digits margin mode =
      let fraction = dbl * Math.Pow(10, digits)
      let value = Math.Truncate fraction
      let fraction = fraction - value
      if fraction = 0 then
          dbl
      else
          let tolerance = margin * dbl
          // Determine whether this is a midpoint value.
          if (fraction >= 0.5 - tolerance) && (fraction <= 0.5 + tolerance) then
              if mode = MidpointRounding.AwayFromZero then
                  (value + 1.) / Math.Pow(10, digits)
              elif value % 2. <> 0 then
                  (value + 1.) / Math.Pow(10, digits)
              else
                  value / Math.Pow(10, digits)
          // Any remaining fractional value greater than .5 is not a midpoint value.
          elif fraction > 0.5 then
              (value + 1.) / Math.Pow(10, digits)
          else
              value / Math.Pow(10, digits)
  
  
  let roundValueAndAdd value =
      let tolerance = 8e-14
      let round = roundApproximate value 0 tolerance
  
      printfn $"{value,5:N1} {value,20:R}  {round MidpointRounding.ToEven,12} {round MidpointRounding.AwayFromZero,15}"
      value + 0.1
  
  printfn "%5s %20s  %12s %15s\n" "Value" "Full Precision" "ToEven" "AwayFromZero"
  let mutable value = 11.1
  for _ = 0 to 5 do
      value <- roundValueAndAdd value
  
  printfn ""
  
  value <- 11.5
  roundValueAndAdd value 
  |> ignore
  
  // The example displays the following output:
  //       Value       Full Precision        ToEven    AwayFromZero
  //
  //        11.1                 11.1            11              11
  //        11.2                 11.2            11              11
  //        11.3   11.299999999999999            11              11
  //        11.4   11.399999999999999            11              11
  //        11.5   11.499999999999998            12              12
  //        11.6   11.599999999999998            12              12
  //
  //        11.5                 11.5            12              12
  

  Public Sub Example()
      Dim value As Double = 11.1
  
      Console.WriteLine("{0,5} {1,20:R}  {2,12} {3,15}\n",
                      "Value", "Full Precision", "ToEven",
                      "AwayFromZero")
      For ctr As Integer = 0 To 5
          value = RoundValueAndAdd(value)
      Next
      Console.WriteLine()
  
      value = 11.5
      RoundValueAndAdd(value)
  End Sub
  
  Private Function RoundValueAndAdd(value As Double) As Double
      Const tolerance As Double = 0.00000000000008
      Console.WriteLine("{0,5:N1} {0,20:R}  {1,12} {2,15}",
                      value,
                      RoundApproximate(value, 0, tolerance, MidpointRounding.ToEven),
                      RoundApproximate(value, 0, tolerance, MidpointRounding.AwayFromZero))
      Return value + 0.1
  End Function
  
  Private Function RoundApproximate(dbl As Double, digits As Integer, margin As Double,
                                   mode As MidpointRounding) As Double
      Dim fraction As Double = dbl * Math.Pow(10, digits)
      Dim value As Double = Math.Truncate(fraction)
      fraction = fraction - value
      If fraction = 0 Then Return dbl
  
      Dim tolerance As Double = margin * dbl
      ' Determine whether this is a midpoint value.
      If (fraction >= 0.5 - tolerance) And (fraction <= 0.5 + tolerance) Then
          If mode = MidpointRounding.AwayFromZero Then
              Return (value + 1) / Math.Pow(10, digits)
          Else
              If value Mod 2 <> 0 Then
                  Return (value + 1) / Math.Pow(10, digits)
              Else
                  Return value / Math.Pow(10, digits)
              End If
          End If
      End If
      ' Any remaining fractional value greater than .5 is not a midpoint value.
      If fraction > 0.5 Then
          Return (value + 1) / Math.Pow(10, digits)
      Else
          Return value / Math.Pow(10, digits)
      End If
  End Function
  
  ' The example displays the following output:
  '       Value       Full Precision        ToEven    AwayFromZero
  '       
  '        11.1                 11.1            11              11
  '        11.2                 11.2            11              11
  '        11.3   11.299999999999999            11              11
  '        11.4   11.399999999999999            11              11
  '        11.5   11.499999999999998            12              12
  '        11.6   11.599999999999998            12              12
  '       
  '        11.5                 11.5            12              12
  

Zaokrouhlování a hodnoty s plovoucí desetinnou čárkou s jednoduchou přesností

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

Single value = 16.325f;
Console.WriteLine("Widening Conversion of {0:R} (type {1}) to {2:R} (type {3}): ",
                  value, value.GetType().Name, (double)value,
                  ((double)(value)).GetType().Name);
Console.WriteLine(Math.Round(value, 2));
Console.WriteLine(Math.Round(value, 2, MidpointRounding.AwayFromZero));
Console.WriteLine();

Decimal decValue = (decimal)value;
Console.WriteLine("Cast of {0:R} (type {1}) to {2} (type {3}): ",
                  value, value.GetType().Name, decValue,
                  decValue.GetType().Name);
Console.WriteLine(Math.Round(decValue, 2));
Console.WriteLine(Math.Round(decValue, 2, MidpointRounding.AwayFromZero));

// The example displays the following output:
//    Widening Conversion of 16.325 (type Single) to 16.325000762939453 (type Double):
//    16.33
//    16.33
//
//    Cast of 16.325 (type Single) to 16.325 (type Decimal):
//    16.32
//    16.33

// In F#, 'float', 'float64', and 'double' are aliases for System.Double...
// 'float32' and 'single' are aliases for System.Single
open System

let value = 16.325f
printfn $"Widening Conversion of {value:R} (type {value.GetType().Name}) to {double value:R} (type {(double value).GetType().Name}): "
printfn $"{Math.Round(decimal value, 2)}"
printfn $"{Math.Round(decimal value, 2, MidpointRounding.AwayFromZero)}"
printfn ""

let decValue = decimal value
printfn $"Cast of {value:R} (type {value.GetType().Name}) to {decValue} (type {decValue.GetType().Name}): "
printfn $"{Math.Round(decValue, 2)}"
printfn $"{Math.Round(decValue, 2, MidpointRounding.AwayFromZero)}"

// The example displays the following output:
//    Widening Conversion of 16.325 (type Single) to 16.325000762939453 (type Double):
//    16.33
//    16.33
//
//    Cast of 16.325 (type Single) to 16.325 (type Decimal):
//    16.32
//    16.33

Dim value As Single = 16.325
Console.WriteLine("Widening Conversion of {0:R} (type {1}) to {2:R} (type {3}): ",
                value, value.GetType().Name, CDbl(value),
                CDbl(value).GetType().Name)
Console.WriteLine(Math.Round(value, 2))
Console.WriteLine(Math.Round(value, 2, MidpointRounding.AwayFromZero))
Console.WriteLine()

Dim decValue As Decimal = CDec(value)
Console.WriteLine("Cast of {0:R} (type {1}) to {2} (type {3}): ",
                value, value.GetType().Name, decValue,
                decValue.GetType().Name)
Console.WriteLine(Math.Round(decValue, 2))
Console.WriteLine(Math.Round(decValue, 2, MidpointRounding.AwayFromZero))
Console.WriteLine()

' The example displays the following output:
'    Widening Conversion of 16.325 (type Single) to 16.325000762939453 (type Double):
'    16.33
'    16.33
'    
'    Cast of 16.325 (type Single) to 16.325 (type Decimal):
'    16.32
'    16.33

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

V mnoha případech lze ztrátu přesnosti minimalizovat nebo odstranit přetypováním nebo převodem Single hodnoty na Decimalhodnotu . Všimněte si, že protož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)

Zdroj:

Math.cs

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

public:
 static double Round(double value, int digits, MidpointRounding mode);

public static double Round(double value, int digits, MidpointRounding mode);

static member Round : double * int * MidpointRounding -> double

Public Shared Function Round (value As Double, digits As Integer, mode As MidpointRounding) As Double

Parametry

value

Double

Číslo s plovoucí desetinnou čárkou s dvojitou přesností, které se má zaokrouhlit.

digits

Int32

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

mode

MidpointRounding

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

Návraty

Double

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

Výjimky

ArgumentOutOfRangeException

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

ArgumentException

mode není platná hodnota MidpointRounding.

Poznámky

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

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

Důležité

Při zaokrouhlování středních hodnot provádí algoritmus zaokrouhlování test rovnosti. Vzhledem k problémů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 Zaokrouhlování a přesnost.

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

Příklad

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

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

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

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

// The example displays the following output:

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

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

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

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

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

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

// The example displays the following output:

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

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

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

Dim posValue As Double = 3.45
Dim negValue As Double = -3.45

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

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

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

'This code example produces the following results:

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

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

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

Poznámky pro volající

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

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

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

open System

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

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

Viz také

• Ceiling(Double)
• Floor(Double)
• Round(Decimal, Int32, MidpointRounding)

Round(Decimal, Int32, MidpointRounding)

Zdroj:

Math.cs

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

public:
 static System::Decimal Round(System::Decimal d, int decimals, MidpointRounding mode);

public static decimal Round(decimal d, int decimals, MidpointRounding mode);

static member Round : decimal * int * MidpointRounding -> decimal

Public Shared Function Round (d As Decimal, decimals As Integer, mode As MidpointRounding) As Decimal

Parametry

d

Decimal

Desetinné číslo, které se má zaokrouhlit.

decimals

Int32

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

mode

MidpointRounding

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

Návraty

Decimal

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

Výjimky

ArgumentOutOfRangeException

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

ArgumentException

mode není platná hodnota MidpointRounding.

OverflowException

Výsledek je mimo rozsah .Decimal

Poznámky

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

Důležité

Při zaokrouhlování středních hodnot provádí algoritmus zaokrouhlování test rovnosti. Vzhledem k problémů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 Zaokrouhlování a přesnost.

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

Příklad

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

decimal result;

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

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

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

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

/*
This code example produces the following results:

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

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

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

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

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

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

// This code example produces the following results:

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

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

Dim result As Decimal = 0D
Dim posValue As Decimal = 3.45D
Dim negValue As Decimal = -3.45D

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

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

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

Viz také

• Ceiling(Double)
• Floor(Double)
• Round(Decimal, Int32, MidpointRounding)

Round(Double, MidpointRounding)

Zdroj:

Math.cs

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

public:
 static double Round(double value, MidpointRounding mode);

public static double Round(double value, MidpointRounding mode);

static member Round : double * MidpointRounding -> double

Public Shared Function Round (value As Double, mode As MidpointRounding) As Double

Parametry

value

Double

Číslo s plovoucí desetinnou čárkou s dvojitou přesností, které se má zaokrouhlit.

mode

MidpointRounding

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

Návraty

Double

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

Výjimky

ArgumentException

mode není platná hodnota MidpointRounding.

Poznámky

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

Důležité

Při zaokrouhlování středních hodnot provádí algoritmus zaokrouhlování test rovnosti. Vzhledem k problémů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 Zaokrouhlování a přesnost.

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

Příklad

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

Double[] values = { 12.0, 12.1, 12.2, 12.3, 12.4, 12.5, 12.6,
                  12.7, 12.8, 12.9, 13.0 };
Console.WriteLine($"{"Value",-10} {"Default",-10} {"ToEven",-10} {"AwayFromZero",-15} {"ToZero",-15}");

foreach (var value in values)
    Console.WriteLine($"{value,-10:R} {Math.Round(value),-10} " +
        $"{Math.Round(value, MidpointRounding.ToEven),-10} " +
        $"{Math.Round(value, MidpointRounding.AwayFromZero),-15} " +
        $"{Math.Round(value, MidpointRounding.ToZero),-15}");

// The example displays the following output:
//       Value      Default    ToEven     AwayFromZero    ToZero
//       12         12         12         12              12
//       12.1       12         12         12              12
//       12.2       12         12         12              12
//       12.3       12         12         12              12
//       12.4       12         12         12              12
//       12.5       12         12         13              12
//       12.6       13         13         13              12
//       12.7       13         13         13              12
//       12.8       13         13         13              12
//       12.9       13         13         13              12
//       13         13         13         13              13

open System

let values = 
    [| 12.; 12.1; 12.2; 12.3; 12.4; 12.5
       12.6; 12.7; 12.8; 12.9; 13. |]

printfn "%-10s %-10s %-10s %-15s %-15s" "Value" "Default" "ToEven" "AwayFromZero" "ToZero"

for value in values do
    $"{value,-10:R} {Math.Round(value),-10} " +
    $"{Math.Round(value, MidpointRounding.ToEven),-10} " +
    $"{Math.Round(value, MidpointRounding.AwayFromZero),-15} " +
    $"{Math.Round(value, MidpointRounding.ToZero),-15}"
    |> printfn "%s"
    
// The example displays the following output:
//       Value      Default    ToEven     AwayFromZero    ToZero
//       12         12         12         12              12
//       12.1       12         12         12              12
//       12.2       12         12         12              12
//       12.3       12         12         12              12
//       12.4       12         12         12              12
//       12.5       12         12         13              12
//       12.6       13         13         13              12
//       12.7       13         13         13              12
//       12.8       13         13         13              12
//       12.9       13         13         13              12
//       13         13         13         13              13

Dim values() As Double = {12.0, 12.1, 12.2, 12.3, 12.4, 12.5, 12.6,
                         12.7, 12.8, 12.9, 13.0}
Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15} {4,-15}", "Value", "Default",
                "ToEven", "AwayFromZero", "ToZero")
For Each value In values
    Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15} {4,-15}",
                   value, Math.Round(value),
                   Math.Round(value, MidpointRounding.ToEven),
                   Math.Round(value, MidpointRounding.AwayFromZero),
                   Math.Round(value, MidpointRounding.ToZero))
Next

' The example displays the following output:
'       Value      Default    ToEven     AwayFromZero     ToZero
'       12         12         12         12               12
'       12.1       12         12         12               12
'       12.2       12         12         12               12
'       12.3       12         12         12               12
'       12.4       12         12         12               12
'       12.5       12         12         13               12
'       12.6       13         13         13               12
'       12.7       13         13         13               12
'       12.8       13         13         13               12
'       12.9       13         13         13               12
'       13         13         13         13               13

Poznámky pro volající

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

open System

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

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

printfn ""

value <- 11.5
roundValueAndAdd value
|> ignore

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

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

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

Viz také

• Ceiling(Double)
• Floor(Double)
• Round(Decimal, MidpointRounding)

Round(Double, Int32)

Zdroj:

Math.cs

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

public:
 static double Round(double value, int digits);

public static double Round(double value, int digits);

static member Round : double * int -> double

Public Shared Function Round (value As Double, digits As Integer) As Double

Parametry

value

Double

Číslo s plovoucí desetinnou čárkou s dvojitou přesností, které se má zaokrouhlit.

digits

Int32

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

Návraty

Double

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

Výjimky

ArgumentOutOfRangeException

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

Poznámky

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

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

Důležité

Při zaokrouhlování středních hodnot provádí algoritmus zaokrouhlování test rovnosti. Vzhledem k problémů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 Zaokrouhlování a přesnost.

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

Příklad

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

Math.Round(3.44, 1); //Returns 3.4.
Math.Round(3.45, 1); //Returns 3.4.
Math.Round(3.46, 1); //Returns 3.5.

Math.Round(4.34, 1); // Returns 4.3
Math.Round(4.35, 1); // Returns 4.4
Math.Round(4.36, 1); // Returns 4.4

open System

printfn $"{Math.Round(3.44, 1)}" //Returns 3.4.
printfn $"{Math.Round(3.45, 1)}" //Returns 3.4.
printfn $"{Math.Round(3.46, 1)}" //Returns 3.5.

printfn $"{Math.Round(4.34, 1)}" // Returns 4.3
printfn $"{Math.Round(4.35, 1)}" // Returns 4.4
printfn $"{Math.Round(4.36, 1)}" // Returns 4.4

Math.Round(3.44, 1) 'Returns 3.4.
Math.Round(3.45, 1) 'Returns 3.4.
Math.Round(3.46, 1) 'Returns 3.5.

Math.Round(4.34, 1) ' Returns 4.3
Math.Round(4.35, 1) ' Returns 4.4
Math.Round(4.36, 1) ' Returns 4.4

Poznámky pro volající

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

using System;

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

open System

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

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

Viz také

• Ceiling(Double)
• Floor(Double)
• Round(Decimal, Int32)

Round(Decimal, Int32)

Zdroj:

Math.cs

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

public:
 static System::Decimal Round(System::Decimal d, int decimals);

public static decimal Round(decimal d, int decimals);

static member Round : decimal * int -> decimal

Public Shared Function Round (d As Decimal, decimals As Integer) As Decimal

Parametry

d

Decimal

Desetinné číslo, které se má zaokrouhlit.

decimals

Int32

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

Návraty

Decimal

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

Výjimky

ArgumentOutOfRangeException

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

OverflowException

Výsledek je mimo rozsah .Decimal

Poznámky

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

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

Důležité

Při zaokrouhlování středních hodnot provádí algoritmus zaokrouhlování test rovnosti. Vzhledem k problémů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 Zaokrouhlování a přesnost.

Příklad

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

Console.WriteLine(Math.Round(3.44m, 1));
Console.WriteLine(Math.Round(3.45m, 1));
Console.WriteLine(Math.Round(3.46m, 1));
Console.WriteLine();

Console.WriteLine(Math.Round(4.34m, 1));
Console.WriteLine(Math.Round(4.35m, 1));
Console.WriteLine(Math.Round(4.36m, 1));

// The example displays the following output:
//       3.4
//       3.4
//       3.5
//
//       4.3
//       4.4
//       4.4

open System

printfn 
    $"""{Math.Round(3.44m, 1)}
{Math.Round(3.45m, 1)}
{Math.Round(3.46m, 1)}

{Math.Round(4.34m, 1)}
{Math.Round(4.35m, 1)}
{Math.Round(4.36m, 1)}"""

// The example displays the following output:
//       3.4
//       3.4
//       3.5
//
//       4.3
//       4.4
//       4.4

Console.WriteLine(Math.Round(3.44, 1))
Console.WriteLine(Math.Round(3.45, 1))
Console.WriteLine(Math.Round(3.46, 1))
Console.WriteLine()

Console.WriteLine(Math.Round(4.34, 1))
Console.WriteLine(Math.Round(4.35, 1))
Console.WriteLine(Math.Round(4.36, 1))

' The example displays the following output:
'       3.4
'       3.4
'       3.5
'       
'       4.3
'       4.4
'       4.4

Viz také

• Ceiling(Double)
• Floor(Double)
• Round(Decimal, Int32)

Round(Double)

Zdroj:

Math.cs

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

public:
 static double Round(double a);

public static double Round(double a);

static member Round : double -> double

Public Shared Function Round (a As Double) As Double

Parametry

a

Double

Číslo s plovoucí desetinnou čárkou s dvojitou přesností, které se má zaokrouhlit.

Návraty

Double

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

Poznámky

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

Důležité

Při zaokrouhlování středních hodnot provádí algoritmus zaokrouhlování test rovnosti. Vzhledem k problémů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 Zaokrouhlování a přesnost.

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

Počínaje Visual Basic 15.8 je výkon převodu typu Double-to-integer optimalizovaný, pokud předáte hodnotu vrácenou metodou Round do některé z funkcí převodu integral conversion, nebo pokud je hodnota double vrácená Round automaticky převedena na celé číslo s Option Strict nastavenou na hodnotu Vypnuto. Tato optimalizace umožňuje, aby kód běžel rychleji – až dvakrát rychleji pro kód, který provede velký počet převodů na celočíselné typy. Následující příklad znázorňuje takové optimalizované převody:

Dim d1 As Double = 1043.75133
Dim i1 As Integer = CInt(Math.Ceiling(d1))        ' Result: 1044

Dim d2 As Double = 7968.4136
Dim i2 As Integer = CInt(Math.Ceiling(d2))        ' Result: 7968

Příklad

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

Console.WriteLine("Classic Math.Round in CSharp");
Console.WriteLine(Math.Round(4.4)); // 4
Console.WriteLine(Math.Round(4.5)); // 4
Console.WriteLine(Math.Round(4.6)); // 5
Console.WriteLine(Math.Round(5.5)); // 6

open System

printfn "Classic Math.Round in F#"
printfn $"{Math.Round(4.4)}" // 4
printfn $"{Math.Round(4.5)}" // 4
printfn $"{Math.Round(4.6)}" // 5
printfn $"{Math.Round(5.5)}" // 6

Module Module1

    Sub Main()
    Console.WriteLine("Classic Math.Round in Visual Basic")
    Console.WriteLine(Math.Round(4.4)) ' 4
    Console.WriteLine(Math.Round(4.5)) ' 4
    Console.WriteLine(Math.Round(4.6)) ' 5
    Console.WriteLine(Math.Round(5.5)) ' 6
    End Sub

End Module

Poznámky pro volající

Kvůli ztrátě přesnosti, která může mít za následek reprezentaci desetinných hodnot jako čísla s plovoucí desetinnou čárkou nebo provádění aritmetických operací s hodnotami s plovoucí desetinnou čárkou, se v některých případech Round(Double) nemusí metoda zdát zaokrouhlit střední hodnoty na nejbližší sudé celé číslo. V následujícím příkladu, protože hodnota s plovoucí desetinou čárkou ,1 nemá žádné konečné binární vyjádření, první volání Round(Double) metody s hodnotou 11,5 vrátí místo 12 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

open System

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

let mutable value = 11.1

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

printfn ""

value <- 11.5
roundValueAndAdd value
|> ignore

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

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

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

Viz také

• Ceiling(Double)
• Floor(Double)
• Round(Decimal)

Round(Decimal)

Zdroj:

Math.cs

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

public:
 static System::Decimal Round(System::Decimal d);

public static decimal Round(decimal d);

static member Round : decimal -> decimal

Public Shared Function Round (d As Decimal) As Decimal

Parametry

d

Decimal

Desetinné číslo, které se má zaokrouhlit.

Návraty

Decimal

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

Výjimky

OverflowException

Výsledek je mimo rozsah .Decimal

Příklady

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

for (decimal value = 4.2m; value <= 4.8m; value+=.1m )
   Console.WriteLine("{0} --> {1}", value, Math.Round(value));
// The example displays the following output:
//       4.2 --> 4
//       4.3 --> 4
//       4.4 --> 4
//       4.5 --> 4
//       4.6 --> 5
//       4.7 --> 5
//       4.8 --> 5

open System

for value in 4.2m .. 0.1m .. 4.8m do
    printfn $"{value} --> {Math.Round value}"
// The example displays the following output:
//       4.2 --> 4
//       4.3 --> 4
//       4.4 --> 4
//       4.5 --> 4
//       4.6 --> 5
//       4.7 --> 5
//       4.8 --> 5

Module Example
   Public Sub Main()
      For value As Decimal = 4.2d To 4.8d Step .1d
         Console.WriteLine("{0} --> {1}", value, Math.Round(value))
      Next   
   End Sub                                                                 
End Module
' The example displays the following output:
'       4.2 --> 4
'       4.3 --> 4
'       4.4 --> 4
'       4.5 --> 4
'       4.6 --> 5
'       4.7 --> 5
'       4.8 --> 5

Poznámky

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

Důležité

Při zaokrouhlování středních hodnot provádí algoritmus zaokrouhlování test rovnosti. Vzhledem k problémů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 Zaokrouhlování a přesnost.

Viz také

• Ceiling(Double)
• Floor(Double)
• Round(Decimal)

Round(Decimal, MidpointRounding)

Zdroj:

Math.cs

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

public:
 static System::Decimal Round(System::Decimal d, MidpointRounding mode);

public static decimal Round(decimal d, MidpointRounding mode);

static member Round : decimal * MidpointRounding -> decimal

Public Shared Function Round (d As Decimal, mode As MidpointRounding) As Decimal

Parametry

d

Decimal

Desetinné číslo, které se má zaokrouhlit.

mode

MidpointRounding

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

Návraty

Decimal

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

Výjimky

ArgumentException

mode není platná hodnota MidpointRounding.

OverflowException

Výsledek je mimo rozsah .Decimal

Poznámky

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

Důležité

Při zaokrouhlování středních hodnot provádí algoritmus zaokrouhlování test rovnosti. Vzhledem k problémů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 Zaokrouhlování a přesnost.

Příklad

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

Console.WriteLine($"{"Value",-10} {"Default",-10} {"ToEven",-10} {"AwayFromZero",-15} {"ToZero",-15}");
for (decimal value = 12.0m; value <= 13.0m; value += 0.1m)
    Console.WriteLine($"{value,-10} {Math.Round(value),-10} " +
        $"{Math.Round(value, MidpointRounding.ToEven),-10} " +
        $"{Math.Round(value, MidpointRounding.AwayFromZero),-15} " +
        $"{Math.Round(value, MidpointRounding.ToZero),-15}");

// The example displays the following output:
//       Value      Default    ToEven     AwayFromZero    ToZero
//       12.0       12         12         12              12
//       12.1       12         12         12              12
//       12.2       12         12         12              12
//       12.3       12         12         12              12
//       12.4       12         12         12              12
//       12.5       12         12         13              12
//       12.6       13         13         13              12
//       12.7       13         13         13              12
//       12.8       13         13         13              12
//       12.9       13         13         13              12
//       13.0       13         13         13              13

printfn $"""{"Value",-10} {"Default",-10} {"ToEven",-10} {"AwayFromZero",-15} {"ToZero",-15}"""
for value in 12m .. 0.1m .. 13m do
    printfn "%-10O %-10O %-10O %-15O %-15O" 
        value
        (Math.Round value)
        (Math.Round(value, MidpointRounding.ToEven))
        (Math.Round(value, MidpointRounding.AwayFromZero))
        (Math.Round(value, MidpointRounding.ToZero))

// The example displays the following output:
//       Value      Default    ToEven     AwayFromZero    ToZero
//       12.0       12         12         12              12
//       12.1       12         12         12              12
//       12.2       12         12         12              12
//       12.3       12         12         12              12
//       12.4       12         12         12              12
//       12.5       12         12         13              12
//       12.6       13         13         13              12
//       12.7       13         13         13              12
//       12.8       13         13         13              12
//       12.9       13         13         13              12
//       13.0       13         13         13              13

Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15} {4,-15}", "Value", "Default",
                "ToEven", "AwayFromZero", "ToZero")
For value As Decimal = 12D To 13D Step 0.1D
    Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15} {4,-15}",
                   value, Math.Round(value),
                   Math.Round(value, MidpointRounding.ToEven),
                   Math.Round(value, MidpointRounding.AwayFromZero),
                   Math.Round(value, MidpointRounding.ToZero))
Next

' The example displays the following output:
'       Value      Default    ToEven     AwayFromZero     ToZero
'       12         12         12         12               12
'       12.1       12         12         12               12
'       12.2       12         12         12               12
'       12.3       12         12         12               12
'       12.4       12         12         12               12
'       12.5       12         12         13               12
'       12.6       13         13         13               12
'       12.7       13         13         13               12
'       12.8       13         13         13               12
'       12.9       13         13         13               12
'       13.0       13         13         13               13

Viz také

• Ceiling(Double)
• Floor(Double)
• Round(Decimal, MidpointRounding)