MidpointRounding MidpointRounding MidpointRounding MidpointRounding Enum

Definizione

Specifica l'elaborazione di un numero che si trova a metà tra due numeri con i metodi di elaborazione matematica.Specifies how mathematical rounding methods should process a number that is midway between two numbers.

public enum class MidpointRounding
[System.Runtime.InteropServices.ComVisible(true)]
public enum MidpointRounding
type MidpointRounding = 
Public Enum MidpointRounding
Ereditarietà
MidpointRoundingMidpointRoundingMidpointRoundingMidpointRounding
Attributi

Campi

AwayFromZero AwayFromZero AwayFromZero AwayFromZero 1

Quando un numero si trova a metà tra due numeri, viene arrotondato al numero più prossimo e più distante dallo zero.When a number is halfway between two others, it is rounded toward the nearest number that is away from zero.

ToEven ToEven ToEven ToEven 0

Quando un numero si trova a metà tra due numeri, viene arrotondato al numero pari più vicino.When a number is halfway between two others, it is rounded toward the nearest even number.

ToNegativeInfinity ToNegativeInfinity ToNegativeInfinity ToNegativeInfinity 3

Quando un numero si trova a metà tra due numeri, viene arrotondato al risultato più prossimo e non maggiore del risultato con precisione infinita.When a number is halfway between two others, it is rounded toward the result closest to and no greater than the infinitely precise result.

ToPositiveInfinity ToPositiveInfinity ToPositiveInfinity ToPositiveInfinity 4

Quando un numero si trova a metà tra due numeri, viene arrotondato al risultato più prossimo e non minore del risultato con precisione infinita.When a number is halfway between two others, it is rounded toward the result closest to and no less than the infinitely precise result.

ToZero ToZero ToZero ToZero 2

Quando un numero si trova a metà tra due numeri, viene arrotondato al risultato più prossimo e con grandezza non maggiore del risultato con precisione infinita.When a number is halfway between two others, it is rounded toward the result closest to and no greater in magnitude than the infinitely precise result.

Esempi

Nell'esempio seguente viene illustrato Math.Round il metodo insieme MidpointRounding all'enumerazione: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 posValue =  3.45m;
decimal negValue = -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(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)

*/
' 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 'Main
End Class 'Sample
'
'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)
'

Commenti

Utilizzare MidpointRounding con gli overload appropriati di Math.Round per fornire un maggiore controllo del processo di arrotondamento.Use MidpointRounding with appropriate overloads of Math.Round to provide more control of the rounding process.

Un'operazione di arrotondamento accetta un numero originale con una precisione implicita o specificata; esamina la cifra successiva, che è a tale precisione più uno; e restituisce il numero più vicino con la stessa precisione del numero originale.A rounding 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. Per i numeri positivi, se la cifra successiva è compresa tra 0 e 4, il numero più vicino è verso l'infinito negativo.For positive numbers, if the next digit is from 0 through 4, the nearest number is toward negative infinity. Se la cifra successiva è compresa tra 6 e 9, il numero più vicino è verso l'infinito positivo.If the next digit is from 6 through 9, the nearest number is toward positive infinity. Per i numeri negativi, se la cifra successiva è compresa tra 0 e 4, il numero più vicino è verso l'infinito positivo.For negative numbers, if the next digit is from 0 through 4, the nearest number is toward positive infinity. Se la cifra successiva è compresa tra 6 e 9, il numero più vicino è verso l'infinito negativo.If the next digit is from 6 through 9, the nearest number is toward negative infinity.

Nei casi precedenti, l' MidpointRounding enumerazione non influisce sul risultato dell'operazione di arrotondamento.In the previous cases, the MidpointRounding enumeration does not affect the result of the rounding operation. Tuttavia, se la cifra successiva è 5, che corrisponde al punto intermedio tra due possibili risultati, e tutte le cifre rimanenti sono zero o non vi sono cifre rimanenti, il numero più vicino è ambiguo.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. In questo caso, l' MidpointRounding enumerazione consente di specificare se l'operazione di arrotondamento restituisce il numero più vicino da zero o il numero pari più vicino.In this case, the MidpointRounding enumeration enables you to specify whether the rounding operation returns the nearest number away from zero or the nearest even number.

Nella tabella seguente vengono illustrati i risultati dell'arrotondamento di alcuni numeri negativi e positivi insieme ai valori MidpointRoundingdi.The following table demonstrates the results of rounding some negative and positive numbers in conjunction with the values of MidpointRounding. La precisione utilizzata per arrotondare i numeri è zero, il che significa che il numero dopo il separatore decimale influiscono sull'operazione di arrotondamento.The precision used to round the numbers is zero, which means the number after the decimal point affects the rounding operation. Per il numero-2,5, ad esempio, la cifra successiva al separatore decimale è 5.For example, for the number -2.5, the digit after the decimal point is 5. Poiché tale cifra è il punto medio, è possibile utilizzare MidpointRounding un valore per determinare il risultato dell'arrotondamento.Because that digit is the midpoint, you can use a MidpointRounding value to determine the result of rounding. Se AwayFromZero si specifica, viene restituito-3 perché è il numero più vicino da zero con una precisione pari a zero.If AwayFromZero is specified, -3 is returned because it is the nearest number away from zero with a precision of zero. Se ToEven si specifica, viene restituito-2 perché è il numero pari più vicino con una precisione pari a zero.If ToEven is specified, -2 is returned because it is the nearest even number with a precision of zero.

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

Si applica a