Math.Round Yöntem

Tanım

Ad Alanı:

System

Bütünleştirilmiş Kodlar:

netstandard.dll, System.Runtime.dll

Bir değeri en yakın tamsayıya veya belirtilen kesirli basamak sayısına yuvarlar.

Aşırı Yüklemeler

Name	Description
Round(Double, Int32, MidpointRounding)	Belirtilen yuvarlama kuralını kullanarak çift duyarlıklı kayan nokta değerini belirtilen sayıda kesirli basamağı yuvarlar.
Round(Decimal, Int32, MidpointRounding)	Belirtilen yuvarlama kuralını kullanarak ondalık değeri belirtilen sayıda kesirli basamağı yuvarlar.
Round(Double, MidpointRounding)	Belirtilen yuvarlama kuralını kullanarak çift duyarlıklı kayan nokta değerini tamsayıya yuvarlar.
Round(Double, Int32)	Çift duyarlıklı kayan nokta değerini belirtilen sayıda kesirli basamağı yuvarlar ve orta nokta değerlerini en yakın çift sayıya yuvarlar.
Round(Decimal, Int32)	Ondalık değeri belirtilen kesirli basamak sayısına yuvarlar ve orta nokta değerlerini en yakın çift sayıya yuvarlar.
Round(Double)	Çift duyarlıklı kayan nokta değerini en yakın tamsayı değerine yuvarlar ve orta nokta değerlerini en yakın çift sayıya yuvarlar.
Round(Decimal)	Ondalık değeri en yakın tamsayı değerine yuvarlar ve orta nokta değerlerini en yakın çift sayıya yuvarlar.
Round(Decimal, MidpointRounding)	Belirtilen yuvarlama kuralını kullanarak ondalık değeri tamsayı olarak yuvarlar.

Örnekler

Açıklamalar bölümündeki örneklere ek olarak, bu makalede yöntemin aşağıdaki aşırı yüklemelerini Math.Round gösteren örnekler de yer alır:

Math.Round(Decimal)Math.Round(Double)Math.Round(Decimal, Int32)Math.Round(Decimal, MidpointRounding)Math.Round(Double, Int32)Math.Round(Double, MidpointRounding)Math.Round(Decimal, Int32, MidpointRounding)Math.Round(Double, Int32, MidpointRounding)

Açıklamalar

Bu bölümde:

• Hangi yöntemi çağırmalıyım?
• Orta nokta değerleri ve yuvarlama kuralları
• Yuvarlama ve duyarlık
• Yuvarlama ve tek duyarlıklı kayan nokta değerleri
• Tek tek aşırı yükleme örnekleri

Hangi yöntemi çağırmalıyım?

Uygun bir yuvarlama yöntemi seçmek için aşağıdaki tabloyu kullanabilirsiniz. Yöntemlere Math.Round ek olarak ve Math.Ceilingdeğerlerini de içerirMath.Floor.

İçin	Call
En yakına yuvarlama kuralını kullanarak sayıyı tamsayıya yuvarlar.	Round(Decimal) -veya- Round(Double)
Belirtilen yuvarlama kuralını kullanarak sayıyı tamsayıya yuvarlar.	Round(Decimal, MidpointRounding) -veya- Round(Double, MidpointRounding)
En yakın kurala yuvarlama kullanarak bir sayıyı belirtilen sayıda kesirli basamağı yuvarlar.	Round(Decimal, Int32) -veya- Round(Double, Int32)
Belirtilen yuvarlama kuralını kullanarak bir sayıyı belirtilen sayıda kesirli basamağı yuvarlar.	Round(Decimal, Int32, MidpointRounding) -veya- Round(Double, Int32, MidpointRounding)
Single Belirtilen yuvarlama kuralını kullanarak ve duyarlık kaybını en aza indirerek değeri belirtilen sayıda kesirli basamağı yuvarlar.	öğesini Single öğesine Decimal dönüştürün ve öğesini çağırın Round(Decimal, Int32, MidpointRounding).
Orta nokta değerlerini yuvarlarken duyarlık sorunlarını en aza indirirken sayıyı belirtilen sayıda kesirli basamağı yuvarlar.	"Büyüktür veya yaklaşık olarak eşittir" karşılaştırması uygulayan bir yuvarlama yöntemi çağır. Bkz . Yuvarlama ve duyarlık.
Kesirli değeri kesirli değerden büyük bir tamsayıya yuvarlar. Örneğin, 3,1'i 4'e yuvarlar.	Ceiling
Kesirli değeri kesirli değerden küçük bir tamsayıya yuvarlar. Örneğin, 3,9'ı 3'e yuvarlar.	Floor

Orta nokta değerleri ve yuvarlama kuralları

Yuvarlama, belirtilen duyarlıklı sayısal değeri daha az duyarlıklı bir değere dönüştürmeyi içerir. Örneğin, yöntemini kullanarak Round(Double) 3,4 değerini 3,0'a yuvarlayabilir ve Round(Double, Int32) yöntemini kullanarak 3,579 değerini 3,58'e yuvarlayabilirsiniz.

Orta nokta değerinde, sonuçtaki en az önemli basamak sonrasındaki değer, iki sayı arasında tam olarak yarı yoldadır. Örneğin, 3,47500 iki ondalık basameğe yuvarlanacaksa orta nokta değeridir ve tamsayıya yuvarlanacaksa 7,500 bir orta nokta değeridir. Bu gibi durumlarda, en yakına yuvarlama stratejisi kullanılırsa, en yakın değer yuvarlama kuralı olmadan kolayca tanımlanamaz.

yöntemi, Round orta nokta değerlerini işlemek için iki yuvarlama kuralını destekler:

• Sıfırdan uzağa yuvarlama

  Orta nokta değerleri sıfırdan bir sonraki sayıya yuvarlanır. Örneğin, 3,75 3,8'e yuvarlar, 3,85 3,9'a yuvarlar, -3,75-3,8'e yuvarlar ve -3,85 de -3,9'a yuvarlar. Bu yuvarlama biçimi numaralandırma üyesi tarafından MidpointRounding.AwayFromZero temsil edilir.

• En yakın çifte veya bankacı yuvarlamasına yuvarlama

  Orta nokta değerleri en yakın çift sayıya yuvarlanir. Örneğin, hem 3,75 hem de 3,85 3,8'e yuvarlar ve -3,75 ve -3,85 de -3,85'i -3,8'e yuvarlar. Bu yuvarlama biçimi numaralandırma üyesi tarafından MidpointRounding.ToEven temsil edilir.

Note

.NET Core 3.0 ve sonraki sürümlerinde, MidpointRounding numaralandırması aracılığıyla üç ek yuvarlama stratejisi sağlanır. Bu stratejiler yalnızca ve MidpointRounding.ToEven olarak MidpointRounding.AwayFromZero orta nokta değerleri için değil, her durumda kullanılır.

Sıfırdan uzağa yuvarlama, en yaygın bilinen yuvarlama biçimidir, en yakına yuvarlama ise finansal ve istatistiksel operasyonlarda standarttır. IEEE Standard 754, bölüm 4'e uygundur. Birden çok yuvarlama işlemi kullanıldığında, en yakına yuvarlama, orta nokta değerlerini tek yönde sürekli yuvarlamanın neden olduğu yuvarlama hatasını azaltır. Bazı durumlarda bu yuvarlama hatası önemli olabilir.

Aşağıdaki örnek, orta nokta değerlerinin tek bir yönde sürekli yuvarlanmasından kaynaklanan yanlılıkları gösterir. Örnek, bir değer dizisinin Decimal gerçek ortalamasını hesaplar ve ardından dizideki değerler iki kural kullanılarak yuvarlandığında ortalamayı hesaplar. Bu örnekte, en yakına yuvarlarken elde eden gerçek ortalama ve ortalama aynıdır. Ancak, sıfırdan uzağa yuvarlama sırasında elde edilen ortalama, gerçek ortalamadan 0,05 (veya 3,6%) farklıdır.

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

Varsayılan olarak, Round yöntemi en yakın çifte yuvarlama kuralını kullanır. Aşağıdaki tabloda yönteminin Round aşırı yüklemeleri ve her birinin kullandığı yuvarlama kuralı listeleniyor.

Overload	Yuvarlama kuralı
Round(Decimal)	ToEven
Round(Double)	ToEven
Round(Decimal, Int32)	ToEven
Round(Double, Int32)	ToEven
Round(Decimal, MidpointRounding)	Parametresi tarafından mode belirlenir.
Round(Double, MidpointRounding)	Parametreye göre mode belirlenir
Round(Decimal, Int32, MidpointRounding)	Parametreye göre mode belirlenir
Round(Double, Int32, MidpointRounding)	Parametreye göre mode belirlenir

Yuvarlama ve duyarlık

Yuvarlama işleminin orta nokta değeri içerip içermediğini belirlemek için, Round yöntem yuvarlanacak özgün değeri 10ⁿ ile çarpar; burada n , dönüş değerinde istenen kesirli basamak sayısıdır ve sonra değerin kalan kesirli bölümünün .5'e eşit mi yoksa daha büyük mü olduğunu belirler. Bu, eşitlik testinin küçük bir varyasyonudur ve başvuru konusunun "Eşitlik Testi" bölümünde Double açıklandığı gibi kayan noktalı değerlerle eşitlik testleri, kayan nokta biçiminin ikili gösterim ve duyarlık ile ilgili sorunları nedeniyle sorunludur. Bu, bir sayının 0,5'ten biraz daha küçük olan kesirli bölümlerinin (duyarlık kaybı nedeniyle) yukarı yuvarlanmaması anlamına gelir.

Aşağıdaki örnekte sorun gösterilmektedir. Sürekli olarak 11.0'a .1 ekler ve sonucu en yakın tamsayıya yuvarlar. 11,5, orta nokta yuvarlama kurallarından birini (ToEven veya AwayFromZero) kullanarak 12'ye yuvarlamalıdır. Ancak, örnekte gösterilen çıktıda gösterildiği gibi, gösterilmez. Örnek, kayan nokta değerinin tam duyarlığını görüntülemek için "R" standart sayısal biçim dizesini kullanır ve yuvarlanacak değerin yinelenen eklemeler sırasında duyarlığını kaybettiğini ve değerinin aslında 11,49999999999999998 olduğunu gösterir. .499999999999998 0,5'ten küçük olduğundan, orta nokta yuvarlama kuralları devreye girmez ve değer aşağı yuvarlanır. Örnekte de gösterildiği gibi, 11.5 sabit değerini bir Double değişkene atarsanız bu sorun oluşmaz.

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

Orta nokta değerlerini yuvarlamada duyarlık sorunları büyük olasılıkla aşağıdaki koşullarda ortaya çıkar:

• Kesirli değer kayan nokta türünün ikili biçiminde tam olarak ifade edilemediğinde.

• Yuvarlanacak değer bir veya daha fazla kayan noktalı işlemden hesaplandığında.

• Yuvarlanacak değer veya Singleyerine bir DoubleDecimal olduğunda. Daha fazla bilgi için yuvarlama ve tek duyarlıklı kayan nokta değerleri başlıklı sonraki bölüme bakın.

Yuvarlama işlemlerinde duyarlık eksikliğinin sorunlu olduğu durumlarda aşağıdakileri yapabilirsiniz:

• Yuvarlama işlemi bir değeri yuvarlayan Double bir aşırı yüklemeyi çağırırsa değerini bir Double değere değiştirebilir Decimal ve bunun yerine değeri yuvarlayan bir Decimal aşırı yüklemeyi çağırabilirsiniz. Veri türü gösterimi Decimal ve duyarlık kaybı sorunlarına da sahip olsa da, bu sorunlar çok daha az yaygındır.

• Yuvarlanacak değerin orta nokta değerine kabul edilebilir bir şekilde yakın olup olmadığını belirlemek için "neredeyse eşittir" testi gerçekleştiren özel bir yuvarlama algoritması tanımlayın. Aşağıdaki örnek, kesirli değerin orta nokta yuvarlama işlemine tabi olacak bir orta nokta değerine yeterince yakın olup olmadığını inceleyen bir yöntemi tanımlar RoundApproximate . Örnekteki çıktıda gösterildiği gibi, önceki örnekte gösterilen yuvarlama sorununu düzeltmektedir.

  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
  

Yuvarlama ve tek duyarlıklı kayan nokta değerleri

yöntemi, Round ve Decimaltüründe Double bağımsız değişkenleri kabul eden aşırı yüklemeler içerir. türüne Singleait değerleri yuvarlayan yöntem yoktur. Single yönteminin aşırı yüklemelerinden birine bir Round değeri geçirirseniz, bu değer bir Double'a dönüştürülür (C#'ta) veya dönüştürülür (Visual Basic) ve Round parametresiyle ilgili Double aşırı yüklemesi çağrılır. Bu bir genişletme dönüştürmesi olsa da, aşağıdaki örnekte gösterildiği gibi genellikle duyarlık kaybı içerir. Single Yöntemine 16,325 değeri geçirildiğinde Round ve en yakın kurala yuvarlama kullanılarak iki ondalık basameğe yuvarlandığında, sonuç 16,33 olur ve beklenen 16,32 sonucu değildir.

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

Bu beklenmeyen sonuç, değerin Singledeğerine dönüştürülmesindeki Double duyarlık kaybından kaynaklanır. Sonuçta Double elde edilen 16,325000762939453 değeri orta nokta değeri olmadığından ve 16,325'ten büyük olduğundan, her zaman yukarı doğru yuvarlanır.

Birçok durumda, örnekte gösterildiği gibi, değerin Singlebir değerine dönüştürülmesi veya dönüştürülmesiyle Decimal duyarlık kaybı en aza indirilebilir veya ortadan kaldırılabilir. Bu bir daraltma dönüştürmesi olduğundan, dönüştürme işleci kullanmayı veya dönüştürme yöntemini çağırmayı gerektirdiğini unutmayın.

Round(Double, Int32, MidpointRounding)

Kaynak:

Math.cs

Belirtilen yuvarlama kuralını kullanarak çift duyarlıklı kayan nokta değerini belirtilen sayıda kesirli basamağı yuvarlar.

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

Parametreler

value

Double

Yuvarlanacak çift duyarlıklı kayan nokta sayısı.

digits

Int32

Dönüş değerindeki kesirli basamak sayısı.

mode

MidpointRounding

Kullanılacak yuvarlama stratejisini belirten numaralandırma değerlerinden biri.

Döndürülenler

Double

Yuvarlatılmış kesirli basamakları olan digits sayıvalue. değerinden valuedigits daha az kesirli basamak varsavalue, değişmeden döndürülür.

Özel durumlar

ArgumentOutOfRangeException

digits 0'dan küçük veya 15'ten büyük.

ArgumentException

mode geçerli bir değeri MidpointRoundingdeğildir.

Açıklamalar

Bağımsız değişkenin digits değeri 0 ile 15 arasında olabilir. Türü tarafından Double desteklenen en fazla tam sayı ve kesirli basamak sayısı 15'tir.

Orta nokta değerleriyle sayıları yuvarlama hakkında bilgi için bkz. Orta nokta değerleri ve yuvarlama kuralları.

Important

Orta nokta değerlerini yuvarlarken yuvarlama algoritması bir eşitlik testi gerçekleştirir. Kayan nokta biçiminde ikili gösterim ve duyarlık sorunları nedeniyle, yöntemi tarafından döndürülen değer beklenmeyen olabilir. Daha fazla bilgi için bkz . Yuvarlama ve duyarlık.

bağımsız değişkeninin value değeri ise Double.NaNyöntemi döndürür Double.NaN. veya valueise Double.PositiveInfinityDouble.NegativeInfinity yöntemi sırasıyla veya Double.PositiveInfinitydöndürürDouble.NegativeInfinity.

Example

Aşağıdaki örnekte, yönteminin Round(Double, Int32, MidpointRounding) numaralandırma ile MidpointRounding nasıl kullanılacağı gösterilmektedir.

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

Arayanlara Notlar

Ondalık değerleri kayan noktalı sayılar olarak temsil etme veya kayan nokta değerleri üzerinde aritmetik işlemler gerçekleştirmenin neden olabileceği duyarlık kaybı nedeniyle, bazı durumlarda Round(Double, Int32, MidpointRounding) yöntem parametre tarafından mode belirtilen orta nokta değerlerini yuvarlar gibi görünmeyebilir. Bu, 2,135 değerinin 2,14 yerine 2,13'e yuvarlandığı aşağıdaki örnekte gösterilmiştir. Bunun nedeni, dahili olarak yöntemin 10value çarpılması ve bu durumda çarpma işleminin duyarlık kaybı yaşamasıdır.

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

Ayrıca bkz.

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

Round(Decimal, Int32, MidpointRounding)

Kaynak:

Math.cs

Belirtilen yuvarlama kuralını kullanarak ondalık değeri belirtilen sayıda kesirli basamağı yuvarlar.

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

Parametreler

d

Decimal

Yuvarlanacak ondalık sayı.

decimals

Int32

Dönüş değerindeki ondalık basamak sayısı.

mode

MidpointRounding

Kullanılacak yuvarlama stratejisini belirten numaralandırma değerlerinden biri.

Döndürülenler

Decimal

Yuvarlatılmış kesirli basamak içeren decimals sayıd. değerinden ddecimals daha az kesirli basamak varsad, değişmeden döndürülür.

Özel durumlar

ArgumentOutOfRangeException

decimals 0'dan küçük veya 28'den büyük.

ArgumentException

mode geçerli bir değeri MidpointRoundingdeğildir.

OverflowException

Sonuç, aralığının Decimaldışındadır.

Açıklamalar

Orta nokta değerleriyle sayıları yuvarlama hakkında bilgi için bkz. Orta nokta değerleri ve yuvarlama kuralları.

Important

Orta nokta değerlerini yuvarlarken yuvarlama algoritması bir eşitlik testi gerçekleştirir. Kayan nokta biçiminde ikili gösterim ve duyarlık sorunları nedeniyle, yöntemi tarafından döndürülen değer beklenmeyen olabilir. Daha fazla bilgi için bkz . Yuvarlama ve duyarlık.

Bağımsız değişkenin decimals değeri 0 ile 28 arasında olabilir.

Example

Aşağıdaki örnekte, yönteminin Round numaralandırma ile MidpointRounding nasıl kullanılacağı gösterilmektedir.

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

Ayrıca bkz.

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

Round(Double, MidpointRounding)

Kaynak:

Math.cs

Belirtilen yuvarlama kuralını kullanarak çift duyarlıklı kayan nokta değerini tamsayıya yuvarlar.

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

Parametreler

value

Double

Yuvarlanacak çift duyarlıklı kayan nokta sayısı.

mode

MidpointRounding

Kullanılacak yuvarlama stratejisini belirten numaralandırma değerlerinden biri.

Döndürülenler

Double

Yuvarlanan value tamsayı. Bu yöntem tam sayı türü yerine bir döndürür Double .

Özel durumlar

ArgumentException

mode geçerli bir değeri MidpointRoundingdeğildir.

Açıklamalar

Orta nokta değerleriyle sayıları yuvarlama hakkında bilgi için bkz. Orta nokta değerleri ve yuvarlama kuralları.

Important

Orta nokta değerlerini yuvarlarken yuvarlama algoritması bir eşitlik testi gerçekleştirir. Kayan nokta biçiminde ikili gösterim ve duyarlık sorunları nedeniyle, yöntemi tarafından döndürülen değer beklenmeyen olabilir. Daha fazla bilgi için bkz . Yuvarlama ve duyarlık.

bağımsız değişkeninin value değeri ise Double.NaNyöntemi döndürür Double.NaN. veya valueise Double.PositiveInfinityDouble.NegativeInfinity yöntemi sırasıyla veya Double.PositiveInfinitydöndürürDouble.NegativeInfinity.

Example

Aşağıdaki örnek, yöntemi tarafından Round(Double, MidpointRounding) döndürülen değerleri farklı mode değerlerle görüntüler.

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

Arayanlara Notlar

Ondalık değerleri kayan noktalı sayılar olarak temsil etme veya kayan nokta değerlerinde aritmetik işlemler gerçekleştirmenin neden olabileceği duyarlık kaybı nedeniyle, bazı durumlarda Round(Double, MidpointRounding) yöntem orta nokta değerlerini en yakın çift tamsayıya yuvarlar gibi görünmeyebilir. Aşağıdaki örnekte, .1 kayan nokta değerinin sonlu ikili gösterimi olmadığından, 11,5 değerine sahip yöntemine Round(Double) yapılan ilk çağrı 12 yerine 11 döndürür.

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

Ayrıca bkz.

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

Round(Double, Int32)

Kaynak:

Math.cs

Çift duyarlıklı kayan nokta değerini belirtilen sayıda kesirli basamağı yuvarlar ve orta nokta değerlerini en yakın çift sayıya yuvarlar.

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

Parametreler

value

Double

Yuvarlanacak çift duyarlıklı kayan nokta sayısı.

digits

Int32

Dönüş değerindeki kesirli basamak sayısı.

Döndürülenler

Double

Buna en value yakın sayı, değerine eşit digitssayıda kesirli basamak içerir.

Özel durumlar

ArgumentOutOfRangeException

digits 0'dan küçük veya 15'ten büyük.

Açıklamalar

Bağımsız değişkenin digits değeri 0 ile 15 arasında olabilir. Türü tarafından Double desteklenen en fazla tam sayı ve kesirli basamak sayısı 15'tir.

Bu yöntem varsayılan yuvarlama kuralını MidpointRounding.ToEvenkullanır. Orta nokta değerleriyle sayıları yuvarlama hakkında bilgi için bkz. Orta nokta değerleri ve yuvarlama kuralları.

Important

Orta nokta değerlerini yuvarlarken yuvarlama algoritması bir eşitlik testi gerçekleştirir. Kayan nokta biçiminde ikili gösterim ve duyarlık sorunları nedeniyle, yöntemi tarafından döndürülen değer beklenmeyen olabilir. Daha fazla bilgi için bkz . Yuvarlama ve duyarlık.

bağımsız değişkeninin value değeri ise Double.NaNyöntemi döndürür Double.NaN. veya valueise Double.PositiveInfinityDouble.NegativeInfinity yöntemi sırasıyla veya Double.PositiveInfinitydöndürürDouble.NegativeInfinity.

Example

Aşağıdaki örnek, iki kesirli basamağı olan çift değerleri tek bir kesirli basamağı olan çift değerlere yuvarlar.

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

Arayanlara Notlar

Ondalık değerlerin kayan noktalı sayılar olarak gösterilmesinden veya kayan nokta değerlerinde aritmetik işlemlerin gerçekleştirilmesinden kaynaklanabilir duyarlık kaybı nedeniyle, bazı durumlarda Round(Double, Int32) yöntem orta nokta değerlerini ondalık konumdaki en yakın çift değere digits yuvarlar gibi görünmeyebilir. Bu, 2,135 değerinin 2,14 yerine 2,13'e yuvarlandığı aşağıdaki örnekte gösterilmiştir. Bunun nedeni, dahili olarak yöntemin 10value çarpılması ve bu durumda çarpma işleminin duyarlık kaybı yaşamasıdır.

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

Ayrıca bkz.

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

Round(Decimal, Int32)

Kaynak:

Math.cs

Ondalık değeri belirtilen kesirli basamak sayısına yuvarlar ve orta nokta değerlerini en yakın çift sayıya yuvarlar.

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

Parametreler

d

Decimal

Yuvarlanacak ondalık sayı.

decimals

Int32

Dönüş değerindeki ondalık basamak sayısı.

Döndürülenler

Decimal

Buna en d yakın sayı, değerine eşit decimalssayıda kesirli basamak içerir.

Özel durumlar

ArgumentOutOfRangeException

decimals 0'dan küçük veya 28'den büyük.

OverflowException

Sonuç, aralığının Decimaldışındadır.

Açıklamalar

Bağımsız değişkenin decimals değeri 0 ile 28 arasında olabilir.

Bu yöntem varsayılan yuvarlama kuralını MidpointRounding.ToEvenkullanır. Orta nokta değerleriyle sayıları yuvarlama hakkında bilgi için bkz. Orta nokta değerleri ve yuvarlama kuralları.

Important

Orta nokta değerlerini yuvarlarken yuvarlama algoritması bir eşitlik testi gerçekleştirir. Kayan nokta biçiminde ikili gösterim ve duyarlık sorunları nedeniyle, yöntemi tarafından döndürülen değer beklenmeyen olabilir. Daha fazla bilgi için bkz . Yuvarlama ve duyarlık.

Example

Aşağıdaki örnek, iki kesirli basamağı olan ondalık değerleri tek bir kesirli basamağı olan değerlere yuvarlar.

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

Ayrıca bkz.

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

Round(Double)

Kaynak:

Math.cs

Çift duyarlıklı kayan nokta değerini en yakın tamsayı değerine yuvarlar ve orta nokta değerlerini en yakın çift sayıya yuvarlar.

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

Parametreler

a

Double

Yuvarlanacak çift duyarlıklı kayan nokta sayısı.

Döndürülenler

Double

En ayakın tamsayı. kesirli bileşeni a , biri çift, diğeri tek olan iki tamsayı arasındaysa çift sayı döndürülür. Bu yöntemin tam sayı türü yerine bir Double döndürdüğüne dikkat edin.

Açıklamalar

Bu yöntem varsayılan yuvarlama kuralını MidpointRounding.ToEvenkullanır. Orta nokta değerleriyle sayıları yuvarlama hakkında bilgi için bkz. Orta nokta değerleri ve yuvarlama kuralları.

Important

Orta nokta değerlerini yuvarlarken yuvarlama algoritması bir eşitlik testi gerçekleştirir. Kayan nokta biçiminde ikili gösterim ve duyarlık sorunları nedeniyle, yöntemi tarafından döndürülen değer beklenmeyen olabilir. Daha fazla bilgi için bkz . Yuvarlama ve duyarlık.

bağımsız değişkeninin a değeri ise Double.NaNyöntemi döndürür Double.NaN. veya aise Double.PositiveInfinityDouble.NegativeInfinity yöntemi sırasıyla veya Double.PositiveInfinitydöndürürDouble.NegativeInfinity.

Visual Basic 15.8'den başlayarak, Round yöntemi tarafından döndürülen değeri integral dönüştürme işlevleri, veya Round tarafından döndürülen Double değeri otomatik olarak Option Strict kapalı olarak ayarlanmış bir tamsayıya dönüştürülürse. Bu iyileştirme, kodun daha hızlı çalışmasına olanak tanır; tamsayı türlerine çok fazla sayıda dönüştürme işlemi sunan kod için iki kat daha hızlıdır. Aşağıdaki örnekte bu tür iyileştirilmiş dönüştürmeler gösterilmektedir:

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

Example

Aşağıdaki örnekte, en yakın tamsayı değerine yuvarlama gösterilmektedir.

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

Arayanlara Notlar

Ondalık değerleri kayan noktalı sayılar olarak temsil etme veya kayan nokta değerlerinde aritmetik işlemler gerçekleştirmenin neden olabileceği duyarlık kaybı nedeniyle, bazı durumlarda Round(Double) yöntem orta nokta değerlerini en yakın çift tamsayıya yuvarlar gibi görünmeyebilir. Aşağıdaki örnekte, .1 kayan nokta değerinin sonlu ikili gösterimi olmadığından, 11,5 değerine sahip yöntemine Round(Double) yapılan ilk çağrı 12 yerine 11 döndürür.

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

Ayrıca bkz.

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

Round(Decimal)

Kaynak:

Math.cs

Ondalık değeri en yakın tamsayı değerine yuvarlar ve orta nokta değerlerini en yakın çift sayıya yuvarlar.

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

Parametreler

d

Decimal

Yuvarlanacak ondalık sayı.

Döndürülenler

Decimal

Parametreye d en yakın tamsayı. kesirli bileşeni d iki tamsayı arasında yarı yarıya ise, bunlardan biri çift, diğeri tek ise çift sayı döndürülür. Bu yöntemin tam sayı türü yerine bir Decimal döndürdüğüne dikkat edin.

Özel durumlar

OverflowException

Sonuç, aralığının Decimaldışındadır.

Örnekler

Aşağıdaki örnekte yöntemi gösterilmektedir Round(Decimal) . Decimal Bu aşırı yükleme varsayılan ToEven kuralı kullandığından 4,5 değeri 5 yerine 4'e yuvarlar.

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

Açıklamalar

Bu yöntem varsayılan yuvarlama kuralını MidpointRounding.ToEvenkullanır. Orta nokta değerleriyle sayıları yuvarlama hakkında bilgi için bkz. Orta nokta değerleri ve yuvarlama kuralları.

Important

Orta nokta değerlerini yuvarlarken yuvarlama algoritması bir eşitlik testi gerçekleştirir. Kayan nokta biçiminde ikili gösterim ve duyarlık sorunları nedeniyle, yöntemi tarafından döndürülen değer beklenmeyen olabilir. Daha fazla bilgi için bkz . Yuvarlama ve duyarlık.

Ayrıca bkz.

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

Round(Decimal, MidpointRounding)

Kaynak:

Math.cs

Belirtilen yuvarlama kuralını kullanarak ondalık değeri tamsayı olarak yuvarlar.

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

Parametreler

d

Decimal

Yuvarlanacak ondalık sayı.

mode

MidpointRounding

Kullanılacak yuvarlama stratejisini belirten numaralandırma değerlerinden biri.

Döndürülenler

Decimal

Yuvarlanan d tamsayı. Bu yöntem tam sayı türü yerine bir döndürür Decimal .

Özel durumlar

ArgumentException

mode geçerli bir değeri MidpointRoundingdeğildir.

OverflowException

Sonuç, aralığının Decimaldışındadır.

Açıklamalar

Orta nokta değerleriyle sayıları yuvarlama hakkında bilgi için bkz. Orta nokta değerleri ve yuvarlama kuralları.

Important

Orta nokta değerlerini yuvarlarken yuvarlama algoritması bir eşitlik testi gerçekleştirir. Kayan nokta biçiminde ikili gösterim ve duyarlık sorunları nedeniyle, yöntemi tarafından döndürülen değer beklenmeyen olabilir. Daha fazla bilgi için bkz . Yuvarlama ve duyarlık.

Example

Aşağıdaki örnek, yöntemi tarafından Round(Decimal, MidpointRounding) döndürülen değerleri farklı mode değerlerle görüntüler.

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

Ayrıca bkz.

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