MidpointRounding Enumeração

Definição

Especifica como métodos de arredondamento matemático devem processar um número que esteja entre dois números.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
Herança
MidpointRounding
Atributos

Campos

AwayFromZero 1

Quando um número está a meio caminho entre outros dois, ele é arredondado para o número mais próximo que esteja distante de zero.When a number is halfway between two others, it is rounded toward the nearest number that is away from zero.

ToEven 0

Quando um número está a meio caminho entre outros dois, ele é arredondado para o número par mais próximo.When a number is halfway between two others, it is rounded toward the nearest even number.

ToNegativeInfinity 3

Quando um número está a meio caminho entre outros dois, ele é arredondado para o resultado mais próximo ao infinitamente preciso e não é maior que ele.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 4

Quando um número está a meio caminho entre outros dois, ele é arredondado para o resultado mais próximo ao infinitamente preciso e não é menor que ele.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 2

Quando um número está a meio caminho entre outros dois, ele é arredondado para o resultado mais próximo ao infinitamente preciso e não é maior em magnitude que ele.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.

Exemplos

O exemplo a seguir demonstra Math.Round o método em conjunto com MidpointRounding a enumeração: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
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)
'

Comentários

Use MidpointRounding com sobrecargas apropriadas do Math.Round para fornecer mais controle sobre o processo de arredondamento.Use MidpointRounding with appropriate overloads of Math.Round to provide more control of the rounding process.

Uma operação de arredondamento usa um número original com uma precisão implícita ou especificada; examina o próximo dígito, que é a precisão mais um; e retorna o número mais próximo com a mesma precisão que o número original.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. Para números positivos, se o próximo dígito for de 0 a 4, o número mais próximo será para infinito negativo.For positive numbers, if the next digit is from 0 through 4, the nearest number is toward negative infinity. Se o próximo dígito for de 6 a 9, o número mais próximo será em relação ao infinito positivo.If the next digit is from 6 through 9, the nearest number is toward positive infinity. Para números negativos, se o próximo dígito for de 0 a 4, o número mais próximo será para infinito positivo.For negative numbers, if the next digit is from 0 through 4, the nearest number is toward positive infinity. Se o próximo dígito for de 6 a 9, o número mais próximo será para infinito negativo.If the next digit is from 6 through 9, the nearest number is toward negative infinity.

Nos casos anteriores, a MidpointRounding enumeração não afeta o resultado da operação de arredondamento.In the previous cases, the MidpointRounding enumeration does not affect the result of the rounding operation. No entanto, se o próximo dígito for 5, que é o ponto médio entre dois resultados possíveis, e todos os dígitos restantes forem zero ou não houver dígitos restantes, o número mais próximo será ambíguo.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. Nesse caso, a MidpointRounding enumeração permite que você especifique se a operação de arredondamento retorna o número mais próximo de zero ou o número par mais próximo.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.

A tabela a seguir demonstra os resultados de arredondar alguns números negativos e positivos em conjunto com os MidpointRoundingvalores de.The following table demonstrates the results of rounding some negative and positive numbers in conjunction with the values of MidpointRounding. A precisão usada para arredondar os números é zero, o que significa que o número após o ponto decimal afeta a operação de arredondamento.The precision used to round the numbers is zero, which means the number after the decimal point affects the rounding operation. Por exemplo, para o número-2,5, o dígito após o ponto decimal é 5.For example, for the number -2.5, the digit after the decimal point is 5. Como esse dígito é o ponto médio, você pode usar MidpointRounding um valor para determinar o resultado do arredondamento.Because that digit is the midpoint, you can use a MidpointRounding value to determine the result of rounding. Se AwayFromZero for especificado,-3 será retornado porque é o número mais próximo de zero com uma precisão de zero.If AwayFromZero is specified, -3 is returned because it is the nearest number away from zero with a precision of zero. Se ToEven for especificado,-2 será retornado porque é o número par mais próximo com uma precisão de zero.If ToEven is specified, -2 is returned because it is the nearest even number with a precision of zero.

Número originalOriginal number AwayFromZeroAwayFromZero Até mesmoToEven
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

Aplica-se a