MidpointRounding Énumération

Définition

public enum class MidpointRounding

public enum MidpointRounding

[System.Runtime.InteropServices.ComVisible(true)]
public enum MidpointRounding

type MidpointRounding = 

[<System.Runtime.InteropServices.ComVisible(true)>]
type MidpointRounding = 

Public Enum MidpointRounding

Héritage

Object

ValueType

Enum

MidpointRounding

Attributs

ComVisibleAttribute

Champs

Exemples

L’exemple suivant illustre la Math.Round méthode conjointement 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)
*/

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

Remarques

Utilisez l’énumération MidpointRounding avec les surcharges appropriées de Math.Round, MathF.Roundet Decimal.Round pour fournir un contrôle plus complet du processus d’arrondi.

Malgré le nom de l’énumération, tous les modes ne concernent pas seulement la façon dont les points intermédiaires sont gérés. MidpointRoundingdéfinit deux stratégies globales d’arrondi ( arrondi à arrondi le plus proche et dirigé) et chaque champ d’énumération participe exactement à l’une de ces stratégies :

• Les modes les plus proches (AwayFromZero et ToEven) arrondissent toujours à la valeur représentée la plus proche. Ils diffèrent uniquement les uns des autres lorsque l’entrée est exactement à mi-chemin entre deux valeurs (un point intermédiaire), ce qui correspond au nom de l’énumération.
• Les modes d’arrondi dirigés (ToNegativeInfinity, ToPositiveInfinityet ToZero) arrondit toujours toutes les valeurs ( pas seulement les points intermédiaires) dans une direction fixe. Le résultat est la valeur représentée la plus proche dans cette direction, même si l’entrée n’est pas un point intermédiaire.

Arrondir à la valeur la plus proche

Champs:

• AwayFromZero
• ToEven

Une opération d'arrondi au plus proche prend un nombre original avec une précision implicite ou spécifiée; examine le chiffre suivant, qui correspond à cette précision plus un; et renvoie le nombre le plus proche avec la même précision que le nombre original. Pour les nombres positifs, si le chiffre suivant est compris entre 0 et 4, le nombre le plus proche est vers l’infini négatif. Si le chiffre suivant est compris entre 6 et 9, le nombre le plus proche est vers l’infini positif. Pour les nombres négatifs, si le chiffre suivant est compris entre 0 et 4, le nombre le plus proche est vers l’infini positif. Si le chiffre suivant est compris entre 6 et 9, le nombre le plus proche est vers l’infini négatif.

Si le chiffre suivant est compris entre 0 et 4 ou 6 et 9, le choix entre AwayFromZero et ToEven n’affecte pas le résultat de l’opération d’arrondi. Toutefois, si le chiffre suivant est égal à 5, qui est le point intermédiaire entre deux résultats possibles et que tous les chiffres restants sont nuls ou qu’il n’y a pas de chiffres restants, le nombre le plus proche est ambigu. Dans ce cas, les modes d’arrondi au plus proche dans MidpointRounding permettent de spécifier si l’opération d’arrondi retourne le nombre le plus proche de zéro ou le nombre pair le plus proche.

Le tableau suivant illustre les résultats de l’arrondi de certains nombres négatifs et positifs en conjonction avec les modes d’arrondi au plus proche. La précision utilisée pour arrondir les nombres est zéro, ce qui signifie que le nombre après la virgule décimale affecte l’opération d’arrondi. Par exemple, pour le nombre -2,5, le chiffre après la virgule décimale est 5. Étant donné que ce chiffre est le point intermédiaire, vous pouvez utiliser une MidpointRounding valeur pour déterminer le résultat de l’arrondi. Si AwayFromZero elle est spécifiée, -3 est retournée, car il s’agit du nombre le plus proche de zéro avec une précision de zéro. Si ToEven elle est spécifiée, -2 est retournée, car il s’agit du nombre pair le plus proche avec une précision de zéro.

Arrondi dirigé

Champs:

• ToNegativeInfinity
• ToPositiveInfinity
• ToZero

Une opération d’arrondi dirigé prend un nombre d’origine avec une précision implicite ou spécifiée et retourne le nombre le plus proche suivant dans une direction spécifique avec la même précision que le nombre d’origine. Modes dirigés sur MidpointRounding le contrôle de la direction vers laquelle chaque valeur est arrondie. Contrairement aux modes les plus proches, ces modes s’appliquent à chaque valeur d’entrée, pas seulement aux points intermédiaires ; par exemple, ToPositiveInfinity arrondit 2,1, 2,5 et 2,8 jusqu’à 3.

Le tableau suivant illustre les résultats de l’arrondi de certains nombres négatifs et positifs en conjonction avec les modes d’arrondi dirigé. La précision utilisée pour arrondir les nombres est zéro, ce qui signifie que le nombre avant la virgule décimale est affecté par l’opération d’arrondi.