C# | Método Math.Round() | Juego – 2

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 tiene otra sobrecarga con la que puede especificar el número de dígitos más allá del punto decimal en el valor devuelto. Devuelve el valor más cercano del número con la precisión igual al segundo parámetro pasado. Si el valor a redondear está exactamente a medio camino entre un número par y un número impar, entonces se devuelve el número par. Math.Round aplica el estándar IEEE 754, sección 4.

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() de los cuales 4 ya se han discutido en C# | Método Math.Round() | Conjunto – 1 .

1. Math.Round(Doble)
2. Math.Round(Doble, Int32)
3. Math.Round(Decimal)
4. Math.Round(Decimal, Int32)
5. Math.Round(Double, Int32, MidpointRounding)
6. Math.Round(Double, MidpointRounding)
7. Math.Round(Decimal, Int32, MidpointRounding)
8. Math.Round (decimal, punto medio de redondeo)

Math.Round(Double, Int32, MidpointRounding)

Este método se utiliza para redondear un valor de punto flotante de precisión doble a un número específico de dígitos fraccionarios. Un parámetro especifica cómo redondear el valor si está a medio camino entre dos números.

Sintaxis:

public static double Round (double val, int digits, MidpointRounding mode);

Parámetros:

val : es el número de punto flotante de precisión doble requerido que se redondeará y el tipo de este parámetro es System.Double .

digits : Es el número de dígitos fraccionarios en el valor devuelto y el tipo de este parámetro es System.Int32 .

modo : Especificación sobre cómo redondear el valor si está a medio camino entre otros dos números y funciona como MidpointRounding .

Tipo de devolución: este método devuelve el número más cercano a val que tiene una cantidad de dígitos fraccionarios igual a digits . Si el valor tiene menos dígitos fraccionarios que dígitos , el valor se devuelve sin cambios. El tipo de retorno de este método es System.Double .

Excepciones:

• ArgumentOutOfRangeException : si el dígito es menor que 0 o mayor que 15.
• ArgumentException : si el modo no es un valor válido de MidpointRounding.

Ejemplo:

// C# program to demonstrate the 
// Math.Round(Double, Int32, 
// MidpointRounding) method
using System;
   
class Geeks 
{
      
    // Main Method
    public static void Main() 
    {
        // The 4 values are store in an double
        // type array name 'val'
        double[] val = {4.125, 4.135, 4.165, 4.175};
          
   
        Console.WriteLine("Rounded values are:"); 
          
        // 'foreach' loop iterates through
        // each item from the array 'values' 
        // and storing the items in a new 
        // variable 'val' 
        foreach(double value in val) 
          
            // '{0}' specify the variable 'val' which is
            // in 'foreach' loop and '{1}' specify the 
            // rounded value, here '2' defines the number
            // of digit after point, e.g. 4.135 == 4.14,
            // after '4.' there is 2 digits'.14' 
            // and here '.ToEven' select the nearest even
            // number e.g 4.125 == 4.12, here nearest even
            // number is '12',
            Console.WriteLine("{0} == {1}", value, Math.Round(value, 2, 
                                             MidpointRounding.ToEven));
              
    }
}

Rounded values are:
4.125 == 4.12
4.135 == 4.14
4.165 == 4.16
4.175 == 4.18

Nota: En algunos casos, puede parecer que este método no redondea los valores de punto medio según lo especificado por el parámetro de modo debido a la pérdida de precisión que puede resultar de representar valores decimales como números de punto flotante o realizar operaciones aritméticas en valores de punto flotante. Esto se ilustra en el ejemplo anterior, donde 4,135 se redondea a 4,13 en lugar de 4,14. Esto ocurre porque internamente el método multiplica val por 10 ^dígitos y la operación de multiplicación, en este caso, sufre una pérdida de precisión.

Math.Round(Double, MidpointRounding)

Este método se utiliza para redondear un valor de punto flotante de precisión doble al entero más próximo. Un parámetro especifica cómo redondear el valor si está a medio camino entre dos números.

Sintaxis:

public static double Round (double val, MidpointRounding mode);

Parámetros:

val : es el número de punto flotante de precisión doble requerido que se redondeará y el tipo de este parámetro es System.Double .

modo : Especificación sobre cómo redondear el valor si está a medio camino entre otros dos números y funciona como MidpointRounding .

Tipo de devolución: este método devuelve el valor entero más cercano. Si el valor está a medio camino entre dos números enteros, uno de los cuales es par y el otro impar, entonces el modo determina cuál de los dos se devuelve. El tipo de retorno de este método es System.Double .

Excepción: este método da ArgumentException si el modo no es un valor válido de MidpointRounding.

Ejemplo:

// C# program to demonstrate the 
// Math.Round(Double, MidpointRounding) method
using System;
   
class Geeks 
{
      
    // Main Method
    public static void Main() 
    {
          
        //'val' is double type variable 
        // which holds the value 4.1
        double val = 4.1;
          
        Console.WriteLine("Inside Loop:\n");
          
        //'for loop', it execute the next
        // output for 8 times
        for (int i = 0; i <= 8; i++) 
        {
              
            // '{0}' specify the variable 'val' and 
            // '{1}' specify the rounded value
            Console.WriteLine("{0} = {1}", val, Math.Round(val, 
                               MidpointRounding.AwayFromZero));
              
            // increment 'val' by '0.1'                
            val += 0.1; 
        }
          
        // a new value is assigned
        // to variable 'val'
        val = 4.5; 
          
        // prints a new line
        Console.WriteLine(); 
          
        //'{0}'specify the variable 'val' in which a new
        // value 4.5 is assigned and '{1}' specify the 
        // new rounded value
        Console.WriteLine("Outside Loop : {0} = {1}", val, 
          Math.Round(val, MidpointRounding.AwayFromZero));
            
    }
}

Inside Loop:

4.1 = 4
4.2 = 4
4.3 = 4
4.4 = 4
4.5 = 4
4.6 = 5
4.7 = 5
4.8 = 5
4.9 = 5

Outside Loop : 4.5 = 5

Nota: En algunos casos, puede parecer que este método no redondea los valores del punto medio al entero par más cercano debido a la pérdida de precisión que puede resultar de representar valores decimales como números de punto flotante o realizar operaciones aritméticas en valores de punto flotante. En el ejemplo anterior, debido a que el valor de coma flotante 0.1 no tiene una representación binaria finita, la primera llamada al método con un valor de 4.5 devuelve 4 en lugar de 5.

Math.Round(Decimal, Int32, MidpointRounding)

Este método se utiliza para redondear un valor decimal a un número específico de dígitos fraccionarios. Un parámetro especifica cómo redondear el valor si está a medio camino entre dos números.

Sintaxis:

public static decimal Round (decimal val, int num, MidpointRounding mode);

Parámetros:

val: Es el número decimal requerido de tipo System.Decimal que se va a redondear.
num: Especifica el número de lugares decimales en el valor devuelto y el tipo de este parámetro es System.Int32 .
modo: proporciona especificaciones sobre cómo redondear val si está a medio camino entre otros dos números.

Tipo de devolución: el número más cercano a val que contiene una cantidad de dígitos fraccionarios igual a num . Si val tiene menos dígitos fraccionarios que decimales, val se devuelve sin cambios.

Excepciones:

• ArgumentOutOfRangeException : si el número es menor que 0 o mayor que 28.
• ArgumentException : si el modo no es un valor válido de MidpointRounding.
• OverflowException : si el resultado está fuera del rango de un decimal .

Ejemplo:

// C# program to demonstrate the 
// Math.Round(Decimal, Int32, 
// MidpointRounding) method
using System;
  
class Geeks 
{
      
    // Main Method
    public static void Main() 
    {
  
        // The 6 values are store in an 
        // double type array name val,
        double[] val = {2.275, 2.375, 2.455, 
                        3.525, 3.635, 3.465 };
                          
        // prints 'Rounded values :'
        Console.WriteLine("Rounded Values: "); 
  
        //'foreach' loop iterates through each item
        // from the array 'val' and storing the items
        // in a new variable 'value'
        foreach(double value in val) 
  
            // '{0}' specify the variable 'value'and 
            // '{1}' specify the rounded value,
            Console.WriteLine("{0} == {1}", value, Math.Round(value, 
                                        2, MidpointRounding.ToEven));
          
    }
}

Rounded Values: 
2.275 == 2.28
2.375 == 2.38
2.455 == 2.46
3.525 == 3.52
3.635 == 3.64
3.465 == 3.46

Math.Round (decimal, punto medio de redondeo)

Este método se utiliza para redondear un valor decimal al entero más cercano. Un parámetro especifica cómo redondear el valor si está a medio camino entre dos números.

Sintaxis:

public static decimal Round (decimal val, MidpointRounding mode);

Parámetros:

val: Es el número decimal requerido de tipo System.Decimal que se va a redondear.
modo: proporciona especificaciones sobre cómo redondear val si está a medio camino entre otros dos números.

Tipo de retorno: Devuelve el valor entero más cercano . Si val está a medio camino entre dos números, uno de los cuales es par y el otro impar, entonces la moda determina cuál de los dos se devuelve.

Excepciones:

• ArgumentException : si el modo no es un valor válido de MidpointRounding.
• OverflowException : si el resultado está fuera del rango de un decimal .

Ejemplo:

// C# program to demonstrate the 
// Math.Round(Decimal, MidpointRounding) method
using System;
  
class Geeks 
{
      
    // Main Method
    public static void Main() 
    {
          
        // The 6 values are store in a 
        // double type array name val
        double[] val = {2.275, 2.375, 2.455, 
                       3.525, 3.635, 3.465 };
          
        // prints 'Rounded values :'
        Console.WriteLine("Rounded values :"); 
  
        //'foreach' loop iterates through each item 
        // from the array 'val' and storing the items 
        // in a new variable 'value' 
        foreach(double value in val) 
  
            // '{0}' specify the variable 'value' and
            // '{1}' specify the rounded value
            Console.WriteLine("{0} == {1}", value, Math.Round(value, 
                                           MidpointRounding.ToEven));
    }
}

Rounded values :
2.275 == 2
2.375 == 2
2.455 == 2
3.525 == 4
3.635 == 4
3.465 == 3

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