Math.Round Metoda

Definicja

Przestrzeń nazw:

System

Zestawy:

netstandard.dll, System.Runtime.dll

Zaokrągla wartość do najbliższej liczby całkowitej lub do określonej liczby cyfr ułamkowych.

Przeciążenia

Nazwa	Opis
Round(Double, Int32, MidpointRounding)	Zaokrągla wartość zmiennoprzecinkową o podwójnej precyzji do określonej liczby cyfr ułamkowych przy użyciu określonej konwencji zaokrąglania.
Round(Decimal, Int32, MidpointRounding)	Zaokrągla wartość dziesiętną do określonej liczby cyfr ułamkowych przy użyciu określonej konwencji zaokrąglania.
Round(Double, MidpointRounding)	Zaokrągla wartość zmiennoprzecinkowa o podwójnej precyzji do liczby całkowitej przy użyciu określonej konwencji zaokrąglania.
Round(Double, Int32)	Zaokrągla wartość zmiennoprzecinkową o podwójnej precyzji do określonej liczby cyfr ułamkowych i zaokrągla wartości punktu środkowego do najbliższej liczby parzystej.
Round(Decimal, Int32)	Zaokrągla wartość dziesiętną do określonej liczby cyfr ułamkowych i zaokrągla wartości punktu środkowego do najbliższej liczby parzystej.
Round(Double)	Zaokrągla wartość zmiennoprzecinkową o podwójnej precyzji do najbliższej wartości całkowitej i zaokrągla wartości punktu środkowego do najbliższej liczby parzyskowej.
Round(Decimal)	Zaokrągla wartość dziesiętną do najbliższej wartości całkowitej i zaokrągla wartości punktu środkowego do najbliższej liczby parzystej.
Round(Decimal, MidpointRounding)	Zaokrągla wartość dziesiętną liczbę całkowitą przy użyciu określonej konwencji zaokrąglania.

Przykłady

Oprócz przykładów w sekcji Uwagi istnieją przykłady w każdym przeciążeniu Math.Round metody .

Uwagi

W tej sekcji:

• Która metoda jest wywoływana?
• Wartości punktu środkowego i konwencje zaokrąglania
• Zaokrąglanie i precyzja
• Zaokrąglanie i wartości zmiennoprzecinkowe o pojedynczej precyzji

Którą metodę mam wywołać?

Poniższa tabela umożliwia wybranie odpowiedniej metody zaokrąglania. Oprócz Math.Round metod obejmuje Math.Ceiling również metody i Math.Floor.

Do	Call
Zaokrąglaj liczbę do liczby całkowitej przy użyciu zaokrąglania do najbliższej konwencji.	Round(Decimal) — lub — Round(Double)
Zaokrąglaj liczbę do liczby całkowitej przy użyciu określonej konwencji zaokrąglania.	Round(Decimal, MidpointRounding) — lub — Round(Double, MidpointRounding)
Zaokrąglij liczbę do określonej liczby cyfr ułamkowych przy użyciu zaokrąglania do najbliższej konwencji.	Round(Decimal, Int32) — lub — Round(Double, Int32)
Zaokrąglaj liczbę do określonej liczby cyfr ułamkowych przy użyciu określonej konwencji zaokrąglania.	Round(Decimal, Int32, MidpointRounding) — lub — Round(Double, Int32, MidpointRounding)
Zaokrąglaj Single wartość do określonej liczby cyfr ułamkowych przy użyciu określonej konwencji zaokrąglania i minimalizując utratę dokładności.	Przekonwertuj element Single na element i wywołaj metodę DecimalRound(Decimal, Int32, MidpointRounding).
Zaokrąglaj liczbę do określonej liczby cyfr ułamkowych, jednocześnie minimalizując problemy z precyzją w zaokrągleniu wartości punktu środkowego.	Wywołaj metodę zaokrąglania, która implementuje porównanie "większe niż lub w przybliżeniu równe". Zobacz Zaokrąglanie i precyzja.
Zaokrąglij wartość ułamkową do liczby całkowitej większej niż wartość ułamkowa. Na przykład zaokrąglij wartość 3,1 do 4.	Ceiling
Zaokrąglij wartość ułamkową do liczby całkowitej, która jest mniejsza niż wartość ułamkowa. Na przykład zaokrąglij wartość 3,9 do 3.	Floor

Wartości punktu środkowego i konwencje zaokrąglania

Zaokrąglanie obejmuje konwertowanie wartości liczbowej z określoną precyzją na wartość o mniejszej precyzji. Na przykład można użyć Round(Double) metody , aby zaokrąglić wartość od 3,4 do 3,0, a Round(Double, Int32) metoda zaokrąglić wartość 3,579 do 3,58.

W wartości punktu środkowego wartość po najmniej znaczącej cyfrze w wyniku jest dokładnie w połowie drogi między dwiema liczbami. Na przykład wartość 3,47500 jest wartością punktu środkowego, jeśli ma być zaokrąglona do dwóch miejsc dziesiętnych, a 7,500 jest wartością punktu środkowego, jeśli ma zostać zaokrąglona do liczby całkowitej. W takich przypadkach, jeśli jest używana strategia zaokrąglona do najbliższej, najbliższej wartości nie można łatwo zidentyfikować bez konwencji zaokrąglania.

Metoda Round obsługuje dwie konwencje zaokrąglania do obsługi wartości punktu środkowego:

• Zaokrąglanie od zera

  Wartości punktu środkowego są zaokrąglane do następnej liczby z dala od zera. Na przykład 3,75 rund do 3,8, 3,85 rund do 3,9, -3,75 rund do -3,8 i -3,85 rund do -3,9. Ta forma zaokrąglania jest reprezentowana przez element MidpointRounding.AwayFromZero członkowski wyliczenia.

• Zaokrąglanie do najbliższej równej lub zaokrąglania bankiera

  Wartości punktu środkowego są zaokrąglane do najbliższej liczby parzysnej. Na przykład zarówno 3,75, jak i 3,85 runda do 3,8, a zarówno -3,75, jak i -3,85 round do -3,8. Ta forma zaokrąglania jest reprezentowana przez element MidpointRounding.ToEven członkowski wyliczenia.

Uwaga / Notatka

W wersjach .NET Core 3.0 i nowszych trzy dodatkowe strategie zaokrąglania są dostępne za pośrednictwem wyliczenia MidpointRounding. Te strategie są używane we wszystkich przypadkach, a nie tylko dla wartości punktu środkowego, jak MidpointRounding.ToEven i MidpointRounding.AwayFromZero są.

Zaokrąglanie od zera jest najbardziej znaną formą zaokrąglania, podczas gdy zaokrąglanie do najbliższego jest standardem w operacjach finansowych i statystycznych. Jest on zgodny ze standardem IEEE 754, sekcja 4. W przypadku użycia w wielu operacjach zaokrąglania zaokrąglanie do najbliższego zmniejsza nawet błąd zaokrąglania, który jest spowodowany spójnym zaokrąglanie wartości punktu środkowego w jednym kierunku. W niektórych przypadkach ten błąd zaokrąglania może być znaczący.

Poniższy przykład ilustruje stronniczy, który może wynikać z spójnej zaokrąglania wartości punktu środkowego w jednym kierunku. W przykładzie obliczana jest prawdziwa średnia tablicy Decimal wartości, a następnie oblicza średnią, gdy wartości w tablicy są zaokrąglane przy użyciu dwóch konwencji. W tym przykładzie średnia true i średnia, że wyniki zaokrąglania do najbliższej są takie same. Jednak średnia, że wyniki zaokrąglania od zera różnią się od .05 (lub o 3,6%) od rzeczywistej średniej.

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

Domyślnie Round metoda używa zaokrąglonej do najbliższej konwencji parzysowej. W poniższej tabeli wymieniono przeciążenia Round metody i konwencję zaokrąglania używaną przez poszczególne metody.

Overload	Konwencja zaokrąglania
Round(Decimal)	ToEven
Round(Double)	ToEven
Round(Decimal, Int32)	ToEven
Round(Double, Int32)	ToEven
Round(Decimal, MidpointRounding)	Określony przez mode parametr.
Round(Double, MidpointRounding)	Określony przez mode parametr
Round(Decimal, Int32, MidpointRounding)	Określony przez mode parametr
Round(Double, Int32, MidpointRounding)	Określony przez mode parametr

Zaokrąglanie i precyzja

Aby określić, czy operacja zaokrąglania obejmuje wartość punktu środkowego, Round metoda mnoży oryginalną wartość do zaokrąglenia o 10ⁿ, gdzie n jest żądaną liczbą cyfr ułamkowych w wartości zwracanej, a następnie określa, czy pozostała część ułamkowa wartości jest większa lub równa .5. Jest to niewielka odmiana testu równości, a jak opisano w sekcji Double "Testowanie równości" w temacie referencyjnym, testy równości z wartościami zmiennoprzecinkowymi są problematyczne ze względu na problemy z reprezentacją binarną i precyzją formatu zmiennoprzecinkowego. Oznacza to, że każda część ułamkowa liczby, która jest nieco mniejsza niż .5 (ze względu na utratę precyzji) nie będzie zaokrąglona w górę.

Poniższy przykład ilustruje problem. Wielokrotnie dodaje wartość .1 do 11.0 i zaokrągla wynik do najbliższej liczby całkowitej. 11,5 powinno zaokrąglić do 12 przy użyciu jednej z konwencji zaokrąglania punktu środkowego (ToEven lub AwayFromZero). Jednak jak pokazuje dane wyjściowe z przykładu, nie. W przykładzie użyto standardowego ciągu formatu liczbowego "R", aby wyświetlić pełną precyzję wartości zmiennoprzecinkowej i pokazano, że wartość, która ma być zaokrąglona, straciła precyzję podczas powtarzających się dodatków, a jej wartość to 11,499999999999998. Ponieważ wartość .499999999999998 jest mniejsza niż .5, konwencje zaokrąglania punktu środkowego nie wchodzą w grę i wartość jest zaokrąglona w dół. Jak pokazano w przykładzie, ten problem nie występuje w przypadku przypisania stałej wartości 11.5 do zmiennej 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

Problemy z precyzją zaokrąglania wartości punktu środkowego najprawdopodobniej wystąpią w następujących warunkach:

• Gdy wartość ułamkowa nie może być wyrażona dokładnie w formacie binarnym typu zmiennoprzecinkowego.
• Gdy wartość, która ma zostać zaokrąglona, jest obliczana na podstawie co najmniej jednej operacji zmiennoprzecinkowej.
• Gdy wartość, która ma zostać zaokrąglona, jest Single zamiast wartością Double lub Decimal. Aby uzyskać więcej informacji, zobacz następną sekcję, zaokrąglanie i wartości zmiennoprzecinkowe o pojedynczej precyzji.

W przypadkach, gdy brak dokładności operacji zaokrąglania jest problematyczny, można wykonać następujące czynności:

• Jeśli operacja zaokrąglania wywołuje przeciążenie, które zaokrągla Double wartość, możesz zmienić Double wartość na Decimal wartość i wywołać przeciążenie, które zaokrągla Decimal wartość. Decimal Chociaż typ danych ma również problemy z reprezentacją i utratą precyzji, te problemy są znacznie mniej powszechne.

• Zdefiniuj niestandardowy algorytm zaokrąglania, który wykonuje test "prawie równy", aby określić, czy wartość do zaokrąglenia jest akceptowanie zbliżona do wartości punktu środkowego. W poniższym przykładzie zdefiniowano metodę RoundApproximate , która sprawdza, czy wartość ułamkowa jest wystarczająco zbliżona do wartości punktu środkowego, aby podlegać zaokrągleniu punktu środkowego. Jak pokazuje dane wyjściowe z przykładu, poprawia problem zaokrąglania pokazany w poprzednim przykładzie.

  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
  

Zaokrąglanie i wartości zmiennoprzecinkowe o pojedynczej precyzji

Metoda Round zawiera przeciążenia, które akceptują argumenty typu Decimal i Double. Nie ma metod zaokrąglenia wartości typu Single. Jeśli przekazujesz wartość Single do jednego z przeciążeń metody Round, jest rzutowana (w języku C#) lub konwertowana (w Visual Basic) na Double, a odpowiednie przeciążenie Round z Double parametr jest wywoływany. Chociaż jest to konwersja rozszerzająca, często wiąże się z utratą precyzji, jak pokazano w poniższym przykładzie. Single Gdy wartość 16,325 jest przekazywana do metody i zaokrąglona do Round dwóch miejsc dziesiętnych przy użyciu zaokrąglania do najbliższej konwencji, wynik wynosi 16,33, a nie oczekiwany wynik 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

Ten nieoczekiwany wynik jest spowodowany utratą dokładności w konwersji Single wartości na Doublewartość . Ponieważ wynikowa Double wartość 16,325000762939453 nie jest wartością punktu środkowego i jest większa niż 16,325, jest zawsze zaokrąglona w górę.

W wielu przypadkach, jak pokazano w przykładzie, utrata dokładności można zminimalizować lub wyeliminować przez rzutowanie lub konwertowanie Single wartości na Decimalwartość . Należy pamiętać, że ponieważ jest to konwersja zawężająca, wymaga użycia operatora rzutowania lub wywołania metody konwersji.

Round(Double, Int32, MidpointRounding)

Źródło:

Math.cs

Zaokrągla wartość zmiennoprzecinkową o podwójnej precyzji do określonej liczby cyfr ułamkowych przy użyciu określonej konwencji zaokrąglania.

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

Liczba zmiennoprzecinkowa o podwójnej precyzji do zaokrąglenia.

digits

Int32

Liczba cyfr ułamkowych w wartości zwracanej.

mode

MidpointRounding

Jedna z wartości wyliczenia określająca, która strategia zaokrąglania ma być używana.

Zwraca

Double

Liczba zawierająca digits cyfry ułamkowe zaokrąglone value do. Jeśli value liczba cyfr ułamkowych jest mniejsza niż digits, value zwracana jest bez zmian.

Wyjątki

ArgumentOutOfRangeException

digits wartość jest mniejsza niż 0 lub większa niż 15.

ArgumentException

mode nie jest prawidłową wartością MidpointRounding.

Uwagi

Wartość argumentu digits może wahać się od 0 do 15. Maksymalna liczba cyfr całkowitych i ułamkowych obsługiwanych przez Double typ wynosi 15.

Zobacz Wartości punktu środkowego i konwencje zaokrąglania , aby uzyskać informacje na temat zaokrąglania liczb z wartościami punktu środkowego.

Ważna

Podczas zaokrąglania wartości punktu środkowego algorytm zaokrąglania wykonuje test równości. Ze względu na problemy z reprezentacją binarną i precyzją w formacie zmiennoprzecinkowym wartość zwracana przez metodę może być nieoczekiwana. Aby uzyskać więcej informacji, zobacz Zaokrąglanie i precyzja.

Jeśli wartość argumentu value to Double.NaN, metoda zwraca Double.NaNwartość . Jeśli value wartość to Double.PositiveInfinity lub Double.NegativeInfinity, metoda zwraca Double.PositiveInfinity wartość lub Double.NegativeInfinity, odpowiednio.

Przykład

W poniższym przykładzie pokazano, jak używać Round(Double, Int32, MidpointRounding) metody z wyliczeniem 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)

Notatki dotyczące wywoływania

Ze względu na utratę dokładności, która może wynikać z reprezentowania wartości dziesiętnych jako liczb zmiennoprzecinkowych lub wykonywania operacji arytmetycznych na wartości zmiennoprzecinkowych, w niektórych przypadkach Round(Double, Int32, MidpointRounding) metoda może nie wydawać się zaokrąglać wartości punktu środkowego zgodnie z parametrem mode . Przedstawiono to w poniższym przykładzie, gdzie 2,135 jest zaokrąglany do 2,13 zamiast 2,14. Dzieje się tak, ponieważ metoda wewnętrznie mnoży value przez 10^cyfr, a operacja mnożenia w tym przypadku cierpi na utratę precyzji.

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

Zobacz też

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

Round(Decimal, Int32, MidpointRounding)

Źródło:

Math.cs

Zaokrągla wartość dziesiętną do określonej liczby cyfr ułamkowych przy użyciu określonej konwencji zaokrąglania.

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

Liczba dziesiętna, która ma być zaokrąglona.

decimals

Int32

Liczba miejsc dziesiętnych w wartości zwracanej.

mode

MidpointRounding

Jedna z wartości wyliczenia określająca, która strategia zaokrąglania ma być używana.

Zwraca

Decimal

Liczba zawierająca decimals cyfry ułamkowe zaokrąglone d do. Jeśli d liczba cyfr ułamkowych jest mniejsza niż decimals, d zwracana jest bez zmian.

Wyjątki

ArgumentOutOfRangeException

decimals wartość jest mniejsza niż 0 lub większa niż 28.

ArgumentException

mode nie jest prawidłową wartością MidpointRounding.

OverflowException

Wynik znajduje się poza zakresem .Decimal

Uwagi

Zobacz Wartości punktu środkowego i konwencje zaokrąglania , aby uzyskać informacje na temat zaokrąglania liczb z wartościami punktu środkowego.

Ważna

Podczas zaokrąglania wartości punktu środkowego algorytm zaokrąglania wykonuje test równości. Ze względu na problemy z reprezentacją binarną i precyzją w formacie zmiennoprzecinkowym wartość zwracana przez metodę może być nieoczekiwana. Aby uzyskać więcej informacji, zobacz Zaokrąglanie i precyzja.

Wartość argumentu decimals może wahać się od 0 do 28.

Przykład

W poniższym przykładzie pokazano, jak używać Round metody z wyliczeniem 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)
'

Zobacz też

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

Round(Double, MidpointRounding)

Źródło:

Math.cs

Zaokrągla wartość zmiennoprzecinkowa o podwójnej precyzji do liczby całkowitej przy użyciu określonej konwencji zaokrąglania.

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

Liczba zmiennoprzecinkowa o podwójnej precyzji do zaokrąglenia.

mode

MidpointRounding

Jedna z wartości wyliczenia określająca, która strategia zaokrąglania ma być używana.

Zwraca

Double

Liczba całkowita zaokrąglona value do. Ta metoda zwraca wartość Double zamiast typu całkowitego.

Wyjątki

ArgumentException

mode nie jest prawidłową wartością MidpointRounding.

Uwagi

Zobacz Wartości punktu środkowego i konwencje zaokrąglania , aby uzyskać informacje na temat zaokrąglania liczb z wartościami punktu środkowego.

Ważna

Podczas zaokrąglania wartości punktu środkowego algorytm zaokrąglania wykonuje test równości. Ze względu na problemy z reprezentacją binarną i precyzją w formacie zmiennoprzecinkowym wartość zwracana przez metodę może być nieoczekiwana. Aby uzyskać więcej informacji, zobacz Zaokrąglanie i precyzja.

Jeśli wartość argumentu value to Double.NaN, metoda zwraca Double.NaNwartość . Jeśli value wartość to Double.PositiveInfinity lub Double.NegativeInfinity, metoda zwraca Double.PositiveInfinity wartość lub Double.NegativeInfinity, odpowiednio.

Przykład

Poniższy przykład przedstawia wartości zwracane przez metodę Round(Double, MidpointRounding) z różnymi mode wartościami.

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

Notatki dotyczące wywoływania

Ze względu na utratę dokładności, która może wynikać z reprezentowania wartości dziesiętnych jako liczb zmiennoprzecinkowych lub wykonywania operacji arytmetycznych na wartości zmiennoprzecinkowych, w niektórych przypadkach Round(Double, MidpointRounding) metoda może nie wydawać się zaokrąglać wartości punktu środkowego do najbliższej parzystej liczby całkowitej. W poniższym przykładzie, ponieważ wartość zmiennoprzecinkowa .1 nie ma skończonej reprezentacji binarnej, pierwsze wywołanie Round(Double) metody o wartości 11,5 zwraca wartość 11 zamiast 12.

using System;

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

      Console.WriteLine();

      value = 11.5;
      RoundValueAndAdd(value);
   }

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

open System

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

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

printfn ""

value <- 11.5
roundValueAndAdd value
|> ignore

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

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

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

Zobacz też

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

Round(Double, Int32)

Źródło:

Math.cs

Zaokrągla wartość zmiennoprzecinkową o podwójnej precyzji do określonej liczby cyfr ułamkowych i zaokrągla wartości punktu środkowego do najbliższej liczby parzystej.

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

Liczba zmiennoprzecinkowa o podwójnej precyzji do zaokrąglenia.

digits

Int32

Liczba cyfr ułamkowych w wartości zwracanej.

Zwraca

Double

Najbliższa liczba value zawierająca liczbę cyfr ułamkowych równą digits.

Wyjątki

ArgumentOutOfRangeException

digits wartość jest mniejsza niż 0 lub większa niż 15.

Uwagi

Wartość argumentu digits może wahać się od 0 do 15. Maksymalna liczba cyfr całkowitych i ułamkowych obsługiwanych przez Double typ wynosi 15.

Ta metoda używa domyślnej konwencji zaokrąglania klasy MidpointRounding.ToEven. Zobacz Wartości punktu środkowego i konwencje zaokrąglania , aby uzyskać informacje na temat zaokrąglania liczb z wartościami punktu środkowego.

Ważna

Podczas zaokrąglania wartości punktu środkowego algorytm zaokrąglania wykonuje test równości. Ze względu na problemy z reprezentacją binarną i precyzją w formacie zmiennoprzecinkowym wartość zwracana przez metodę może być nieoczekiwana. Aby uzyskać więcej informacji, zobacz Zaokrąglanie i precyzja.

Jeśli wartość argumentu value to Double.NaN, metoda zwraca Double.NaNwartość . Jeśli value wartość to Double.PositiveInfinity lub Double.NegativeInfinity, metoda zwraca Double.PositiveInfinity wartość lub Double.NegativeInfinity, odpowiednio.

Przykład

Poniższy przykład zaokrągla podwójne wartości z dwiema cyframi ułamkowymi do podwojenia, które mają pojedynczą cyfrę ułamkową.

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

Notatki dotyczące wywoływania

Ze względu na utratę dokładności, która może wynikać z reprezentowania wartości dziesiętnych jako liczb zmiennoprzecinkowych lub wykonywania operacji arytmetycznych na wartości zmiennoprzecinkowych, w niektórych przypadkach Round(Double, Int32) metoda może nie wydawać się zaokrąglać wartości punktu środkowego do najbliższej parzystej wartości w digits pozycji dziesiętnej. Przedstawiono to w poniższym przykładzie, gdzie 2,135 jest zaokrąglany do 2,13 zamiast 2,14. Dzieje się tak, ponieważ metoda wewnętrznie mnoży value przez 10^cyfr, a operacja mnożenia w tym przypadku cierpi na utratę precyzji.

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

Zobacz też

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

Round(Decimal, Int32)

Źródło:

Math.cs

Zaokrągla wartość dziesiętną do określonej liczby cyfr ułamkowych i zaokrągla wartości punktu środkowego do najbliższej liczby parzystej.

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

Liczba dziesiętna, która ma być zaokrąglona.

decimals

Int32

Liczba miejsc dziesiętnych w wartości zwracanej.

Zwraca

Decimal

Najbliższa liczba d zawierająca liczbę cyfr ułamkowych równą decimals.

Wyjątki

ArgumentOutOfRangeException

decimals wartość jest mniejsza niż 0 lub większa niż 28.

OverflowException

Wynik znajduje się poza zakresem .Decimal

Uwagi

Wartość argumentu decimals może wahać się od 0 do 28.

Ta metoda używa domyślnej konwencji zaokrąglania klasy MidpointRounding.ToEven. Aby uzyskać informacje na temat zaokrąglania liczb z wartościami punktu środkowego, zobacz Midpoint values and rounding conventions (Wartości punktu środkowego i konwencje zaokrąglania).

Ważna

Podczas zaokrąglania wartości punktu środkowego algorytm zaokrąglania wykonuje test równości. Ze względu na problemy z reprezentacją binarną i precyzją w formacie zmiennoprzecinkowym wartość zwracana przez metodę może być nieoczekiwana. Aby uzyskać więcej informacji, zobacz Zaokrąglanie i precyzja.

Przykład

Poniższy przykład zaokrągla wartości dziesiętne z dwiema cyframi ułamkowymi do wartości, które mają pojedynczą cyfrę ułamkową.

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

Zobacz też

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

Round(Double)

Źródło:

Math.cs

Zaokrągla wartość zmiennoprzecinkową o podwójnej precyzji do najbliższej wartości całkowitej i zaokrągla wartości punktu środkowego do najbliższej liczby parzyskowej.

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

Liczba zmiennoprzecinkowa o podwójnej precyzji do zaokrąglenia.

Zwraca

Double

Liczba całkowita najbliższa a. Jeśli składnik ułamkowy elementu a jest w połowie drogi między dwiema liczbami całkowitymi, z których jedna jest parzysta, a drugą nieparzystą, zwracana jest liczba parzysta. Należy pamiętać, że ta metoda zwraca Double wartość zamiast typu całkowitego.

Uwagi

Ta metoda używa domyślnej konwencji zaokrąglania klasy MidpointRounding.ToEven. Aby uzyskać informacje na temat zaokrąglania liczb z wartościami punktu środkowego, zobacz Midpoint values and rounding conventions (Wartości punktu środkowego i konwencje zaokrąglania).

Ważna

Podczas zaokrąglania wartości punktu środkowego algorytm zaokrąglania wykonuje test równości. Ze względu na problemy z reprezentacją binarną i precyzją w formacie zmiennoprzecinkowym wartość zwracana przez metodę może być nieoczekiwana. Aby uzyskać więcej informacji, zobacz Zaokrąglanie i precyzja.

Jeśli wartość argumentu a to Double.NaN, metoda zwraca Double.NaNwartość . Jeśli a wartość to Double.PositiveInfinity lub Double.NegativeInfinity, metoda zwraca Double.PositiveInfinity wartość lub Double.NegativeInfinity, odpowiednio.

Począwszy od Visual Basic 15.8, wydajność konwersji podwójnej do liczby całkowitej jest zoptymalizowana w przypadku przekazania wartości zwróconej przez metodę Round do dowolnej z funkcji konwersji integral konwersji, lub jeśli wartość Podwójna zwracana przez Round jest automatycznie konwertowana na liczbę całkowitą z wartością Option Strict ustawioną na wartość Wyłączone. Ta optymalizacja umożliwia szybsze uruchamianie kodu — nawet dwa razy szybciej w przypadku kodu, który wykonuje dużą liczbę konwersji na typy całkowite. Poniższy przykład ilustruje takie zoptymalizowane konwersje:

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

Przykład

W poniższym przykładzie pokazano zaokrąglanie do najbliższej wartości całkowitej.

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

Notatki dotyczące wywoływania

Ze względu na utratę dokładności, która może wynikać z reprezentowania wartości dziesiętnych jako liczb zmiennoprzecinkowych lub wykonywania operacji arytmetycznych na wartości zmiennoprzecinkowych, w niektórych przypadkach Round(Double) metoda może nie wydawać się zaokrąglać wartości punktu środkowego do najbliższej parzystej liczby całkowitej. W poniższym przykładzie, ponieważ wartość zmiennoprzecinkowa .1 nie ma skończonej reprezentacji binarnej, pierwsze wywołanie Round(Double) metody o wartości 11,5 zwraca wartość 11 zamiast 12.

using System;

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

      Console.WriteLine();

      value = 11.5;
      RoundValueAndAdd(value);
   }

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

open System

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

let mutable value = 11.1

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

printfn ""

value <- 11.5
roundValueAndAdd value
|> ignore

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

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

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

Zobacz też

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

Round(Decimal)

Źródło:

Math.cs

Zaokrągla wartość dziesiętną do najbliższej wartości całkowitej i zaokrągla wartości punktu środkowego do najbliższej liczby parzystej.

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

Liczba dziesiętna, która ma być zaokrąglona.

Zwraca

Decimal

Liczba całkowita najbliższa parametrowi d . Jeśli składnik ułamkowy elementu d znajduje się w połowie między dwiema liczbami całkowitymi, z których jedna jest parzysta, a drugą nieparzystą, zwracana jest liczba parzysta. Należy pamiętać, że ta metoda zwraca Decimal wartość zamiast typu całkowitego.

Wyjątki

OverflowException

Wynik znajduje się poza zakresem .Decimal

Przykłady

W poniższym przykładzie przedstawiono metodę Round(Decimal) . Wartość Decimal 4,5 zaokrągla do 4, a nie 5, ponieważ to przeciążenie używa konwencji domyślnej ToEven .

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

Uwagi

Ta metoda używa domyślnej konwencji zaokrąglania klasy MidpointRounding.ToEven. Aby uzyskać informacje na temat zaokrąglania liczb z wartościami punktu środkowego, zobacz Midpoint values and rounding conventions (Wartości punktu środkowego i konwencje zaokrąglania).

Ważna

Podczas zaokrąglania wartości punktu środkowego algorytm zaokrąglania wykonuje test równości. Ze względu na problemy z reprezentacją binarną i precyzją w formacie zmiennoprzecinkowym wartość zwracana przez metodę może być nieoczekiwana. Aby uzyskać więcej informacji, zobacz Zaokrąglanie i precyzja.

Zobacz też

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

Round(Decimal, MidpointRounding)

Źródło:

Math.cs

Zaokrągla wartość dziesiętną liczbę całkowitą przy użyciu określonej konwencji zaokrąglania.

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

Liczba dziesiętna, która ma być zaokrąglona.

mode

MidpointRounding

Jedna z wartości wyliczenia określająca, która strategia zaokrąglania ma być używana.

Zwraca

Decimal

Liczba całkowita zaokrąglona d do. Ta metoda zwraca wartość Decimal zamiast typu całkowitego.

Wyjątki

ArgumentException

mode nie jest prawidłową wartością MidpointRounding.

OverflowException

Wynik znajduje się poza zakresem .Decimal

Uwagi

Aby uzyskać informacje na temat zaokrąglania liczb z wartościami punktu środkowego, zobacz Midpoint values and rounding conventions (Wartości punktu środkowego i konwencje zaokrąglania).

Ważna

Podczas zaokrąglania wartości punktu środkowego algorytm zaokrąglania wykonuje test równości. Ze względu na problemy z reprezentacją binarną i precyzją w formacie zmiennoprzecinkowym wartość zwracana przez metodę może być nieoczekiwana. Aby uzyskać więcej informacji, zobacz Zaokrąglanie i precyzja.

Przykład

Poniższy przykład przedstawia wartości zwracane przez metodę Round(Decimal, MidpointRounding) z różnymi mode wartościami.

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

Zobacz też

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