Decimal.Round Metoda

Definice

Zaokrouhlí hodnotu na nejbližší celé číslo nebo na zadaný počet desetinných míst.Rounds a value to the nearest integer or specified number of decimal places.

Přetížení

Round(Decimal)

Zaokrouhlí desítkovou hodnotu na nejbližší celé číslo.Rounds a decimal value to the nearest integer.

Round(Decimal, Int32)

Zaokrouhlí Decimal hodnotu na zadaný počet desetinných míst.Rounds a Decimal value to a specified number of decimal places.

Round(Decimal, MidpointRounding)

Zaokrouhlí desítkovou hodnotu na nejbližší celé číslo.Rounds a decimal value to the nearest integer. Parametr určuje, jak se má hodnota zaokrouhlit, pokud je uprostřed mezi dvěma dalšími čísly.A parameter specifies how to round the value if it is midway between two other numbers.

Round(Decimal, Int32, MidpointRounding)

Zaokrouhlí desítkovou hodnotu na zadanou přesnost.Rounds a decimal value to a specified precision. Parametr určuje, jak se má hodnota zaokrouhlit, pokud je uprostřed mezi dvěma dalšími čísly.A parameter specifies how to round the value if it is midway between two other numbers.

Round(Decimal)

Zaokrouhlí desítkovou hodnotu na nejbližší celé číslo.Rounds a decimal value to the nearest integer.

public:
 static System::Decimal Round(System::Decimal d);
public static decimal Round (decimal d);
static member Round : decimal -> decimal
Public Shared Function Round (d As Decimal) As Decimal

Parametry

d
Decimal

Desetinné číslo, které má být zaokrouhleno.A decimal number to round.

Návraty

Celé číslo, které je nejblíže parametru d.The integer that is nearest to the d parameter. Pokud je d uprostřed mezi dvěma celými čísly, jedna z nich je sudá a druhá lichá, je vráceno sudé číslo.If d is halfway between two integers, one of which is even and the other odd, the even number is returned.

Výjimky

Výsledek je mimo rozsah hodnoty Decimal.The result is outside the range of a Decimal value.

Příklady

Následující příklad zaokrouhlí rozsah hodnot Decimal mezi 100 a 102 na nejbližší celé číslo.The following example rounds a range of Decimal values between 100 and 102 to the nearest integer. Vzhledem k tomu, že metoda používá zaokrouhlování bank, počítejte s tím, že 100,5 se zaokrouhlí na 100 a 101,5 se zaokrouhlí na 102.Because the method uses banker's rounding, note that 100.5 rounds to 100 and 101.5 rounds to 102.

using System;

public class Example
{
   public static void Main()
   {
      for (decimal value = 100m; value <= 102m; value += .1m)
         Console.WriteLine("{0} --> {1}", value, Decimal.Round(value));
   }
}
// The example displays the following output:
//     100 --> 100
//     100.1 --> 100
//     100.2 --> 100
//     100.3 --> 100
//     100.4 --> 100
//     100.5 --> 100
//     100.6 --> 101
//     100.7 --> 101
//     100.8 --> 101
//     100.9 --> 101
//     101.0 --> 101
//     101.1 --> 101
//     101.2 --> 101
//     101.3 --> 101
//     101.4 --> 101
//     101.5 --> 102
//     101.6 --> 102
//     101.7 --> 102
//     101.8 --> 102
//     101.9 --> 102
//     102.0 --> 102
Module Example
   Public Sub Main()
      For value As Decimal = 100d To 102d Step .1d
         Console.WriteLine("{0} --> {1}", value, Decimal.Round(value))
      Next
   End Sub
End Module
' The example displays the following output:
'     100 --> 100
'     100.1 --> 100
'     100.2 --> 100
'     100.3 --> 100
'     100.4 --> 100
'     100.5 --> 100
'     100.6 --> 101
'     100.7 --> 101
'     100.8 --> 101
'     100.9 --> 101
'     101.0 --> 101
'     101.1 --> 101
'     101.2 --> 101
'     101.3 --> 101
'     101.4 --> 101
'     101.5 --> 102
'     101.6 --> 102
'     101.7 --> 102
'     101.8 --> 102
'     101.9 --> 102
'     102.0 --> 102

Poznámky

Chování této metody se řídí standardem IEEE 754, část 4.The behavior of this method follows IEEE Standard 754, section 4. Tento druh zaokrouhlování se někdy označuje jako kulatá polovina pro i zaokrouhlování bank.This kind of rounding is sometimes called round half to even or banker's rounding. Minimalizuje chyby zaokrouhlení, které jsou výsledkem konzistentního zaokrouhlování střední hodnoty v jednom směru.It minimizes rounding errors that result from consistently rounding a midpoint value in a single direction. Je ekvivalentní volání metody Round(Decimal, MidpointRounding) s argumentem mode MidpointRounding.ToEven.It is equivalent to calling the Round(Decimal, MidpointRounding) method with a mode argument of MidpointRounding.ToEven.

Viz také

Round(Decimal, Int32)

Zaokrouhlí Decimal hodnotu na zadaný počet desetinných míst.Rounds a Decimal value to a specified number of decimal places.

public:
 static System::Decimal Round(System::Decimal d, int decimals);
public static decimal Round (decimal d, int decimals);
static member Round : decimal * int -> decimal
Public Shared Function Round (d As Decimal, decimals As Integer) As Decimal

Parametry

d
Decimal

Desetinné číslo, které má být zaokrouhleno.A decimal number to round.

decimals
Int32

Hodnota od 0 do 28, která určuje počet desetinných míst, která se mají zaokrouhlit.A value from 0 to 28 that specifies the number of decimal places to round to.

Návraty

Desítkové číslo ekvivalentní d zaokrouhlené na decimals počet desetinných míst.The decimal number equivalent to d rounded to decimals number of decimal places.

Výjimky

decimals není hodnota od 0 do 28.decimals is not a value from 0 to 28.

Příklady

Následující příklad zaokrouhlí několik Decimal hodnot na zadaný počet desetinných míst pomocí metody Round.The following example rounds several Decimal values to a specified number of decimal places using the Round method.

using System;

class Example
{
   public static void Main()
   {
      // Define a set of Decimal values.
      decimal[] values = { 1.45m, 1.55m, 123.456789m, 123.456789m, 
                           123.456789m, -123.456m, 
                           new Decimal(1230000000, 0, 0, true, 7 ),
                           new Decimal(1230000000, 0, 0, true, 7 ), 
                           -9999999999.9999999999m, 
                           -9999999999.9999999999m };
      // Define a set of integers to for decimals argument.
      int[] decimals = { 1, 1, 4, 6, 8, 0, 3, 11, 9, 10};
      
      Console.WriteLine("{0,26}{1,8}{2,26}", 
                        "Argument", "Digits", "Result" );
      Console.WriteLine("{0,26}{1,8}{2,26}", 
                        "--------", "------", "------" );
      for (int ctr = 0; ctr < values.Length; ctr++)
        Console.WriteLine("{0,26}{1,8}{2,26}", 
                          values[ctr], decimals[ctr], 
                          Decimal.Round(values[ctr], decimals[ctr]));
    }
}
// The example displays the following output:
//                   Argument  Digits                    Result
//                   --------  ------                    ------
//                       1.45       1                       1.4
//                       1.55       1                       1.6
//                 123.456789       4                  123.4568
//                 123.456789       6                123.456789
//                 123.456789       8                123.456789
//                   -123.456       0                      -123
//               -123.0000000       3                  -123.000
//               -123.0000000      11              -123.0000000
//     -9999999999.9999999999       9    -10000000000.000000000
//     -9999999999.9999999999      10    -9999999999.9999999999
Public Module Example
   Public Sub Main()
      ' Define a set of Decimal values.
      Dim values() As Decimal = { 1.45d, 1.55d, 123.456789d, 123.456789d, 
                                  123.456789d, -123.456d, 
                                  New Decimal(1230000000, 0, 0, true, 7 ),
                                  New Decimal(1230000000, 0, 0, true, 7 ), 
                                  -9999999999.9999999999d, 
                                  -9999999999.9999999999d }
      ' Define a set of integers to for decimals argument.
      Dim decimals() As Integer = { 1, 1, 4, 6, 8, 0, 3, 11, 9, 10}
      
      Console.WriteLine("{0,26}{1,8}{2,26}", 
                        "Argument", "Digits", "Result" )
      Console.WriteLine("{0,26}{1,8}{2,26}", 
                        "--------", "------", "------" )
      For ctr As Integer = 0 To values.Length - 1
        Console.WriteLine("{0,26}{1,8}{2,26}", 
                          values(ctr), decimals(ctr), 
                          Decimal.Round(values(ctr), decimals(ctr)))
      Next
   End Sub
End Module
' The example displays the following output:
'                   Argument  Digits                    Result
'                   --------  ------                    ------
'                       1.45       1                       1.4
'                       1.55       1                       1.6
'                 123.456789       4                  123.4568
'                 123.456789       6                123.456789
'                 123.456789       8                123.456789
'                   -123.456       0                      -123
'               -123.0000000       3                  -123.000
'               -123.0000000      11              -123.0000000
'     -9999999999.9999999999       9    -10000000000.000000000
'     -9999999999.9999999999      10    -9999999999.9999999999

Poznámky

Tato metoda je ekvivalentní volání metody Round(Decimal, Int32, MidpointRounding) s argumentem mode MidpointRounding.ToEven. Když je d přesně uprostřed mezi dvěma zaoblenými hodnotami, výsledkem je zaoblená hodnota, která má sudé číslo na zcela pravou pozici.This method is equivalent to calling the Round(Decimal, Int32, MidpointRounding) method with a mode argument of MidpointRounding.ToEven.When d is exactly halfway between two rounded values, the result is the rounded value that has an even digit in the far right decimal position. Například když se zaokrouhlí na dvě desetinná místa, hodnota 2,345 se naplní 2,34 a hodnota 2,355 se bude 2,36.For example, when rounded to two decimals, the value 2.345 becomes 2.34 and the value 2.355 becomes 2.36. Tento proces se označuje jako zaokrouhlení směrem k i Zaokrouhlení bank.This process is known as rounding toward even, or banker's rounding. Minimalizuje chyby zaokrouhlení, které jsou výsledkem konzistentního zaokrouhlování střední hodnoty v jednom směru.It minimizes rounding errors that result from consistently rounding a midpoint value in a single direction.

Viz také

Round(Decimal, MidpointRounding)

Zaokrouhlí desítkovou hodnotu na nejbližší celé číslo.Rounds a decimal value to the nearest integer. Parametr určuje, jak se má hodnota zaokrouhlit, pokud je uprostřed mezi dvěma dalšími čísly.A parameter specifies how to round the value if it is midway between two other numbers.

public:
 static System::Decimal Round(System::Decimal d, MidpointRounding mode);
public static decimal Round (decimal d, MidpointRounding mode);
static member Round : decimal * MidpointRounding -> decimal
Public Shared Function Round (d As Decimal, mode As MidpointRounding) As Decimal

Parametry

d
Decimal

Desetinné číslo, které má být zaokrouhleno.A decimal number to round.

mode
MidpointRounding

Hodnota, která určuje, jak se má zaokrouhlit d, pokud je uprostřed mezi dvěma dalšími čísly.A value that specifies how to round d if it is midway between two other numbers.

Návraty

Celé číslo, které je nejblíže parametru d.The integer that is nearest to the d parameter. Pokud je d uprostřed mezi dvěma čísly, jedna z nich je sudá a druhá lichá, mode parametr určuje, který ze dvou čísel je vrácen.If d is halfway between two numbers, one of which is even and the other odd, the mode parameter determines which of the two numbers is returned.

Výjimky

mode není MidpointRounding hodnota.mode is not a MidpointRounding value.

Výsledek je mimo rozsah objektu Decimal.The result is outside the range of a Decimal object.

Příklady

Následující příklad zobrazí hodnoty vrácené metodou Round(Decimal), Round(Decimal, MidpointRounding) metoda s modem argumentem ToEvena metodou Round(Decimal, MidpointRounding) s argumentem mode AwayFromZero.The following example displays values returned by the Round(Decimal) method, the Round(Decimal, MidpointRounding) method with a mode argument of ToEven, and the Round(Decimal, MidpointRounding) method with a mode argument of AwayFromZero.

Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15}", "Value", "Default", 
                  "ToEven", "AwayFromZero");
for (decimal value = 12.0m; value <= 13.0m; value += 0.1m)
   Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15}",
                     value, Math.Round(value), 
                     Math.Round(value, MidpointRounding.ToEven),
                     Math.Round(value, MidpointRounding.AwayFromZero));
// The example displays the following output:
//       Value      Default    ToEven     AwayFromZero
//       12         12         12         12
//       12.1       12         12         12
//       12.2       12         12         12
//       12.3       12         12         12
//       12.4       12         12         12
//       12.5       12         12         13
//       12.6       13         13         13
//       12.7       13         13         13
//       12.8       13         13         13
//       12.9       13         13         13
//       13.0       13         13         13
Module Example
   Public Sub Main()
      Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15}", "Value", "Default", 
                        "ToEven", "AwayFromZero")
      For value As Decimal = 12.0d To 13.0d Step .1d
         Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15}",
                           value, Math.Round(value), 
                           Math.Round(value, MidpointRounding.ToEven),
                           Math.Round(value, MidpointRounding.AwayFromZero))
      Next
   End Sub
End Module
' The example displays the following output:
'       Value      Default    ToEven     AwayFromZero
'       12         12         12         12
'       12.1       12         12         12
'       12.2       12         12         12
'       12.3       12         12         12
'       12.4       12         12         12
'       12.5       12         12         13
'       12.6       13         13         13
'       12.7       13         13         13
'       12.8       13         13         13
'       12.9       13         13         13
'       13.0       13         13         13

Poznámky

V hodnotě středního bodu je hodnota za nejmenší důležitou číslicí ve výsledku přesně poloviční způsob mezi dvěma čísly.In a midpoint value, the value after the least significant digit in the result is precisely half way between two numbers. Například hodnota 7,5 je střední hodnota, pokud má být zaokrouhlena na celé číslo.For example, 7.5 is a midpoint value if it is to be rounded to an integer. U hodnot středního bodu nelze nejbližší hodnotu snadno identifikovat bez konvence zaokrouhlení, která je určena argumentem mode.For midpoint values, the nearest value can't be easily identified without a rounding convention, which is specified by the mode argument. Metoda Round podporuje dvě konvence zaokrouhlení pro zpracování hodnot středního bodu.The Round method supports two rounding conventions for handling midpoint values.

Zaokrouhlení směrem od nulyRounding away from zero.
Střední hodnoty se zaokrouhlují na další číslo od nuly.Midpoint values are rounded to the next number away from zero. Například 3,5 zaokrouhlí na 4, 4,5 zaokrouhlí na 5,-3,5 zaokrouhlí na-4 a-4,5 zaokrouhlí na-5.For example, 3.5 rounds to 4, 4.5 rounds to 5, -3.5 rounds to -4, and -4.5 rounds to -5. Tato forma zaokrouhlení je reprezentována MidpointRounding.AwayFromZerom členem výčtu.This form of rounding is represented by the MidpointRounding.AwayFromZero enumeration member.

Zaokrouhlení směrem od nuly je nejrozšířenějším známým formulářem zaokrouhlení.Rounding away from zero is the most widely known form of rounding.

Zaokrouhlování na sudé nebo zaokrouhlení bankRounding to even, or banker's rounding
Střední hodnoty jsou zaokrouhleny na nejbližší sudé číslo.Midpoint values are rounded to the nearest even number. Například 3,5 a 4,5 se zaokrouhlí na 4 a na číslo-3,5 a-4,5 na-4.For example, both 3.5 and 4.5 round to 4, and both -3.5 and -4.5 round to -4. Tato forma zaokrouhlení je reprezentována MidpointRounding.ToEvenm členem výčtu.This form of rounding is represented by the MidpointRounding.ToEven enumeration member.

Zaokrouhlení na nejbližší je standardní forma zaokrouhlení, která se používá ve finančních a statistických operacích.Rounding to nearest is the standard form of rounding used in financial and statistical operations. V souladu se standardem IEEE 754, oddílem 4.It conforms to IEEE Standard 754, section 4. Při použití ve více operacích zaokrouhlení zkracuje chybu zaokrouhlování, která je způsobena konzistentním zaokrouhlováním středních hodnot v jednom směru.When used in multiple rounding operations, it reduces the rounding error that is caused by consistently rounding midpoint values in a single direction. V některých případech může být tato chyba zaokrouhlení významná.In some cases, this rounding error can be significant.

Viz také

Round(Decimal, Int32, MidpointRounding)

Zaokrouhlí desítkovou hodnotu na zadanou přesnost.Rounds a decimal value to a specified precision. Parametr určuje, jak se má hodnota zaokrouhlit, pokud je uprostřed mezi dvěma dalšími čísly.A parameter specifies how to round the value if it is midway between two other numbers.

public:
 static System::Decimal Round(System::Decimal d, int decimals, MidpointRounding mode);
public static decimal Round (decimal d, int decimals, MidpointRounding mode);
static member Round : decimal * int * MidpointRounding -> decimal
Public Shared Function Round (d As Decimal, decimals As Integer, mode As MidpointRounding) As Decimal

Parametry

d
Decimal

Desetinné číslo, které má být zaokrouhleno.A decimal number to round.

decimals
Int32

Počet významných desetinných míst (přesnost) v návratové hodnotě.The number of significant decimal places (precision) in the return value.

mode
MidpointRounding

Hodnota, která určuje, jak se má zaokrouhlit d, pokud je uprostřed mezi dvěma dalšími čísly.A value that specifies how to round d if it is midway between two other numbers.

Návraty

Číslo, které je nejblíže parametru d, s přesností rovnou parametru decimals.The number that is nearest to the d parameter with a precision equal to the decimals parameter. Pokud je d uprostřed mezi dvěma čísly, jedna z nich je sudá a druhá lichá, mode parametr určuje, který ze dvou čísel je vrácen.If d is halfway between two numbers, one of which is even and the other odd, the mode parameter determines which of the two numbers is returned. Pokud je přesnost d menší než decimals, d se vrátí beze změny.If the precision of d is less than decimals, d is returned unchanged.

Výjimky

decimals je menší než 0 nebo větší než 28.decimals is less than 0 or greater than 28.

mode není MidpointRounding hodnota.mode is not a MidpointRounding value.

Výsledek je mimo rozsah objektu Decimal.The result is outside the range of a Decimal object.

Příklady

Následující příklad ukazuje, jak použít metodu Round(Decimal, Int32, MidpointRounding) s výčtem MidpointRounding.The following example demonstrates how to use the Round(Decimal, Int32, MidpointRounding) method with the MidpointRounding enumeration.

// This example demonstrates the Math.Round() method in conjunction 
// with the MidpointRounding enumeration.
using namespace System;

void main()
{
    Decimal result = (Decimal) 0.0;
    Decimal posValue = (Decimal) 3.45;
    Decimal negValue = (Decimal) -3.45;

    // By default, round a positive and a negative value to the nearest
    // even number. The precision of the result is 1 decimal place.
    result = 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 to the nearest even number, then to the
    // nearest number away from zero. 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);
    Console::WriteLine();

    // Round a negative value to the nearest even number, then to the
    // nearest number away from zero. 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);
    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)

*/
decimal result = 0.0m;
decimal posValue =  3.45m;
decimal negValue = -3.45m;

// By default, round a positive and a negative value to the nearest even number. 
// The precision of the result is 1 decimal place.

result = 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 to the nearest even number, then to the nearest number away from zero. 
// 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);
Console.WriteLine();

// Round a negative value to the nearest even number, then to the nearest number away from zero. 
// 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);
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)

*/
' This example demonstrates the Math.Round() method in conjunction 
' with the MidpointRounding enumeration.
Class Sample
    Public Shared Sub Main() 
        Dim result As Decimal = 0D
        Dim posValue As Decimal = 3.45D
        Dim negValue As Decimal = -3.45D
        
        ' By default, round a positive and a negative value to the nearest even number. 
        ' The precision of the result is 1 decimal place.
        result = 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 to the nearest even number, then to the nearest number 
        ' away from zero. 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)
        Console.WriteLine()
        
        ' Round a negative value to the nearest even number, then to the nearest number 
        ' away from zero. 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)
        Console.WriteLine()
    
    End Sub
End Class
'
'This code example produces the following results:
'
' 3.4 = Math.Round( 3.45, 1)
'-3.4 = Math.Round(-3.45, 1)
'
' 3.4 = Math.Round( 3.45, 1, MidpointRounding.ToEven)
' 3.5 = Math.Round( 3.45, 1, MidpointRounding.AwayFromZero)
'
'-3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
'-3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)
'

Poznámky

Parametr decimals určuje počet významných desetinných míst v návratové hodnotě a rozsahů od 0 do 28.The decimals parameter specifies the number of significant decimal places in the return value and ranges from 0 to 28. Pokud je decimals nula, vrátí se celé číslo.If decimals is zero, an integer is returned.

V hodnotě středního bodu je hodnota za nejmenší důležitou číslicí ve výsledku přesně poloviční způsob mezi dvěma čísly.In a midpoint value, the value after the least significant digit in the result is precisely half way between two numbers. Například hodnota 3,47500 je střední hodnota, pokud má být zaokrouhlena na dvě desetinná místa a 7,500 je střední hodnota, pokud má být zaokrouhlena na celé číslo.For example, 3.47500 is a midpoint value if it is to be rounded two decimal places, and 7.500 is a midpoint value if it is to be rounded to an integer. V těchto případech se nejbližší hodnota nedá snadno identifikovat bez konvence zaokrouhlení, která je určená argumentem mode.In these cases, the nearest value can't be easily identified without a rounding convention, which is specified by the mode argument. Metoda Round(Decimal, Int32, MidpointRounding) podporuje dvě konvence zaokrouhlení pro zpracování hodnot středního bodu.The Round(Decimal, Int32, MidpointRounding) method supports two rounding conventions for handling midpoint values.

Zaokrouhlení směrem od nulyRounding away from zero.
Střední hodnoty se zaokrouhlují na další číslo od nuly.Midpoint values are rounded to the next number away from zero. Například 3,75 se zaokrouhlí na 3,8, 3,85 se zaokrouhlí na 3,9,-3,75 se zaokrouhlí na-3,8 a-3,85 se zaokrouhlí na-3,9.For example, 3.75 rounds to 3.8, 3.85 rounds to 3.9, -3.75 rounds to -3.8, and -3.85 rounds to -3.9. Tato forma zaokrouhlení je reprezentována MidpointRounding.AwayFromZerom členem výčtu.This form of rounding is represented by the MidpointRounding.AwayFromZero enumeration member.

Zaokrouhlení směrem od nuly je nejrozšířenějším známým formulářem zaokrouhlení.Rounding away from zero is the most widely known form of rounding.

Zaokrouhlování na sudé nebo zaokrouhlení bankRounding to even, or banker's rounding
Střední hodnoty jsou zaokrouhleny na nejbližší sudé číslo.Midpoint values are rounded to the nearest even number. Například 3,75 a 3,85 se zaokrouhlí na 3,8 a současně na 3,75 a-3,85.For example, both 3.75 and 3.85 round to 3.8, and both -3.75 and -3.85 round to -3.8. Tato forma zaokrouhlení je reprezentována MidpointRounding.ToEvenm členem výčtu.This form of rounding is represented by the MidpointRounding.ToEven enumeration member.

Zaokrouhlení na nejbližší je standardní forma zaokrouhlení, která se používá ve finančních a statistických operacích.Rounding to nearest is the standard form of rounding used in financial and statistical operations. V souladu se standardem IEEE 754, oddílem 4.It conforms to IEEE Standard 754, section 4. Při použití ve více operacích zaokrouhlení zkracuje chybu zaokrouhlování, která je způsobena konzistentním zaokrouhlováním středních hodnot v jednom směru.When used in multiple rounding operations, it reduces the rounding error that is caused by consistently rounding midpoint values in a single direction. V některých případech může být tato chyba zaokrouhlení významná.In some cases, this rounding error can be significant.

Viz také

Platí pro