Math.Round C# (Cómo funciona para desarrolladores)

En el ámbito de la programación en C#, el método de valor Math.Round desempeña un papel fundamental en el redondeo de valores numéricos, especialmente cuando se trata de tipos de datos de valor doble y decimal. Este método permite a los desarrolladores redondear un valor numérico dado al valor integral más cercano o a un número especificado de dígitos fraccionarios menos, proporcionando flexibilidad y precisión en las operaciones matemáticas. Existen varios tipos de redondeo, como el redondeo del punto medio. En este artículo, nos adentraremos en los entresijos de Math.Round en C#, explorando sus diversos aspectos y escenarios de uso. En las secciones siguientes de este artículo, exploraremos la utilización del IronPDF biblioteca de Iron Software para la gestión de archivos PDF.

Fundamentos de Math.Round en C#

El método Math.Round

El método Math.Round en C# es una potente herramienta para redondear dígitos fraccionarios utilizando la convención de redondeo especificada. Forma parte del espacio de nombres System y proporciona varias sobrecargas para acomodar diferentes operaciones de redondeo.

/* methods overloaded by Math.Round
Math.Round(Double)
Math.Round(Double, Int32) //  int32 especifica el número de dígitos fraccionarios
Math.Round(Double, Int32, MidpointRounding)  //  int32 especifica el número de dígitos fraccionarios, MidpointRounding tipo de método de redondeo
Math.Round(Double, MidpointRounding)  //  MidpointRounding tipo de método de redondeo
Math.Round(Decimal)
Math.Round(Decimal, Int32) //  int32 especifica el número de dígitos fraccionarios
Math.Round(Decimal, Int32, MidpointRounding)
Math.Round(Decimal, MidpointRounding)
*/

/* methods overloaded by Math.Round
Math.Round(Double)
Math.Round(Double, Int32) //  int32 especifica el número de dígitos fraccionarios
Math.Round(Double, Int32, MidpointRounding)  //  int32 especifica el número de dígitos fraccionarios, MidpointRounding tipo de método de redondeo
Math.Round(Double, MidpointRounding)  //  MidpointRounding tipo de método de redondeo
Math.Round(Decimal)
Math.Round(Decimal, Int32) //  int32 especifica el número de dígitos fraccionarios
Math.Round(Decimal, Int32, MidpointRounding)
Math.Round(Decimal, MidpointRounding)
*/

' methods overloaded by Math.Round
'Math.Round(Double)
'Math.Round(Double, Int32) //  int32 especifica el número de dígitos fraccionarios
'Math.Round(Double, Int32, MidpointRounding)  //  int32 especifica el número de dígitos fraccionarios, MidpointRounding tipo de método de redondeo
'Math.Round(Double, MidpointRounding)  //  MidpointRounding tipo de método de redondeo
'Math.Round(Decimal)
'Math.Round(Decimal, Int32) //  int32 especifica el número de dígitos fraccionarios
'Math.Round(Decimal, Int32, MidpointRounding)
'Math.Round(Decimal, MidpointRounding)
'

Redondear valor doble

Cuando se trabaja con valores dobles, se suele utilizar Math.Round para redondear un número al entero más próximo. Por ejemplo:

double originalValue = 3.75;
double roundedValue = Math.Round(originalValue);
//  Salida: 4

double originalValue = 3.75;
double roundedValue = Math.Round(originalValue);
//  Salida: 4

Dim originalValue As Double = 3.75
Dim roundedValue As Double = Math.Round(originalValue)
'  Salida: 4

En este ejemplo, el método Math.Round redondeó el valor doble original 3.75 al valor integral más cercano, que es 4.

Redondear valor decimal

Del mismo modo, el método Math.Round se aplica a los valores decimales. Considere el siguiente ejemplo:

decimal originalValue = 8.625m;
decimal roundedValue = Math.Round(originalValue, 2);
//  Salida: 8.63

decimal originalValue = 8.625m;
decimal roundedValue = Math.Round(originalValue, 2);
//  Salida: 8.63

Dim originalValue As Decimal = 8.625D
Dim roundedValue As Decimal = Math.Round(originalValue, 2)
'  Salida: 8.63

Aquí, el método Math.Round se utiliza para redondear el número decimal 8.625 a dos decimales, dando como resultado el valor redondeado 8.63.

Valor entero más próximo

El propósito principal de Math.Round es redondear un valor numérico dado al entero más cercano. Si la parte fraccionaria está exactamente a medio camino entre dos números enteros, el método sigue una convención de operaciones de redondeo especificada. La enumeración MidpointRounding se puede utilizar como argumento en el método Math.Round, determina si se redondea hacia el número par o impar más cercano.

Son posibles varios tipos de operaciones de redondeo, como se muestra en la imagen anterior. Los nombres se explican por sí solos.

Convenio de redondeo especificado

Exploremos cómo puede emplearse el modo MidpointRounding:

double originalValue = 5.5;
double roundedValueEven = Math.Round(originalValue, MidpointRounding.ToEven);
double roundedValueOdd = Math.Round(originalValue, MidpointRounding.AwayFromZero);
//  Salida: roundedValueEven = 6, roundedValueOdd = 5

double originalValue = 5.5;
double roundedValueEven = Math.Round(originalValue, MidpointRounding.ToEven);
double roundedValueOdd = Math.Round(originalValue, MidpointRounding.AwayFromZero);
//  Salida: roundedValueEven = 6, roundedValueOdd = 5

Dim originalValue As Double = 5.5
Dim roundedValueEven As Double = Math.Round(originalValue, MidpointRounding.ToEven)
Dim roundedValueOdd As Double = Math.Round(originalValue, MidpointRounding.AwayFromZero)
'  Salida: roundedValueEven = 6, roundedValueOdd = 5

En este ejemplo, al redondear el valor a 5,5, MidpointRounding.ToEven redondea hacia el número par más próximo (con un resultado de 6)mientras que MidpointRounding.AwayFromZero redondea a partir de cero, obteniendo 5.

Redondeo al número especificado de decimales

Para redondear un número a un número determinado de decimales, el método Math.Round permite incluir un parámetro adicional que representa el número de dígitos int:

decimal originalValue = 9.123456m;
decimal roundedValue = Math.Round(originalValue, 3); //  redondear valores
//  Salida: 9.123

decimal originalValue = 9.123456m;
decimal roundedValue = Math.Round(originalValue, 3); //  redondear valores
//  Salida: 9.123

Dim originalValue As Decimal = 9.123456D
Dim roundedValue As Decimal = Math.Round(originalValue, 3) '  redondear valores
'  Salida: 9.123

Aquí, el número decimal 9,123456 se redondea a tres decimales, lo que da como resultado el valor redondeado 9,123.

Valores medios y convenciones de redondeo en C#

Un valor de punto medio se produce cuando el valor después del dígito menos significativo del resultado está exactamente a medio camino entre dos números. Por ejemplo, 2,56500 es un valor de punto medio cuando se redondea a dos decimales 2,57, y 3,500 es un valor de punto medio cuando se redondea a un entero 4. El reto consiste en identificar el valor más próximo en la estrategia de redondeo para valores de punto medio sin una convención de redondeo definida.

El método Round en C# soporta dos convenciones de redondeo para manejar valores de punto medio:

Redondeo a partir de cero: Los valores del punto medio se redondean al número siguiente a cero. Por ejemplo, 3.75 se redondea a 3.8, 3.85 se redondea a 3.9, -3.75 se redondea a -3.8, y -3.85 se redondea a -3.9. Este método está representado por el miembro de la enumeración MidpointRounding.AwayFromZero.

Redondeo al par más próximo (Redondeo bancario): Los valores del punto medio se redondean al número par más próximo. Los casos incluyen tanto 3,75 como 3,85 redondeando a 3,8, y tanto -3,75 como -3,85 redondeando a -3,8. Este método de redondeo se indica mediante el miembro de la enumeración MidpointRounding.ToEven.

decimal [] decimalSampleValues = { 1.15m, 1.25m, 1.35m, 1.45m, 1.55m, 1.65m };
decimal sum = 0;
//  Calcular valores medios verdaderos.
foreach (var value in decimalSampleValues)
{ 
    sum += value; 
}
//  imprimir
Console.WriteLine("True mean values:     {0:N2}", sum / decimalSampleValues.Length);
//  Calcular valores medios con redondeo a partir de cero.
sum = 0;
foreach (var value in decimalSampleValues)
{ 
    sum += Math.Round(value, 1, MidpointRounding.AwayFromZero); 
}
//  imprimir
Console.WriteLine("AwayFromZero:  {0:N2}", sum / decimalSampleValues.Length);
//  Calcular valores medios con redondeo al más próximo.
sum = 0;
foreach (var value in decimalSampleValues)
{ 
    sum += Math.Round(value, 1, MidpointRounding.ToEven); 
}
//  imprimir
Console.WriteLine("ToEven:        {0:N2}", sum / decimalSampleValues.Length);

decimal [] decimalSampleValues = { 1.15m, 1.25m, 1.35m, 1.45m, 1.55m, 1.65m };
decimal sum = 0;
//  Calcular valores medios verdaderos.
foreach (var value in decimalSampleValues)
{ 
    sum += value; 
}
//  imprimir
Console.WriteLine("True mean values:     {0:N2}", sum / decimalSampleValues.Length);
//  Calcular valores medios con redondeo a partir de cero.
sum = 0;
foreach (var value in decimalSampleValues)
{ 
    sum += Math.Round(value, 1, MidpointRounding.AwayFromZero); 
}
//  imprimir
Console.WriteLine("AwayFromZero:  {0:N2}", sum / decimalSampleValues.Length);
//  Calcular valores medios con redondeo al más próximo.
sum = 0;
foreach (var value in decimalSampleValues)
{ 
    sum += Math.Round(value, 1, MidpointRounding.ToEven); 
}
//  imprimir
Console.WriteLine("ToEven:        {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
'  Calcular valores medios verdaderos.
For Each value In decimalSampleValues
	sum += value
Next value
'  imprimir
Console.WriteLine("True mean values:     {0:N2}", sum / decimalSampleValues.Length)
'  Calcular valores medios con redondeo a partir de cero.
sum = 0
For Each value In decimalSampleValues
	sum += Math.Round(value, 1, MidpointRounding.AwayFromZero)
Next value
'  imprimir
Console.WriteLine("AwayFromZero:  {0:N2}", sum / decimalSampleValues.Length)
'  Calcular valores medios con redondeo al más próximo.
sum = 0
For Each value In decimalSampleValues
	sum += Math.Round(value, 1, MidpointRounding.ToEven)
Next value
'  imprimir
Console.WriteLine("ToEven:        {0:N2}", sum / decimalSampleValues.Length)

Salida

Punto medioModos de redondeo

LejosDeCero: 1

La estrategia de redondeo AwayFromZero redondea al número más cercano, cuando un número está a medio camino entre otros dos.

ToZero: 2

Esta estrategia se caracteriza por el redondeo dirigido hacia cero. El resultado es el más cercano y no mayor en magnitud que el resultado infinitamente preciso.

Hasta: 0

Esta estrategia consiste en redondear al número más próximo, y cuando un número está a medio camino entre otros dos, se redondea hacia el número par más próximo.

ToNegativeInfinity: 3

Esta estrategia implica redondear en sentido descendente, siendo el resultado lo más cercano y no mayor que el resultado infinitamente preciso.

ToPositiveInfinity: 4

Esta estrategia consiste en redondear en sentido ascendente, siendo el resultado lo más cercano y no inferior al resultado infinitamente preciso.

Precisión y doble precisión en coma flotante

Precisión y valores dobles

Cuando se trabaja con números en coma flotante de doble precisión, es esencial comprender la imprecisión potencial debida a la naturaleza de la representación en coma flotante. El método Math.Round ayuda a mitigar los problemas de precisión redondeando los valores al entero más cercano o a un número especificado de decimales.

Precisión especificada con Math.Round

Los desarrolladores pueden aprovechar el método Math.Round para conseguir la precisión deseada en sus cálculos:

double originalValue = 123.456789;
double result = Math.Round(originalValue, 4);
//  Salida: 123,4568, valor redondeado

double originalValue = 123.456789;
double result = Math.Round(originalValue, 4);
//  Salida: 123,4568, valor redondeado

Dim originalValue As Double = 123.456789
Dim result As Double = Math.Round(originalValue, 4)
'  Salida: 123,4568, valor redondeado

En este ejemplo, el valor doble 123,456789 se redondea a cuatro decimales, lo que da como resultado el valor más preciso 123,4568.

Estrategia de redondeo del punto medio

Manejo de valores de punto medio

La estrategia de redondeo del punto medio resulta crucial cuando un valor fraccionario se encuentra exactamente a medio camino entre dos números enteros. El método Math.Round emplea la estrategia MidpointRounding especificada para resolver estos casos.

Ejemplo de redondeo del punto medio

Considere el siguiente ejemplo en el que se utiliza el redondeo del punto medio:

double originalValue = 7.5;
double roundedValue = Math.Round(originalValue, MidpointRounding.AwayFromZero);
//  Salida: 8

double originalValue = 7.5;
double roundedValue = Math.Round(originalValue, MidpointRounding.AwayFromZero);
//  Salida: 8

Dim originalValue As Double = 7.5
Dim roundedValue As Double = Math.Round(originalValue, MidpointRounding.AwayFromZero)
'  Salida: 8

Aquí, el valor 7,5 se redondea a partir de cero, lo que da como resultado el valor redondeado 8.

Aplicación en situaciones reales

He aquí algunos ejemplos de su aplicación en diversos contextos:

Cálculos financieros

En las aplicaciones financieras, el redondeo preciso es crucial. Por ejemplo, al calcular tipos de interés, convertir divisas o realizar cálculos fiscales, puede emplearse el método Math.Round para garantizar que los resultados se redondean al número adecuado de decimales, respetando las normas financieras.

double interestRate = 0.04567;
double roundedInterest = Math.Round(interestRate, 4); //  Redondear a 4 decimales

double interestRate = 0.04567;
double roundedInterest = Math.Round(interestRate, 4); //  Redondear a 4 decimales

Dim interestRate As Double = 0.04567
Dim roundedInterest As Double = Math.Round(interestRate, 4) '  Redondear a 4 decimales

Pantalla de interfaz de usuario

Cuando se presentan valores numéricos en una interfaz de usuario, es habitual redondear los números para mejorar la legibilidad. Por ejemplo, en un cuadro de mandos que muestre lecturas de temperatura o datos financieros, el redondeo mediante Math.Round puede mejorar la claridad de la información presentada.

double temperature = 23.678;
double roundedTemperature = Math.Round(temperature, 1); //  Redondear a 1 decimal

double temperature = 23.678;
double roundedTemperature = Math.Round(temperature, 1); //  Redondear a 1 decimal

Dim temperature As Double = 23.678
Dim roundedTemperature As Double = Math.Round(temperature, 1) '  Redondear a 1 decimal

Análisis estadístico

En el análisis estadístico, el redondeo preciso es esencial para evitar introducir sesgos o imprecisiones. Ya sea para calcular la media, la mediana u otras medidas estadísticas, el método Math.Round puede ayudar a presentar los resultados con el nivel de precisión deseado.

double meanValue = CalculateMean(data);
double roundedMean = Math.Round(meanValue, 2); //  Redondear el valor medio a 2 decimales

double meanValue = CalculateMean(data);
double roundedMean = Math.Round(meanValue, 2); //  Redondear el valor medio a 2 decimales

Dim meanValue As Double = CalculateMean(data)
Dim roundedMean As Double = Math.Round(meanValue, 2) '  Redondear el valor medio a 2 decimales

Cálculos científicos

En las aplicaciones científicas, la precisión es crucial. Cuando se trabaja con datos experimentales o cálculos científicos, el redondeo mediante Math.Round garantiza que los resultados se presenten de forma significativa y precisa.

double experimentalResult = 9.87654321;
double roundedResult = Math.Round(experimentalResult, 5); //  Redondear a 5 decimales

double experimentalResult = 9.87654321;
double roundedResult = Math.Round(experimentalResult, 5); //  Redondear a 5 decimales

Dim experimentalResult As Double = 9.87654321
Dim roundedResult As Double = Math.Round(experimentalResult, 5) '  Redondear a 5 decimales

Modelización matemática

Al aplicar modelos matemáticos o simulaciones, el redondeo puede ser necesario para simplificar cálculos complejos. El método Math.Round puede aplicarse para controlar la precisión de los resultados intermedios en el proceso de modelado.

double modelResult = SimulatePhysicalSystem(parameters);
double roundedModelResult = Math.Round(modelResult, 3); //  Redondear a 3 decimales

double modelResult = SimulatePhysicalSystem(parameters);
double roundedModelResult = Math.Round(modelResult, 3); //  Redondear a 3 decimales

Dim modelResult As Double = SimulatePhysicalSystem(parameters)
Dim roundedModelResult As Double = Math.Round(modelResult, 3) '  Redondear a 3 decimales

Desarrollo de juegos

En el desarrollo de juegos, la precisión numérica es crucial para los cálculos de física, posicionamiento y otras operaciones matemáticas. El método Math.Round puede utilizarse para garantizar que los valores relacionados con el juego se redondean a un nivel de precisión adecuado.

double playerPosition = CalculatePlayerPosition();
double roundedPosition = Math.Round(playerPosition, 2); //  Redondear a 2 decimales

double playerPosition = CalculatePlayerPosition();
double roundedPosition = Math.Round(playerPosition, 2); //  Redondear a 2 decimales

Dim playerPosition As Double = CalculatePlayerPosition()
Dim roundedPosition As Double = Math.Round(playerPosition, 2) '  Redondear a 2 decimales

En cada uno de estos escenarios, el método Math.Round permite a los desarrolladores controlar la precisión de los valores numéricos, promoviendo la exactitud y legibilidad en sus aplicaciones.

Presentación de IronPDF

Veamos ahora cómo podemos generar documentos PDF utilizando IronPDF Biblioteca PDF en C# de **Software de hierro.

Instalación

Tiene la opción de instalar IronPDF a través de la consola del gestor de paquetes NuGet o del gestor de paquetes de Visual Studio.

dotnet add package IronPdf

dotnet add package IronPdf

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'dotnet add package IronPdf

Instale IronPDF utilizando NuGet Package Manager buscando "ironpdf" en la barra de búsqueda.

Uso de IronPDF para generar un PDF

Console.WriteLine("Params Example");
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 ");
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>";
//  Crear un nuevo documento PDF
var pdfDocument = new ChromePdfRenderer();
pdfDocument.RenderHtmlAsPdf(content).SaveAs("cart.pdf");

Console.WriteLine("Params Example");
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 ");
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>";
//  Crear un nuevo documento PDF
var pdfDocument = new ChromePdfRenderer();
pdfDocument.RenderHtmlAsPdf(content).SaveAs("cart.pdf");

Imports Microsoft.VisualBasic

Console.WriteLine("Params Example")
Dim cart As New List(Of String)()
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'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 ")
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>"
'  Crear un nuevo documento PDF
Dim pdfDocument = New ChromePdfRenderer()
pdfDocument.RenderHtmlAsPdf(content).SaveAs("cart.pdf")

En el código anterior, estamos generando un documento HTML para los artículos del carrito y luego lo guardamos como un documento PDF utilizando IronPDF.

Salida

Licencias (prueba gratuita disponible)

Para habilitar la funcionalidad del código proporcionado, es necesario adquirir una clave de licencia. Puede obtener una clave de prueba en esta dirección aquí y debe insertarse en el archivo appsettings.json.

"IronPdf.LicenseKey": "your license key"

"IronPdf.LicenseKey": "your license key"

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'"IronPdf.LicenseKey": "your license key"

Indique su dirección de correo electrónico para obtener una licencia de prueba.

Conclusión

En conclusión, el método Math.Round en C# es una herramienta versátil para redondear valores dobles y decimales, ofreciendo a los desarrolladores la flexibilidad de redondear al entero más cercano o a un número especificado de decimales. Comprender los entresijos de Math.Round, incluido su tratamiento de los valores de punto medio y el uso de estrategias MidpointRounding, es esencial para realizar operaciones matemáticas precisas y fiables en la programación en C#. Ya se trate de cálculos financieros, pantallas de interfaz de usuario u otros escenarios que requieran una representación numérica precisa, el método Math.Round resulta ser un activo indispensable en la caja de herramientas de un programador. Además, vimos cómo IronPDF es una biblioteca versátil para generar documentos PDF.