MidpointRounding Énumération

Définition

Spécifie comment les méthodes d'arrondi mathématiques doivent traiter un nombre qui se trouve à mi-chemin entre deux nombres.Specifies how mathematical rounding methods should process a number that is midway between two numbers.

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

Champs

AwayFromZero 1

Arrondir au mode le plus proche : lorsqu’un nombre se trouve à mi-chemin entre deux autres, il est arrondi au nombre le plus proche qui est éloigné de zéro.Round to nearest mode: when a number is halfway between two others, it is rounded toward the nearest number that is away from zero.

ToEven 0

Arrondir au mode le plus proche : lorsqu’un nombre se trouve à mi-chemin entre deux autres, il est arrondi au nombre pair le plus proche.Round to nearest mode: when a number is halfway between two others, it is rounded toward the nearest even number.

ToNegativeInfinity 3

Mode dirigé : le nombre est arrondi à la valeur inférieure, le résultat étant le plus proche possible du résultat à précision infinie sans être supérieur.Directed mode: the number is rounded down, with the result closest to and no greater than the infinitely precise result.

ToPositiveInfinity 4

Mode dirigé : le nombre est arrondi à la valeur supérieure, le résultat étant le plus proche possible du résultat à précision infinie sans être inférieur.Directed mode: the number is rounded up, with the result closest to and no less than the infinitely precise result.

ToZero 2

Mode dirigé : le nombre est arrondi vers zéro, le résultat étant le plus proche possible du résultat à précision infinie sans être inférieur en magnitude.Directed mode: the number is rounded toward zero, with the result closest to and no greater in magnitude than the infinitely precise result.

Exemples

L’exemple suivant illustre la Math.Round méthode conjointement avec l' MidpointRounding énumération :The following example demonstrates the Math.Round method in conjunction with the MidpointRounding enumeration:

// This example demonstrates the Math.Round() method in conjunction 
// with the MidpointRounding enumeration.
using namespace System;

void main()
{
    Decimal result = (Decimal) 0.0;
    Decimal posValue = (Decimal) 3.45;
    Decimal negValue = (Decimal) -3.45;

    // By default, round a positive and a negative value to the nearest
    // even number. The precision of the result is 1 decimal place.
    result = Math::Round(posValue, 1);
    Console::WriteLine("{0,4} = Math.Round({1,5}, 1)", result, posValue);
    result = Math::Round(negValue, 1);
    Console::WriteLine("{0,4} = Math.Round({1,5}, 1)", result, negValue);
    Console::WriteLine();

    // Round a positive value to the nearest even number, then to the
    // nearest number away from zero. The precision of the result is 1
    // decimal place.
    result = Math::Round(posValue, 1, MidpointRounding::ToEven);
    Console::WriteLine(
        "{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)",
        result, posValue);
    result = Math::Round(posValue, 1, MidpointRounding::AwayFromZero);
    Console::WriteLine(
        "{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)",
        result, posValue);
    Console::WriteLine();

    // Round a negative value to the nearest even number, then to the
    // nearest number away from zero. The precision of the result is 1
    // decimal place.
    result = Math::Round(negValue, 1, MidpointRounding::ToEven);
    Console::WriteLine(
        "{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)",
        result, negValue);
    result = Math::Round(negValue, 1, MidpointRounding::AwayFromZero);
    Console::WriteLine(
        "{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)",
        result, negValue);
    Console::WriteLine();
}

/*
This code example produces the following results:

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

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

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

*/
decimal result = 0.0m;
decimal positiveValue = 3.45m;
decimal negativeValue = -3.45m;

// By default, round a positive and a negative value to the nearest even number.
// The precision of the result is 1 decimal place.

result = Math.Round(positiveValue, 1);
Console.WriteLine($"{result} = Math.Round({positiveValue}, 1)");
result = Math.Round(negativeValue, 1);
Console.WriteLine($"{result} = Math.Round({negativeValue}, 1)");
Console.WriteLine();

// Round a positive value to the nearest even number, then to the nearest number away from zero.
// The precision of the result is 1 decimal place.

result = Math.Round(positiveValue, 1, MidpointRounding.ToEven);
Console.WriteLine($"{result} = Math.Round({positiveValue}, 1, MidpointRounding.ToEven)");
result = Math.Round(positiveValue, 1, MidpointRounding.AwayFromZero);
Console.WriteLine($"{result} = Math.Round({positiveValue}, 1, MidpointRounding.AwayFromZero)");
Console.WriteLine();

// Round a negative value to the nearest even number, then to the nearest number away from zero.
// The precision of the result is 1 decimal place.

result = Math.Round(negativeValue, 1, MidpointRounding.ToEven);
Console.WriteLine($"{result} = Math.Round({negativeValue}, 1, MidpointRounding.ToEven)");
result = Math.Round(negativeValue, 1, MidpointRounding.AwayFromZero);
Console.WriteLine($"{result} = Math.Round({negativeValue}, 1, MidpointRounding.AwayFromZero)");
Console.WriteLine();
/*
This code example produces the following results:

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

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

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

*/
' This example demonstrates the Math.Round() method in conjunction 
' with the MidpointRounding enumeration.
Class Sample
    Public Shared Sub Main() 
        Dim result As Decimal = 0D
        Dim posValue As Decimal = 3.45D
        Dim negValue As Decimal = -3.45D
        
        ' By default, round a positive and a negative value to the nearest even number. 
        ' The precision of the result is 1 decimal place.
        result = Math.Round(posValue, 1)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1)", result, posValue)
        result = Math.Round(negValue, 1)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1)", result, negValue)
        Console.WriteLine()
        
        ' Round a positive value to the nearest even number, then to the nearest number 
        ' away from zero. The precision of the result is 1 decimal place.
        result = Math.Round(posValue, 1, MidpointRounding.ToEven)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)", _
                           result, posValue)
        result = Math.Round(posValue, 1, MidpointRounding.AwayFromZero)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)", _
                           result, posValue)
        Console.WriteLine()
        
        ' Round a negative value to the nearest even number, then to the nearest number 
        ' away from zero. The precision of the result is 1 decimal place.
        result = Math.Round(negValue, 1, MidpointRounding.ToEven)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)", _
                            result, negValue)
        result = Math.Round(negValue, 1, MidpointRounding.AwayFromZero)
        Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)", _
                           result, negValue)
        Console.WriteLine()
    
    End Sub
End Class
'
'This code example produces the following results:
'
' 3.4 = Math.Round( 3.45, 1)
'-3.4 = Math.Round(-3.45, 1)
'
' 3.4 = Math.Round( 3.45, 1, MidpointRounding.ToEven)
' 3.5 = Math.Round( 3.45, 1, MidpointRounding.AwayFromZero)
'
'-3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
'-3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)
'

Remarques

Utilisez MidpointRounding avec les surcharges appropriées de Math.Round pour fournir davantage de contrôle sur le processus d’arrondi.Use MidpointRounding with appropriate overloads of Math.Round to provide more control of the rounding process.

Arrondir au plus procheRound to nearest

Une opération d’arrondi à la valeur la plus proche accepte un nombre d’origine avec une précision implicite ou spécifiée. examine le chiffre suivant, qui est à cette précision plus un ; et retourne le nombre le plus proche avec la même précision que le nombre d’origine.A round-to-nearest operation takes an original number with an implicit or specified precision; examines the next digit, which is at that precision plus one; and returns the nearest number with the same precision as the original number. 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.For positive numbers, if the next digit is from 0 through 4, the nearest number is toward negative infinity. Si le chiffre suivant est compris entre 6 et 9, le nombre le plus proche est vers l’infini positif.If the next digit is from 6 through 9, the nearest number is toward positive infinity. 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.For negative numbers, if the next digit is from 0 through 4, the nearest number is toward positive infinity. Si le chiffre suivant est compris entre 6 et 9, le nombre le plus proche est vers l’infini négatif.If the next digit is from 6 through 9, the nearest number is toward negative infinity.

Dans les cas précédents, les MidpointRounding.AwayFromZero et MidpointRounding.ToEven n’affectent pas le résultat de l’opération d’arrondi.In the previous cases, the MidpointRounding.AwayFromZero and MidpointRounding.ToEven do not affect the result of the rounding operation. Toutefois, si le chiffre suivant est 5, qui est le milieu entre deux résultats possibles, et tous les chiffres restants sont nuls ou il n’y a pas de chiffres restants, le nombre le plus proche est ambigu.However, if the next digit is 5, which is the midpoint between two possible results, and all remaining digits are zero or there are no remaining digits, the nearest number is ambiguous. Dans ce cas, les modes d’arrondi vers le plus proche dans MidpointRounding vous 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.In this case, the round-to-nearest modes in MidpointRounding enable you to specify whether the rounding operation returns the nearest number away from zero or the nearest even number.

Le tableau suivant montre les résultats de l’arrondi de nombres négatifs et positifs avec les modes arrondi à la valeur la plus proche.The following table demonstrates the results of rounding some negative and positive numbers in conjunction with round-to-nearest modes. La précision utilisée pour arrondir les nombres est égale à zéro, ce qui signifie que le nombre après la virgule décimale affecte l’opération d’arrondi.The precision used to round the numbers is zero, which means the number after the decimal point affects the rounding operation. Par exemple, pour le nombre-2,5, le chiffre après la virgule décimale est 5.For example, for the number -2.5, the digit after the decimal point is 5. Étant donné que ce chiffre est le milieu, vous pouvez utiliser une MidpointRounding valeur pour déterminer le résultat de l’arrondi.Because that digit is the midpoint, you can use a MidpointRounding value to determine the result of rounding. Si AwayFromZero est spécifié,-3 est retourné parce qu’il s’agit du nombre le plus proche de zéro avec une précision de zéro.If AwayFromZero is specified, -3 is returned because it is the nearest number away from zero with a precision of zero. Si ToEven est spécifié,-2 est retourné parce qu’il s’agit du nombre pair le plus proche avec une précision de zéro.If ToEven is specified, -2 is returned because it is the nearest even number with a precision of zero.

Numéro d’origineOriginal number AwayFromZeroAwayFromZero ToEvenToEven
3,53.5 44 44
2.82.8 33 33
2.52.5 33 22
2.12.1 22 22
-2.1-2.1 -2-2 -2-2
-2.5-2.5 -3-3 -2-2
-2.8-2.8 -3-3 -3-3
-3.5-3.5 -4-4 -4-4

Arrondi dirigéDirected rounding

Une opération d’arrondi dirigée prend un nombre d’origine avec une précision implicite ou spécifiée et retourne le nombre suivant le plus proche de certains prédéfinis avec la même précision que le nombre d’origine.A directed rounding operation takes an original number with an implicit or specified precision and returns the next number closest to some predefined one with the same precision as the original number. Modes dirigés sur MidpointRounding le contrôle vers le nombre prédéfini dans lequel l’arrondi est effectué.Directed modes on MidpointRounding control toward which predefined number the rounding is performed.

Le tableau suivant montre les résultats de l’arrondi de nombres négatifs et positifs conjointement aux modes d’arrondi dirigés.The following table demonstrates the results of rounding some negative and positive numbers in conjunction with directed rounding modes. La précision utilisée pour arrondir les nombres est égale à zéro, ce qui signifie que le nombre avant la virgule décimale est affecté par l’opération d’arrondi.The precision used to round the numbers is zero, which means the number before the decimal point is affected by the rounding operation.

Numéro d’origineOriginal number ToNegativeInfinityToNegativeInfinity ToPositiveInfinityToPositiveInfinity ToZeroToZero
2.82.8 22 33 22
2.52.5 22 33 22
2.12.1 22 33 22
-2.1-2.1 -3-3 -2-2 -2-2
-2.5-2.5 -3-3 -2-2 -2-2
-2.8-2.8 -3-3 -2-2 -2-2

S’applique à