No contexto da programação em C#, o método Math.Round desempenha um papel fundamental no arredondamento de valores numéricos, especialmente ao lidar com tipos de dados do tipo double e decimal. Esse método permite que os desenvolvedores arredondem um determinado valor numérico para o número inteiro mais próximo ou para um número especificado de casas decimais, proporcionando flexibilidade e precisão em operações matemáticas. Existem vários tipos de arredondamento disponíveis, como o arredondamento para o ponto médio. Neste artigo, vamos explorar as complexidades do Math.Round em C#, analisando seus diversos aspectos e cenários de uso. Nas seções subsequentes deste artigo, exploraremos a utilização da biblioteca IronPDF da Iron Software para manipulação de PDFs.
O método Math.Round em C# é uma ferramenta poderosa para arredondar dígitos fracionários usando uma convenção de arredondamento específica. Faz parte do namespace System e fornece diversas sobrecargas para acomodar diferentes operações de arredondamento.
// Methods overloaded by Math.Round
Math.Round(Double)
Math.Round(Double, Int32) // Int32 specifies number of fractional digits
Math.Round(Double, Int32, MidpointRounding) // Int32 specifies number of fractional digits, MidpointRounding is the type of rounding method
Math.Round(Double, MidpointRounding) // MidpointRounding is the type of rounding method
Math.Round(Decimal)
Math.Round(Decimal, Int32) // Int32 specifies number of fractional digits
Math.Round(Decimal, Int32, MidpointRounding)
Math.Round(Decimal, MidpointRounding)' Methods overloaded by Math.Round
'INSTANT VB TODO TASK: The following line uses invalid syntax:
'Math.Round(Double) Math.Round(Double, Int32) Math.Round(Double, Int32, MidpointRounding) Math.Round(Double, MidpointRounding) Math.Round(Decimal) Math.Round(Decimal, Int32) Math.Round(Decimal, Int32, MidpointRounding) Math.Round(Decimal, MidpointRounding)Ao lidar com valores do tipo double, Math.Round é comumente usado para arredondar um número para o inteiro mais próximo. Por exemplo:
double originalValue = 3.75;
double roundedValue = Math.Round(originalValue);
// Output: 4Dim originalValue As Double = 3.75
Dim roundedValue As Double = Math.Round(originalValue)
' Output: 4Neste exemplo, o método Math.Round arredondou o valor original double 3,75 para o valor inteiro mais próximo, que é 4.
Da mesma forma, o método Math.Round se aplica a valores decimais. Considere o seguinte exemplo:
decimal originalValue = 8.625m;
decimal roundedValue = Math.Round(originalValue, 2);
// Output: 8.63Dim originalValue As Decimal = 8.625D
Dim roundedValue As Decimal = Math.Round(originalValue, 2)
' Output: 8.63Neste caso, o método Math.Round é usado para arredondar o número decimal 8,625 para duas casas decimais, resultando no valor arredondado 8,63.
O objetivo principal de Math.Round é arredondar um determinado valor numérico para o inteiro mais próximo. Quando a parte fracionária está exatamente a meio caminho entre dois números inteiros, o método segue uma convenção de arredondamento específica. A enumeração MidpointRounding pode ser usada como argumento no método Math.Round e determina se o arredondamento deve ser feito para o número par mais próximo ou para longe de zero.
Vamos explorar como o modo MidpointRounding pode ser utilizado:
double originalValue = 5.5;
double roundedValueEven = Math.Round(originalValue, MidpointRounding.ToEven);
double roundedValueOdd = Math.Round(originalValue, MidpointRounding.AwayFromZero);
// Output: roundedValueEven = 6, roundedValueOdd = 6Dim originalValue As Double = 5.5
Dim roundedValueEven As Double = Math.Round(originalValue, MidpointRounding.ToEven)
Dim roundedValueOdd As Double = Math.Round(originalValue, MidpointRounding.AwayFromZero)
' Output: roundedValueEven = 6, roundedValueOdd = 6Neste exemplo, ao arredondar o valor 5,5, MidpointRounding.ToEven arredonda para o número par mais próximo (resultando em 6) e MidpointRounding.AwayFromZero arredonda para longe de zero, resultando em 6.
Para arredondar um número para um número específico de casas decimais, o método Math.Round permite a inclusão de um parâmetro adicional que representa o número de dígitos fracionários:
decimal originalValue = 9.123456m;
decimal roundedValue = Math.Round(originalValue, 3);
// Output: 9.123Dim originalValue As Decimal = 9.123456D
Dim roundedValue As Decimal = Math.Round(originalValue, 3)
' Output: 9.123Neste caso, o número decimal 9,123456 foi arredondado para três casas decimais, resultando no valor arredondado 9,123.
Um valor intermediário surge quando o valor após o dígito menos significativo no resultado está exatamente a meio caminho entre dois números. Por exemplo, 2,56500 é um valor médio quando arredondado para duas casas decimais, resultando em 2,57, e 3,500 é um valor médio quando arredondado para o inteiro 4. O desafio reside em identificar o valor mais próximo na estratégia de arredondamento para o mais próximo para valores médios sem uma convenção de arredondamento definida.
O método Round em C# suporta duas convenções de arredondamento para lidar com valores de ponto médio:
Arredondamento a partir de zero: Os valores do ponto médio são arredondados para o número seguinte, afastando-se de zero. Este método é representado pelo membro de enumeração MidpointRounding.AwayFromZero.
Arredondamento para o número par mais próximo (arredondamento bancário): os valores do ponto médio são arredondados para o número par mais próximo. Essa abordagem de arredondamento é indicada pelo membro de enumeração MidpointRounding.ToEven.
decimal[] decimalSampleValues = { 1.15m, 1.25m, 1.35m, 1.45m, 1.55m, 1.65m };
decimal sum = 0;
// Calculate true mean values.
foreach (var value in decimalSampleValues)
{
sum += value;
}
Console.WriteLine("True mean values: {0:N2}", sum / decimalSampleValues.Length);
// Calculate mean values with rounding away from zero.
sum = 0;
foreach (var value in decimalSampleValues)
{
sum += Math.Round(value, 1, MidpointRounding.AwayFromZero);
}
Console.WriteLine("AwayFromZero mean: {0:N2}", sum / decimalSampleValues.Length);
// Calculate mean values with rounding to the nearest even.
sum = 0;
foreach (var value in decimalSampleValues)
{
sum += Math.Round(value, 1, MidpointRounding.ToEven);
}
Console.WriteLine("ToEven mean: {0:N2}", sum / decimalSampleValues.Length);Dim decimalSampleValues() As Decimal = { 1.15D, 1.25D, 1.35D, 1.45D, 1.55D, 1.65D }
Dim sum As Decimal = 0
' Calculate true mean values.
For Each value In decimalSampleValues
sum += value
Next value
Console.WriteLine("True mean values: {0:N2}", sum / decimalSampleValues.Length)
' Calculate mean values with rounding away from zero.
sum = 0
For Each value In decimalSampleValues
sum += Math.Round(value, 1, MidpointRounding.AwayFromZero)
Next value
Console.WriteLine("AwayFromZero mean: {0:N2}", sum / decimalSampleValues.Length)
' Calculate mean values with rounding to the nearest even.
sum = 0
For Each value In decimalSampleValues
sum += Math.Round(value, 1, MidpointRounding.ToEven)
Next value
Console.WriteLine("ToEven mean: {0:N2}", sum / decimalSampleValues.Length)
A estratégia de arredondamento AwayFromZero arredonda para o número mais próximo, arredondando um número que esteja exatamente no meio de outros dois números, afastando-o de zero.
Essa estratégia é caracterizada pelo arredondamento direcionado para zero. O resultado é o mais próximo possível do resultado infinitamente preciso, não sendo, portanto, maior em magnitude.
Essa estratégia envolve arredondar para o número mais próximo e, quando um número está exatamente no meio de outros dois, ele é arredondado para o número par mais próximo.
Essa estratégia envolve arredondar para baixo, sendo o resultado o mais próximo possível e não maior que o resultado infinitamente preciso.
Essa estratégia envolve arredondar para cima, de modo que o resultado seja o mais próximo possível e não inferior ao resultado infinitamente preciso.
Ao trabalhar com números de ponto flutuante de dupla precisão, é essencial compreender a potencial imprecisão devido à natureza da representação em ponto flutuante. O método Math.Round ajuda a mitigar problemas de precisão arredondando valores para o inteiro mais próximo ou para um número específico de casas decimais.
Os desenvolvedores podem usar o método Math.Round para obter a precisão desejada em seus cálculos:
double originalValue = 123.456789;
double result = Math.Round(originalValue, 4);
// Output: 123.4568, rounded valueDim originalValue As Double = 123.456789
Dim result As Double = Math.Round(originalValue, 4)
' Output: 123.4568, rounded valueNeste exemplo, o valor double 123,456789 é arredondado para quatro casas decimais, resultando no valor mais preciso 123,4568.
A estratégia de arredondamento pelo ponto médio torna-se crucial quando um valor fracionário está exatamente no meio entre dois números inteiros. O método Math.Round emprega a estratégia MidpointRounding especificada para resolver esses casos.
Considere o seguinte exemplo em que o arredondamento pelo ponto médio é utilizado:
double originalValue = 7.5;
double roundedValue = Math.Round(originalValue, MidpointRounding.AwayFromZero);
// Output: 8Dim originalValue As Double = 7.5
Dim roundedValue As Double = Math.Round(originalValue, MidpointRounding.AwayFromZero)
' Output: 8Neste caso, o valor 7,5 é arredondado para longe de zero, resultando no valor arredondado 8.
Aqui estão alguns exemplos de sua aplicação em diversos contextos:
Em aplicações financeiras, o arredondamento preciso é crucial. Por exemplo, ao calcular taxas de juros, converter moedas ou lidar com cálculos de impostos, o método Math.Round pode ser empregado para garantir que os resultados sejam arredondados para o número apropriado de casas decimais, em conformidade com os padrões financeiros.
double interestRate = 0.04567;
double roundedInterest = Math.Round(interestRate, 4); // Round to 4 decimal placesDim interestRate As Double = 0.04567
Dim roundedInterest As Double = Math.Round(interestRate, 4) ' Round to 4 decimal placesAo apresentar valores numéricos em uma interface de usuário, é comum arredondar os números para facilitar a leitura. O arredondamento usando Math.Round pode melhorar a clareza das informações apresentadas.
double temperature = 23.678;
double roundedTemperature = Math.Round(temperature, 1); // Round to 1 decimal placeDim temperature As Double = 23.678
Dim roundedTemperature As Double = Math.Round(temperature, 1) ' Round to 1 decimal placeEm análises estatísticas, o arredondamento preciso é essencial para evitar a introdução de vieses ou imprecisões. O método Math.Round pode ajudar a apresentar resultados com o nível de precisão desejado.
double meanValue = CalculateMean(data);
double roundedMean = Math.Round(meanValue, 2); // Round mean value to 2 decimal placesDim meanValue As Double = CalculateMean(data)
Dim roundedMean As Double = Math.Round(meanValue, 2) ' Round mean value to 2 decimal placesEm aplicações científicas, a precisão é crucial. Ao lidar com dados experimentais ou cálculos científicos, o arredondamento usando Math.Round garante que os resultados sejam apresentados de forma significativa e precisa.
double experimentalResult = 9.87654321;
double roundedResult = Math.Round(experimentalResult, 5); // Round to 5 decimal placesDim experimentalResult As Double = 9.87654321
Dim roundedResult As Double = Math.Round(experimentalResult, 5) ' Round to 5 decimal placesNa implementação de modelos matemáticos ou simulações, o arredondamento pode simplificar cálculos complexos. O método Math.Round pode ser aplicado para controlar a precisão dos resultados intermediários no processo de modelagem.
double modelResult = SimulatePhysicalSystem(parameters);
double roundedModelResult = Math.Round(modelResult, 3); // Round to 3 decimal placesDim modelResult As Double = SimulatePhysicalSystem(parameters)
Dim roundedModelResult As Double = Math.Round(modelResult, 3) ' Round to 3 decimal placesNo desenvolvimento de jogos, a precisão numérica é crucial para cálculos de física, posicionamento e outras operações matemáticas. O método Math.Round garante que os valores relacionados ao jogo sejam arredondados para um nível de precisão apropriado.
double playerPosition = CalculatePlayerPosition();
double roundedPosition = Math.Round(playerPosition, 2); // Round to 2 decimal placesDim playerPosition As Double = CalculatePlayerPosition()
Dim roundedPosition As Double = Math.Round(playerPosition, 2) ' Round to 2 decimal placesEm cada um desses cenários, o método Math.Round permite que os desenvolvedores controlem a precisão dos valores numéricos, promovendo exatidão e legibilidade em seus aplicativos.
A principal característica do IronPDF é sua função de conversão de HTML para PDF , mantendo layouts e estilos. Ele converte conteúdo da web em PDFs, o que é ótimo para relatórios, faturas e documentação. Você pode converter facilmente arquivos HTML, URLs e strings HTML em PDFs.
using IronPdf;
class Program
{
static void Main(string[] args)
{
var renderer = new ChromePdfRenderer();
// Convert HTML String to PDF
var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");
// Convert HTML File to PDF
var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");
// Convert URL to PDF
var url = "http://ironpdf.com"; // Specify the URL
var pdfFromUrl = renderer.RenderUrlAsPdf(url);
pdfFromUrl.SaveAs("URLToPDF.pdf");
}
}Imports IronPdf
Friend Class Program
Shared Sub Main(ByVal args() As String)
Dim renderer = New ChromePdfRenderer()
' Convert HTML String to PDF
Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")
' Convert HTML File to PDF
Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")
' Convert URL to PDF
Dim url = "http://ironpdf.com" ' Specify the URL
Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
pdfFromUrl.SaveAs("URLToPDF.pdf")
End Sub
End ClassAgora vamos ver como podemos gerar documentos PDF usando a biblioteca IronPDF C# PDF da Iron Software .
Você tem a opção de instalar o IronPDF através do console do Gerenciador de Pacotes NuGet ou do gerenciador de pacotes do Visual Studio.
Instale o IronPDF usando o Gerenciador de Pacotes NuGet pesquisando "IronPDF" na barra de pesquisa.
using IronPdf;
List<string> cart = new List<string>();
void AddItems(params string[] items)
{
for (int i = 0; i < items.Length; i++)
{
cart.Add(items[i]);
}
}
Console.WriteLine("Enter the cart items as comma-separated values:");
var itemsString = Console.ReadLine();
if (itemsString != null)
{
var items = itemsString.Split(",").ToArray();
AddItems(items);
}
AddItems("Sample1", "Sample2");
Console.WriteLine("-------------------------------------------------------");
Console.WriteLine("Display Cart");
string name = "Sam";
var count = cart.Count;
string content = $@"
<!DOCTYPE html>
<html>
<body>
<h1>Hello, {name}!</h1>
<p>You have {count} items in the cart.</p>
" + string.Join("\n", cart.Select(x => $"<p>{x}</p>"))
+ @"
</body>
</html>";
var pdfRenderer = new ChromePdfRenderer();
pdfRenderer.RenderHtmlAsPdf(content).SaveAs("cart.pdf");Imports Microsoft.VisualBasic
Imports IronPdf
Private cart As New List(Of String)()
Private Sub AddItems(ParamArray ByVal items() As String)
For i As Integer = 0 To items.Length - 1
cart.Add(items(i))
Next i
End Sub
Console.WriteLine("Enter the cart items as comma-separated values:")
Dim itemsString = Console.ReadLine()
If itemsString IsNot Nothing Then
Dim items = itemsString.Split(",").ToArray()
AddItems(items)
End If
AddItems("Sample1", "Sample2")
Console.WriteLine("-------------------------------------------------------")
Console.WriteLine("Display Cart")
Dim name As String = "Sam"
Dim count = cart.Count
Dim content As String = $"
<!DOCTYPE html>
<html>
<body>
<h1>Hello, {name}!</h1>
<p>You have {count} items in the cart.</p>
" & String.Join(vbLf, cart.Select(Function(x) $"<p>{x}</p>")) & "
</body>
</html>"
Dim pdfRenderer = New ChromePdfRenderer()
pdfRenderer.RenderHtmlAsPdf(content).SaveAs("cart.pdf")No código acima, estamos gerando um documento HTML para os itens do carrinho e, em seguida, salvando-o como um documento PDF usando o IronPDF.
Para ativar as funcionalidades do código fornecido, é necessário adquirir uma chave de licença. Você pode obter uma chave de avaliação aqui e ela deve ser inserida no arquivo appsettings.json.
"IronPdf.LicenseKey": "your license key"Forneça seu endereço de e-mail para receber uma licença de avaliação.
Em resumo, o método Math.Round em C# é uma ferramenta versátil para arredondar valores decimais e de ponto flutuante de dupla precisão, oferecendo aos desenvolvedores a flexibilidade de arredondar para o inteiro mais próximo ou para um número específico de casas decimais. Compreender as complexidades do Math.Round, incluindo o tratamento de valores de ponto médio e o uso de estratégias de arredondamento de ponto médio, é essencial para operações matemáticas precisas e confiáveis na programação em C#. Seja para lidar com cálculos financeiros, interfaces de usuário ou outros cenários que exigem representação numérica precisa, o método Math.Round se mostra uma ferramenta indispensável no conjunto de recursos de um programador. Além disso, vimos como o IronPDF é uma biblioteca versátil para gerar documentos PDF.
Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais bem estruturados e visualmente atraentes.
IronPDF faz parte do IRON SUITE.
10 produtos de API .NET para seus documentos de escritório
Quando você precisa que seu PDF tenha a aparência de HTML, rapidamente.
