Math.Round Metode

Referensi

Definisi

Ruang nama:: System

Rakitan:: System.Runtime.Extensions.dll

Rakitan:: System.Runtime.dll

Rakitan:: mscorlib.dll

Rakitan:: netstandard.dll

Penting

Beberapa informasi terkait produk prarilis yang dapat diubah secara signifikan sebelum dirilis. Microsoft tidak memberikan jaminan, tersirat maupun tersurat, sehubungan dengan informasi yang diberikan di sini.

Membulatkan nilai ke bilangan bulat terdekat atau ke jumlah digit pecahan yang ditentukan.

Overload

Round(Double, Int32, MidpointRounding)	Membulatkan nilai titik mengambang presisi ganda ke jumlah digit pecahan tertentu menggunakan konvensi pembulatan yang ditentukan.
Round(Decimal, Int32, MidpointRounding)	Membulatkan nilai desimal ke jumlah digit pecahan tertentu menggunakan konvensi pembulatan yang ditentukan.
Round(Double, MidpointRounding)	Membulatkan nilai titik mengambang presisi ganda ke bilangan bulat menggunakan konvensi pembulatan yang ditentukan.
Round(Double, Int32)	Membulatkan nilai titik mengambang presisi ganda ke jumlah digit pecahan tertentu, dan membulatkan nilai titik tengah ke angka genap terdekat.
Round(Decimal, Int32)	Membulatkan nilai desimal ke jumlah digit pecahan tertentu, dan membulatkan nilai titik tengah ke angka genap terdekat.
Round(Double)	Membulatkan nilai floating-point presisi ganda ke nilai integral terdekat, dan membulatkan nilai titik tengah ke angka genap terdekat.
Round(Decimal)	Membulatkan nilai desimal ke nilai integral terdekat, dan membulatkan nilai titik tengah ke angka genap terdekat.
Round(Decimal, MidpointRounding)	Membulatkan nilai desimal bilangan bulat menggunakan konvensi pembulatan yang ditentukan.

Contoh

Selain contoh di bagian Keterangan , artikel ini menyertakan contoh yang mengilustrasikan kelebihan beban Math.Round metode berikut:

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)

Keterangan

Di bagian ini:

Metode mana yang saya panggil?
Nilai titik tengah dan konvensi pembulatan
Pembulatan dan presisi
Nilai titik mengambang presisi tunggal dan pembulatan
Contoh kelebihan beban individu

Metode mana yang saya panggil?

Anda bisa menggunakan tabel berikut untuk memilih metode pembulatan yang sesuai. Selain Math.Round metode , ini juga termasuk Math.Ceiling dan Math.Floor.

Untuk	Call
Membulatkan angka ke bilangan bulat dengan menggunakan konvensi pembulatan ke terdekat.	Round(Decimal) -atau- Round(Double)
Membulatkan angka ke bilangan bulat dengan menggunakan konvensi pembulatan tertentu.	Round(Decimal, MidpointRounding) -atau- Round(Double, MidpointRounding)
Membulatkan angka ke jumlah digit pecahan tertentu dengan menggunakan pembulatan ke konvensi terdekat.	Round(Decimal, Int32) -atau- Round(Double, Int32)
Membulatkan angka ke jumlah digit pecahan tertentu dengan menggunakan konvensi pembulatan tertentu.	Round(Decimal, Int32, MidpointRounding) -atau- Round(Double, Int32, MidpointRounding)
Single Membulatkan nilai ke jumlah digit pecahan tertentu dengan menggunakan konvensi pembulatan tertentu dan meminimalkan hilangnya presisi.	Konversi ke Single Decimal dan panggil Round(Decimal, Int32, MidpointRounding).
Membulatkan angka ke jumlah digit pecahan tertentu sambil meminimalkan masalah presisi dalam nilai titik tengah pembulatan.	Panggil metode pembulatan yang mengimplementasikan perbandingan "lebih besar dari atau kira-kira sama dengan". Lihat Pembulatan dan presisi.
Membulatkan nilai pecahan ke bilangan bulat yang lebih besar dari nilai pecahan. Misalnya, ronde 3.1 hingga 4.	Ceiling
Membulatkan nilai pecahan ke bilangan bulat yang kurang dari nilai pecahan. Misalnya, ronde 3,9 hingga 3.	Floor

Nilai titik tengah dan konvensi pembulatan

Pembulatan melibatkan konversi nilai numerik dengan presisi tertentu menjadi nilai dengan presisi yang lebih sedikit. Misalnya, Anda dapat menggunakan Round(Double) metode untuk membulatkan nilai 3,4 hingga 3,0, dan Round(Double, Int32) metode untuk membulatkan nilai 3,579 hingga 3,58.

Dalam nilai titik tengah, nilai setelah digit yang paling tidak signifikan dalam hasil justru setengah jalan di antara dua angka. Misalnya, 3,47500 adalah nilai titik tengah jika akan dibulatkan ke dua tempat desimal, dan 7,500 adalah nilai titik tengah jika akan dibulatkan ke bilangan bulat. Dalam kasus ini, jika strategi round-to-nearest digunakan, nilai terdekat tidak dapat dengan mudah diidentifikasi tanpa konvensi pembulatan.

Metode ini Round mendukung dua konvensi pembulatan untuk menangani nilai titik tengah:

Membulatkan jauh dari nol

Nilai titik tengah dibulatkan ke angka berikutnya menjauh dari nol. Misalnya, 3,75 membulatkan ke 3,8, 3,85 membulatkan ke 3,9, -3,75 membulatkan ke -3,8, dan -3,85 membulatkan ke -3,9. Bentuk pembulatan ini diwakili oleh MidpointRounding.AwayFromZero anggota enumerasi.
Pembulatan ke pembulatan terdekat, atau pembulatan bankir

Nilai titik tengah dibulatkan ke angka genap terdekat. Misalnya, 3,75 dan 3,85 membulatkan ke 3,8, dan -3,75 dan -3,85 dibulatkan ke -3,8. Bentuk pembulatan ini diwakili oleh MidpointRounding.ToEven anggota enumerasi.

Catatan

Dalam .NET Core 3.0 dan versi yang lebih baru, tiga strategi pembulatan tambahan tersedia melalui MidpointRounding enumerasi. Strategi ini digunakan dalam semua kasus, bukan hanya untuk nilai titik tengah seperti MidpointRounding.ToEven dan MidpointRounding.AwayFromZero .

Membulatkan jauh dari nol adalah bentuk pembulatan yang paling dikenal luas, sementara pembulatan ke terdekat bahkan adalah standar dalam operasi keuangan dan statistik. Ini sesuai dengan IEEE Standard 754, bagian 4. Saat digunakan dalam beberapa operasi pembulatan, pembulatan ke terdekat bahkan mengurangi kesalahan pembulatan yang disebabkan oleh pembulatan nilai titik tengah secara konsisten dalam satu arah. Dalam beberapa kasus, kesalahan pembulatan ini bisa signifikan.

Contoh berikut mengilustrasikan bias yang dapat dihasilkan dari nilai titik tengah yang dibulatkan secara konsisten dalam satu arah. Contoh menghitung rata-rata sebenarnya dari array Decimal nilai, lalu menghitung rata-rata saat nilai dalam array dibulatkan dengan menggunakan dua konvensi. Dalam contoh ini, rata-rata sebenarnya dan rata-rata yang menghasilkan saat membulatkan ke terdekat adalah sama. Namun, rata-rata yang menghasilkan ketika membulatkan jauh dari nol berbeda dengan .05 (atau sebesar 3,6%) dari rata-rata sebenarnya.

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

Secara default, Round metode ini menggunakan konvensi putaran ke konvensi genap terdekat. Tabel berikut mencantumkan kelebihan beban Round metode dan konvensi pembulatan yang digunakan masing-masing.

Overload	Konvensi pembulatan
Round(Decimal)	ToEven
Round(Double)	ToEven
Round(Decimal, Int32)	ToEven
Round(Double, Int32)	ToEven
Round(Decimal, MidpointRounding)	Ditentukan oleh `mode` parameter.
Round(Double, MidpointRounding)	Ditentukan oleh `mode` parameter
Round(Decimal, Int32, MidpointRounding)	Ditentukan oleh `mode` parameter
Round(Double, Int32, MidpointRounding)	Ditentukan oleh `mode` parameter

Pembulatan dan presisi

Untuk menentukan apakah operasi pembulatan melibatkan nilai titik tengah, Round metode mengalikan nilai asli yang akan dibulatkan sebesar 10ⁿ, di mana n adalah jumlah digit pecahan yang diinginkan dalam nilai pengembalian, lalu menentukan apakah bagian pecahan nilai yang tersisa lebih besar dari atau sama dengan .5. Ini adalah sedikit variasi pada pengujian untuk kesetaraan, dan seperti yang dibahas di bagian "Pengujian untuk Kesetaraan" dari Double topik referensi, pengujian untuk kesetaraan dengan nilai floating-point bermasalah karena masalah format floating-point dengan representasi biner dan presisi. Ini berarti bahwa setiap bagian pecahan dari angka yang sedikit kurang dari .5 (karena hilangnya presisi) tidak akan dibulatkan ke atas.

Contoh berikut mengilustrasikan masalah. Ini berulang kali menambahkan .1 ke 11.0 dan membulatkan hasil ke bilangan bulat terdekat. 11.5 harus membulatkan ke 12 menggunakan salah satu konvensi pembulatan titik tengah (ToEven atau AwayFromZero). Namun, seperti yang ditunjukkan oleh output dari contoh, itu tidak. Contohnya menggunakan string format numerik standar "R" untuk menampilkan presisi penuh nilai titik mengambang, dan menunjukkan bahwa nilai yang akan dibulatkan telah kehilangan presisi selama penambahan berulang, dan nilainya sebenarnya 11,4999999999999998. Karena .499999999999998 kurang dari .5, konvensi pembulatan titik tengah tidak diputar dan nilainya dibulatkan ke bawah. Seperti yang ditunjukkan oleh contoh, masalah ini tidak terjadi jika Anda menetapkan nilai konstanta 11,5 ke Double variabel.

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

Masalah presisi dalam nilai titik tengah pembulatan kemungkinan besar muncul dalam kondisi berikut:

Ketika nilai pecahan tidak dapat diekspresikan dengan tepat dalam format biner jenis floating-point.
Ketika nilai yang akan dibulatkan dihitung dari satu atau beberapa operasi floating-point.
Ketika nilai yang akan dibulatkan adalah Single bukan Double atau Decimal. Untuk informasi selengkapnya, lihat bagian berikutnya, Pembulatan dan nilai floating-point presisi tunggal.

Dalam kasus di mana kurangnya presisi dalam operasi pembulatan bermasalah, Anda dapat melakukan hal berikut:

Jika operasi pembulatan memanggil kelebihan beban yang membulatkan Double nilai, Anda dapat mengubah Double menjadi Decimal nilai dan memanggil kelebihan beban yang membulatkan Decimal nilai sebagai gantinya. Decimal Meskipun jenis data juga memiliki masalah representasi dan hilangnya presisi, masalah ini jauh lebih umum.

Tentukan algoritma pembulatan kustom yang melakukan pengujian "hampir sama" untuk menentukan apakah nilai yang akan dibulatkan dapat diterima mendekati nilai titik tengah. Contoh berikut mendefinisikan RoundApproximate metode yang memeriksa apakah nilai pecahan cukup dekat dengan nilai titik tengah untuk tunduk pada pembulatan titik tengah. Seperti yang ditunjukkan oleh output dari contoh, ini memperbaiki masalah pembulatan yang ditunjukkan pada contoh sebelumnya.

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

Pembulatan dan nilai floating-point presisi tunggal

Metode ini Round mencakup kelebihan beban yang menerima argumen jenis Decimal dan Double. Tidak ada metode yang membulatkan nilai jenis Single. Jika Anda meneruskan Single nilai ke salah satu kelebihan beban Round metode, nilai tersebut ditransmisikan (dalam C#) atau dikonversi (dalam Visual Basic) ke Double, dan kelebihan beban yang Double sesuai Round dengan parameter dipanggil. Meskipun ini adalah konversi yang melebar, ini sering melibatkan hilangnya presisi, seperti yang diilustrasikan contoh berikut. Single Ketika nilai 16,325 diteruskan ke Round metode dan dibulatkan ke dua tempat desimal menggunakan pembulatan ke konvensi terdekat, hasilnya adalah 16,33 dan bukan hasil yang diharapkan 16,32.

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

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

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

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

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

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

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

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

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

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

Hasil yang tidak terduga ini disebabkan oleh hilangnya presisi dalam konversi Single nilai menjadi Double. Karena nilai yang Double dihasilkan 16,325000762939453 bukan nilai titik tengah dan lebih besar dari 16,325, nilai selalu dibulatkan ke atas.

Dalam banyak kasus, seperti yang digambarkan contoh, hilangnya presisi dapat diminimalkan atau dihilangkan dengan mentransmisikan atau mengonversi Single nilai menjadi Decimal. Perhatikan bahwa, karena ini adalah konversi yang mempersempit, diperlukan penggunaan operator transmisi atau memanggil metode konversi.

Round(Double, Int32, MidpointRounding)

Sumber:: Math.cs

Sumber:: Math.cs

Sumber:: Math.cs

Membulatkan nilai titik mengambang presisi ganda ke jumlah digit pecahan tertentu menggunakan konvensi pembulatan yang ditentukan.

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

Parameter

value: Double

Angka floating-point presisi ganda yang akan dibulatkan.

digits: Int32

Jumlah digit pecahan dalam nilai yang dikembalikan.

mode: MidpointRounding

Salah satu nilai enumerasi yang menentukan strategi pembulatan mana yang akan digunakan.

Mengembalikan

Double

Angka yang memiliki digits digit pecahan yang value dibulatkan ke. Jika value memiliki lebih sedikit digit pecahan daripada digits, value dikembalikan tidak berubah.

Pengecualian

ArgumentOutOfRangeException

digits kurang dari 0 atau lebih besar dari 15.

ArgumentException

mode bukan nilai yang valid dari MidpointRounding.

Keterangan

Nilai digits argumen dapat berkisar antara 0 hingga 15. Jumlah maksimum digit integral dan pecahan yang didukung oleh Double jenis adalah 15.

Lihat Nilai titik tengah dan konvensi pembulatan untuk informasi tentang pembulatan angka dengan nilai titik tengah.

Penting

Saat membulatkan nilai titik tengah, algoritma pembulatan melakukan uji kesetaraan. Karena masalah representasi biner dan presisi dalam format floating-point, nilai yang dikembalikan oleh metode dapat tidak terduga. Untuk informasi selengkapnya, lihat Pembulatan dan presisi.

Jika nilai value argumen adalah Double.NaN, metode akan mengembalikan Double.NaN. Jika value adalah Double.PositiveInfinity atau Double.NegativeInfinity, metode mengembalikan Double.PositiveInfinity atau Double.NegativeInfinity, masing-masing.

Contoh

Contoh berikut menunjukkan cara menggunakan Round(Double, Int32, MidpointRounding) metode dengan MidpointRounding enumerasi.


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

Catatan Bagi Pemanggil

Karena hilangnya presisi yang dapat dihasilkan dari mewakili nilai desimal sebagai angka floating-point atau melakukan operasi aritmatika pada nilai floating-point, dalam beberapa kasus Round(Double, Int32, MidpointRounding) metode mungkin tidak tampak membulatkan nilai titik tengah seperti yang ditentukan oleh mode parameter. Ini diilustrasikan dalam contoh berikut, di mana 2,135 dibulatkan ke 2,13 alih-alih 2,14. Ini terjadi karena secara internal metode mengalikan value 10^digit, dan operasi perkalian dalam hal ini menderita kehilangan presisi.

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

Lihat juga

Berlaku untuk

Round(Decimal, Int32, MidpointRounding)

Sumber:: Math.cs

Sumber:: Math.cs

Sumber:: Math.cs

Membulatkan nilai desimal ke jumlah digit pecahan tertentu menggunakan konvensi pembulatan yang ditentukan.

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

Parameter

d: Decimal

Angka desimal yang akan dibulatkan.

decimals: Int32

Jumlah tempat desimal dalam nilai yang dikembalikan.

mode: MidpointRounding

Salah satu nilai enumerasi yang menentukan strategi pembulatan mana yang akan digunakan.

Mengembalikan

Decimal

Angka dengan decimals digit pecahan yang d dibulatkan ke. Jika d memiliki lebih sedikit digit pecahan daripada decimals, d dikembalikan tidak berubah.

Pengecualian

ArgumentOutOfRangeException

decimals kurang dari 0 atau lebih besar dari 28.

ArgumentException

mode bukan nilai yang valid dari MidpointRounding.

OverflowException

Hasilnya berada di luar rentang Decimal.

Keterangan

Lihat Nilai titik tengah dan konvensi pembulatan untuk informasi tentang pembulatan angka dengan nilai titik tengah.

Penting

Nilai decimals argumen dapat berkisar antara 0 hingga 28.

Contoh

Contoh berikut menunjukkan cara menggunakan Round metode dengan MidpointRounding enumerasi.

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

Lihat juga

Berlaku untuk

Round(Double, MidpointRounding)

Sumber:: Math.cs

Sumber:: Math.cs

Sumber:: Math.cs

Membulatkan nilai titik mengambang presisi ganda ke bilangan bulat menggunakan konvensi pembulatan yang ditentukan.

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

Parameter

value: Double

Angka floating-point presisi ganda yang akan dibulatkan.

mode: MidpointRounding

Salah satu nilai enumerasi yang menentukan strategi pembulatan mana yang akan digunakan.

Mengembalikan

Double

Bilangan bulat yang value dibulatkan ke. Metode ini mengembalikan Double bukan jenis integral.

Pengecualian

ArgumentException

mode bukan nilai yang valid dari MidpointRounding.

Keterangan

Lihat Nilai titik tengah dan konvensi pembulatan untuk informasi tentang pembulatan angka dengan nilai titik tengah.

Penting

Contoh

Contoh berikut menampilkan nilai yang Round(Double, MidpointRounding) dikembalikan oleh metode dengan nilai yang berbeda mode .

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

Catatan Bagi Pemanggil

Karena hilangnya presisi yang dapat diakibatkan dari mewakili nilai desimal sebagai angka floating-point atau melakukan operasi aritmatika pada nilai floating-point, dalam beberapa kasus Round(Double, MidpointRounding) metode mungkin tidak tampak membulatkan nilai titik tengah ke bilangan bulat bahkan terdekat. Dalam contoh berikut, karena nilai floating-point .1 tidak memiliki representasi biner terbatas, panggilan pertama ke Round(Double) metode dengan nilai 11,5 mengembalikan 11, bukan 12.

using System;

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

      Console.WriteLine();

      value = 11.5;
      RoundValueAndAdd(value);
   }

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

open System

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

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

printfn ""

value <- 11.5
roundValueAndAdd value
|> ignore

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

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

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

Lihat juga

Berlaku untuk

Round(Double, Int32)

Sumber:: Math.cs

Sumber:: Math.cs

Sumber:: Math.cs

Membulatkan nilai titik mengambang presisi ganda ke jumlah digit pecahan tertentu, dan membulatkan nilai titik tengah ke angka genap terdekat.

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

Parameter

value: Double

Angka floating-point presisi ganda yang akan dibulatkan.

digits: Int32

Jumlah digit pecahan dalam nilai yang dikembalikan.

Mengembalikan

Double

Angka terdekat value dengan yang berisi sejumlah digit pecahan sama dengan digits.

Pengecualian

ArgumentOutOfRangeException

digits kurang dari 0 atau lebih besar dari 15.

Keterangan

Nilai digits argumen dapat berkisar antara 0 hingga 15. Jumlah maksimum digit integral dan pecahan yang didukung oleh Double jenis adalah 15.

Metode ini menggunakan konvensi pembulatan default .MidpointRounding.ToEven Lihat Nilai titik tengah dan konvensi pembulatan untuk informasi tentang pembulatan angka dengan nilai titik tengah.

Penting

Contoh

Contoh berikut membulatkan nilai ganda dengan dua digit pecahan menjadi ganda yang memiliki satu digit pecahan.

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

Catatan Bagi Pemanggil

Karena hilangnya presisi yang dapat disebabkan oleh mewakili nilai desimal sebagai angka floating-point atau melakukan operasi aritmatika pada nilai floating-point, dalam beberapa kasus Round(Double, Int32) metode mungkin tidak tampak membulatkan nilai titik tengah ke nilai genap terdekat dalam digits posisi desimal. Ini diilustrasikan dalam contoh berikut, di mana 2,135 dibulatkan ke 2,13 alih-alih 2,14. Ini terjadi karena secara internal metode mengalikan value 10^digit, dan operasi perkalian dalam hal ini menderita kehilangan presisi.

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

Lihat juga

Berlaku untuk

Round(Decimal, Int32)

Sumber:: Math.cs

Sumber:: Math.cs

Sumber:: Math.cs

Membulatkan nilai desimal ke jumlah digit pecahan tertentu, dan membulatkan nilai titik tengah ke angka genap terdekat.

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

Parameter

d: Decimal

Angka desimal yang akan dibulatkan.

decimals: Int32

Jumlah tempat desimal dalam nilai yang dikembalikan.

Mengembalikan

Decimal

Angka terdekat dengan d yang berisi sejumlah digit pecahan sama dengan decimals.

Pengecualian

ArgumentOutOfRangeException

decimals kurang dari 0 atau lebih besar dari 28.

OverflowException

Hasilnya berada di luar rentang Decimal.

Keterangan

Nilai decimals argumen dapat berkisar dari 0 hingga 28.

Metode ini menggunakan konvensi pembulatan default .MidpointRounding.ToEven Untuk informasi tentang pembulatan angka dengan nilai titik tengah, lihat Nilai titik tengah dan konvensi pembulatan.

Penting

Saat membulatkan nilai titik tengah, algoritma pembulatan melakukan pengujian kesetaraan. Karena masalah representasi biner dan presisi dalam format floating-point, nilai yang dikembalikan oleh metode dapat tidak terduga. Untuk informasi selengkapnya, lihat Pembulatan dan presisi.

Contoh

Contoh berikut membulatkan nilai desimal dengan dua digit pecahan ke nilai yang memiliki satu digit pecahan.

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

Lihat juga

Berlaku untuk

Round(Double)

Sumber:: Math.cs

Sumber:: Math.cs

Sumber:: Math.cs

Membulatkan nilai floating-point presisi ganda ke nilai integral terdekat, dan membulatkan nilai titik tengah ke angka genap terdekat.

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

Parameter

a: Double

Angka titik mengambang presisi ganda yang akan dibulatkan.

Mengembalikan

Double

Bilangan bulat terdekat a. Jika komponen pecahan a setengah antara dua bilangan bulat, salah satunya genap dan ganjil lainnya, maka angka genap dikembalikan. Perhatikan bahwa metode ini mengembalikan Double bukan jenis integral.

Keterangan

Metode ini menggunakan konvensi pembulatan default .MidpointRounding.ToEven Untuk informasi tentang pembulatan angka dengan nilai titik tengah, lihat Nilai titik tengah dan konvensi pembulatan.

Penting

Jika nilai a argumen adalah Double.NaN, metode mengembalikan Double.NaN. Jika a adalah Double.PositiveInfinity atau Double.NegativeInfinity, metode mengembalikan Double.PositiveInfinity atau Double.NegativeInfinity, masing-masing.

Dimulai dengan Visual Basic 15.8, performa konversi Double-to-integer dioptimalkan jika Anda meneruskan nilai yang dikembalikan oleh Round metode ke salah satu fungsi konversi integral, atau jika nilai Ganda yang dikembalikan oleh Round secara otomatis dikonversi ke bilangan bulat dengan Opsi Ketat diatur ke Nonaktif. Pengoptimalan ini memungkinkan kode berjalan lebih cepat -- hingga dua kali lebih cepat untuk kode yang melakukan sejumlah besar konversi ke jenis bilangan bulat. Contoh berikut mengilustrasikan konversi yang dioptimalkan tersebut:

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

Contoh

Contoh berikut menunjukkan pembulatan ke nilai bilangan bulat terdekat.

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

Catatan Bagi Pemanggil

Karena hilangnya presisi yang dapat dihasilkan dari mewakili nilai desimal sebagai angka floating-point atau melakukan operasi aritmatika pada nilai floating-point, dalam beberapa kasus Round(Double) metode mungkin tidak muncul untuk membulatkan nilai titik tengah ke bilangan bulat genap terdekat. Dalam contoh berikut, karena nilai floating-point .1 tidak memiliki representasi biner terbatas, panggilan pertama ke Round(Double) metode dengan nilai 11,5 mengembalikan 11, bukan 12.

using System;

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

      Console.WriteLine();

      value = 11.5;
      RoundValueAndAdd(value);
   }

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

open System

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

let mutable value = 11.1

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

printfn ""

value <- 11.5
roundValueAndAdd value
|> ignore

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

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

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

Lihat juga

Berlaku untuk

Round(Decimal)

Sumber:: Math.cs

Sumber:: Math.cs

Sumber:: Math.cs

Membulatkan nilai desimal ke nilai integral terdekat, dan membulatkan nilai titik tengah ke angka genap terdekat.

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

Parameter

d: Decimal

Angka desimal yang akan dibulatkan.

Mengembalikan

Decimal

Bilangan bulat terdekat dengan d parameter . Jika komponen pecahan d setengah di antara dua bilangan bulat, salah satunya genap dan ganjil lainnya, angka genap dikembalikan. Perhatikan bahwa metode ini mengembalikan Decimal bukan jenis integral.

Pengecualian

OverflowException

Hasilnya berada di luar rentang Decimal.

Contoh

Contoh berikut menunjukkan Round(Decimal) metode . Nilai Decimal 4,5 dibulatkan ke 4 daripada 5, karena kelebihan beban ini menggunakan konvensi default ToEven .

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

open System

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

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

Keterangan

Metode ini menggunakan konvensi pembulatan default .MidpointRounding.ToEven Untuk informasi tentang pembulatan angka dengan nilai titik tengah, lihat Nilai titik tengah dan konvensi pembulatan.

Penting

Lihat juga

Berlaku untuk

Round(Decimal, MidpointRounding)

Sumber:: Math.cs

Sumber:: Math.cs

Sumber:: Math.cs

Membulatkan nilai desimal bilangan bulat menggunakan konvensi pembulatan yang ditentukan.

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

Parameter

d: Decimal

Angka desimal yang akan dibulatkan.

mode: MidpointRounding

Salah satu nilai enumerasi yang menentukan strategi pembulatan mana yang akan digunakan.

Mengembalikan

Decimal

Bilangan bulat yang d dibulatkan ke. Metode ini mengembalikan alih-alih Decimal jenis integral.

Pengecualian

ArgumentException

mode bukan nilai yang valid dari MidpointRounding.

OverflowException

Hasilnya berada di luar rentang Decimal.

Keterangan

Untuk informasi tentang pembulatan angka dengan nilai titik tengah, lihat Nilai titik tengah dan konvensi pembulatan.

Penting

Contoh

Contoh berikut menampilkan nilai yang dikembalikan oleh Round(Decimal, MidpointRounding) metode dengan nilai yang berbeda mode .

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

Lihat juga

Berlaku untuk

Bagikan melalui

Math.Round Metode

Definisi

Overload

Contoh

Keterangan

Metode mana yang saya panggil?

Nilai titik tengah dan konvensi pembulatan

Pembulatan dan presisi

Pembulatan dan nilai floating-point presisi tunggal

Round(Double, Int32, MidpointRounding)

Parameter

Mengembalikan

Pengecualian

Keterangan

Contoh

Catatan Bagi Pemanggil

Lihat juga

Berlaku untuk

Round(Decimal, Int32, MidpointRounding)

Parameter

Mengembalikan

Pengecualian

Keterangan

Contoh

Lihat juga

Berlaku untuk

Round(Double, MidpointRounding)

Parameter

Mengembalikan

Pengecualian

Keterangan

Contoh

Catatan Bagi Pemanggil

Lihat juga

Berlaku untuk

Round(Double, Int32)

Parameter

Mengembalikan

Pengecualian

Keterangan

Contoh

Catatan Bagi Pemanggil

Lihat juga

Berlaku untuk

Round(Decimal, Int32)

Parameter

Mengembalikan

Pengecualian

Keterangan

Contoh

Lihat juga

Berlaku untuk

Round(Double)

Parameter

Mengembalikan

Keterangan

Contoh

Catatan Bagi Pemanggil

Lihat juga

Berlaku untuk

Round(Decimal)

Parameter

Mengembalikan

Pengecualian

Contoh

Keterangan

Lihat juga

Berlaku untuk

Round(Decimal, MidpointRounding)

Parameter

Mengembalikan

Pengecualian

Keterangan

Contoh

Lihat juga

Berlaku untuk

Sumber Daya Tambahan: