Decimal.Round Méthode

Définition

Arrondit une valeur à l'entier le plus proche ou au nombre spécifié de décimales.Rounds a value to the nearest integer or specified number of decimal places.

Surcharges

Round(Decimal)

Arrondit une valeur décimale à l'entier le plus proche.Rounds a decimal value to the nearest integer.

Round(Decimal, Int32)

Arrondit une valeur Decimal au nombre de décimales spécifié.Rounds a Decimal value to a specified number of decimal places.

Round(Decimal, MidpointRounding)

Arrondit une valeur décimale à l'entier le plus proche.Rounds a decimal value to the nearest integer. Un paramètre spécifie comment arrondir une valeur qui se trouve à mi-chemin entre deux nombres.A parameter specifies how to round the value if it is midway between two other numbers.

Round(Decimal, Int32, MidpointRounding)

Arrondit une valeur décimale à la précision spécifiée.Rounds a decimal value to a specified precision. Un paramètre spécifie comment arrondir une valeur qui se trouve à mi-chemin entre deux nombres.A parameter specifies how to round the value if it is midway between two other numbers.

Round(Decimal)

Arrondit une valeur décimale à l'entier le plus proche.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

Paramètres

d
Decimal

Nombre décimal à arrondir.A decimal number to round.

Retours

Decimal

Entier le plus proche du paramètre d.The integer that is nearest to the d parameter. Si d se trouve à mi-chemin entre deux entiers, l'un pair et l'autre impair, le nombre pair est retourné.If d is halfway between two integers, one of which is even and the other odd, the even number is returned.

Exceptions

Le résultat se situe hors de la plage d’une valeur Decimal.The result is outside the range of a Decimal value.

Exemples

L’exemple suivant arrondit une plage de Decimal valeurs comprises entre 100 et 102 à l’entier le plus proche.The following example rounds a range of Decimal values between 100 and 102 to the nearest integer. Étant donné que la méthode utilise l’arrondi de Banker, Notez que 100,5 arrondit à 100 et 101,5 à 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

Remarques

Le comportement de cette méthode est conforme à la norme IEEE 754, section 4.The behavior of this method follows IEEE Standard 754, section 4. Ce type d’arrondi est parfois appelé « moitié ronde » pour l’arrondi de manière égale ou bancaire.This kind of rounding is sometimes called round half to even or banker's rounding. Il minimise les erreurs d’arrondi qui résultent d’un arrondi cohérent d’une valeur de milieu dans une seule direction.It minimizes rounding errors that result from consistently rounding a midpoint value in a single direction. Cela équivaut à appeler la Round(Decimal, MidpointRounding) méthode avec un mode argument de MidpointRounding.ToEven .It is equivalent to calling the Round(Decimal, MidpointRounding) method with a mode argument of MidpointRounding.ToEven.

Voir aussi

S’applique à

Round(Decimal, Int32)

Arrondit une valeur Decimal au nombre de décimales spécifié.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

Paramètres

d
Decimal

Nombre décimal à arrondir.A decimal number to round.

decimals
Int32

Valeur de 0 à 28 qui spécifie le nombre de décimales auquel arrondir le chiffre.A value from 0 to 28 that specifies the number of decimal places to round to.

Retours

Decimal

Nombre décimal équivalent à d arrondi à decimals décimales.The decimal number equivalent to d rounded to decimals number of decimal places.

Exceptions

decimals n’est pas une valeur comprise entre 0 et 28.decimals is not a value from 0 to 28.

Exemples

L’exemple suivant arrondit plusieurs Decimal valeurs à un nombre spécifié de décimales à l’aide de la Round méthode.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

Remarques

Cette méthode est équivalente à l’appel Round(Decimal, Int32, MidpointRounding) de la méthode avec un mode argument de MidpointRounding.ToEven . Lorsque d se trouve à mi-chemin entre deux valeurs arrondies, le résultat est la valeur arrondie qui a un chiffre pair à la position décimale la plus à droite.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. Par exemple, lorsqu'elle est arrondie à deux décimales, la valeur 2,345 devient 2,34 et la valeur 2,355 devient 2,36.For example, when rounded to two decimals, the value 2.345 becomes 2.34 and the value 2.355 becomes 2.36. Ce processus est connu sous le nom d' arrondi à pair ou d’arrondi bancaire.This process is known as rounding toward even, or banker's rounding. Il minimise les erreurs d’arrondi qui résultent d’un arrondi cohérent d’une valeur de milieu dans une seule direction.It minimizes rounding errors that result from consistently rounding a midpoint value in a single direction.

Voir aussi

S’applique à

Round(Decimal, MidpointRounding)

Arrondit une valeur décimale à l'entier le plus proche.Rounds a decimal value to the nearest integer. Un paramètre spécifie comment arrondir une valeur qui se trouve à mi-chemin entre deux nombres.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

Paramètres

d
Decimal

Nombre décimal à arrondir.A decimal number to round.

mode
MidpointRounding

Valeur qui spécifie comment arrondir d s'il se trouve à mi-chemin entre deux autres nombres.A value that specifies how to round d if it is midway between two other numbers.

Retours

Decimal

Entier le plus proche du paramètre d.The integer that is nearest to the d parameter. Si d se trouve à mi-chemin entre deux nombres, l'un pair et l'autre impair, le paramètre mode détermine le nombre qui est retourné.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.

Exceptions

mode n’est pas une valeur MidpointRounding.mode is not a MidpointRounding value.

Le résultat se situe hors de la plage d’un objet Decimal.The result is outside the range of a Decimal object.

Exemples

L’exemple suivant affiche les valeurs retournées par la Round(Decimal) méthode, la Round(Decimal, MidpointRounding) méthode avec un mode argument de ToEven et la Round(Decimal, MidpointRounding) méthode avec un mode argument de 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         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         13         13         13

Remarques

Dans une valeur de milieu, la valeur qui se trouve après le chiffre le moins significatif dans le résultat est précisément à mi-chemin entre deux nombres.In a midpoint value, the value after the least significant digit in the result is precisely half way between two numbers. Par exemple, 7,5 est une valeur de milieu si elle doit être arrondie à un entier.For example, 7.5 is a midpoint value if it is to be rounded to an integer. Pour les valeurs de milieu, la valeur la plus proche ne peut pas être facilement identifiée sans convention d’arrondi, qui est spécifiée par l' mode argument.For midpoint values, the nearest value can't be easily identified without a rounding convention, which is specified by the mode argument. La Round méthode prend en charge deux conventions d’arrondi pour gérer les valeurs de milieu.The Round method supports two rounding conventions for handling midpoint values.

Arrondi à l’opposé de zéro.Rounding away from zero.
Les valeurs médianes sont arrondies au nombre suivant en s’éloignant de zéro.Midpoint values are rounded to the next number away from zero. Par exemple, 3,5 arrondit à 4, 4,5 arrondit à 5,-3,5 s’arrondit à-4, et-4,5 à-5.For example, 3.5 rounds to 4, 4.5 rounds to 5, -3.5 rounds to -4, and -4.5 rounds to -5. Cette forme d’arrondi est représentée par le membre de l' MidpointRounding.AwayFromZero énumération.This form of rounding is represented by the MidpointRounding.AwayFromZero enumeration member.

L’arrondi à une valeur différente de zéro est la forme d’arrondi la plus communément connue.Rounding away from zero is the most widely known form of rounding.

Arrondi à pair ou arrondi de la BanqueRounding to even, or banker's rounding
Les valeurs médianes sont arrondies au nombre pair le plus proche.Midpoint values are rounded to the nearest even number. Par exemple, 3,5 et 4,5 arrondissent à 4, et-3,5 et-4,5 arrondi à-4.For example, both 3.5 and 4.5 round to 4, and both -3.5 and -4.5 round to -4. Cette forme d’arrondi est représentée par le membre de l' MidpointRounding.ToEven énumération.This form of rounding is represented by the MidpointRounding.ToEven enumeration member.

L’arrondi au plus proche est la forme standard de l’arrondi utilisé dans les opérations financières et statistiques.Rounding to nearest is the standard form of rounding used in financial and statistical operations. Elle est conforme à la norme IEEE 754, section 4.It conforms to IEEE Standard 754, section 4. Lorsqu’elle est utilisée dans plusieurs opérations d’arrondi, elle réduit l’erreur d’arrondi provoquée par l’arrondi cohérent des valeurs médianes dans une seule direction.When used in multiple rounding operations, it reduces the rounding error that is caused by consistently rounding midpoint values in a single direction. Dans certains cas, cette erreur d’arrondi peut être importante.In some cases, this rounding error can be significant.

Voir aussi

S’applique à

Round(Decimal, Int32, MidpointRounding)

Arrondit une valeur décimale à la précision spécifiée.Rounds a decimal value to a specified precision. Un paramètre spécifie comment arrondir une valeur qui se trouve à mi-chemin entre deux nombres.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

Paramètres

d
Decimal

Nombre décimal à arrondir.A decimal number to round.

decimals
Int32

Nombre de décimales significatives (précision) de la valeur de retour.The number of significant decimal places (precision) in the return value.

mode
MidpointRounding

Valeur qui spécifie comment arrondir d s'il se trouve à mi-chemin entre deux autres nombres.A value that specifies how to round d if it is midway between two other numbers.

Retours

Decimal

Nombre le plus proche du paramètre d avec une précision égale au paramètre decimals.The number that is nearest to the d parameter with a precision equal to the decimals parameter. Si d se trouve à mi-chemin entre deux nombres, l'un pair et l'autre impair, le paramètre mode détermine le nombre qui est retourné.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. Si la précision de d est inférieure à decimals, d est retourné sans modification.If the precision of d is less than decimals, d is returned unchanged.

Exceptions

decimals est inférieur à 0 ou supérieur à 28.decimals is less than 0 or greater than 28.

mode n’est pas une valeur MidpointRounding.mode is not a MidpointRounding value.

Le résultat se situe hors de la plage d’un objet Decimal.The result is outside the range of a Decimal object.

Exemples

L’exemple suivant montre comment utiliser la Round(Decimal, Int32, MidpointRounding) méthode avec l' MidpointRounding énumération.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 positiveValue = 3.45m;
decimal negativeValue = -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(positiveValue, 1);
Console.WriteLine($"{result} = Math.Round({positiveValue}, 1)");
result = Math.Round(negativeValue, 1);
Console.WriteLine($"{result} = Math.Round({negativeValue}, 1)");
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(positiveValue, 1, MidpointRounding.ToEven);
Console.WriteLine($"{result} = Math.Round({positiveValue}, 1, MidpointRounding.ToEven)");
result = Math.Round(positiveValue, 1, MidpointRounding.AwayFromZero);
Console.WriteLine($"{result} = Math.Round({positiveValue}, 1, MidpointRounding.AwayFromZero)");
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(negativeValue, 1, MidpointRounding.ToEven);
Console.WriteLine($"{result} = Math.Round({negativeValue}, 1, MidpointRounding.ToEven)");
result = Math.Round(negativeValue, 1, MidpointRounding.AwayFromZero);
Console.WriteLine($"{result} = Math.Round({negativeValue}, 1, MidpointRounding.AwayFromZero)");
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)
'

Remarques

Le decimals paramètre spécifie le nombre de décimales significatives dans la valeur de retour et est compris entre 0 et 28.The decimals parameter specifies the number of significant decimal places in the return value and ranges from 0 to 28. Si decimals est égal à zéro, un entier est retourné.If decimals is zero, an integer is returned.

Dans une valeur de milieu, la valeur qui se trouve après le chiffre le moins significatif dans le résultat est précisément à mi-chemin entre deux nombres.In a midpoint value, the value after the least significant digit in the result is precisely half way between two numbers. Par exemple, 3,47500 est une valeur de milieu si elle doit être arrondie à deux décimales, et 7,500 est une valeur médiane si elle doit être arrondie à un entier.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. Dans ce cas, la valeur la plus proche ne peut pas être facilement identifiée sans convention d’arrondi, qui est spécifiée par l' mode argument.In these cases, the nearest value can't be easily identified without a rounding convention, which is specified by the mode argument. La Round(Decimal, Int32, MidpointRounding) méthode prend en charge deux conventions d’arrondi pour gérer les valeurs de milieu.The Round(Decimal, Int32, MidpointRounding) method supports two rounding conventions for handling midpoint values.

Arrondi à l’opposé de zéro.Rounding away from zero.
Les valeurs médianes sont arrondies au nombre suivant en s’éloignant de zéro.Midpoint values are rounded to the next number away from zero. Par exemple, 3,75 arrondit à 3,8, 3,85 s’arrondit à 3,9,-3,75 arrondit à-3,8 et-3,85 arrondit à-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. Cette forme d’arrondi est représentée par le membre de l' MidpointRounding.AwayFromZero énumération.This form of rounding is represented by the MidpointRounding.AwayFromZero enumeration member.

L’arrondi à une valeur différente de zéro est la forme d’arrondi la plus communément connue.Rounding away from zero is the most widely known form of rounding.

Arrondi à pair ou arrondi de la BanqueRounding to even, or banker's rounding
Les valeurs médianes sont arrondies au nombre pair le plus proche.Midpoint values are rounded to the nearest even number. Par exemple, 3,75 et 3,85 arrondissent à 3,8, et les deux-3,75 et-3,85 arrondissent à-3,8.For example, both 3.75 and 3.85 round to 3.8, and both -3.75 and -3.85 round to -3.8. Cette forme d’arrondi est représentée par le membre de l' MidpointRounding.ToEven énumération.This form of rounding is represented by the MidpointRounding.ToEven enumeration member.

L’arrondi au plus proche est la forme standard de l’arrondi utilisé dans les opérations financières et statistiques.Rounding to nearest is the standard form of rounding used in financial and statistical operations. Elle est conforme à la norme IEEE 754, section 4.It conforms to IEEE Standard 754, section 4. Lorsqu’elle est utilisée dans plusieurs opérations d’arrondi, elle réduit l’erreur d’arrondi provoquée par l’arrondi cohérent des valeurs médianes dans une seule direction.When used in multiple rounding operations, it reduces the rounding error that is caused by consistently rounding midpoint values in a single direction. Dans certains cas, cette erreur d’arrondi peut être importante.In some cases, this rounding error can be significant.

Voir aussi

S’applique à