C# | Método Math.Round() | Serie 1 – Part 1

En C#, Math.Round() es un método de clase Math que se usa para redondear un valor al entero más cercano o al número particular de dígitos fraccionarios. Este método se puede sobrecargar cambiando el número y el tipo de argumentos pasados. Hay un total de 8 métodos en la lista de sobrecarga del método Math.Round(). Aquí analizaremos solo 4 métodos y los 4 métodos restantes se analizan en C# | Método Math.Round() | Juego – 2 .

• Math.Round(Doble)
• Math.Round(Doble, Int32)
• Math.Round(Decimal)
• Math.Round(Decimal, Int32)
• Math.Round(Double, Int32, MidpointRounding)
• Math.Round(Double, MidpointRounding)
• Math.Round(Decimal, Int32, MidpointRounding)
• Math.Round (decimal, punto medio de redondeo)

Math.Round(Doble)

Este método redondea un valor de punto flotante de precisión doble al valor entero más cercano.

Sintaxis:

public static double Round(double x)

Parámetro:

x : Un número de coma flotante doble que se va a redondear. El tipo de este parámetro es System.Double .

Tipo de retorno: Devuelve el entero más cercano a x y el tipo de retorno es System.Double .

Nota: En caso de que el componente fraccionario de x esté a medio camino entre dos enteros, uno de los cuales es par y el otro impar, entonces se devuelve el número par.

Ejemplo:

// C# program to demonstrate the 
// Math.Round(Double) method
using System;
  
class Geeks {
  
    // Main method
    static void Main(string[] args)
    {
  
        // Case-1
        // A double value whose fractional part is 
        // less than the halfway between two 
        // consecutive integers
        Double dx1 = 12.434565d;
  
        // Output value will be 12
        Console.WriteLine("Rounded value of " + dx1 + 
                          " is " + Math.Round(dx1));
  
        // Case-2
        // A double value whose fractional part is 
        // greater than the halfway between two 
        // consecutive integers
        Double dx2 = 12.634565d;
  
        // Output value will be 13
        Console.WriteLine("Rounded value of " + dx2 + 
                          " is " + Math.Round(dx2));
    }
}

Rounded value of 12.434565 is 12
Rounded value of 12.634565 is 13

Explicación: en el código anterior, suponga que el usuario desea redondear el valor doble especificado anteriormente al entero más cercano. Entonces, el compilador primero verificará si ese valor doble es mayor o menor que el valor integral par e impar de ese número doble. Si es menor que el valor medio, su salida será el valor mínimo, de lo contrario, si es mayor que el valor medio, su salida será el valor máximo.

Math.Round(Doble, Int32)

Este método redondea un valor de punto flotante de precisión doble a un número específico de dígitos fraccionarios.

Sintaxis:

public static double Round(double x, Int32 y)

Parámetro:

x : Un número de coma flotante doble que se va a redondear. El tipo de este parámetro es System.Double .
y : Es el número de dígitos fraccionarios en el valor devuelto. El tipo de este parámetro es System.Int32 .

Tipo de retorno: Devuelve el entero más cercano a x que contiene un número de dígitos fraccionarios igual a y y el tipo de retorno es System.Double .

Excepción: este método dará ArgumentOutOfRangeException si el valor de y es menor que 0 o mayor que 15.

Ejemplo:

// C# program to demonstrate the 
// Math.Round(Double, Int32) method
using System;
   
class Geeks {
   
    // Main method
    static void Main(string[] args)
    {
   
        // double type
        Double dx1 = 12.434565d;
   
        // using method
        Console.WriteLine("Rounded value of " + dx1 + 
                          " is " + Math.Round(dx1, 4));
   
        // double type
        Double dx2 = 12.634565d;
   
        // using method
        Console.WriteLine("Rounded value of " + dx2 + 
                          " is " + Math.Round(dx2,2));
    }
}

Rounded value of 12.434565 is 12.4346
Rounded value of 12.634565 is 12.63

Explicación: El método verificará si el dígito al lado del número especificado de dígitos decimales es mayor o igual a 5 o no. Si es mayor o igual a 5, incrementa el número anterior; de lo contrario, el dígito anterior permanece igual.

Math.Round(Decimal)

Este método redondea un valor decimal cuya precisión es de 128 bits al valor entero más cercano.

Sintaxis:

public static decimal Round(decimal x)

Parámetro:

x : Es un número decimal que se va a redondear. El tipo de este parámetro es System.Decimal .

Tipo de retorno: Devuelve el entero más cercano a x y el tipo de retorno es System.Decimal .

Nota: En caso de que el componente fraccionario de x esté a medio camino entre dos enteros, uno de los cuales es par y el otro impar, entonces se devuelve el número par.

Ejemplo:

// C# program to demonstrate the 
// Math.Round(Decimal) method
using System;
  
class Geeks {
  
    // Main method
    static void Main(string[] args)
    {
  
        // Case-1
        // A decimal value whose fractional part is 
        // less than the halfway between two 
        // consecutive integers
        Decimal dec1 = 12.345m;
  
        Console.WriteLine("Value of dec1 is " + dec1);
  
        Console.WriteLine("Rounded value of " + dec1 + 
                          " is " + Math.Round(dec1));
  
        // Case-2
        // A double value whose fractional part is 
        // greater than the halfway between two 
        // consecutive integers
        Decimal dec2 = 12.785m;
  
        Console.WriteLine("Value of dec2 is " + dec2);
  
        Console.WriteLine("Rounded value of " + dec2 + 
                          " is " + Math.Round(dec2));
    }
}

Value of dec1 is 12.345
Rounded value of 12.345 is 12
Value of dec2 is 12.785
Rounded value of 12.785 is 13

Math.Round(Decimal, Int32)

Este método redondea un valor decimal a un número específico de dígitos fraccionarios.

Sintaxis:

public static decimal Round(decimal x, Int32 y)

Parámetro:

x : Un número decimal que se va a redondear. El tipo de este parámetro es System.Decimal .
y : Es el número de dígitos fraccionarios en el valor devuelto. El tipo de este parámetro es System.Int32 .

Tipo de retorno: Devuelve el entero más cercano a x que contiene un número de dígitos fraccionarios igual a y y el tipo de retorno es System.Decimal .

Excepción: este método dará ArgumentOutOfRangeException si el valor de y es menor que 0 o mayor que 15 y OverflowException en caso de que el resultado esté fuera del rango de un decimal.

Ejemplo:

// C# program to demonstrate the 
// Math.Round(Decimal, Int32) method
using System;
  
class Geeks {
  
    // Main Method
    static void Main(string[] args)
    {
  
        // Case - 1
        // The value of digit after specified 
        // number is less than 5 & Here y = 3
        Decimal dx1 = 12.2234565m;
  
        // Output value will be 12.223
        Console.WriteLine("Rounded value of " + dx1 + 
                          " is " + Math.Round(dx1, 3));
  
        // Case - 2
        // The value of digit after specified 
        // number is greater than 5 & Here y = 4
        Decimal dx2 = 12.8734765m;
  
        // Output value will be 12.8735
        Console.WriteLine("Rounded value of " + dx2 + 
                          " is " + Math.Round(dx2, 4));
  
    }
}

Rounded value of 12.2234565 is 12.223
Rounded value of 12.8734765 is 12.8735

Nota: Los códigos anteriores para el valor decimal funcionan de manera similar al caso del valor doble. La única diferencia entre el tipo Decimal y el tipo Doble radica en el concepto de precisión, es decir, en el caso de Doble, la precisión es de 64 bits y en el caso de la precisión Decimal es de 128 bits.

Referencia: https://docs.microsoft.com/en-us/dotnet/api/system.math.round?view=netframework-4.7.2