Por que .NET uso banqueiro do arredondamento por defeito?

Question

De acordo com a documentação, o href="http://msdn.microsoft.com/en-us/library/zy06z30k.aspx" rel="noreferrer"> decimal.Round método usa uma redonda to-mesmo algoritmo que não é comum para a maioria das aplicações. Então, eu sempre acabar escrevendo uma função personalizada para fazer o algoritmo de metade até rodada mais natural:

public static decimal RoundHalfUp(this decimal d, int decimals)
{
    if (decimals < 0)
    {
        throw new ArgumentException("The decimals must be non-negative", 
            "decimals");
    }

    decimal multiplier = (decimal)Math.Pow(10, decimals);
    decimal number = d * multiplier;

    if (decimal.Truncate(number) < number)
    {
        number += 0.5m;
    }
    return decimal.Round(number) / multiplier;
}

Alguém sabe a razão por trás dessa decisão de projeto-quadro?

Existe alguma aplicação built-in do algoritmo round-meia-se no quadro? Ou talvez alguma API não gerenciado do Windows?

Pode ser enganosa para iniciantes que decimal.Round(2.5m, 0) Basta escrever esperando 3 como resultado, mas recebendo 2 em vez.

Answer 1

Provavelmente porque é um algoritmo de melhor. Ao longo de muitos arredondamentos realizados, você será, em média salientar que todos .5 de acabar arredondamento igualmente cima e para baixo. Isto dá melhores estimativas de resultados reais se você são, por exemplo, adicionando um monte de números arredondados. Eu diria que, mesmo que não é o que alguns podem esperar, é provavelmente a coisa mais certa a fazer.

Answer 2

As outras respostas com razões pelas quais o algoritmo do banqueiro (aka metade rodada até mesmo ) é uma boa escolha são bastante correto. Ele não sofre de negativo ou viés positivo tanto quanto o metade rodada longe do método de zero distribuições sobre mais razoáveis.

Mas a pergunta era porque .NET usar arredondamento real do banqueiro como padrão - ea resposta é que a Microsoft tem seguido a IEEE 754 padrão . Isto também é mencionado em MSDN para Math.Round sob Observações.

Observe também que .NET suporta o método alternativo especificado pelo IEEE, fornecendo a enumeração MidpointRounding. Eles poderia naturalmente ter fornecido mais alternativas para resolver laços, mas eles optam por apenas cumprir o padrão IEEE.

Answer 3

Enquanto eu não posso responder a pergunta "Por que os designers da Microsoft escolher este como o padrão?", Eu só quero salientar que uma função extra é desnecessária.

Math.Round permite que você especifique um MidpointRounding :

• Toeven -. Quando um número está a meio caminho entre dois outros, ele é arredondado para o número par mais próximo
• AwayFromZero - Quando um número está a meio caminho entre dois outros, ele é arredondado para o número mais próximo que está longe de zero.

Answer 4

Os decimais são usados ??principalmente para dinheiro ; arredondamento do banqueiro é comum quando se trabalha com dinheiro . Ou você poderia dizer.

É principalmente banqueiros que precisam de tipo decimal; portanto, ele faz “Arredondamento do banqueiro”

Bankers arredondamento tem a vantagem de que, em média, você vai obter o mesmo resultado se você:

• em volta de um conjunto de “linhas de nota fiscal” antes de adicionar-los,
• ou adicioná-los até depois rodada do total

O arredondamento antes de adicionar-se salvou um monte de trabalho nos dias antes dos computadores.

(No Reino Unido quando fomos bancos decimais não lidar com meia pence, mas por muitos anos ainda havia uma moeda de meio pence e fazer compras preços muitas vezes tiveram que terminam em meia pence - assim que os lotes de arredondamento)

Answer 5

Use outro sobrecarga da função redonda como esta:

decimal.Round(2.5m, 0,MidpointRounding.AwayFromZero)

Ele irá imprimir 3 . E se você usar

decimal.Round(2.5m, 0,MidpointRounding.ToEven)

você obterá arredondamento do banqueiro.

Answer 6

Além disso, nota que "arredondamento" através de uma cadeia de formato (como "0") produz um resultado diferente do que "Math.Round ()". Ou seja, que 5, .5, etc .. é sempre arredondado para cima:

let d, d' = 2.5, 3.5

Debug.WriteLine(Math.Round(d))      // 2.5 -> 2
Debug.WriteLine(d.ToString("0"))    // 2.5 -> 3

Debug.WriteLine(Math.Round(d'))     // 3.5 -> 4
Debug.WriteLine(d'.ToString("0"))   // 3.5 -> 4


let dd, dd' = 2.25, 2.35

Debug.WriteLine(Math.Round(dd, 1))     // 2.25 -> 2.2
Debug.WriteLine(dd.ToString("0.0"))    // 2.25 -> 2.3

Debug.WriteLine(Math.Round(dd', 1))    // 2.35 -> 2.4
Debug.WriteLine(dd'.ToString("0.0"))   // 2.35 -> 2.4