Respostas:
Aqui estão alguns exemplos:
decimal a = 1.994444M;
Math.Round(a, 2); //returns 1.99
decimal b = 1.995555M;
Math.Round(b, 2); //returns 2.00
Você também pode consultar os arredondamentos dos banqueiros / arredondados para o mesmo com a seguinte sobrecarga:
Math.Round(a, 2, MidpointRounding.ToEven);
Há mais informações aqui .
0.005
ao número antes de arredondar. Da mesma forma, para arredondar para baixo , subtraia 0.005
antes de passar para a Math.Round
função.
MidPointRounding.ToEven
(também conhecido como "Bankers Rounding") é porque todos nós aprendemos a arredondar na escola, onde 0,5 arredondamentos causam arredondamentos demais. Este é um problema ao lidar com dinheiro, cálculos de impostos etc.
Tente o seguinte:
twoDec = Math.Round(val, 2)
Pessoalmente, nunca arredondo nada. Mantenha-o o mais resoluto possível, pois o arredondamento é um arenque vermelho no CS de qualquer maneira. Mas você deseja formatar dados para seus usuários e, para esse fim, acho que string.Format("{0:0.00}", number)
é uma boa abordagem.
Se você gostaria de uma string
> (1.7289).ToString("#.##")
"1.73"
Ou um decimal
> Math.Round((Decimal)x, 2)
1.73m
Mas lembre-se! O arredondamento não é distributivo, ou seja. round(x*y) != round(x) * round(y)
. Portanto, não faça nenhum arredondamento até o final de um cálculo, caso contrário você perderá a precisão.
A Wikipedia tem uma boa página sobre arredondamentos em geral.
Todos os idiomas .NET (gerenciados) podem usar qualquer um dos mecanismos de arredondamento do CLR (Common Language Run Time). Por exemplo, o método Math.Round () (como mencionado acima) permite que o desenvolvedor especifique o tipo de arredondamento (Arredondar para o par ou Afastar do zero). O método Convert.ToInt32 () e suas variações usam o arredondamento para o par . Os métodos Ceiling () e Floor () estão relacionados.
Você também pode arredondar com formatação numérica personalizada .
Observe que Decimal.Round () usa um método diferente de Math.Round ();
Aqui está uma posição útil no algoritmo de arredondamento do banqueiro. Veja um dos posts engraçados de Raymond aqui sobre arredondamentos ...
// converte até duas casas decimais
String.Format("{0:0.00}", 140.6767554); // "140.67"
String.Format("{0:0.00}", 140.1); // "140.10"
String.Format("{0:0.00}", 140); // "140.00"
Double d = 140.6767554;
Double dc = Math.Round((Double)d, 2); // 140.67
decimal d = 140.6767554M;
decimal dc = Math.Round(d, 2); // 140.67
=========
// just two decimal places
String.Format("{0:0.##}", 123.4567); // "123.46"
String.Format("{0:0.##}", 123.4); // "123.4"
String.Format("{0:0.##}", 123.0); // "123"
também pode combinar "0" com "#".
String.Format("{0:0.0#}", 123.4567) // "123.46"
String.Format("{0:0.0#}", 123.4) // "123.4"
String.Format("{0:0.0#}", 123.0) // "123.0"
Eu sei que é uma pergunta antiga, mas observe as seguintes diferenças entre a rodada de matemática e a rodada de formato de string :
decimal d1 = (decimal)1.125;
Math.Round(d1, 2).Dump(); // returns 1.12
d1.ToString("#.##").Dump(); // returns "1.13"
decimal d2 = (decimal)1.1251;
Math.Round(d2, 2).Dump(); // returns 1.13
d2.ToString("#.##").Dump(); // returns "1.13"
Se você deseja arredondar um número, pode obter resultados diferentes dependendo de: como você usa a função Math.Round () (se for um arredondamento para cima ou para baixo), você está trabalhando com números duplos e / ou flutuantes e você aplica o arredondamento do ponto médio. Especialmente, ao usar com operações dentro dele ou a variável a arredondar vem de uma operação. Digamos que você queira multiplicar esses dois números: 0,75 * 0,95 = 0,7125 . Direita? Não em c #
Vamos ver o que acontece se você quiser arredondar para a terceira casa decimal:
double result = 0.75d * 0.95d; // result = 0.71249999999999991
double result = 0.75f * 0.95f; // result = 0.71249997615814209
result = Math.Round(result, 3, MidpointRounding.ToEven); // result = 0.712. Ok
result = Math.Round(result, 3, MidpointRounding.AwayFromZero); // result = 0.712. Should be 0.713
Como você vê, a primeira rodada () está correta se você deseja arredondar o ponto médio. Mas a segunda rodada () está errada se você deseja arredondar.
Isso se aplica a números negativos:
double result = -0.75 * 0.95; //result = -0.71249999999999991
result = Math.Round(result, 3, MidpointRounding.ToEven); // result = -0.712. Ok
result = Math.Round(result, 3, MidpointRounding.AwayFromZero); // result = -0.712. Should be -0.713
Portanto, IMHO, você deve criar sua própria função de quebra automática para Math.Round () que atenda aos seus requisitos. Eu criei uma função na qual o parâmetro 'roundUp = true' significa arredondar para o próximo número maior. Ou seja: 0,7125 arredonda para 0,713 e -0,7125 arredonda para -0,712 (porque -0,712> -0,713). Esta é a função que eu criei e funciona para qualquer número de decimais:
double Redondea(double value, int precision, bool roundUp = true)
{
if ((decimal)value == 0.0m)
return 0.0;
double corrector = 1 / Math.Pow(10, precision + 2);
if ((decimal)value < 0.0m)
{
if (roundUp)
return Math.Round(value, precision, MidpointRounding.ToEven);
else
return Math.Round(value - corrector, precision, MidpointRounding.AwayFromZero);
}
else
{
if (roundUp)
return Math.Round(value + corrector, precision, MidpointRounding.AwayFromZero);
else
return Math.Round(value, precision, MidpointRounding.ToEven);
}
}
A variável 'corrector' é para corrigir a imprecisão de operar com números flutuantes ou duplos.
Uma coisa que você pode querer verificar é o Mecanismo de Arredondamento da Matemática.
http://msdn.microsoft.com/en-us/library/system.midpointrounding.aspx
Fora isso, recomendo a abordagem Math.Round (inputNumer, numberOfPlaces) sobre a * 100/100 porque é mais limpa.
Você deve poder especificar o número de dígitos que deseja arredondar usando Math.Round (YourNumber, 2)
Você pode ler mais aqui .
Math.Floor (123456.646 * 100) / 100 Retornaria 123456.64
sequência a = "10.65678";
decimal d = Math.Round (Convert.ToDouble (a.ToString ()), 2)
Teve uma situação estranha em que eu tinha uma variável decimal, ao serializar 55.50, ele sempre define o valor padrão matematicamente como 55.5. Porém, por algum motivo, nosso sistema cliente espera seriamente 55,50 e eles definitivamente esperam decimais. Foi quando eu escrevi o auxiliar abaixo, que sempre converte qualquer valor decimal preenchido em 2 dígitos com zeros em vez de enviar uma string.
public static class DecimalExtensions
{
public static decimal WithTwoDecimalPoints(this decimal val)
{
return decimal.Parse(val.ToString("0.00"));
}
}
O uso deve ser
var sampleDecimalValueV1 = 2.5m;
Console.WriteLine(sampleDecimalValueV1.WithTwoDecimalPoints());
decimal sampleDecimalValueV1 = 2;
Console.WriteLine(sampleDecimalValueV1.WithTwoDecimalPoints());
Resultado:
2.50
2.00