Math.Round Méthode

Définition

Arrondit une valeur à l'entier le plus proche ou au nombre spécifié de chiffres fractionnaires.Rounds a value to the nearest integer or to the specified number of fractional digits.

Surcharges

Round(Decimal, Int32, MidpointRounding)

Arrondit une valeur décimale au nombre de chiffres fractionnaires spécifié, et utilise la convention d’arrondi spécifiée pour les valeurs médianes.Rounds a decimal value to a specified number of fractional digits, and uses the specified rounding convention for midpoint values.

Round(Double, Int32, MidpointRounding)

Arrondit un nombre à virgule flottante double précision au nombre de chiffres fractionnaires spécifié, et utilise la convention d’arrondi spécifiée pour les valeurs médianes.Rounds a double-precision floating-point value to a specified number of fractional digits, and uses the specified rounding convention for midpoint values.

Round(Double, MidpointRounding)

Arrondit un nombre à virgule flottante double précision au nombre entier le plus proche, et utilise la convention d’arrondi spécifiée pour les valeurs médianes.Rounds a double-precision floating-point value to the nearest integer, and uses the specified rounding convention for midpoint values.

Round(Double, Int32)

Arrondit un nombre à virgule flottante double précision au nombre de chiffres fractionnaires spécifié, et les valeurs médianes au nombre pair le plus proche.Rounds a double-precision floating-point value to a specified number of fractional digits, and rounds midpoint values to the nearest even number.

Round(Double)

Arrondit un nombre à virgule flottante double précision au nombre entier le plus proche, et les valeurs médianes au nombre pair le plus proche.Rounds a double-precision floating-point value to the nearest integral value, and rounds midpoint values to the nearest even number.

Round(Decimal, Int32)

Arrondit une valeur décimale au nombre de chiffres fractionnaires spécifié, et les valeurs médianes au nombre pair le plus proche.Rounds a decimal value to a specified number of fractional digits, and rounds midpoint values to the nearest even number.

Round(Decimal)

Arrondit une valeur décimale au nombre entier le plus proche, et les valeurs médianes au nombre pair le plus proche.Rounds a decimal value to the nearest integral value, and rounds midpoint values to the nearest even number.

Round(Decimal, MidpointRounding)

Arrondit une valeur décimale au nombre entier le plus proche, et utilise la convention d’arrondi spécifiée pour les valeurs médianes.Rounds a decimal value to the nearest integer, and uses the specified rounding convention for midpoint values.

Exemples

Outre les exemples de la section Notes , cet article contient des exemples qui illustrent les surcharges suivantes de la Math.Round méthode :In addition to the examples in the Remarks section, this article includes examples that illustrate the following overloads of the Math.Round method:

Math. Round (décimal)Math.Round(Decimal)
Math. Round (double)Math.Round(Double)
Math. Round (Decimal, Int32)Math.Round(Decimal, Int32)
Math. Round (Decimal, MidpointRounding)Math.Round(Decimal, MidpointRounding)
Math. Round (double, Int32)Math.Round(Double, Int32)
Math. Round (double, MidpointRounding)Math.Round(Double, MidpointRounding)
Math. Round (Decimal, Int32, MidpointRounding)Math.Round(Decimal, Int32, MidpointRounding)
Math. Round (double, Int32, MidpointRounding)Math.Round(Double, Int32, MidpointRounding)

Remarques

Dans cette section :In this section:

Quelle méthode appelle-t-elle ?Which method do I call?

Vous pouvez utiliser le tableau suivant pour sélectionner une méthode d’arrondi appropriée.You can use the following table to select an appropriate rounding method. Outre les Math.Round méthodes, elle comprend également Math.Ceiling et Math.Floor .In addition to the Math.Round methods, it also includes Math.Ceiling and Math.Floor.

ÀTo CallCall
Arrondit un nombre à un entier à l’aide de la Convention d’arrondi au plus proche.Round a number to an integer by using the rounding to nearest convention. Round(Decimal)

- ou --or-

Round(Double)
Arrondit un nombre à un entier à l’aide d’une convention d’arrondi spécifiée.Round a number to an integer by using a specified rounding convention. Round(Decimal, MidpointRounding)

- ou --or-

Round(Double, MidpointRounding)
Arrondit un nombre à un nombre spécifié de chiffres fractionnaires à l’aide de la Convention d’arrondi au plus proche.Round a number to a specified number of fractional digits by using the rounding to nearest convention. Round(Decimal, Int32)

- ou --or-

Round(Double, Int32)
Arrondit un nombre à un nombre spécifié de chiffres fractionnaires à l’aide d’une convention d’arrondi spécifiée.Round a number to a specified number of fractional digits by using a specified rounding convention. Round(Decimal, Int32, MidpointRounding)

- ou --or-

Round(Double, Int32, MidpointRounding)
Arrondit une Single valeur à un nombre spécifié de chiffres fractionnaires à l’aide d’une convention d’arrondi spécifiée et en minimisant la perte de précision.Round a Single value to a specified number of fractional digits by using a specified rounding convention and minimizing the loss of precision. Convertit Single en Decimal et appelle Round(Decimal, Int32, MidpointRounding) .Convert the Single to a Decimal and call Round(Decimal, Int32, MidpointRounding).
Arrondit un nombre à un nombre spécifié de chiffres fractionnaires tout en minimisant les problèmes de précision dans l’arrondi des valeurs de milieu.Round a number to a specified number of fractional digits while minimizing problems of precision in rounding midpoint values. Appelez une méthode d’arrondi qui implémente une comparaison « supérieur ou égal à ».Call a rounding method that implements a "greater than or approximately equal to" comparison. Consultez arrondi et précision.See Rounding and precision.
Arrondit une valeur fractionnaire à un entier supérieur à la valeur fractionnaire.Round a fractional value to an integer that is greater than the fractional value. Par exemple, arrondissez 3,1 à 4.For example, round 3.1 to 4. Ceiling
Arrondit une valeur fractionnaire à un entier inférieur à la valeur fractionnaire.Round a fractional value to an integer that is less than the fractional value. Par exemple, arrondissez 3,9 à 3.For example, round 3.9 to 3. Floor

Valeurs de point médian et conventions d’arrondiMidpoint values and rounding conventions

L’arrondi implique la conversion d’une valeur numérique avec une précision spécifiée à la valeur la plus proche avec moins de précision.Rounding involves converting a numeric value with a specified precision to the nearest value with less precision. Par exemple, vous pouvez utiliser la Round(Double) méthode pour arrondir une valeur de 3,4 à 3,0, et la Round(Double, Int32) méthode pour arrondir une valeur de 3,579 à 3,58.For example, you can use the Round(Double) method to round a value of 3.4 to 3.0, and the Round(Double, Int32) method to round a value of 3.579 to 3.58.

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.In these cases, the nearest value can't be easily identified without a rounding convention.

La Round méthode prend en charge deux conventions d’arrondi pour gérer les valeurs médianes :The Round method supports two rounding conventions for handling midpoint values:

  • Arrondi à l’opposé de zéroRounding 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 au plus proche ou arrondi bancaireRounding to nearest, 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.

    L’exemple suivant illustre l’écart qui peut résulter de l’arrondi cohérent des valeurs médianes dans une seule direction.The following example illustrates the bias that can result from consistently rounding midpoint values in a single direction. L’exemple calcule la moyenne réelle d’un tableau de Decimal valeurs, puis calcule la moyenne lorsque les valeurs du tableau sont arrondies à l’aide des deux conventions.The example computes the true mean of an array of Decimal values, and then computes the mean when the values in the array are rounded by using the two conventions. Dans cet exemple, la moyenne réelle et la moyenne qui résultent de l’arrondi au plus proche sont les mêmes.In this example, the true mean and the mean that results when rounding to nearest are the same. Toutefois, la moyenne obtenue lorsque l’arrondi est différent de zéro diffère de 0,05 (ou de 3,6%) de la moyenne réelle.However, the mean that results when rounding away from zero differs by .05 (or by 3.6%) from the true mean.

    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
    
    Module Example
       Public Sub Main()
          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)
       End Sub
    End Module
    ' The example displays the following output:
    '       True mean:     1.40
    '       AwayFromZero:  1.45
    '       ToEven:        1.40
    

Par défaut, la Round méthode utilise l’arrondi à la Convention la plus proche.By default, the Round method uses the rounding to nearest convention. Le tableau suivant répertorie les surcharges de la Round méthode et la Convention d’arrondi que chacune utilise.The following table lists the overloads of the Round method and the rounding convention that each uses.

SurchargeOverload Convention d’arrondiRounding convention
Round(Decimal) ToEven
Round(Double) ToEven
Round(Decimal, Int32) ToEven
Round(Double, Int32) ToEven
Round(Decimal, MidpointRounding) Déterminé par le mode paramètre.Determined by mode parameter.
Round(Double, MidpointRounding) Déterminé par le mode paramètreDetermined by mode parameter
Round(Decimal, Int32, MidpointRounding) Déterminé par le mode paramètreDetermined by mode parameter
Round(Double, Int32, MidpointRounding) Déterminé par le mode paramètreDetermined by mode parameter

Arrondi et précisionRounding and precision

Pour déterminer si une opération d’arrondi implique une valeur de milieu, la Round méthode multiplie la valeur d’origine pour être arrondie par 10 n, où n est le nombre souhaité de chiffres fractionnaires dans la valeur de retour, puis détermine si la partie fractionnaire restante de la valeur est supérieure ou égale à. 5.In order to determine whether a rounding operation involves a midpoint value, the Round method multiplies the original value to be rounded by 10 n, where n is the desired number of fractional digits in the return value, and then determines whether the remaining fractional portion of the value is greater than or equal to .5. Il s’agit d’une légère variation sur un test d’égalité, et comme indiqué dans la section « test d’égalité » de la Double rubrique de référence, les tests d’égalité avec des valeurs à virgule flottante sont problématiques en raison des problèmes liés au format à virgule flottante avec la représentation binaire et la précision.This is a slight variation on a test for equality, and as discussed in the "Testing for Equality" section of the Double reference topic, tests for equality with floating-point values are problematic because of the floating-point format's issues with binary representation and precision. Cela signifie que toute partie fractionnaire d’un nombre légèrement inférieure à 0,5 (en raison d’une perte de précision) n’est pas arrondie vers le haut.This means that any fractional portion of a number that is slightly less than .5 (because of a loss of precision) will not be rounded upward.

Important

Pour arrondir les valeurs du point médian, l’algorithme d’arrondi effectue un test d’égalité.When rounding midpoint values, the rounding algorithm performs an equality test. En raison de problèmes liés à la représentation binaire et à la précision du format à virgule flottante, la valeur retournée par la méthode peut être inattendue.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Pour plus d’informations, consultez « Arrondi et précision ».For more information, see "Rounding and precision".

L'exemple de code suivant illustre le problème.The following example illustrates the problem. Il ajoute de manière répétée la valeur. 1 à 11,0 et arrondit le résultat à l’entier le plus proche.It repeatedly adds .1 to 11.0 and rounds the result to the nearest integer. Quelle que soit la Convention d’arrondi, 11,5 doit arrondir à 12.Regardless of the rounding convention, 11.5 should round to 12. Toutefois, comme le montre la sortie de l’exemple, ce n’est pas le cas.However, as the output from the example shows, it does not. L’exemple utilise la chaîne de format numérique standard « R » pour afficher la précision totale de la valeur à virgule flottante, et indique que la valeur à arrondir a perdu la précision lors des ajouts répétés, et que sa valeur est en fait 11.499999999999998.The example uses the "R" standard numeric format string to display the floating point value's full precision, and shows that the value to be rounded has lost precision during repeated additions, and its value is actually 11.499999999999998. Étant donné que. 499999999999998 est inférieur à 5, la valeur n’est pas arrondie à l’entier le plus élevé suivant.Because .499999999999998 is less than .5, the value is not rounded to the next highest integer. Comme le montre l’exemple, ce problème ne se produit pas si nous affectons simplement la valeur constante 11,5 à une Double variable.As the example also shows, this problem does not occur if we simply assign the constant value 11.5 to a Double variable.

using System;

public class Example
{
   public static void Main()
   {
      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
Module Example
   Public Sub Main()
      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 + .1
   End Function   
End Module
' 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

Les problèmes de précision dans l’arrondi des valeurs de milieu sont susceptibles de se produire dans les conditions suivantes :Problems of precision in rounding midpoint values are most likely to arise in the following conditions:

  • Lorsqu’une valeur fractionnaire ne peut pas être exprimée précisément dans le format binaire du type à virgule flottante.When a fractional value cannot be expressed precisely in the floating-point type's binary format.

  • Lorsque la valeur à arrondir est calculée à partir d’une ou plusieurs opérations à virgule flottante.When the value to be rounded is calculated from one or more floating-point operations.

  • Lorsque la valeur à arrondir est un Single plutôt qu’un Double ou Decimal .When the value to be rounded is a Single rather than a Double or Decimal. Pour plus d’informations, consultez la section suivante, arrondi et valeurs à virgule flottante simple précision.For more information, see the next section, Rounding and single-precision floating-point values.

Dans les cas où le manque de précision dans les opérations d’arrondis est problématique, vous pouvez effectuer les opérations suivantes :In cases where the lack of precision in rounding operations is problematic, you can do the following:

  • Si l’opération d’arrondi appelle une surcharge qui arrondit une Double valeur, vous pouvez remplacer le Double par une Decimal valeur et appeler une surcharge qui arrondit une valeur à la Decimal place.If the rounding operation calls an overload that rounds a Double value, you can change the Double to a Decimal value and call an overload that rounds a Decimal value instead. Bien que le Decimal type de données présente également des problèmes de représentation et de perte de précision, ces problèmes sont beaucoup moins fréquents.Although the Decimal data type also has problems of representation and loss of precision, these issues are far less common.

  • Définissez un algorithme d’arrondi personnalisé qui effectue un test « presque égal » pour déterminer si la valeur à arrondir est acceptable de près d’une valeur de milieu.Define a custom rounding algorithm that performs a "nearly equal" test to determine whether the value to be rounded is acceptably close to a midpoint value. L’exemple suivant définit une RoundApproximate méthode qui vérifie si une valeur fractionnaire est suffisamment proche d’une valeur de milieu pour être soumise à un arrondi médian.The following example defines a RoundApproximate method that examines whether a fractional value is sufficiently near to a midpoint value to be subject to midpoint rounding. Comme le montre la sortie de l’exemple, il corrige le problème d’arrondi indiqué dans l’exemple précédent.As the output from the example shows, it corrects the rounding problem shown in the previous example.

    :::code language="csharp" source="~/samples/snippets/csharp/VS_Snippets_CLR_System/system.math.round.overload/cs/precision2.cs" interactive="try-dotnet" id="Snippet8":::
    :::code language="vb" source="~/samples/snippets/visualbasic/VS_Snippets_CLR_System/system.math.round.overload/vb/precision2.vb" id="Snippet8":::
    

Arrondi et valeurs à virgule flottante simple précisionRounding and single-precision floating-point values

La Round méthode comprend des surcharges qui acceptent des arguments de type Decimal et Double .The Round method includes overloads that accept arguments of type Decimal and Double. Il n’existe aucune méthode qui arrondit les valeurs de type Single .There are no methods that round values of type Single. Si vous transmettez une Single valeur à l’une des surcharges de la Round méthode, elle est castée (en C#) ou convertie (en Visual Basic) en Double , et la Round surcharge correspondante avec un Double paramètre est appelée.If you pass a Single value to one of the overloads of the Round method, it is cast (in C#) or converted (in Visual Basic) to a Double, and the corresponding Round overload with a Double parameter is called. Bien qu’il s’agisse d’une conversion étendue, elle implique souvent une perte de précision, comme l’illustre l’exemple suivant.Although this is a widening conversion, it often involves a loss of precision, as the following example illustrates. Quand une Single valeur de 16,325 est transmise à la Round méthode et arrondie à deux décimales à l’aide de la Convention d’arrondi à la plus proche, le résultat est 16,33 et non le résultat attendu de 16,32.When a Single value of 16.325 is passed to the Round method and rounded to two decimal places using the rounding to nearest convention, the result is 16.33 and not the expected result of 16.32.

using System;

public class Example
{
   public static void Main()
   {
      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
Module Example
   Public Sub Main()
      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()
   End Sub
End Module
' 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

Ce résultat inattendu est dû à une perte de précision dans la conversion de la Single valeur en Double .This unexpected result is due to a loss of precision in the conversion of the Single value to a Double. Étant donné que la valeur résultante Double de 16.325000762939453 n’est pas une valeur de milieu et est supérieure à 16,325, elle est toujours arrondie vers le haut.Because the resulting Double value of 16.325000762939453 is not a midpoint value and is greater than 16.325, it is always rounded upward.

Dans de nombreux cas, comme l’illustre l’exemple, la perte de précision peut être réduite ou éliminée en effectuant un cast ou en convertissant la Single valeur en Decimal .In many cases, as the example illustrates, the loss of precision can be minimized or eliminated by casting or converting the Single value to a Decimal. Notez que, étant donné qu’il s’agit d’une conversion restrictive, elle requiert l’utilisation d’un opérateur de cast ou l’appel d’une méthode de conversion.Note that, because this is a narrowing conversion, it requires using a cast operator or calling a conversion method.

Round(Decimal, Int32, MidpointRounding)

Arrondit une valeur décimale au nombre de chiffres fractionnaires spécifié, et utilise la convention d’arrondi spécifiée pour les valeurs médianes.Rounds a decimal value to a specified number of fractional digits, and uses the specified rounding convention for midpoint values.

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 be rounded.

decimals
Int32

Nombre de décimales de la valeur de retour.The number of decimal places in the return value.

mode
MidpointRounding

Spécification sur la façon d'arrondir d s'il se trouve à mi-chemin entre deux nombres.Specification for how to round d if it is midway between two other numbers.

Retours

Decimal

Nombre le plus proche de d contenant un nombre de chiffres fractionnaires égal à decimals.The number nearest to d that contains a number of fractional digits equal to decimals. Si d a moins de chiffres fractionnaires que decimals, d est retourné sans modification.If d has fewer fractional digits 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 valide de MidpointRounding.mode is not a valid value of MidpointRounding.

Le résultat est à l'extérieur de la plage d'un Decimal.The result is outside the range of a Decimal.

Remarques

Pour plus d’informations sur l’arrondi des nombres avec des valeurs médianes, consultez valeurs de point médian et conventions d’arrondi .See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Important

Pour arrondir les valeurs du point médian, l’algorithme d’arrondi effectue un test d’égalité.When rounding midpoint values, the rounding algorithm performs an equality test. En raison de problèmes liés à la représentation binaire et à la précision du format à virgule flottante, la valeur retournée par la méthode peut être inattendue.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Pour plus d’informations, consultez « Arrondi et précision ».For more information, see "Rounding and precision".

La valeur de l' decimals argument peut être comprise entre 0 et 28.The value of the decimals argument can range from 0 to 28.

ExempleExample

L’exemple suivant montre comment utiliser la Round méthode avec l' MidpointRounding énumération.The following example demonstrates how to use the Round 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)
'

Voir aussi

S’applique à

Round(Double, Int32, MidpointRounding)

Arrondit un nombre à virgule flottante double précision au nombre de chiffres fractionnaires spécifié, et utilise la convention d’arrondi spécifiée pour les valeurs médianes.Rounds a double-precision floating-point value to a specified number of fractional digits, and uses the specified rounding convention for midpoint values.

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

Paramètres

value
Double

Nombre à virgule flottante double précision à arrondir.A double-precision floating-point number to be rounded.

digits
Int32

Nombre de chiffres fractionnaires de la valeur de retour.The number of fractional digits in the return value.

mode
MidpointRounding

Spécification sur la façon d'arrondir value s'il se trouve à mi-chemin entre deux nombres.Specification for how to round value if it is midway between two other numbers.

Retours

Double

Nombre le plus proche de value contenant un nombre de chiffres fractionnaires égal à digits.The number nearest to value that has a number of fractional digits equal to digits. Si value a moins de chiffres fractionnaires que digits, value est retourné sans modification.If value has fewer fractional digits than digits, value is returned unchanged.

Exceptions

digits est inférieur à 0 ou supérieur à 15.digits is less than 0 or greater than 15.

mode n’est pas une valeur valide de MidpointRounding.mode is not a valid value of MidpointRounding.

Remarques

La valeur de l' digits argument peut être comprise entre 0 et 15.The value of the digits argument can range from 0 to 15. Notez que 15 est le nombre maximal de chiffres intégraux et fractionnaires pris en charge par le Double type.Note that 15 is the maximum number of integral and fractional digits supported by the Double type.

Pour plus d’informations sur l’arrondi des nombres avec des valeurs médianes, consultez valeurs de point médian et conventions d’arrondi .See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Important

Pour arrondir les valeurs du point médian, l’algorithme d’arrondi effectue un test d’égalité.When rounding midpoint values, the rounding algorithm performs an equality test. En raison de problèmes liés à la représentation binaire et à la précision du format à virgule flottante, la valeur retournée par la méthode peut être inattendue.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Pour plus d’informations, consultez « Arrondi et précision ».For more information, see "Rounding and precision".

Si la valeur de l' value argument est Double.NaN , la méthode retourne Double.NaN .If the value of the value argument is Double.NaN, the method returns Double.NaN. Si value a Double.PositiveInfinity la valeur ou Double.NegativeInfinity , la méthode retourne Double.PositiveInfinity ou Double.NegativeInfinity , respectivement.If value is Double.PositiveInfinity or Double.NegativeInfinity, the method returns Double.PositiveInfinity or Double.NegativeInfinity, respectively.

ExempleExample

L’exemple suivant montre comment utiliser la Round(Double, Int32, MidpointRounding) méthode avec l' MidpointRounding énumération.The following example demonstrates how to use the Round(Double, Int32, MidpointRounding) method with the MidpointRounding enumeration.

 double posValue =  3.45;
 double negValue = -3.45;

 // Round a positive and a negative value using the default.
 double 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)\n", result, negValue);

 // 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)\n",
                   result, posValue);

 // Round a negative 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)\n",
                   result, negValue);
// 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.45, 1, MidpointRounding.ToEven)
//       -3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)
Module Example
    Public Sub Main() 
        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()
    End Sub
End Module
' 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.45, 1, MidpointRounding.ToEven)
'       -3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)

Notes pour les appelants

En raison de la perte de précision qui peut résulter de la représentation de valeurs décimales sous la forme de nombres à virgule flottante ou d’opérations arithmétiques sur des valeurs à virgule flottante, il Round(Double, Int32, MidpointRounding) se peut que la méthode n’apparaisse pas pour arrondir les valeurs de point médian comme spécifié par le mode paramètre.Because of the loss of precision that can result from representing decimal values as floating-point numbers or performing arithmetic operations on floating-point values, in some cases the Round(Double, Int32, MidpointRounding) method may not appear to round midpoint values as specified by the mode parameter. Cela est illustré dans l’exemple suivant, où 2,135 est arrondi à 2,13 au lieu de 2,14.This is illustrated in the following example, where 2.135 is rounded to 2.13 instead of 2.14. Cela se produit car en interne, la méthode multiplie value par 10chiffres, et l’opération de multiplication dans ce cas subit une perte de précision.This occurs because internally the method multiplies value by 10digits, and the multiplication operation in this case suffers from a loss of precision.

::: code Language = "CSharp" source = "~/Samples/snippets/CSharp/VS_Snippets_CLR_System/System.Math.Round/CS/round4.cs" interactive = "Try-DotNet-method" ID = "Snippet3" :::::: code Language = "VB" source = "~/Samples/snippets/VisualBasic/VS_Snippets_CLR_System/System.Math.Round/VB/round4.vb" ID = "Snippet3" ::::::code language="csharp" source="~/samples/snippets/csharp/VS_Snippets_CLR_System/system.math.round/cs/round4.cs" interactive="try-dotnet-method" id="Snippet3"::: :::code language="vb" source="~/samples/snippets/visualbasic/VS_Snippets_CLR_System/system.math.round/vb/round4.vb" id="Snippet3":::

Voir aussi

S’applique à

Round(Double, MidpointRounding)

Arrondit un nombre à virgule flottante double précision au nombre entier le plus proche, et utilise la convention d’arrondi spécifiée pour les valeurs médianes.Rounds a double-precision floating-point value to the nearest integer, and uses the specified rounding convention for midpoint values.

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

Paramètres

value
Double

Nombre à virgule flottante double précision à arrondir.A double-precision floating-point number to be rounded.

mode
MidpointRounding

Spécification sur la façon d'arrondir value s'il se trouve à mi-chemin entre deux nombres.Specification for how to round value if it is midway between two other numbers.

Retours

Double

Entier le plus proche de value.The integer nearest value. Si value se trouve à égale distance de deux entiers, l'un pair et l'autre impair, mode détermine le nombre qui sera retourné.If value is halfway between two integers, one of which is even and the other odd, then mode determines which of the two is returned. Notez que cette méthode retourne un objet Double plutôt qu'un type intégral.Note that this method returns a Double instead of an integral type.

Exceptions

mode n’est pas une valeur valide de MidpointRounding.mode is not a valid value of MidpointRounding.

Remarques

Pour plus d’informations sur l’arrondi des nombres avec des valeurs médianes, consultez valeurs de point médian et conventions d’arrondi .See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Important

Pour arrondir les valeurs du point médian, l’algorithme d’arrondi effectue un test d’égalité.When rounding midpoint values, the rounding algorithm performs an equality test. En raison de problèmes liés à la représentation binaire et à la précision du format à virgule flottante, la valeur retournée par la méthode peut être inattendue.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Pour plus d’informations, consultez « Arrondi et précision ».For more information, see "Rounding and precision".

Si la valeur de l' value argument est Double.NaN , la méthode retourne Double.NaN .If the value of the value argument is Double.NaN, the method returns Double.NaN. Si value a Double.PositiveInfinity la valeur ou Double.NegativeInfinity , la méthode retourne Double.PositiveInfinity ou Double.NegativeInfinity , respectivement.If value is Double.PositiveInfinity or Double.NegativeInfinity, the method returns Double.PositiveInfinity or Double.NegativeInfinity, respectively.

ExempleExample

L’exemple suivant affiche les valeurs retournées par la Round(Double) méthode, la Round(Double, MidpointRounding) méthode avec un mode argument de ToEven et la Round(Double, MidpointRounding) méthode avec un mode argument de AwayFromZero .The following example displays values returned by the Round(Double) method, the Round(Double, MidpointRounding) method with a mode argument of ToEven, and the Round(Double, MidpointRounding) method with a mode argument of AwayFromZero.

using System;

public class Example
{
   public static void Main()
   {
      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("{0,-10} {1,-10} {2,-10} {3,-15}", "Value", "Default",
                        "ToEven", "AwayFromZero");
      foreach (var value in values)
         Console.WriteLine("{0,-10:R} {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()
      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}", "Value", "Default", 
                        "ToEven", "AwayFromZero")
      For Each value In values
         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

Notes pour les appelants

En raison de la perte de précision qui peut résulter de la représentation de valeurs décimales sous la forme de nombres à virgule flottante ou d’opérations arithmétiques sur des valeurs à virgule flottante, il Round(Double, MidpointRounding) se peut que la méthode n’apparaisse pas pour arrondir les valeurs médianes à l’entier pair le plus proche.Because of the loss of precision that can result from representing decimal values as floating-point numbers or performing arithmetic operations on floating-point values, in some cases the Round(Double, MidpointRounding) method may not appear to round midpoint values to the nearest even integer. Dans l’exemple suivant, étant donné que la valeur à virgule flottante. 1 n’a pas de représentation binaire finie, le premier appel à la Round(Double) méthode avec une valeur de 11,5 retourne 11 au lieu de 12.In the following example, because the floating-point value .1 has no finite binary representation, the first call to the Round(Double) method with a value of 11.5 returns 11 instead of 12.

::: code Language = "CSharp" source = "~/Samples/snippets/CSharp/VS_Snippets_CLR_System/System.Math.Round/CS/round5.cs" interactive = "Try-dotnet" ID = "Snippet4" :::::: code Language = "VB" source = "~/Samples/snippets/VisualBasic/VS_Snippets_CLR_System/System.Math.Round/VB/round5.vb" ID = "Snippet4" ::::::code language="csharp" source="~/samples/snippets/csharp/VS_Snippets_CLR_System/system.math.round/cs/round5.cs" interactive="try-dotnet" id="Snippet4"::: :::code language="vb" source="~/samples/snippets/visualbasic/VS_Snippets_CLR_System/system.math.round/vb/round5.vb" id="Snippet4":::

Voir aussi

S’applique à

Round(Double, Int32)

Arrondit un nombre à virgule flottante double précision au nombre de chiffres fractionnaires spécifié, et les valeurs médianes au nombre pair le plus proche.Rounds a double-precision floating-point value to a specified number of fractional digits, and rounds midpoint values to the nearest even number.

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

Paramètres

value
Double

Nombre à virgule flottante double précision à arrondir.A double-precision floating-point number to be rounded.

digits
Int32

Nombre de chiffres fractionnaires de la valeur de retour.The number of fractional digits in the return value.

Retours

Double

Nombre le plus proche de value contenant un nombre de chiffres fractionnaires égal à digits.The number nearest to value that contains a number of fractional digits equal to digits.

Exceptions

digits est inférieur à 0 ou supérieur à 15.digits is less than 0 or greater than 15.

Remarques

La valeur de l' digits argument peut être comprise entre 0 et 15.The value of the digits argument can range from 0 to 15. Notez que 15 est le nombre maximal de chiffres intégraux et fractionnaires pris en charge par le Double type.Note that 15 is the maximum number of integral and fractional digits supported by the Double type.

Cette méthode utilise la Convention d’arrondi par défaut de MidpointRounding.ToEven .This method uses the default rounding convention of MidpointRounding.ToEven. Pour plus d’informations sur l’arrondi des nombres avec des valeurs médianes, consultez valeurs de point médian et conventions d’arrondi .See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Important

Pour arrondir les valeurs du point médian, l’algorithme d’arrondi effectue un test d’égalité.When rounding midpoint values, the rounding algorithm performs an equality test. En raison de problèmes liés à la représentation binaire et à la précision du format à virgule flottante, la valeur retournée par la méthode peut être inattendue.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Pour plus d’informations, consultez « Arrondi et précision ».For more information, see "Rounding and precision".

Si la valeur de l' value argument est Double.NaN , la méthode retourne Double.NaN .If the value of the value argument is Double.NaN, the method returns Double.NaN. Si value a Double.PositiveInfinity la valeur ou Double.NegativeInfinity , la méthode retourne Double.PositiveInfinity ou Double.NegativeInfinity , respectivement.If value is Double.PositiveInfinity or Double.NegativeInfinity, the method returns Double.PositiveInfinity or Double.NegativeInfinity, respectively.

ExempleExample

L’exemple suivant arrondit les valeurs doubles avec deux chiffres fractionnaires à des doubles qui ont un seul chiffre fractionnaire.The following example rounds double values with two fractional digits to doubles that have a single fractional digit.

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

Notes pour les appelants

En raison de la perte de précision qui peut résulter de la représentation de valeurs décimales sous la forme de nombres à virgule flottante ou d’opérations arithmétiques sur des valeurs à virgule flottante, la Round(Double, Int32) méthode peut ne pas apparaître pour arrondir les valeurs médianes à la valeur paire la plus proche dans la digits position décimale.Because of the loss of precision that can result from representing decimal values as floating-point numbers or performing arithmetic operations on floating-point values, in some cases the Round(Double, Int32) method may not appear to round midpoint values to the nearest even value in the digits decimal position. Cela est illustré dans l’exemple suivant, où 2,135 est arrondi à 2,13 au lieu de 2,14.This is illustrated in the following example, where 2.135 is rounded to 2.13 instead of 2.14. Cela se produit car en interne, la méthode multiplie value par 10chiffres, et l’opération de multiplication dans ce cas subit une perte de précision.This occurs because internally the method multiplies value by 10digits, and the multiplication operation in this case suffers from a loss of precision.

::: code Language = "CSharp" source = "~/Samples/snippets/CSharp/VS_Snippets_CLR_System/System.Math.Round/CS/Round3.cs" interactive = "Try-dotnet" ID = "Snippet2" :::::: code Language = "VB" source = "~/Samples/snippets/VisualBasic/VS_Snippets_CLR_System/System.Math.Round/VB/Round3.vb" ID = "Snippet2" ::::::code language="csharp" source="~/samples/snippets/csharp/VS_Snippets_CLR_System/system.math.round/cs/round3.cs" interactive="try-dotnet" id="Snippet2"::: :::code language="vb" source="~/samples/snippets/visualbasic/VS_Snippets_CLR_System/system.math.round/vb/round3.vb" id="Snippet2":::

Voir aussi

S’applique à

Round(Double)

Arrondit un nombre à virgule flottante double précision au nombre entier le plus proche, et les valeurs médianes au nombre pair le plus proche.Rounds a double-precision floating-point value to the nearest integral value, and rounds midpoint values to the nearest even number.

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

Paramètres

a
Double

Nombre à virgule flottante double précision à arrondir.A double-precision floating-point number to be rounded.

Retours

Double

Entier le plus proche de a.The integer nearest a. Si le composant fractionnaire de a se trouve à égale distance de deux entiers, l'un pair et l'autre impair, le nombre pair est retourné.If the fractional component of a is halfway between two integers, one of which is even and the other odd, then the even number is returned. Notez que cette méthode retourne un objet Double plutôt qu'un type intégral.Note that this method returns a Double instead of an integral type.

Remarques

Cette méthode utilise la Convention d’arrondi par défaut de MidpointRounding.ToEven .This method uses the default rounding convention of MidpointRounding.ToEven. Pour plus d’informations sur l’arrondi des nombres avec des valeurs médianes, consultez valeurs de point médian et conventions d’arrondi .See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Important

Pour arrondir les valeurs du point médian, l’algorithme d’arrondi effectue un test d’égalité.When rounding midpoint values, the rounding algorithm performs an equality test. En raison de problèmes liés à la représentation binaire et à la précision du format à virgule flottante, la valeur retournée par la méthode peut être inattendue.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Pour plus d’informations, consultez « Arrondi et précision ».For more information, see "Rounding and precision".

Si la valeur de l' a argument est Double.NaN , la méthode retourne Double.NaN .If the value of the a argument is Double.NaN, the method returns Double.NaN. Si a a Double.PositiveInfinity la valeur ou Double.NegativeInfinity , la méthode retourne Double.PositiveInfinity ou Double.NegativeInfinity , respectivement.If a is Double.PositiveInfinity or Double.NegativeInfinity, the method returns Double.PositiveInfinity or Double.NegativeInfinity, respectively.

À compter de Visual Basic 15,8, les performances de la conversion de double à entier sont optimisées si vous transmettez la valeur retournée par la Round méthode à l’une des fonctions de conversion intégrale, ou si la valeur double retournée par Round est automatiquement convertie en un entier avec option strict définie à OFF.Starting with Visual Basic 15.8, the performance of Double-to-integer conversion is optimized if you pass the value returned by the Round method to the any of the integral conversion functions, or if the Double value returned by Round is automatically converted to an integer with Option Strict set to Off. Cette optimisation permet au code de s’exécuter plus rapidement (jusqu’à deux fois plus rapidement pour le code qui effectue un grand nombre de conversions en types d’entier).This optimization allows code to run faster -- up to twice as fast for code that does a large number of conversions to integer types. L’exemple suivant illustre ces conversions optimisées :The following example illustrates such optimized conversions:

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

ExempleExample

L’exemple suivant illustre l’arrondi à la valeur entière la plus proche.The following example demonstrates rounding to the nearest integer value.

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

Notes pour les appelants

En raison de la perte de précision qui peut résulter de la représentation de valeurs décimales sous la forme de nombres à virgule flottante ou d’opérations arithmétiques sur des valeurs à virgule flottante, il Round(Double) se peut que la méthode n’apparaisse pas pour arrondir les valeurs médianes à l’entier pair le plus proche.Because of the loss of precision that can result from representing decimal values as floating-point numbers or performing arithmetic operations on floating-point values, in some cases the Round(Double) method may not appear to round midpoint values to the nearest even integer. Dans l’exemple suivant, étant donné que la valeur à virgule flottante. 1 n’a pas de représentation binaire finie, le premier appel à la Round(Double) méthode avec une valeur de 11,5 retourne 11 au lieu de 12.In the following example, because the floating-point value .1 has no finite binary representation, the first call to the Round(Double) method with a value of 11.5 returns 11 instead of 12.

::: code Language = "CSharp" source = "~/Samples/snippets/CSharp/VS_Snippets_CLR_System/System.Math.Round/CS/Round2.cs" interactive = "Try-dotnet" ID = "Snippet1" :::::: code Language = "VB" source = "~/Samples/snippets/VisualBasic/VS_Snippets_CLR_System/System.Math.Round/VB/Round2.vb" ID = "Snippet1" ::::::code language="csharp" source="~/samples/snippets/csharp/VS_Snippets_CLR_System/system.math.round/cs/round2.cs" interactive="try-dotnet" id="Snippet1"::: :::code language="vb" source="~/samples/snippets/visualbasic/VS_Snippets_CLR_System/system.math.round/vb/round2.vb" id="Snippet1":::

Voir aussi

S’applique à

Round(Decimal, Int32)

Arrondit une valeur décimale au nombre de chiffres fractionnaires spécifié, et les valeurs médianes au nombre pair le plus proche.Rounds a decimal value to a specified number of fractional digits, and rounds midpoint values to the nearest even number.

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 be rounded.

decimals
Int32

Nombre de décimales de la valeur de retour.The number of decimal places in the return value.

Retours

Decimal

Nombre le plus proche de d contenant un nombre de chiffres fractionnaires égal à decimals.The number nearest to d that contains a number of fractional digits equal to decimals.

Exceptions

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

Le résultat est à l'extérieur de la plage d'un Decimal.The result is outside the range of a Decimal.

Remarques

La valeur de l' decimals argument peut être comprise entre 0 et 28.The value of the decimals argument can range from 0 to 28.

Cette méthode utilise la Convention d’arrondi par défaut de MidpointRounding.ToEven .This method uses the default rounding convention of MidpointRounding.ToEven. Pour plus d’informations sur l’arrondi des nombres avec des valeurs médianes, consultez valeurs de point médian et conventions d’arrondi .See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Important

Pour arrondir les valeurs du point médian, l’algorithme d’arrondi effectue un test d’égalité.When rounding midpoint values, the rounding algorithm performs an equality test. En raison de problèmes liés à la représentation binaire et à la précision du format à virgule flottante, la valeur retournée par la méthode peut être inattendue.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Pour plus d’informations, consultez « Arrondi et précision ».For more information, see "Rounding and precision".

ExempleExample

L’exemple suivant arrondit les valeurs décimales avec deux chiffres fractionnaires à des valeurs qui ont un seul chiffre fractionnaire.The following example rounds decimal values with two fractional digits to values that have a single fractional digit.

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
Public Module Example
   Sub Main()
      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)) 
   End Sub  
End Module
' The example displays the following output:
'       3.4
'       3.4
'       3.5
'       
'       4.3
'       4.4
'       4.4

Voir aussi

S’applique à

Round(Decimal)

Arrondit une valeur décimale au nombre entier le plus proche, et les valeurs médianes au nombre pair le plus proche.Rounds a decimal value to the nearest integral value, and rounds midpoint values to the nearest even number.

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 be rounded.

Retours

Decimal

Le nombre entier le plus proche du paramètre d.The integer nearest the d parameter. Si le composant fractionnaire de d se trouve à égale distance de deux entiers, l'un pair et l'autre impair, le nombre pair est retourné.If the fractional component of d is halfway between two integers, one of which is even and the other odd, the even number is returned. Notez que cette méthode retourne un objet Decimal plutôt qu'un type intégral.Note that this method returns a Decimal instead of an integral type.

Exceptions

Le résultat est à l'extérieur de la plage d'un Decimal.The result is outside the range of a Decimal.

Exemples

L’exemple suivant illustre la Round(Decimal) méthode.The following example demonstrates the Round(Decimal) method. Notez que la Decimal valeur de 4,5 est arrondie à 4 au lieu de 5, car cette surcharge utilise la Convention par défaut ToEven .Note that the Decimal value of 4.5 rounds to 4 rather than 5, because this overload uses the default ToEven convention.

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

Remarques

Cette méthode utilise la Convention d’arrondi par défaut de MidpointRounding.ToEven .This method uses the default rounding convention of MidpointRounding.ToEven. Pour plus d’informations sur l’arrondi des nombres avec des valeurs médianes, consultez valeurs de point médian et conventions d’arrondi .See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Important

Pour arrondir les valeurs du point médian, l’algorithme d’arrondi effectue un test d’égalité.When rounding midpoint values, the rounding algorithm performs an equality test. En raison de problèmes liés à la représentation binaire et à la précision du format à virgule flottante, la valeur retournée par la méthode peut être inattendue.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Pour plus d’informations, consultez « Arrondi et précision ».For more information, see "Rounding and precision".

Voir aussi

S’applique à

Round(Decimal, MidpointRounding)

Arrondit une valeur décimale au nombre entier le plus proche, et utilise la convention d’arrondi spécifiée pour les valeurs médianes.Rounds a decimal value to the nearest integer, and uses the specified rounding convention for midpoint values.

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 be rounded.

mode
MidpointRounding

Spécification sur la façon d'arrondir d s'il se trouve à mi-chemin entre deux nombres.Specification for how to round d if it is midway between two other numbers.

Retours

Decimal

Entier le plus proche de d.The integer nearest d. Si d se trouve à égale distance de deux nombres, l'un pair et l'autre impair, mode détermine le nombre qui sera retourné.If d is halfway between two numbers, one of which is even and the other odd, then mode determines which of the two is returned. Notez que cette méthode retourne un objet Decimal plutôt qu'un type intégral.Note that this method returns a Decimal instead of an integral type.

Exceptions

mode n’est pas une valeur valide de MidpointRounding.mode is not a valid value of MidpointRounding.

Le résultat est à l'extérieur de la plage d'un Decimal.The result is outside the range of a Decimal.

Remarques

Pour plus d’informations sur l’arrondi des nombres avec des valeurs médianes, consultez valeurs de point médian et conventions d’arrondi .See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.

Important

Pour arrondir les valeurs du point médian, l’algorithme d’arrondi effectue un test d’égalité.When rounding midpoint values, the rounding algorithm performs an equality test. En raison de problèmes liés à la représentation binaire et à la précision du format à virgule flottante, la valeur retournée par la méthode peut être inattendue.Because of problems of binary representation and precision in the floating-point format, the value returned by the method can be unexpected. Pour plus d’informations, consultez « Arrondi et précision ».For more information, see "Rounding and precision".

ExempleExample

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

Voir aussi

S’applique à