Math.Round Yöntem

Başvuru

Tanım

Ad Alanı:: System

Bütünleştirilmiş Kod:: System.Runtime.Extensions.dll

Bütünleştirilmiş Kod:: System.Runtime.dll

Bütünleştirilmiş Kod:: mscorlib.dll

Bütünleştirilmiş Kod:: netstandard.dll

Önemli

Bazı bilgiler ürünün ön sürümüyle ilgilidir ve sürüm öncesinde önemli değişiklikler yapılmış olabilir. Burada verilen bilgilerle ilgili olarak Microsoft açık veya zımni hiçbir garanti vermez.

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

Aşırı Yüklemeler

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 sayıda kesirli basamağı 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 bir tamsayıya yuvarlar.

Örnekler

Açıklamalar bölümündeki örneklere ek olarak, bu makale yönteminin aşağıdaki aşırı yüklemelerini Math.Round gösteren örnekler içerir:

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ümdeki konular:

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öntemlerine Math.Round ek olarak ve Math.Floorde içerirMath.Ceiling.

Amaç	Call
En yakına yuvarlama kuralını kullanarak bir sayıyı tamsayıya yuvarlar.	Round(Decimal) -veya- Round(Double)
Belirtilen yuvarlama kuralını kullanarak bir sayıyı tamsayıya yuvarlar.	Round(Decimal, MidpointRounding) -veya- Round(Double, MidpointRounding)
En yakına yuvarlama kuralını 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 daha 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'u 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, 3,4 değerini 3,0'a yuvarlarken yöntemini ve Round(Double, Int32) 3,579 değerini 3,58'e yuvarlama yöntemini kullanabilirsinizRound(Double).

Orta nokta değerinde, sonuçtaki en az anlamlı basamak sonrasındaki değer, iki sayı arasında tam olarak yarı yarıyadır. Örneğin, 3,47500 iki ondalık basameğe yuvarlanacaksa orta nokta değeridir ve tamsayıya yuvarlanacaksa 7,500 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 yuvarlama veya bankacı 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.

Not

.NET Core 3.0 ve sonraki sürümlerde, numaralandırma aracılığıyla MidpointRounding üç ek yuvarlama stratejisi sağlanır. Bu stratejiler yalnızca ve MidpointRounding.AwayFromZero olarak MidpointRounding.ToEven 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 işlemlerde 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 bir yönde tutarlı bir şekilde yuvarlamanın neden olduğu yuvarlama hatasını bile azaltır. Bazı durumlarda bu yuvarlama hatası önemli olabilir.

Aşağıdaki örnek, orta nokta değerlerinin tek bir yönde tutarlı bir şekilde yuvarlanmasından kaynaklanabilir yanlılıkları gösterir. Örnek, bir değer dizisinin gerçek ortalamasını Decimal hesaplar ve ardından dizideki değerlerin iki kural kullanılarak yuvarlandığı ortalamayı hesaplar. Bu örnekte, en yakına yuvarlanırken elde eden gerçek ortalama ve ortalama aynıdır. Ancak sıfırdan uzağa yuvarlanırken 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ı listelemektedir.

Aşırı	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)	Parametresi tarafından `mode` belirlenir
Round(Decimal, Int32, MidpointRounding)	Parametresi tarafından `mode` belirlenir
Round(Double, Int32, MidpointRounding)	Parametresi tarafından `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 değerin kalan kesirli kısmının 0,5'ten büyük veya buna eşit olup olmadığını 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 herhangi bir kesirli kısmının (duyarlık kaybı nedeniyle) yukarı yuvarlanmadığı anlamına gelir.

Aşağıdaki örnek, sorunu gösterir. Sürekli olarak 11.0'a .1 ekler ve sonucu en yakın tamsayıya yuvarlar. 11,5, orta nokta yuvarlama kurallarını (ToEven veya AwayFromZero) kullanarak 12'ye yuvarlamalıdır. Ancak, örnekteki çı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ın kaybolduğunu ve değerinin aslında 11,49999999999998 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 bir 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 Decimalyerine bir Single Double 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 Decimal değere değiştirebilir Double ve bunun yerine değeri yuvarlayan bir Decimal aşırı yüklemeyi çağırabilirsiniz. Veri türü gösterim ve duyarlık kaybı sorunlarına da sahip olsa Decimal da, bu sorunlar çok daha az yaygındır.

Yuvarlanacak değerin orta nokta değerine kabul edilebilir ş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çin 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 sorunu düzeltildi.

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 Doubletüründeki Decimal bağımsız değişkenleri kabul eden aşırı yüklemeler içerir. türüne Singleait değerleri yuvarlayan yöntem yoktur. Bir Single değeri yöntemin aşırı yüklemelerinden Round birine geçirirseniz, bu değer (C#'ta) veya bir Doubleöğesine dönüştürülür (Visual Basic'te) ve parametresiyle Double ilgili Round aşırı yükleme ç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 Doubledeğerine dönüştürülmesindeki Single 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, duyarlık kaybı, değerin dönüştürülmesi veya değerine Decimaldönüştürülmesiyle Single 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

Kaynak:: Math.cs

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 noktalı bir sayı.

digits: Int32

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

mode: MidpointRounding

Hangi yuvarlama stratejisinin kullanılacağını belirten numaralandırma değerlerinden biri.

Döndürülenler

Double

Yuvarlatılmış kesirli basamakların bulunduğu value sayıdigits. değerinden digitsvalue 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ı.

Önemli

Orta nokta değerlerini yuvarlarken, yuvarlama algoritması bir eşitlik testi gerçekleştirir. Kayan nokta biçimindeki 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.NaN, yöntemi döndürür Double.NaN. veya Double.NegativeInfinityise Double.PositiveInfinityvalue, yöntem sırasıyla veya Double.NegativeInfinitydöndürürDouble.PositiveInfinity.

Örnek

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ştirme sonucu ortaya çıkabilen duyarlık kaybı nedeniyle, bazı durumlarda Round(Double, Int32, MidpointRounding) yöntem parametresi 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. Bu durum, yöntemin dahili olarak 10^basamakla çarpılması value ve bu durumda çarpma işleminin duyarlık kaybı yaşamasından kaynaklanı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.

Şunlara uygulanır

Round(Decimal, Int32, MidpointRounding)

Kaynak:: Math.cs

Kaynak:: Math.cs

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 bir sayı.

decimals: Int32

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

mode: MidpointRounding

Hangi yuvarlama stratejisinin kullanılacağını belirten numaralandırma değerlerinden biri.

Döndürülenler

Decimal

Yuvarlatılmış kesirli basamaklar içeren d sayıdecimals. değerinden decimalsd 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ı.

Önemli

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

Örnek

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.

Şunlara uygulanır

Round(Double, MidpointRounding)

Kaynak:: Math.cs

Kaynak:: Math.cs

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 noktalı bir sayı.

mode: MidpointRounding

Hangi yuvarlama stratejisinin kullanılacağını 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ı.

Önemli

Örnek

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ğerleri üzerinde aritmetik işlemler gerçekleştirme sonucu ortaya çıkabilecek 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.

Şunlara uygulanır

Round(Double, Int32)

Kaynak:: Math.cs

Kaynak:: Math.cs

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 noktalı bir sayı.

digits: Int32

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

Döndürülenler

Double

değerine eşit digitskesirli basamak sayısını içeren en value yakın sayıdır.

Ö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ı.

Önemli

Örnek

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

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ğerleri üzerinde aritmetik işlemler gerçekleştirilmesinden kaynaklanan duyarlık kaybı nedeniyle, yöntem bazı durumlarda Round(Double, Int32) 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. Bu durum, yöntemin dahili olarak 10^basamakla çarpılması value ve bu durumda çarpma işleminin duyarlık kaybı yaşamasından kaynaklanı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.

Şunlara uygulanır

Round(Decimal, Int32)

Kaynak:: Math.cs

Kaynak:: Math.cs

Kaynak:: Math.cs

Ondalık değeri belirtilen sayıda kesirli basamağı 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 bir sayı.

decimals: Int32

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

Döndürülenler

Decimal

değerine eşit decimalskesirli basamak sayısını içeren en d yakın sayıdır.

Ö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ı.

Önemli

Örnek

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.

Şunlara uygulanır

Round(Double)

Kaynak:: Math.cs

Kaynak:: Math.cs

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 noktalı bir sayı.

Döndürülenler

Double

En ayakın tamsayı. kesirli bileşeni a iki tamsayı arasında yarı yarıya ise, biri çift ve diğeri tek ise, çift sayı döndürülür. Bu yöntemin tam sayı türü yerine bir Double döndürdüğünü unutmayın.

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

Önemli

bağımsız değişkeninin a değeri ise Double.NaN, yöntemi döndürür Double.NaN. veya Double.NegativeInfinityise Double.PositiveInfinitya, yöntem sırasıyla veya Double.NegativeInfinitydöndürürDouble.PositiveInfinity.

Visual Basic 15.8'den başlayarak, yöntem tarafından Round döndürülen değeri tamsayı dönüştürme işlevlerinden herhangi birine geçirirseniz veya tarafından döndürülen Round Double değeri otomatik olarak Option Strict ayarı Kapalı olarak ayarlanmış bir tamsayıya dönüştürülürse Çift tamsayı dönüştürmenin performansı iyileştirilir. Bu iyileştirme, kodun daha hızlı çalışmasını sağlar; tamsayı türlerine çok sayıda dönüştürme işlemi yürüten 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

Örnek

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

using namespace System;

void main()
{
    Console::WriteLine("Classic Math.Round in CPP");
    Console::WriteLine(Math::Round(4.4));     // 4
    Console::WriteLine(Math::Round(4.5));     // 4
    Console::WriteLine(Math::Round(4.6));     // 5
    Console::WriteLine(Math::Round(5.5));     // 6
}

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

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ğerleri üzerinde aritmetik işlemler gerçekleştirme sonucu ortaya çıkabilecek 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.

Şunlara uygulanır

Round(Decimal)

Kaynak:: Math.cs

Kaynak:: Math.cs

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 bir sayı.

Döndürülenler

Decimal

Parametreye d en yakın tamsayı. kesirli bileşeni d iki tamsayı arasındaysa (biri çift, diğeri tek) çift sayı döndürülür. Bu yöntemin tam sayı türü yerine bir Decimal döndürdüğünü unutmayın.

Ö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ı.

Önemli

Ayrıca bkz.

Şunlara uygulanır

Round(Decimal, MidpointRounding)

Kaynak:: Math.cs

Kaynak:: Math.cs

Kaynak:: Math.cs

Belirtilen yuvarlama kuralını kullanarak ondalık değeri bir tamsayıya 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 bir sayı.

mode: MidpointRounding

Hangi yuvarlama stratejisinin kullanılacağını 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ı.

Önemli

Örnek

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.

Şunlara uygulanır

Aracılığıyla paylaş

Math.Round Yöntem

Tanım

Aşırı Yüklemeler

Örnekler

Açıklamalar

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

Round(Double, Int32, MidpointRounding)

Parametreler

Döndürülenler

Özel durumlar

Açıklamalar

Örnek

Arayanlara Notlar

Ayrıca bkz.

Şunlara uygulanır

Round(Decimal, Int32, MidpointRounding)

Parametreler

Döndürülenler

Özel durumlar

Açıklamalar

Örnek

Ayrıca bkz.

Şunlara uygulanır

Round(Double, MidpointRounding)

Parametreler

Döndürülenler

Özel durumlar

Açıklamalar

Örnek

Arayanlara Notlar

Ayrıca bkz.

Şunlara uygulanır

Round(Double, Int32)

Parametreler

Döndürülenler

Özel durumlar

Açıklamalar

Örnek

Arayanlara Notlar

Ayrıca bkz.

Şunlara uygulanır

Round(Decimal, Int32)

Parametreler

Döndürülenler

Özel durumlar

Açıklamalar

Örnek

Ayrıca bkz.

Şunlara uygulanır

Round(Double)

Parametreler

Döndürülenler

Açıklamalar

Örnek

Arayanlara Notlar

Ayrıca bkz.

Şunlara uygulanır

Round(Decimal)

Parametreler

Döndürülenler

Özel durumlar

Örnekler

Açıklamalar

Ayrıca bkz.

Şunlara uygulanır

Round(Decimal, MidpointRounding)

Parametreler

Döndürülenler

Özel durumlar

Açıklamalar

Örnek

Ayrıca bkz.

Şunlara uygulanır

Ek kaynaklar