Math.Round Méthode

Définition

Espace de noms:: System

Assemblys:: mscorlib.dll, System.Runtime.Extensions.dll

Assemblys:: netstandard.dll, System.Runtime.dll

Assembly:: System.Runtime.Extensions.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

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

Surcharges

Nom	Description
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 une valeur à virgule flottante double précision à un nombre spécifié de chiffres fractionnaires et arrondit les valeurs intermédiaires au nombre pair le plus proche.
Round(Decimal, Int32)	Arrondit une valeur décimale à un nombre spécifié de chiffres fractionnaires, et arrondit les valeurs intermédiaires au nombre pair le plus proche.
Round(Double)	Arrondit une valeur à virgule flottante double précision à la valeur intégrale la plus proche et arrondit les valeurs intermédiaires au nombre pair le plus proche.
Round(Decimal)	Arrondit une valeur décimale à la valeur intégrale la plus proche et arrondit les valeurs intermédiaires 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 , il existe des exemples dans chaque surcharge de la Math.Round méthode.

Remarques

Dans cette section :

Quelle méthode dois-je appeler ?
Valeurs intermédiaires et conventions d’arrondi
Arrondi et précision
Arrondi et valeurs à virgule flottante simple précision

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
Arrondissez un nombre à un entier à l’aide de la convention arrondie à la plus proche.	Round(Decimal) - ou - Round(Double)
Arrondissez un nombre à un entier à l’aide d’une convention d’arrondi spécifiée.	Round(Decimal, MidpointRounding) - ou - Round(Double, MidpointRounding)
Arrondissez un nombre à un nombre spécifié de chiffres fractionnels en utilisant l’arrondi à la convention la plus proche.	Round(Decimal, Int32) - ou - Round(Double, Int32)
Arrondissez un nombre à un nombre spécifié de chiffres fractionnels à l’aide d’une convention d’arrondi spécifiée.	Round(Decimal, Int32, MidpointRounding) - ou - Round(Double, Int32, MidpointRounding)
Arrondissez une Single valeur à un nombre spécifié de chiffres fractionnels à l’aide d’une convention d’arrondi spécifiée et réduisez la perte de précision.	Convertissez-le Single en un Decimal et appelez Round(Decimal, Int32, MidpointRounding).
Arrondissez un nombre à un nombre spécifié de chiffres fractionnels tout en minimisant les problèmes de précision dans l’arrondi des valeurs intermédiaires.	Appelez une méthode d’arrondi qui implémente une comparaison « supérieure ou approximativement égale à ». Voir arrondi et précision.
Arrondissez une valeur fractionnaire à un entier supérieur à la valeur fractionnaire. Par exemple, arrondissez 3,1 à 4.	Ceiling
Arrondissez une valeur fractionnaire à un entier inférieur à la valeur fractionnelle. Par exemple, arrondissez 3,9 à 3.	Floor

Valeurs intermédiaires et conventions d’arrondi

L’arrondi implique la conversion d’une valeur numérique avec une précision spécifiée en une valeur avec moins de précision. Par exemple, vous pouvez utiliser la Round(Double) méthode pour arrondir une valeur comprise entre 3,4 et 3,0 et la Round(Double, Int32) méthode pour arrondir une valeur de 3,579 à 3,58.

Dans une valeur intermédiaire, la valeur après le chiffre le moins significatif dans le résultat est exactement de moitié entre deux nombres. Par exemple, la valeur 3.47500 est une valeur intermédiaire si elle doit être arrondie à deux décimales, et 7,500 est une valeur de milieu s’il doit être arrondi à un entier. Dans ces cas, si la stratégie round-to-near est utilisée, la valeur la plus proche ne peut pas être facilement identifiée sans convention d’arrondi.

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

Arrondi de zéro

Les valeurs intermédiaires sont arrondies au nombre suivant à l’écart de zéro. Par exemple, 3,75 arrondis à 3,8, 3,85 arrondis à 3,9, -3,75 arrondis à -3,8 et -3,85 arrondis à -3,9. Cette forme d’arrondi est représentée par le membre d’énumération MidpointRounding.AwayFromZero .
Arrondi à la plus proche même, ou arrondi de banquier

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

Note

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 intermédiaires comme MidpointRounding.ToEven et MidpointRounding.AwayFromZero sont.

Arrondir à zéro est la forme la plus connue d’arrondi, tandis que l’arrondi au plus proche est la norme dans les opérations financières et statistiques. Il est conforme à IEEE Standard 754, section 4. Lorsqu’elle est utilisée dans plusieurs opérations d’arrondi, l’arrondi à la plus proche réduit même l’erreur d’arrondi provoquée par l’arrondi cohérent des valeurs intermédiaires 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 cohérent des valeurs intermédiaires dans une direction unique. 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 qui aboutit lors de l’arrondi au plus proche sont les mêmes. Toutefois, la moyenne qui résulte de l’arrondi de zéro diffère de .05 (ou de 3,6%) de la vraie moyenne.

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 l’arrondi jusqu’à la convention même la plus proche. Le tableau suivant répertorie les surcharges de la Round méthode et la convention d’arrondi que chacune utilise.

Overload	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` paramètre
Round(Decimal, Int32, MidpointRounding)	Déterminé par `mode` paramètre
Round(Double, Int32, MidpointRounding)	Déterminé par `mode` paramètre

Arrondi et précision

Pour déterminer si une opération d’arrondi implique une valeur intermédiaire, la Round méthode multiplie la valeur d’origine à arrondir de 10ⁿ, 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. Il s’agit d’une légère variation sur un test d’égalité et, comme indiqué dans la section « Test de l’é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 format à virgule flottante avec la représentation binaire et la précision. Cela signifie que toute partie fractionnaire d’un nombre légèrement inférieure à .5 (en raison d’une perte de précision) ne sera pas arrondie vers le haut.

L’exemple 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 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 complète de la valeur à virgule flottante et montre que la valeur à arrondir a perdu de précision pendant les ajouts répétés, et sa valeur est en fait 11,49999999999999999999998. Étant donné que .499999999999998 est inférieur à .5, les conventions d’arrondi intermédiaire ne sont pas entrées en jeu et la valeur est arrondie vers le bas. Comme l’illustre é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 intermédiaires sont susceptibles de survenir 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 plutôt Single qu’une ou Decimal.Double Pour plus d’informations, consultez la section suivante, Arrondi et valeurs à virgule flottante simple précision.

Dans les cas où l’absence 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 passer à Double une Decimal valeur et appeler une surcharge qui arrondit une Decimal valeur à la 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 acceptable à proximité d’une valeur intermédiaire. L’exemple suivant définit une RoundApproximate méthode qui examine si une valeur fractionnelle est suffisamment proche d’une valeur de milieu pour être soumise à l’arrondi 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 Single à l’une des surcharges de la méthode Round, elle est convertie (en C#) ou convertie (en Visual Basic) en Double, et la surcharge Round correspondante avec un paramètre Double est appelée. Bien qu’il s’agit d’une conversion étendue, 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 de 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 un Double. Étant donné que la valeur résultante Double de 16,32500762939453 n’est pas une valeur intermédiaire 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 un Decimal. Notez que, étant donné qu’il s’agit d’une conversion étroite, il 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

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 fractionnels dans la valeur de retour.

mode: MidpointRounding

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

Retours

Double

Nombre avec digits des chiffres fractionnaires value arrondis. S’il value a moins de chiffres fractionnels que digits, value est retourné inchangé.

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 aller de 0 à 15. Le nombre maximal de chiffres intégral et fractionnaires pris en charge par le Double type est de 15.

Consultez les valeurs intermédiaires et les conventions d’arrondi pour plus d’informations sur l’arrondi des nombres avec des valeurs intermédiaires.

Important

Lors de l’arrondi de valeurs intermédiaires, l’algorithme d’arrondi effectue un test d’égalité. En raison de problèmes de représentation binaire et de précision au 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 c’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 d’opérations arithmétiques sur des valeurs à virgule flottante, dans certains cas, la Round(Double, Int32, MidpointRounding) méthode peut ne pas sembler arrondir les valeurs intermédiaires comme spécifié par le mode paramètre. Ceci 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 10^chiffres et que 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

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 dans 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 d chiffres fractionnels arrondis. S’il d a moins de chiffres fractionnels que decimals, d est retourné inchangé.

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 en dehors de la plage d’un Decimal.

Remarques

Consultez les valeurs intermédiaires et les conventions d’arrondi pour plus d’informations sur l’arrondi des nombres avec des valeurs intermédiaires.

Important

La valeur de l’argument decimals peut aller de 0 à 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

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 type intégral au lieu d’un type intégral.

Exceptions

ArgumentException

mode n’est pas une valeur valide de MidpointRounding.

Remarques

Consultez les valeurs intermédiaires et les conventions d’arrondi pour plus d’informations sur l’arrondi des nombres avec des valeurs intermédiaires.

Important

Exemple

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

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 sous forme de nombres à virgule flottante ou 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 intermédiaires à 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

Source:: Math.cs

Source:: Math.cs

Arrondit une valeur à virgule flottante double précision à un nombre spécifié de chiffres fractionnaires et arrondit les valeurs intermédiaires 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 fractionnels dans la valeur de retour.

Retours

Double

Nombre le plus proche de value celui qui contient un nombre de chiffres fractionnels égaux à digits.

Exceptions

ArgumentOutOfRangeException

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

Remarques

La valeur de l’argument digits peut aller de 0 à 15. Le nombre maximal de chiffres intégral 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. Consultez les valeurs intermédiaires et les conventions d’arrondi pour plus d’informations sur l’arrondi des nombres avec des valeurs intermédiaires.

Important

Exemple

L’exemple suivant arrondit les valeurs doubles avec deux chiffres fractionnels pour les doubles qui ont un chiffre fractionnel unique.

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 sous forme de nombres à virgule flottante ou 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 intermédiaires à la valeur même la plus proche dans la digits position décimale. Ceci 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 10^chiffres et que 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

Source:: Math.cs

Source:: Math.cs

Arrondit une valeur décimale à un nombre spécifié de chiffres fractionnaires, et arrondit les valeurs intermédiaires 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 dans la valeur de retour.

Retours

Decimal

Nombre le plus proche de d celui qui contient un nombre de chiffres fractionnels égaux à decimals.

Exceptions

ArgumentOutOfRangeException

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

OverflowException

Le résultat est en dehors de la plage d’un Decimal.

Remarques

La valeur de l’argument decimals peut aller de 0 à 28.

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

Important

Exemple

L’exemple suivant arrondit les valeurs décimales avec deux chiffres fractionnels à des valeurs qui ont un chiffre fractionnel unique.

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

Source:: Math.cs

Source:: Math.cs

Arrondit une valeur à virgule flottante double précision à la valeur intégrale la plus proche et arrondit les valeurs intermédiaires 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 aproche . Si le composant fractionnaire de a est à mi-chemin entre deux entiers, l’un d’entre eux étant pair et l’autre impair, le nombre pair est retourné. Notez que cette méthode retourne un Double type intégral au lieu d’un type intégral.

Remarques

Important

Si la valeur de l’argument a est Double.NaN, la méthode retourne Double.NaN. Si a c’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-à-entier sont optimisées si vous transmettez la valeur retournée par la méthode Round à l’une des fonctions de conversion integral, ou si la valeur double retournée par Round est automatiquement convertie en entier avec Option Strict défini sur Désactivé. Cette optimisation permet au code d’exécuter plus rapidement , jusqu’à deux fois plus rapide pour le code qui effectue un grand nombre de conversions en types entiers. 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.

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 sous forme de nombres à virgule flottante ou 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 intermédiaires à 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

Source:: Math.cs

Source:: Math.cs

Arrondit une valeur décimale à la valeur intégrale la plus proche et arrondit les valeurs intermédiaires 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

Entier le plus proche du d paramètre. Si le composant fractionnaire de d est à mi-chemin entre deux entiers, l’un d’entre eux étant pair et l’autre impair, le nombre pair est retourné. Notez que cette méthode retourne un Decimal type intégral au lieu d’un type intégral.

Exceptions

OverflowException

Le résultat est en dehors de la plage d’un Decimal.

Exemples

L’exemple suivant illustre la Round(Decimal) méthode. La Decimal valeur de 4,5 arrondis à 4 au lieu de 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

Important

Voir aussi

S’applique à

Round(Decimal, MidpointRounding)

Source:: Math.cs

Source:: Math.cs

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 type intégral au lieu d’un type intégral.

Exceptions

ArgumentException

mode n’est pas une valeur valide de MidpointRounding.

OverflowException

Le résultat est en dehors de la plage d’un Decimal.

Remarques

Pour plus d’informations sur l’arrondi de nombres avec des valeurs intermédiaires, consultez les valeurs intermédiaires et les conventions d’arrondi.

Important

Exemple

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

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 à

Commentaires

Cette page a-t-elle été utile ?