Math.Round Méthode

  • Référence

Définition

Espace de noms:
System
Assembly:
System.Runtime.Extensions.dll
Assembly:
System.Runtime.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll

Arrondit une valeur à l'entier le plus proche ou au nombre spécifié de chiffres fractionnaires.

Surcharges

Round(Double, Int32, MidpointRounding)

Arrondit une valeur à virgule flottante double précision à un nombre spécifié de chiffres fractionnaires à l’aide de la convention d’arrondi spécifiée.
Round(Decimal, Int32, MidpointRounding)

Arrondit une valeur décimale à un nombre spécifié de chiffres fractionnaires à l’aide de la convention d’arrondi spécifiée.
Round(Double, MidpointRounding)

Arrondit une valeur à virgule flottante double précision à un entier à l’aide de la convention d’arrondi spécifiée.
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.
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.
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.
Round(Decimal)

Arrondit une valeur décimale au nombre entier le plus proche, et les valeurs médianes au nombre pair le plus proche.
Round(Decimal, MidpointRounding)

Arrondit une valeur décimale à un entier à l’aide de la convention d’arrondi spécifiée.

Exemples

Outre les exemples de la section Notes , cet article inclut des exemples qui illustrent les surcharges suivantes de la Math.Round méthode :

Math.Round(Decimal)Math.Round(Double)Math.Round(Decimal, Int32)Math.Round(Decimal, MidpointRounding)Math.Round(Double, Int32)Math.Round(Double, MidpointRounding)Math.Round(Decimal, Int32, MidpointRounding)Math.Round(Double, Int32, MidpointRounding)

Remarques

Dans cette section :

Quelle méthode dois-je appeler ?

Vous pouvez utiliser le tableau suivant pour sélectionner une méthode d’arrondi appropriée. En plus des Math.Round méthodes, il inclut Math.Ceiling également et Math.Floor.

À Call
Arrondir un nombre à un entier à l’aide de la convention d’arrondi à la plus proche. Round(Decimal)
- ou -
Round(Double)
Arrondir un nombre à un entier à l’aide d’une convention d’arrondi spécifiée. Round(Decimal, MidpointRounding)
- ou -
Round(Double, MidpointRounding)
Arrondir un nombre à un nombre spécifié de chiffres fractionnaires en utilisant l’arrondi à la convention la plus proche. Round(Decimal, Int32)
- ou -
Round(Double, Int32)
Arrondir un nombre à un nombre spécifié de chiffres fractionnaires à l’aide d’une convention d’arrondi spécifiée. Round(Decimal, Int32, MidpointRounding)
- ou -
Round(Double, Int32, MidpointRounding)
Arrondir une Single valeur à un nombre spécifié de chiffres fractionnaires en utilisant une convention d’arrondi spécifiée et en minimisant la perte de précision. Convertissez en Single et Decimal appelez Round(Decimal, Int32, MidpointRounding).
Arrondir un nombre à un nombre spécifié de chiffres fractionnaires tout en réduisant les problèmes de précision lors de l’arrondi des valeurs du point moyen. Appelez une méthode d’arrondi qui implémente une comparaison « supérieure ou approximativement égale à ». Consultez Arrondi et précision.
Arrondir une valeur fractionnaire à un entier supérieur à la valeur fractionnaire. Par exemple, arrondissez 3.1 à 4. Ceiling
Arrondir une valeur fractionnaire à un entier inférieur à la valeur fractionnaire. Par exemple, arrondissez 3.9 à 3. Floor

Valeurs de point intermédiaire et conventions d’arrondi

L’arrondi implique la conversion d’une valeur numérique avec une précision spécifiée en valeur avec moins de précision. 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.

Dans une valeur de point intermédiaire, la valeur après le chiffre le moins significatif dans le résultat est précisément à la moitié entre deux nombres. Par exemple, 3,47500 est une valeur de point intermédiaire si elle doit être arrondie à deux décimales, et 7,500 est une valeur de point intermédiaire si elle doit être arrondie à un entier. Dans ce cas, si la stratégie arrondie à la plus proche est utilisée, la valeur la plus proche ne peut pas être facilement identifiée sans une convention d’arrondi.

La Round méthode prend en charge deux conventions d’arrondi pour la gestion des valeurs de point intermédiaire :

  • Arrondi à zéro

    Les valeurs médianes sont arrondies au nombre suivant, loin de zéro. Par exemple, 3,75 arrondit à 3,8, 3,85 arrondit à 3,9, -3,75 arrondit à -3,8 et -3,85 arrondit à -3,9. Cette forme d’arrondi est représentée par le membre d’énumération MidpointRounding.AwayFromZero .

  • Arrondi à la paire la plus proche, ou arrondi du banquier

    Les valeurs médianes sont arrondies au nombre pair le plus proche. Par exemple, 3,75 et 3,85 arrondit à 3,8, et -3,75 et -3,85 arrondit à -3,8. Cette forme d’arrondi est représentée par le membre d’énumération MidpointRounding.ToEven .

Notes

Dans .NET Core 3.0 et versions ultérieures, trois stratégies d’arrondi supplémentaires sont disponibles via l’énumération MidpointRounding . Ces stratégies sont utilisées dans tous les cas, pas seulement pour les valeurs de point intermédiaire telles que MidpointRounding.ToEven et MidpointRounding.AwayFromZero sont.

L’arrondi à zéro est la forme d’arrondi la plus connue, tandis que l’arrondi à la plus proche même est la norme dans les opérations financières et statistiques. Il est conforme à la norme IEEE 754, section 4. Lorsqu’il est utilisé dans plusieurs opérations d’arrondi, l’arrondi à la plus proche réduit même l’erreur d’arrondi provoquée par l’arrondi systématiquement des valeurs de point médian dans une seule direction. Dans certains cas, cette erreur d’arrondi peut être significative.

L’exemple suivant illustre le biais qui peut résulter de l’arrondi constant des valeurs médianes dans une seule direction. L’exemple calcule la vraie moyenne d’un tableau de Decimal valeurs, puis calcule la moyenne lorsque les valeurs du tableau sont arrondies à l’aide des deux conventions. Dans cet exemple, la moyenne vraie et la moyenne que les résultats lors de l’arrondi au plus proche sont les mêmes. Toutefois, la moyenne des résultats lors de l’arrondi de zéro diffère de 0,05 (ou de 3,6 %) de la moyenne réelle.

decimal[] values = { 1.15m, 1.25m, 1.35m, 1.45m, 1.55m, 1.65m };
decimal sum = 0;

// Calculate true mean.
foreach (var value in values)
    sum += value;

Console.WriteLine("True mean:     {0:N2}", sum / values.Length);

// Calculate mean with rounding away from zero.
sum = 0;
foreach (var value in values)
    sum += Math.Round(value, 1, MidpointRounding.AwayFromZero);

Console.WriteLine("AwayFromZero:  {0:N2}", sum / values.Length);

// Calculate mean with rounding to nearest.
sum = 0;
foreach (var value in values)
    sum += Math.Round(value, 1, MidpointRounding.ToEven);

Console.WriteLine("ToEven:        {0:N2}", sum / values.Length);

// The example displays the following output:
//       True mean:     1.40
//       AwayFromZero:  1.45
//       ToEven:        1.40

open System

let values = [| 1.15m; 1.25m; 1.35m; 1.45m; 1.55m; 1.65m |]
let mutable sum = 0m

// Calculate true mean.
for value in values do
    sum <- sum + value

printfn $"True mean:     {sum / decimal values.Length:N2}"

// Calculate mean with rounding away from zero.
sum <- 0m
for value in values do
    sum <- sum + Math.Round(value, 1, MidpointRounding.AwayFromZero)

printfn $"AwayFromZero:  {sum / decimal values.Length:N2}"

// Calculate mean with rounding to nearest.
sum <- 0m
for value in values do
    sum <- sum + Math.Round(value, 1, MidpointRounding.ToEven)

printfn $"ToEven:        {sum / decimal values.Length:N2}"

// The example displays the following output:
//       True mean:     1.40
//       AwayFromZero:  1.45
//       ToEven:        1.40

Dim values() As Decimal = {1.15D, 1.25D, 1.35D, 1.45D, 1.55D, 1.65D}
Dim sum As Decimal

' Calculate true mean.
For Each value In values
    sum += value
Next
Console.WriteLine("True mean:     {0:N2}", sum / values.Length)

' Calculate mean with rounding away from zero.
sum = 0
For Each value In values
    sum += Math.Round(value, 1, MidpointRounding.AwayFromZero)
Next
Console.WriteLine("AwayFromZero:  {0:N2}", sum / values.Length)

' Calculate mean with rounding to nearest.
sum = 0
For Each value In values
    sum += Math.Round(value, 1, MidpointRounding.ToEven)
Next
Console.WriteLine("ToEven:        {0:N2}", sum / values.Length)

' The example displays the following output:
'       True mean:     1.40
'       AwayFromZero:  1.45
'       ToEven:        1.40

Par défaut, la Round méthode utilise la convention arrondie à la convention paire la plus proche. Le tableau suivant répertorie les surcharges de la méthode et la Round convention d’arrondi que chacun utilise.

Surcharge Convention d’arrondi
Round(Decimal) ToEven
Round(Double) ToEven
Round(Decimal, Int32) ToEven
Round(Double, Int32) ToEven
Round(Decimal, MidpointRounding) Déterminé par mode paramètre.
Round(Double, MidpointRounding) Déterminé par mode le paramètre
Round(Decimal, Int32, MidpointRounding) Déterminé par mode le paramètre
Round(Double, Int32, MidpointRounding) Déterminé par mode le paramètre

Arrondi et précision

Pour déterminer si une opération d’arrondi implique une valeur médiane, la Round méthode multiplie la valeur d’origine pour être arrondie par 10n, où n est le nombre souhaité de chiffres fractionnaires dans la valeur renvoyée, puis détermine si la partie fractionnaire restante de la valeur est supérieure ou égale à .5. Il s’agit d’une légère variation d’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 les valeurs à virgule flottante sont problématiques en raison des problèmes de représentation binaire et de précision du format à virgule flottante. Cela signifie que toute partie fractionnaire d’un nombre légèrement inférieur à .5 (en raison d’une perte de précision) ne sera pas arrondie vers le haut.

L'exemple de code suivant illustre le problème. Il ajoute à plusieurs reprises .1 à 11.0 et arrondit le résultat à l’entier le plus proche. 11.5 doit arrondir à 12 à l’aide de l’une des conventions d’arrondi du point intermédiaire (ToEven ou AwayFromZero). Toutefois, comme le montre la sortie de l’exemple, ce n’est pas le cas. L’exemple utilise la chaîne de format numérique standard « R » pour afficher la précision totale de la valeur à virgule flottante et montre que la valeur à arrondir a perdu de précision lors d’ajouts répétés, et sa valeur est en fait 11,4999999999998. Étant donné que .499999999999998 est inférieur à .5, les conventions d’arrondi du point médian n’entrent pas en jeu et la valeur est arrondie vers le bas. Comme le montre également l’exemple, ce problème ne se produit pas si vous affectez la valeur constante 11.5 à une Double variable.

public static void Example()
{
    Console.WriteLine("{0,5} {1,20:R}  {2,12} {3,15}\n",
                      "Value", "Full Precision", "ToEven",
                      "AwayFromZero");
    double value = 11.1;
    for (int ctr = 0; ctr <= 5; ctr++)
        value = RoundValueAndAdd(value);

    Console.WriteLine();

    value = 11.5;
    RoundValueAndAdd(value);
}

private static double RoundValueAndAdd(double value)
{
    Console.WriteLine("{0,5:N1} {0,20:R}  {1,12} {2,15}",
                      value, Math.Round(value, MidpointRounding.ToEven),
                      Math.Round(value, MidpointRounding.AwayFromZero));
    return value + .1;
}

// The example displays the following output:
//       Value       Full Precision        ToEven    AwayFromZero
//
//        11.1                 11.1            11              11
//        11.2                 11.2            11              11
//        11.3   11.299999999999999            11              11
//        11.4   11.399999999999999            11              11
//        11.5   11.499999999999998            11              11
//        11.6   11.599999999999998            12              12
//
//        11.5                 11.5            12              12

open System

let roundValueAndAdd (value: double) =
    printfn $"{value,5:N1} {value,20:R}  {Math.Round(value, MidpointRounding.ToEven),12} {Math.Round(value, MidpointRounding.AwayFromZero),15}"
    value + 0.1

printfn "%5s %20s  %12s %15s\n" "Value" "Full Precision" "ToEven" "AwayFromZero"
let mutable value = 11.1
for _ = 0 to 5 do
    value <- roundValueAndAdd value

printfn ""

value <- 11.5
roundValueAndAdd value
|> ignore

// The example displays the following output:
//       Value       Full Precision        ToEven    AwayFromZero
//
//        11.1                 11.1            11              11
//        11.2                 11.2            11              11
//        11.3   11.299999999999999            11              11
//        11.4   11.399999999999999            11              11
//        11.5   11.499999999999998            11              11
//        11.6   11.599999999999998            12              12
//
//        11.5                 11.5            12              12

Public Sub Example()
    Dim value As Double = 11.1

    Console.WriteLine("{0,5} {1,20:R}  {2,12} {3,15}",
                    "Value", "Full Precision", "ToEven",
                    "AwayFromZero")
    Console.WriteLine()
    For ctr As Integer = 0 To 5
        value = RoundValueAndAdd(value)
    Next
    Console.WriteLine()

    value = 11.5
    RoundValueAndAdd(value)
End Sub

Private Function RoundValueAndAdd(value As Double) As Double
    Console.WriteLine("{0,5:N1} {0,20:R}  {1,12} {2,15}",
                    value, Math.Round(value, MidpointRounding.ToEven),
                    Math.Round(value, MidpointRounding.AwayFromZero))
    Return value + 0.1
End Function

' The example displays the following output:
'       Value       Full Precision        ToEven    AwayFromZero
'       
'        11.1                 11.1            11              11
'        11.2                 11.2            11              11
'        11.3   11.299999999999999            11              11
'        11.4   11.399999999999999            11              11
'        11.5   11.499999999999998            11              11
'        11.6   11.599999999999998            12              12
'       
'        11.5                 11.5            12              12

Les problèmes de précision dans l’arrondi des valeurs médianes sont plus susceptibles de se produire dans les conditions suivantes :

  • Lorsqu’une valeur fractionnaire ne peut pas être exprimée précisément dans le format binaire du type à virgule flottante.

  • Lorsque la valeur à arrondir est calculée à partir d’une ou plusieurs opérations à virgule flottante.

  • Lorsque la valeur à arrondir est un Single plutôt qu’un Double ou Decimal. Pour plus d’informations, consultez la section suivante, Arrondi et valeurs à virgule flottante simple précision.

Dans les cas où le manque de précision dans les opérations d’arrondi est problématique, vous pouvez effectuer les opérations suivantes :

  • Si l’opération d’arrondi appelle une surcharge qui arrondit une Double valeur, vous pouvez remplacer par une Decimal valeur et appeler une surcharge qui arrondit une Decimal valeur à la Double place. 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 courants.

  • Définissez un algorithme d’arrondi personnalisé qui effectue un test « presque égal » pour déterminer si la valeur à arrondir est acceptablement proche d’une valeur médiane. L’exemple suivant définit une RoundApproximate méthode qui examine si une valeur fractionnaire est suffisamment proche d’une valeur médiane pour être soumise à l’arrondi de point intermédiaire. Comme le montre la sortie de l’exemple, il corrige le problème d’arrondi indiqué dans l’exemple précédent.

    public static void Example()
{
    Console.WriteLine("{0,5} {1,20:R}  {2,12} {3,15}\n",
                      "Value", "Full Precision", "ToEven",
                      "AwayFromZero");
    double value = 11.1;
    for (int ctr = 0; ctr <= 5; ctr++)
        value = RoundValueAndAdd(value);

    Console.WriteLine();

    value = 11.5;
    RoundValueAndAdd(value);
}

private static double RoundValueAndAdd(double value)
{
    const double tolerance = 8e-14;

    Console.WriteLine("{0,5:N1} {0,20:R}  {1,12} {2,15}",
                      value,
                      RoundApproximate(value, 0, tolerance, MidpointRounding.ToEven),
                      RoundApproximate(value, 0, tolerance, MidpointRounding.AwayFromZero));
    return value + .1;
}

private static double RoundApproximate(double dbl, int digits, double margin,
                                  MidpointRounding mode)
{
    double fraction = dbl * Math.Pow(10, digits);
    double value = Math.Truncate(fraction);
    fraction = fraction - value;
    if (fraction == 0)
        return dbl;

    double tolerance = margin * dbl;
    // Determine whether this is a midpoint value.
    if ((fraction >= .5 - tolerance) & (fraction <= .5 + tolerance))
    {
        if (mode == MidpointRounding.AwayFromZero)
            return (value + 1) / Math.Pow(10, digits);
        else
           if (value % 2 != 0)
            return (value + 1) / Math.Pow(10, digits);
        else
            return value / Math.Pow(10, digits);
    }
    // Any remaining fractional value greater than .5 is not a midpoint value.
    if (fraction > .5)
        return (value + 1) / Math.Pow(10, digits);
    else
        return value / Math.Pow(10, digits);
}

// The example displays the following output:
//       Value       Full Precision        ToEven    AwayFromZero
//
//        11.1                 11.1            11              11
//        11.2                 11.2            11              11
//        11.3   11.299999999999999            11              11
//        11.4   11.399999999999999            11              11
//        11.5   11.499999999999998            12              12
//        11.6   11.599999999999998            12              12
//
//        11.5                 11.5            12              12

    open System

let roundApproximate dbl digits margin mode =
    let fraction = dbl * Math.Pow(10, digits)
    let value = Math.Truncate fraction
    let fraction = fraction - value
    if fraction = 0 then
        dbl
    else
        let tolerance = margin * dbl
        // Determine whether this is a midpoint value.
        if (fraction >= 0.5 - tolerance) && (fraction <= 0.5 + tolerance) then
            if mode = MidpointRounding.AwayFromZero then
                (value + 1.) / Math.Pow(10, digits)
            elif value % 2. <> 0 then
                (value + 1.) / Math.Pow(10, digits)
            else
                value / Math.Pow(10, digits)
        // Any remaining fractional value greater than .5 is not a midpoint value.
        elif fraction > 0.5 then
            (value + 1.) / Math.Pow(10, digits)
        else
            value / Math.Pow(10, digits)


let roundValueAndAdd value =
    let tolerance = 8e-14
    let round = roundApproximate value 0 tolerance

    printfn $"{value,5:N1} {value,20:R}  {round MidpointRounding.ToEven,12} {round MidpointRounding.AwayFromZero,15}"
    value + 0.1

printfn "%5s %20s  %12s %15s\n" "Value" "Full Precision" "ToEven" "AwayFromZero"
let mutable value = 11.1
for _ = 0 to 5 do
    value <- roundValueAndAdd value

printfn ""

value <- 11.5
roundValueAndAdd value 
|> ignore

// The example displays the following output:
//       Value       Full Precision        ToEven    AwayFromZero
//
//        11.1                 11.1            11              11
//        11.2                 11.2            11              11
//        11.3   11.299999999999999            11              11
//        11.4   11.399999999999999            11              11
//        11.5   11.499999999999998            12              12
//        11.6   11.599999999999998            12              12
//
//        11.5                 11.5            12              12

    Public Sub Example()
    Dim value As Double = 11.1

    Console.WriteLine("{0,5} {1,20:R}  {2,12} {3,15}\n",
                    "Value", "Full Precision", "ToEven",
                    "AwayFromZero")
    For ctr As Integer = 0 To 5
        value = RoundValueAndAdd(value)
    Next
    Console.WriteLine()

    value = 11.5
    RoundValueAndAdd(value)
End Sub

Private Function RoundValueAndAdd(value As Double) As Double
    Const tolerance As Double = 0.00000000000008
    Console.WriteLine("{0,5:N1} {0,20:R}  {1,12} {2,15}",
                    value,
                    RoundApproximate(value, 0, tolerance, MidpointRounding.ToEven),
                    RoundApproximate(value, 0, tolerance, MidpointRounding.AwayFromZero))
    Return value + 0.1
End Function

Private Function RoundApproximate(dbl As Double, digits As Integer, margin As Double,
                                 mode As MidpointRounding) As Double
    Dim fraction As Double = dbl * Math.Pow(10, digits)
    Dim value As Double = Math.Truncate(fraction)
    fraction = fraction - value
    If fraction = 0 Then Return dbl

    Dim tolerance As Double = margin * dbl
    ' Determine whether this is a midpoint value.
    If (fraction >= 0.5 - tolerance) And (fraction <= 0.5 + tolerance) Then
        If mode = MidpointRounding.AwayFromZero Then
            Return (value + 1) / Math.Pow(10, digits)
        Else
            If value Mod 2 <> 0 Then
                Return (value + 1) / Math.Pow(10, digits)
            Else
                Return value / Math.Pow(10, digits)
            End If
        End If
    End If
    ' Any remaining fractional value greater than .5 is not a midpoint value.
    If fraction > 0.5 Then
        Return (value + 1) / Math.Pow(10, digits)
    Else
        Return value / Math.Pow(10, digits)
    End If
End Function

' The example displays the following output:
'       Value       Full Precision        ToEven    AwayFromZero
'       
'        11.1                 11.1            11              11
'        11.2                 11.2            11              11
'        11.3   11.299999999999999            11              11
'        11.4   11.399999999999999            11              11
'        11.5   11.499999999999998            12              12
'        11.6   11.599999999999998            12              12
'       
'        11.5                 11.5            12              12

Arrondi et valeurs à virgule flottante simple précision

La Round méthode inclut des surcharges qui acceptent des arguments de type Decimal et Double. Il n’existe aucune méthode qui arrondit les valeurs de type Single. Si vous passez une valeur à l’une Single des surcharges de la Round méthode, elle est castée (en C#) ou convertie (en Visual Basic) en Double, et la surcharge correspondante Round avec un Double paramètre est appelée. Bien qu’il s’agisse d’une conversion élargie, elle implique souvent une perte de précision, comme l’illustre l’exemple suivant. Lorsqu’une Single valeur de 16,325 est passée à la Round méthode et arrondie à deux décimales à l’aide de l’arrondi à la convention la plus proche, le résultat est 16,33 et non le résultat attendu de 16,32.

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

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

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

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

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

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

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

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

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

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

Ce résultat inattendu est dû à une perte de précision dans la conversion de la Single valeur en .Double Étant donné que la valeur résultante Double de 16,325000762939453 n’est pas une valeur médiane et est supérieure à 16,325, elle est toujours arrondie vers le haut.

Dans de nombreux cas, comme l’illustre l’exemple, la perte de précision peut être réduite ou éliminée en cas de conversion ou de conversion de la Single valeur en .Decimal Notez que, comme il s’agit d’une conversion restrictive, elle nécessite l’utilisation d’un opérateur de cast ou l’appel d’une méthode de conversion.

Round(Double, Int32, MidpointRounding)

Source:
Math.cs
Source:
Math.cs
Source:
Math.cs

Arrondit une valeur à virgule flottante double précision à un nombre spécifié de chiffres fractionnaires à l’aide de la convention d’arrondi spécifiée.

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.

digits
Int32

Nombre de chiffres fractionnaires de la valeur de retour.

mode
MidpointRounding

Une des valeurs d’énumération qui spécifie la stratégie d’arrondi à utiliser.

Retours

Double

Nombre dont digits les chiffres fractionnaires sont arrondis value à. Si value a moins de chiffres fractionnaires que digits, value est retourné sans modification.

Exceptions

ArgumentOutOfRangeException

digits est inférieur à 0 ou supérieur à 15.

ArgumentException

mode n’est pas une valeur valide de MidpointRounding.

Remarques

La valeur de l’argument digits peut être comprise entre 0 et 15. Le nombre maximal de chiffres entiers et fractionnaires pris en charge par le Double type est de 15.

Pour plus d’informations sur l’arrondi des nombres avec des valeurs médianes, consultez Valeurs de point moyen et conventions d’arrondi .

Important

Pour arrondir les valeurs du point médian, l’algorithme d’arrondi effectue un test d’égalité. 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. Pour plus d’informations, consultez Arrondi et précision.

Si la valeur de l’argument value est Double.NaN, la méthode retourne Double.NaN. Si value est Double.PositiveInfinity ou Double.NegativeInfinity, la méthode retourne Double.PositiveInfinity ou Double.NegativeInfinity, respectivement.

Exemple

L’exemple suivant montre comment utiliser la Round(Double, Int32, MidpointRounding) méthode avec l’énumération MidpointRounding .


// Round a positive and a negative value using the default.
double result = Math.Round(3.45, 1);
Console.WriteLine($"{result,4} = Math.Round({3.45,5}, 1)");
result = Math.Round(-3.45, 1);
Console.WriteLine($"{result,4} = Math.Round({-3.45,5}, 1)\n");

// Round a positive value using a MidpointRounding value.
result = Math.Round(3.45, 1, MidpointRounding.ToEven);
Console.WriteLine($"{result,4} = Math.Round({3.45,5}, 1, MidpointRounding.ToEven)");
result = Math.Round(3.45, 1, MidpointRounding.AwayFromZero);
Console.WriteLine($"{result,4} = Math.Round({3.45,5}, 1, MidpointRounding.AwayFromZero)");
result = Math.Round(3.47, 1, MidpointRounding.ToZero);
Console.WriteLine($"{result,4} = Math.Round({3.47,5}, 1, MidpointRounding.ToZero)\n");

// Round a negative value using a MidpointRounding value.
result = Math.Round(-3.45, 1, MidpointRounding.ToEven);
Console.WriteLine($"{result,4} = Math.Round({-3.45,5}, 1, MidpointRounding.ToEven)");
result = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero);
Console.WriteLine($"{result,4} = Math.Round({-3.45,5}, 1, MidpointRounding.AwayFromZero)");
result = Math.Round(-3.47, 1, MidpointRounding.ToZero);
Console.WriteLine($"{result,4} = Math.Round({-3.47,5}, 1, MidpointRounding.ToZero)\n");

// The example displays the following output:

//         3.4 = Math.Round( 3.45, 1)
//         -3.4 = Math.Round(-3.45, 1)

//         3.4 = Math.Round(3.45, 1, MidpointRounding.ToEven)
//         3.5 = Math.Round(3.45, 1, MidpointRounding.AwayFromZero)
//         3.4 = Math.Round(3.47, 1, MidpointRounding.ToZero)

//         -3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
//         -3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)
//         -3.4 = Math.Round(-3.47, 1, MidpointRounding.ToZero)

// Round a positive and a negative value using the default.
let result = Math.Round(3.45, 1)
printfn $"{result,4} = Math.Round({3.45,5}, 1)"
let result = Math.Round(-3.45, 1)
printfn $"{result,4} = Math.Round({-3.45,5}, 1)\n"

// Round a positive value using a MidpointRounding value.
let result = Math.Round(3.45, 1, MidpointRounding.ToEven)
printfn $"{result,4} = Math.Round({3.45,5}, 1, MidpointRounding.ToEven)"
let result = Math.Round(3.45, 1, MidpointRounding.AwayFromZero)
printfn $"{result,4} = Math.Round({3.45,5}, 1, MidpointRounding.AwayFromZero)"
let result = Math.Round(3.47, 1, MidpointRounding.ToZero)
printfn $"{result,4} = Math.Round({3.47,5}, 1, MidpointRounding.ToZero)\n"

// Round a negative value using a MidpointRounding value.
let result = Math.Round(-3.45, 1, MidpointRounding.ToEven)
printfn $"{result,4} = Math.Round({-3.45,5}, 1, MidpointRounding.ToEven)"
let result = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)
printfn $"{result,4} = Math.Round({-3.45,5}, 1, MidpointRounding.AwayFromZero)"
let result = Math.Round(-3.47, 1, MidpointRounding.ToZero)
printfn $"{result,4} = Math.Round({-3.47,5}, 1, MidpointRounding.ToZero)\n"

// The example displays the following output:

//         3.4 = Math.Round( 3.45, 1)
//         -3.4 = Math.Round(-3.45, 1)

//         3.4 = Math.Round(3.45, 1, MidpointRounding.ToEven)
//         3.5 = Math.Round(3.45, 1, MidpointRounding.AwayFromZero)
//         3.4 = Math.Round(3.47, 1, MidpointRounding.ToZero)

//         -3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
//         -3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)
//         -3.4 = Math.Round(-3.47, 1, MidpointRounding.ToZero)

Dim posValue As Double = 3.45
Dim negValue As Double = -3.45

' Round a positive and a negative value using the default.  
Dim result As Double = Math.Round(posValue, 1)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1)", result, posValue)
result = Math.Round(negValue, 1)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1)", result, negValue)
Console.WriteLine()

' Round a positive value using a MidpointRounding value. 
result = Math.Round(posValue, 1, MidpointRounding.ToEven)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)",
                   result, posValue)
result = Math.Round(posValue, 1, MidpointRounding.AwayFromZero)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)",
                   result, posValue)
Console.WriteLine()

' Round a positive value using a MidpointRounding value. 
result = Math.Round(negValue, 1, MidpointRounding.ToEven)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)",
                    result, negValue)
result = Math.Round(negValue, 1, MidpointRounding.AwayFromZero)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)",
                   result, negValue)
Console.WriteLine()

'This code example produces the following results:

'  3.4 = Math.Round( 3.45, 1)
' -3.4 = Math.Round(-3.45, 1)

' 3.4 = Math.Round( 3.45, 1, MidpointRounding.ToEven)
' 3.5 = Math.Round( 3.45, 1, MidpointRounding.AwayFromZero)

' -3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
' -3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)

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 forme de nombres à virgule flottante ou de l’exécution d’opérations arithmétiques sur des valeurs à virgule flottante, dans certains cas, la Round(Double, Int32, MidpointRounding) méthode peut ne pas sembler arrondie aux valeurs du point moyen comme spécifié par le mode paramètre . Cela est illustré dans l’exemple suivant, où 2,135 est arrondi à 2,13 au lieu de 2,14. Cela se produit parce que la méthode se multiplie value en interne par 10chiffres, et l’opération de multiplication dans ce cas souffre d’une perte de précision.

double[] values = { 2.125, 2.135, 2.145, 3.125, 3.135, 3.145 };
foreach (double value in values)
   Console.WriteLine("{0} --> {1}", value,
                     Math.Round(value, 2, MidpointRounding.AwayFromZero));

// The example displays the following output:
//       2.125 --> 2.13
//       2.135 --> 2.13
//       2.145 --> 2.15
//       3.125 --> 3.13
//       3.135 --> 3.14
//       3.145 --> 3.15

open System

let values = [| 2.125; 2.135; 2.145; 3.125; 3.135; 3.145 |]
for value in values do
    printfn $"{value} --> {Math.Round(value, 2, MidpointRounding.AwayFromZero)}"
// The example displays the following output:
//       2.125 --> 2.13
//       2.135 --> 2.13
//       2.145 --> 2.15
//       3.125 --> 3.13
//       3.135 --> 3.14
//       3.145 --> 3.15

Module Example
   Public Sub Main()
      Dim values() As Double = { 2.125, 2.135, 2.145, 3.125, 3.135, 3.145 }
      For Each value As Double In values
         Console.WriteLine("{0} --> {1}", value, 
                           Math.Round(value, 2, MidpointRounding.AwayFromZero))
      Next
   End Sub
End Module
' The example displays the following output:
'       2.125 --> 2.13
'       2.135 --> 2.13
'       2.145 --> 2.15
'       3.125 --> 3.13
'       3.135 --> 3.14
'       3.145 --> 3.15

Voir aussi

S’applique à

Round(Decimal, Int32, MidpointRounding)

Source:
Math.cs
Source:
Math.cs
Source:
Math.cs

Arrondit une valeur décimale à un nombre spécifié de chiffres fractionnaires à l’aide de la convention d’arrondi spécifiée.

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.

decimals
Int32

Nombre de décimales de la valeur de retour.

mode
MidpointRounding

Une des valeurs d’énumération qui spécifie la stratégie d’arrondi à utiliser.

Retours

Decimal

Nombre avec decimals des chiffres fractionnaires d arrondis à. Si d a moins de chiffres fractionnaires que decimals, d est retourné sans modification.

Exceptions

ArgumentOutOfRangeException

decimals est inférieur à 0 ou supérieur à 28.

ArgumentException

mode n’est pas une valeur valide de MidpointRounding.

OverflowException

Le résultat est à l'extérieur de la plage d'un Decimal.

Remarques

Pour plus d’informations sur l’arrondi des nombres avec des valeurs médianes, consultez Valeurs de point moyen et conventions d’arrondi .

Important

Pour arrondir les valeurs du point médian, l’algorithme d’arrondi effectue un test d’égalité. 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. Pour plus d’informations, consultez Arrondi et précision.

La valeur de l’argument decimals peut être comprise entre 0 et 28.

Exemple

L’exemple suivant montre comment utiliser la Round méthode avec l’énumération MidpointRounding .

decimal result;

// Round a positive value using different strategies.
// The precision of the result is 1 decimal place.

result = Math.Round(3.45m, 1, MidpointRounding.ToEven);
Console.WriteLine($"{result} = Math.Round({3.45m}, 1, MidpointRounding.ToEven)");
result = Math.Round(3.45m, 1, MidpointRounding.AwayFromZero);
Console.WriteLine($"{result} = Math.Round({3.45m}, 1, MidpointRounding.AwayFromZero)");
result = Math.Round(3.47m, 1, MidpointRounding.ToZero);
Console.WriteLine($"{result} = Math.Round({3.47m}, 1, MidpointRounding.ToZero)\n");

// Round a negative value using different strategies.
// The precision of the result is 1 decimal place.

result = Math.Round(-3.45m, 1, MidpointRounding.ToEven);
Console.WriteLine($"{result} = Math.Round({-3.45m}, 1, MidpointRounding.ToEven)");
result = Math.Round(-3.45m, 1, MidpointRounding.AwayFromZero);
Console.WriteLine($"{result} = Math.Round({-3.45m}, 1, MidpointRounding.AwayFromZero)");
result = Math.Round(-3.47m, 1, MidpointRounding.ToZero);
Console.WriteLine($"{result} = Math.Round({-3.47m}, 1, MidpointRounding.ToZero)\n");

/*
This code example produces the following results:

3.4 = Math.Round(3.45, 1, MidpointRounding.ToEven)
3.5 = Math.Round(3.45, 1, MidpointRounding.AwayFromZero)
3.4 = Math.Round(3.47, 1, MidpointRounding.ToZero)

-3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
-3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)
-3.4 = Math.Round(-3.47, 1, MidpointRounding.ToZero)
*/

// Round a positive value using different strategies.
// The precision of the result is 1 decimal place.

let result = Math.Round(3.45m, 1, MidpointRounding.ToEven)
printfn $"{result} = Math.Round({3.45m}, 1, MidpointRounding.ToEven)"
let result = Math.Round(3.45m, 1, MidpointRounding.AwayFromZero)
printfn $"{result} = Math.Round({3.45m}, 1, MidpointRounding.AwayFromZero)"
let result = Math.Round(3.47m, 1, MidpointRounding.ToZero)
printfn $"{result} = Math.Round({3.47m}, 1, MidpointRounding.ToZero)\n"

// Round a negative value using different strategies.
// The precision of the result is 1 decimal place.

let result = Math.Round(-3.45m, 1, MidpointRounding.ToEven)
printfn $"{result} = Math.Round({-3.45m}, 1, MidpointRounding.ToEven)"
let result = Math.Round(-3.45m, 1, MidpointRounding.AwayFromZero)
printfn $"{result} = Math.Round({-3.45m}, 1, MidpointRounding.AwayFromZero)"
let result = Math.Round(-3.47m, 1, MidpointRounding.ToZero)
printfn $"{result} = Math.Round({-3.47m}, 1, MidpointRounding.ToZero)\n"

// This code example produces the following results:

// 3.4 = Math.Round(3.45, 1, MidpointRounding.ToEven)
// 3.5 = Math.Round(3.45, 1, MidpointRounding.AwayFromZero)
// 3.4 = Math.Round(3.47, 1, MidpointRounding.ToZero)

// -3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
// -3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)
// -3.4 = Math.Round(-3.47, 1, MidpointRounding.ToZero)

Dim result As Decimal = 0D
Dim posValue As Decimal = 3.45D
Dim negValue As Decimal = -3.45D

' Round a positive value using different strategies.
' The precision of the result is 1 decimal place.
result = Math.Round(posValue, 1, MidpointRounding.ToEven)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)",
                   result, posValue)
result = Math.Round(posValue, 1, MidpointRounding.AwayFromZero)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)",
                   result, posValue)
result = Math.Round(posValue, 1, MidpointRounding.ToZero)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToZero)",
                   result, posValue)
Console.WriteLine()

' Round a negative value using different strategies.
' The precision of the result is 1 decimal place.
result = Math.Round(negValue, 1, MidpointRounding.ToEven)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)",
                    result, negValue)
result = Math.Round(negValue, 1, MidpointRounding.AwayFromZero)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)",
                   result, negValue)
result = Math.Round(negValue, 1, MidpointRounding.ToZero)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToZero)",
                   result, negValue)
Console.WriteLine()

'This code example produces the following results:
'
'        3.4 = Math.Round(3.45, 1, MidpointRounding.ToEven)
'        3.5 = Math.Round(3.45, 1, MidpointRounding.AwayFromZero)
'        3.4 = Math.Round(3.45, 1, MidpointRounding.ToZero)
'
'        -3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
'        -3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)
'        -3.4 = Math.Round(-3.45, 1, MidpointRounding.ToZero)
'

Voir aussi

S’applique à

Round(Double, MidpointRounding)

Source:
Math.cs
Source:
Math.cs
Source:
Math.cs

Arrondit une valeur à virgule flottante double précision à un entier à l’aide de la convention d’arrondi spécifiée.

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.

mode
MidpointRounding

Une des valeurs d’énumération qui spécifie la stratégie d’arrondi à utiliser.

Retours

Double

Entier value arrondi à. Cette méthode retourne un Double au lieu d’un type intégral.

Exceptions

ArgumentException

mode n’est pas une valeur valide de MidpointRounding.

Remarques

Pour plus d’informations sur l’arrondi des nombres avec des valeurs médianes, consultez Valeurs de point moyen et conventions d’arrondi .

Important

Pour arrondir les valeurs du point médian, l’algorithme d’arrondi effectue un test d’égalité. 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. Pour plus d’informations, consultez Arrondi et précision.

Si la valeur de l’argument value est Double.NaN, la méthode retourne Double.NaN. Si value est Double.PositiveInfinity ou Double.NegativeInfinity, la méthode retourne Double.PositiveInfinity ou Double.NegativeInfinity, respectivement.

Exemple

L’exemple suivant affiche les valeurs retournées par la Round(Double, MidpointRounding) méthode avec des valeurs différentes mode .

Double[] values = { 12.0, 12.1, 12.2, 12.3, 12.4, 12.5, 12.6,
                  12.7, 12.8, 12.9, 13.0 };
Console.WriteLine($"{"Value",-10} {"Default",-10} {"ToEven",-10} {"AwayFromZero",-15} {"ToZero",-15}");

foreach (var value in values)
    Console.WriteLine($"{value,-10:R} {Math.Round(value),-10} " +
        $"{Math.Round(value, MidpointRounding.ToEven),-10} " +
        $"{Math.Round(value, MidpointRounding.AwayFromZero),-15} " +
        $"{Math.Round(value, MidpointRounding.ToZero),-15}");

// The example displays the following output:
//       Value      Default    ToEven     AwayFromZero    ToZero
//       12         12         12         12              12
//       12.1       12         12         12              12
//       12.2       12         12         12              12
//       12.3       12         12         12              12
//       12.4       12         12         12              12
//       12.5       12         12         13              12
//       12.6       13         13         13              12
//       12.7       13         13         13              12
//       12.8       13         13         13              12
//       12.9       13         13         13              12
//       13         13         13         13              13

open System

let values = 
    [| 12.; 12.1; 12.2; 12.3; 12.4; 12.5
       12.6; 12.7; 12.8; 12.9; 13. |]

printfn "%-10s %-10s %-10s %-15s %-15s" "Value" "Default" "ToEven" "AwayFromZero" "ToZero"

for value in values do
    $"{value,-10:R} {Math.Round(value),-10} " +
    $"{Math.Round(value, MidpointRounding.ToEven),-10} " +
    $"{Math.Round(value, MidpointRounding.AwayFromZero),-15} " +
    $"{Math.Round(value, MidpointRounding.ToZero),-15}"
    |> printfn "%s"
    
// The example displays the following output:
//       Value      Default    ToEven     AwayFromZero    ToZero
//       12         12         12         12              12
//       12.1       12         12         12              12
//       12.2       12         12         12              12
//       12.3       12         12         12              12
//       12.4       12         12         12              12
//       12.5       12         12         13              12
//       12.6       13         13         13              12
//       12.7       13         13         13              12
//       12.8       13         13         13              12
//       12.9       13         13         13              12
//       13         13         13         13              13

Dim values() As Double = {12.0, 12.1, 12.2, 12.3, 12.4, 12.5, 12.6,
                         12.7, 12.8, 12.9, 13.0}
Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15} {4,-15}", "Value", "Default",
                "ToEven", "AwayFromZero", "ToZero")
For Each value In values
    Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15} {4,-15}",
                   value, Math.Round(value),
                   Math.Round(value, MidpointRounding.ToEven),
                   Math.Round(value, MidpointRounding.AwayFromZero),
                   Math.Round(value, MidpointRounding.ToZero))
Next

' The example displays the following output:
'       Value      Default    ToEven     AwayFromZero     ToZero
'       12         12         12         12               12
'       12.1       12         12         12               12
'       12.2       12         12         12               12
'       12.3       12         12         12               12
'       12.4       12         12         12               12
'       12.5       12         12         13               12
'       12.6       13         13         13               12
'       12.7       13         13         13               12
'       12.8       13         13         13               12
'       12.9       13         13         13               12
'       13         13         13         13               13

Notes pour les appelants

En raison de la perte de précision qui peut résulter de la représentation de valeurs décimales en tant que nombres à virgule flottante ou de l’exécution d’opérations arithmétiques sur des valeurs à virgule flottante, dans certains cas, la Round(Double, MidpointRounding) méthode peut ne pas sembler arrondir les valeurs du point moyen à l’entier pair le plus proche. 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.

using System;

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

      Console.WriteLine();

      value = 11.5;
      RoundValueAndAdd(value);
   }

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

open System

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

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

printfn ""

value <- 11.5
roundValueAndAdd value
|> ignore

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

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

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

Voir aussi

S’applique à

Round(Double, Int32)

Source:
Math.cs
Source:
Math.cs
Source:
Math.cs

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.

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.

digits
Int32

Nombre de chiffres fractionnaires de la valeur de retour.

Retours

Double

Nombre le plus proche de value contenant un nombre de chiffres fractionnaires égal à digits.

Exceptions

ArgumentOutOfRangeException

digits est inférieur à 0 ou supérieur à 15.

Remarques

La valeur de l’argument digits peut être comprise entre 0 et 15. Le nombre maximal de chiffres entiers et fractionnaires pris en charge par le Double type est de 15.

Cette méthode utilise la convention d’arrondi par défaut de MidpointRounding.ToEven. Pour plus d’informations sur l’arrondi des nombres avec des valeurs médianes, consultez Valeurs de point moyen et conventions d’arrondi .

Important

Pour arrondir les valeurs du point médian, l’algorithme d’arrondi effectue un test d’égalité. 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. Pour plus d’informations, consultez Arrondi et précision.

Si la valeur de l’argument value est Double.NaN, la méthode retourne Double.NaN. Si value est Double.PositiveInfinity ou Double.NegativeInfinity, la méthode retourne Double.PositiveInfinity ou Double.NegativeInfinity, respectivement.

Exemple

L’exemple suivant arrondit les valeurs doubles avec deux chiffres fractionnaires à des doubles qui ont un seul chiffre fractionnaire.

Math::Round(3.44, 1); //Returns 3.4.
Math::Round(3.45, 1); //Returns 3.4.
Math::Round(3.46, 1); //Returns 3.5.

Math::Round(4.34, 1); // Returns 4.3
Math::Round(4.35, 1); // Returns 4.4
Math::Round(4.36, 1); // Returns 4.4

Math.Round(3.44, 1); //Returns 3.4.
Math.Round(3.45, 1); //Returns 3.4.
Math.Round(3.46, 1); //Returns 3.5.

Math.Round(4.34, 1); // Returns 4.3
Math.Round(4.35, 1); // Returns 4.4
Math.Round(4.36, 1); // Returns 4.4

open System

printfn $"{Math.Round(3.44, 1)}" //Returns 3.4.
printfn $"{Math.Round(3.45, 1)}" //Returns 3.4.
printfn $"{Math.Round(3.46, 1)}" //Returns 3.5.

printfn $"{Math.Round(4.34, 1)}" // Returns 4.3
printfn $"{Math.Round(4.35, 1)}" // Returns 4.4
printfn $"{Math.Round(4.36, 1)}" // Returns 4.4

Math.Round(3.44, 1) 'Returns 3.4.
Math.Round(3.45, 1) 'Returns 3.4.
Math.Round(3.46, 1) 'Returns 3.5.

Math.Round(4.34, 1) ' Returns 4.3
Math.Round(4.35, 1) ' Returns 4.4
Math.Round(4.36, 1) ' Returns 4.4

Notes pour les appelants

En raison de la perte de précision qui peut résulter de la représentation de valeurs décimales en tant que nombres à virgule flottante ou de l’exécution d’opérations arithmétiques sur des valeurs à virgule flottante, dans certains cas, la Round(Double, Int32) méthode peut ne pas sembler arrondir les valeurs du point moyen à la valeur paire la plus proche dans la digits position décimale. Cela est illustré dans l’exemple suivant, où 2,135 est arrondi à 2,13 au lieu de 2,14. Cela se produit parce que la méthode se multiplie value en interne par 10chiffres, et l’opération de multiplication dans ce cas souffre d’une perte de précision.

using System;

public class Example
{
   public static void Main()
   {
      double[] values = { 2.125, 2.135, 2.145, 3.125, 3.135, 3.145 };
      foreach (double value in values)
         Console.WriteLine("{0} --> {1}", value, Math.Round(value, 2));
   }
}
// The example displays the following output:
//       2.125 --> 2.12
//       2.135 --> 2.13
//       2.145 --> 2.14
//       3.125 --> 3.12
//       3.135 --> 3.14
//       3.145 --> 3.14

open System

let values = [| 2.125; 2.135; 2.145; 3.125; 3.135; 3.145 |]
for value in values do
    printfn $"{value} --> {Math.Round(value, 2)}"
// The example displays the following output:
//       2.125 --> 2.12
//       2.135 --> 2.13
//       2.145 --> 2.14
//       3.125 --> 3.12
//       3.135 --> 3.14
//       3.145 --> 3.14

Module Example
   Public Sub Main()
      Dim values() As Double = { 2.125, 2.135, 2.145, 3.125, 3.135, 3.145 }
      For Each value As Double In values
         Console.WriteLine("{0} --> {1}", value, Math.Round(value, 2))
      Next
   End Sub
End Module
' The example displays the following output:
'       2.125 --> 2.12
'       2.135 --> 2.13
'       2.145 --> 2.14
'       3.125 --> 3.12
'       3.135 --> 3.14
'       3.145 --> 3.14

Voir aussi

S’applique à

Round(Decimal, Int32)

Source:
Math.cs
Source:
Math.cs
Source:
Math.cs

Arrondit une valeur décimale au nombre de chiffres fractionnaires spécifié, et les valeurs médianes au nombre pair le plus proche.

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.

decimals
Int32

Nombre de décimales de la valeur de retour.

Retours

Decimal

Nombre le plus proche de d contenant un nombre de chiffres fractionnaires égal à decimals.

Exceptions

ArgumentOutOfRangeException

decimals est inférieur à 0 ou supérieur à 28.

OverflowException

Le résultat est à l'extérieur de la plage d'un Decimal.

Remarques

La valeur de l’argument decimals peut être comprise entre 0 et 28.

Cette méthode utilise la convention d’arrondi par défaut de MidpointRounding.ToEven. Pour plus d’informations sur l’arrondi des nombres avec des valeurs de point moyen, consultez Valeurs de point intermédiaire et conventions d’arrondi.

Important

Pour arrondir les valeurs du point médian, l’algorithme d’arrondi effectue un test d’égalité. 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. Pour plus d’informations, consultez Arrondi et précision.

Exemple

L’exemple suivant arrondit les valeurs décimales avec deux chiffres fractionnaires aux valeurs qui ont un seul chiffre fractionnaire.

Console.WriteLine(Math.Round(3.44m, 1));
Console.WriteLine(Math.Round(3.45m, 1));
Console.WriteLine(Math.Round(3.46m, 1));
Console.WriteLine();

Console.WriteLine(Math.Round(4.34m, 1));
Console.WriteLine(Math.Round(4.35m, 1));
Console.WriteLine(Math.Round(4.36m, 1));

// The example displays the following output:
//       3.4
//       3.4
//       3.5
//
//       4.3
//       4.4
//       4.4

open System

printfn 
    $"""{Math.Round(3.44m, 1)}
{Math.Round(3.45m, 1)}
{Math.Round(3.46m, 1)}

{Math.Round(4.34m, 1)}
{Math.Round(4.35m, 1)}
{Math.Round(4.36m, 1)}"""

// The example displays the following output:
//       3.4
//       3.4
//       3.5
//
//       4.3
//       4.4
//       4.4

Console.WriteLine(Math.Round(3.44, 1))
Console.WriteLine(Math.Round(3.45, 1))
Console.WriteLine(Math.Round(3.46, 1))
Console.WriteLine()

Console.WriteLine(Math.Round(4.34, 1))
Console.WriteLine(Math.Round(4.35, 1))
Console.WriteLine(Math.Round(4.36, 1))

' The example displays the following output:
'       3.4
'       3.4
'       3.5
'       
'       4.3
'       4.4
'       4.4

Voir aussi

S’applique à

Round(Double)

Source:
Math.cs
Source:
Math.cs
Source:
Math.cs

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.

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.

Retours

Double

Entier le plus proche de 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é. Notez que cette méthode retourne un objet Double plutôt qu'un type intégral.

Remarques

Cette méthode utilise la convention d’arrondi par défaut de MidpointRounding.ToEven. Pour plus d’informations sur l’arrondi des nombres avec des valeurs de point moyen, consultez Valeurs de point intermédiaire et conventions d’arrondi.

Important

Pour arrondir les valeurs du point médian, l’algorithme d’arrondi effectue un test d’égalité. 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. Pour plus d’informations, consultez Arrondi et précision.

Si la valeur de l’argument a est Double.NaN, la méthode retourne Double.NaN. Si a est Double.PositiveInfinity ou Double.NegativeInfinity, la méthode retourne Double.PositiveInfinity ou Double.NegativeInfinity, respectivement.

À compter de Visual Basic 15.8, les performances de la conversion double en entier sont optimisées si vous transmettez la valeur retournée par la méthode à l’une Round des fonctions de conversion intégrale, ou si la valeur Double retournée par Round est automatiquement convertie en entier avec Option Strict définie sur 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). L’exemple suivant illustre ces conversions optimisées :

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

Exemple

L’exemple suivant illustre l’arrondi à la valeur entière la plus proche.

using namespace System;

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

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

open System

printfn "Classic Math.Round in F#"
printfn $"{Math.Round(4.4)}" // 4
printfn $"{Math.Round(4.5)}" // 4
printfn $"{Math.Round(4.6)}" // 5
printfn $"{Math.Round(5.5)}" // 6

Module Module1

    Sub Main()
    Console.WriteLine("Classic Math.Round in Visual Basic")
    Console.WriteLine(Math.Round(4.4)) ' 4
    Console.WriteLine(Math.Round(4.5)) ' 4
    Console.WriteLine(Math.Round(4.6)) ' 5
    Console.WriteLine(Math.Round(5.5)) ' 6
    End Sub

End Module

Notes pour les appelants

En raison de la perte de précision qui peut résulter de la représentation de valeurs décimales en tant que nombres à virgule flottante ou de l’exécution d’opérations arithmétiques sur des valeurs à virgule flottante, dans certains cas, la Round(Double) méthode peut ne pas sembler arrondir les valeurs du point moyen à l’entier pair le plus proche. 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.

using System;

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

      Console.WriteLine();

      value = 11.5;
      RoundValueAndAdd(value);
   }

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

open System

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

let mutable value = 11.1

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

printfn ""

value <- 11.5
roundValueAndAdd value
|> ignore

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

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

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

Voir aussi

S’applique à

Round(Decimal)

Source:
Math.cs
Source:
Math.cs
Source:
Math.cs

Arrondit une valeur décimale au nombre entier le plus proche, et les valeurs médianes au nombre pair le plus proche.

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.

Retours

Decimal

Le nombre entier le plus proche du paramètre d. 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é. Notez que cette méthode retourne un objet Decimal plutôt qu'un type intégral.

Exceptions

OverflowException

Le résultat est à l'extérieur de la plage d'un Decimal.

Exemples

L’exemple suivant illustre la Round(Decimal) méthode. La Decimal valeur de 4,5 est arrondie à 4 plutôt qu’à 5, car cette surcharge utilise la convention par défaut ToEven .

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

open System

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

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

Remarques

Cette méthode utilise la convention d’arrondi par défaut de MidpointRounding.ToEven. Pour plus d’informations sur l’arrondi des nombres avec des valeurs de point moyen, consultez Valeurs de point intermédiaire et conventions d’arrondi.

Important

Pour arrondir les valeurs du point médian, l’algorithme d’arrondi effectue un test d’égalité. 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. Pour plus d’informations, consultez Arrondi et précision.

Voir aussi

S’applique à

Round(Decimal, MidpointRounding)

Source:
Math.cs
Source:
Math.cs
Source:
Math.cs

Arrondit une valeur décimale à un entier à l’aide de la convention d’arrondi spécifiée.

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.

mode
MidpointRounding

Une des valeurs d’énumération qui spécifie la stratégie d’arrondi à utiliser.

Retours

Decimal

Entier d arrondi à. Cette méthode retourne un Decimal au lieu d’un type intégral.

Exceptions

ArgumentException

mode n’est pas une valeur valide de MidpointRounding.

OverflowException

Le résultat est à l'extérieur de la plage d'un Decimal.

Remarques

Pour plus d’informations sur l’arrondi des nombres avec des valeurs de point moyen, consultez Valeurs de point intermédiaire et conventions d’arrondi.

Important

Pour arrondir les valeurs du point médian, l’algorithme d’arrondi effectue un test d’égalité. 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. Pour plus d’informations, consultez Arrondi et précision.

Exemple

L’exemple suivant affiche les valeurs retournées par la Round(Decimal, MidpointRounding) méthode avec des valeurs différentes mode .

Console.WriteLine($"{"Value",-10} {"Default",-10} {"ToEven",-10} {"AwayFromZero",-15} {"ToZero",-15}");
for (decimal value = 12.0m; value <= 13.0m; value += 0.1m)
    Console.WriteLine($"{value,-10} {Math.Round(value),-10} " +
        $"{Math.Round(value, MidpointRounding.ToEven),-10} " +
        $"{Math.Round(value, MidpointRounding.AwayFromZero),-15} " +
        $"{Math.Round(value, MidpointRounding.ToZero),-15}");

// The example displays the following output:
//       Value      Default    ToEven     AwayFromZero    ToZero
//       12.0       12         12         12              12
//       12.1       12         12         12              12
//       12.2       12         12         12              12
//       12.3       12         12         12              12
//       12.4       12         12         12              12
//       12.5       12         12         13              12
//       12.6       13         13         13              12
//       12.7       13         13         13              12
//       12.8       13         13         13              12
//       12.9       13         13         13              12
//       13.0       13         13         13              13

printfn $"""{"Value",-10} {"Default",-10} {"ToEven",-10} {"AwayFromZero",-15} {"ToZero",-15}"""
for value in 12m .. 0.1m .. 13m do
    printfn "%-10O %-10O %-10O %-15O %-15O" 
        value
        (Math.Round value)
        (Math.Round(value, MidpointRounding.ToEven))
        (Math.Round(value, MidpointRounding.AwayFromZero))
        (Math.Round(value, MidpointRounding.ToZero))

// The example displays the following output:
//       Value      Default    ToEven     AwayFromZero    ToZero
//       12.0       12         12         12              12
//       12.1       12         12         12              12
//       12.2       12         12         12              12
//       12.3       12         12         12              12
//       12.4       12         12         12              12
//       12.5       12         12         13              12
//       12.6       13         13         13              12
//       12.7       13         13         13              12
//       12.8       13         13         13              12
//       12.9       13         13         13              12
//       13.0       13         13         13              13

Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15} {4,-15}", "Value", "Default",
                "ToEven", "AwayFromZero", "ToZero")
For value As Decimal = 12D To 13D Step 0.1D
    Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15} {4,-15}",
                   value, Math.Round(value),
                   Math.Round(value, MidpointRounding.ToEven),
                   Math.Round(value, MidpointRounding.AwayFromZero),
                   Math.Round(value, MidpointRounding.ToZero))
Next

' The example displays the following output:
'       Value      Default    ToEven     AwayFromZero     ToZero
'       12         12         12         12               12
'       12.1       12         12         12               12
'       12.2       12         12         12               12
'       12.3       12         12         12               12
'       12.4       12         12         12               12
'       12.5       12         12         13               12
'       12.6       13         13         13               12
'       12.7       13         13         13               12
'       12.8       13         13         13               12
'       12.9       13         13         13               12
'       13.0       13         13         13               13

Voir aussi

S’applique à