Math.Round Método

Definición

Espacio de nombres:

System

Ensamblado:

System.Runtime.dll

Redondea un valor al entero más próximo o al número especificado de dígitos fraccionarios.

Sobrecargas

Round(Double, Int32, MidpointRounding)	Redondea un valor de punto flotante de doble precisión a un número especificado de dígitos fraccionarios mediante la convención de redondeo especificada.
Round(Decimal, Int32, MidpointRounding)	Redondea un valor decimal a un número especificado de dígitos fraccionarios mediante la convención de redondeo especificada.
Round(Double, MidpointRounding)	Redondea un valor de punto flotante de doble precisión a un entero mediante la convención de redondeo especificada.
Round(Double, Int32)	Redondea un valor de punto flotante de precisión doble a un número especificado de dígitos fraccionarios y los valores de punto medio al número par más cercano.
Round(Decimal, Int32)	Redondea un valor decimal a un número especificado de dígitos fraccionarios y los valores de punto medio al número par más cercano.
Round(Double)	Redondea un valor de punto flotante de precisión doble al valor entero más cercano y los valores de punto medio al número par más cercano.
Round(Decimal)	Redondea un valor decimal al valor entero más cercano y los valores de punto medio al número par más cercano.
Round(Decimal, MidpointRounding)	Redondea un valor decimal un entero mediante la convención de redondeo especificada.

Ejemplos

Además de los ejemplos de la sección Comentarios , en este artículo se incluyen ejemplos que ilustran las siguientes sobrecargas del Math.Round método :

Math.Round(Decimal)Math.Round(Double)Math.Round(Decimal, Int32)Math.Round(Decimal, MidpointRounding)Math.Round(Double, Int32)Math.Round(Double, MidpointRounding)Math.Round(Decimal, Int32, MidpointRounding)Math.Round(Double, Int32, MidpointRounding)

Comentarios

En esta sección:

• ¿A qué método se llama?
• Valores de punto medio y convenciones de redondeo
• Redondeo y precisión
• Redondeo y valores de punto flotante de precisión sencilla
• Ejemplos de sobrecargas individuales

¿A qué método se llama?

Puede usar la tabla siguiente para seleccionar un método de redondeo adecuado. Además de los Math.Round métodos, también incluye Math.Ceiling y Math.Floor.

En	Call
Redondee un número a un entero mediante la convención de redondeo al más cercano.	Round(Decimal) O bien Round(Double)
Redondea un número a un entero mediante una convención de redondeo especificada.	Round(Decimal, MidpointRounding) O bien Round(Double, MidpointRounding)
Redondee un número a un número especificado de dígitos fraccionarios mediante el redondeo a la convención más cercana.	Round(Decimal, Int32) O bien Round(Double, Int32)
Redondee un número a un número especificado de dígitos fraccionarios mediante una convención de redondeo especificada.	Round(Decimal, Int32, MidpointRounding) O bien Round(Double, Int32, MidpointRounding)
Redondea un Single valor a un número especificado de dígitos fraccionarios mediante una convención de redondeo especificada y minimiza la pérdida de precisión.	Convierta en Single y Decimal llame a Round(Decimal, Int32, MidpointRounding).
Redondea un número a un número especificado de dígitos fraccionarios a la vez que minimiza los problemas de precisión en los valores de punto medio de redondeo.	Llame a un método de redondeo que implemente una comparación "mayor o aproximadamente igual a". Consulte Redondeo y precisión.
Redondea un valor fraccionado a un entero mayor que el valor fraccional. Por ejemplo, redondea de 3,1 a 4.	Ceiling
Redondea un valor fraccionado a un entero menor que el valor fraccional. Por ejemplo, redondea de 3,9 a 3.	Floor

Valores de punto medio y convenciones de redondeo

El redondeo implica convertir un valor numérico con una precisión especificada en un valor con menos precisión. Por ejemplo, puede usar el Round(Double) método para redondear un valor de 3,4 a 3,0 y el Round(Double, Int32) método para redondear un valor de 3,579 a 3,58.

En un valor de punto medio, el valor después del dígito menos significativo en el resultado es precisamente la mitad entre dos números. Por ejemplo, 3,47500 es un valor de punto medio si se redondea a dos posiciones decimales y 7,500 es un valor de punto medio si se va a redondear a un entero. En estos casos, si se usa la estrategia de redondeo a la más cercana, el valor más cercano no se puede identificar fácilmente sin una convención de redondeo.

El Round método admite dos convenciones de redondeo para controlar los valores de punto medio:

• Redondeo de cero

  Los valores de punto medio se redondean al siguiente número lejos de cero. Por ejemplo, 3,75 redondea a 3,8, 3,85 ronda a 3,9, -3,75 redondea a -3,8 y -3,85 redondea a -3,9. Esta forma de redondeo se representa mediante el miembro de MidpointRounding.AwayFromZero enumeración.

• Redondeo al más cercano, o redondeo del banquero

  Los valores de punto medio se redondean al número par más cercano. Por ejemplo, tanto 3,75 como 3,85 redondeo a 3,8 y -3,75 y -3,85 redondeo a -3,8. Esta forma de redondeo se representa mediante el MidpointRounding.ToEven miembro de enumeración.

Nota

En .NET Core 3.0 y versiones posteriores, hay disponibles tres estrategias de redondeo adicionales a través de la MidpointRounding enumeración. Estas estrategias se usan en todos los casos, no solo para los valores de punto medio como MidpointRounding.ToEven y MidpointRounding.AwayFromZero son.

Redondear lejos de cero es la forma más conocida de redondeo, mientras que el redondeo al más cercano incluso es el estándar en operaciones financieras y estadísticas. Se ajusta a ieee Standard 754, sección 4. Cuando se usa en varias operaciones de redondeo, el redondeo al más cercano reduce incluso el error de redondeo causado por el redondeo constante de los valores de punto medio en una sola dirección. En algunos casos, este error de redondeo puede ser significativo.

En el ejemplo siguiente se muestra el sesgo que puede resultar de redondear constantemente los valores de punto medio en una sola dirección. En el ejemplo se calcula la media verdadera de una matriz de Decimal valores y, a continuación, se calcula la media cuando los valores de la matriz se redondean mediante las dos convenciones. En este ejemplo, la media verdadera y la media que da como resultado el redondeo al más cercano son los mismos. Sin embargo, la media que resulta al redondear de cero difiere en .05 (o en un 3,6 %) de la media verdadera.

decimal[] values = { 1.15m, 1.25m, 1.35m, 1.45m, 1.55m, 1.65m };
decimal sum = 0;

// Calculate true mean.
foreach (var value in values)
    sum += value;

Console.WriteLine("True mean:     {0:N2}", sum / values.Length);

// Calculate mean with rounding away from zero.
sum = 0;
foreach (var value in values)
    sum += Math.Round(value, 1, MidpointRounding.AwayFromZero);

Console.WriteLine("AwayFromZero:  {0:N2}", sum / values.Length);

// Calculate mean with rounding to nearest.
sum = 0;
foreach (var value in values)
    sum += Math.Round(value, 1, MidpointRounding.ToEven);

Console.WriteLine("ToEven:        {0:N2}", sum / values.Length);

// The example displays the following output:
//       True mean:     1.40
//       AwayFromZero:  1.45
//       ToEven:        1.40

open System

let values = [| 1.15m; 1.25m; 1.35m; 1.45m; 1.55m; 1.65m |]
let mutable sum = 0m

// Calculate true mean.
for value in values do
    sum <- sum + value

printfn $"True mean:     {sum / decimal values.Length:N2}"

// Calculate mean with rounding away from zero.
sum <- 0m
for value in values do
    sum <- sum + Math.Round(value, 1, MidpointRounding.AwayFromZero)

printfn $"AwayFromZero:  {sum / decimal values.Length:N2}"

// Calculate mean with rounding to nearest.
sum <- 0m
for value in values do
    sum <- sum + Math.Round(value, 1, MidpointRounding.ToEven)

printfn $"ToEven:        {sum / decimal values.Length:N2}"

// The example displays the following output:
//       True mean:     1.40
//       AwayFromZero:  1.45
//       ToEven:        1.40

Dim values() As Decimal = {1.15D, 1.25D, 1.35D, 1.45D, 1.55D, 1.65D}
Dim sum As Decimal

' Calculate true mean.
For Each value In values
    sum += value
Next
Console.WriteLine("True mean:     {0:N2}", sum / values.Length)

' Calculate mean with rounding away from zero.
sum = 0
For Each value In values
    sum += Math.Round(value, 1, MidpointRounding.AwayFromZero)
Next
Console.WriteLine("AwayFromZero:  {0:N2}", sum / values.Length)

' Calculate mean with rounding to nearest.
sum = 0
For Each value In values
    sum += Math.Round(value, 1, MidpointRounding.ToEven)
Next
Console.WriteLine("ToEven:        {0:N2}", sum / values.Length)

' The example displays the following output:
'       True mean:     1.40
'       AwayFromZero:  1.45
'       ToEven:        1.40

De forma predeterminada, el Round método usa la convención uniforme de redondeo a más cercana. En la tabla siguiente se enumeran las sobrecargas del Round método y la convención de redondeo que cada uno usa.

Sobrecarga	Convención de redondeo
Round(Decimal)	ToEven
Round(Double)	ToEven
Round(Decimal, Int32)	ToEven
Round(Double, Int32)	ToEven
Round(Decimal, MidpointRounding)	Determinado por mode parámetro.
Round(Double, MidpointRounding)	Determinado por mode parámetro
Round(Decimal, Int32, MidpointRounding)	Determinado por mode parámetro
Round(Double, Int32, MidpointRounding)	Determinado por mode parámetro

Redondeo y precisión

Para determinar si una operación de redondeo implica un valor de punto medio, el Round método multiplica el valor original que se redondea en 10ⁿ, donde n es el número deseado de dígitos fraccionarios en el valor devuelto y, a continuación, determina si la parte fraccionararia restante del valor es mayor o igual que .5. Se trata de una ligera variación en una prueba de igualdad y, como se describe en la sección "Pruebas para la igualdad" del Double tema de referencia, las pruebas para la igualdad con los valores de punto flotante son problemáticas debido a los problemas del formato de punto flotante con la representación binaria y la precisión. Esto significa que cualquier parte fraccionaria de un número que sea ligeramente menor que .5 (debido a una pérdida de precisión) no se redondeará hacia arriba.

En el siguiente ejemplo se ilustra el problema. Agrega repetidamente .1 a 11.0 y redondea el resultado al entero más cercano. 11.5 debe redondear a 12 mediante cualquiera de las convenciones de redondeo de punto medio (ToEven o AwayFromZero). Sin embargo, como se muestra en la salida del ejemplo, no lo hace. En el ejemplo se usa la cadena de formato numérico estándar "R" para mostrar la precisión completa del valor de punto flotante y se muestra que el valor que se va a redondear ha perdido precisión durante las adiciones repetidas y su valor es realmente 11,4999999999999998. Dado que .499999999999998 es menor que .5, las convenciones de redondeo medio no entran en juego y el valor se redondea hacia abajo. Como también se muestra en el ejemplo, este problema no se produce si asigna el valor constante 11.5 a una Double variable.

public static void Example()
{
    Console.WriteLine("{0,5} {1,20:R}  {2,12} {3,15}\n",
                      "Value", "Full Precision", "ToEven",
                      "AwayFromZero");
    double value = 11.1;
    for (int ctr = 0; ctr <= 5; ctr++)
        value = RoundValueAndAdd(value);

    Console.WriteLine();

    value = 11.5;
    RoundValueAndAdd(value);
}

private static double RoundValueAndAdd(double value)
{
    Console.WriteLine("{0,5:N1} {0,20:R}  {1,12} {2,15}",
                      value, Math.Round(value, MidpointRounding.ToEven),
                      Math.Round(value, MidpointRounding.AwayFromZero));
    return value + .1;
}

// The example displays the following output:
//       Value       Full Precision        ToEven    AwayFromZero
//
//        11.1                 11.1            11              11
//        11.2                 11.2            11              11
//        11.3   11.299999999999999            11              11
//        11.4   11.399999999999999            11              11
//        11.5   11.499999999999998            11              11
//        11.6   11.599999999999998            12              12
//
//        11.5                 11.5            12              12

open System

let roundValueAndAdd (value: double) =
    printfn $"{value,5:N1} {value,20:R}  {Math.Round(value, MidpointRounding.ToEven),12} {Math.Round(value, MidpointRounding.AwayFromZero),15}"
    value + 0.1

printfn "%5s %20s  %12s %15s\n" "Value" "Full Precision" "ToEven" "AwayFromZero"
let mutable value = 11.1
for _ = 0 to 5 do
    value <- roundValueAndAdd value

printfn ""

value <- 11.5
roundValueAndAdd value
|> ignore

// The example displays the following output:
//       Value       Full Precision        ToEven    AwayFromZero
//
//        11.1                 11.1            11              11
//        11.2                 11.2            11              11
//        11.3   11.299999999999999            11              11
//        11.4   11.399999999999999            11              11
//        11.5   11.499999999999998            11              11
//        11.6   11.599999999999998            12              12
//
//        11.5                 11.5            12              12

Public Sub Example()
    Dim value As Double = 11.1

    Console.WriteLine("{0,5} {1,20:R}  {2,12} {3,15}",
                    "Value", "Full Precision", "ToEven",
                    "AwayFromZero")
    Console.WriteLine()
    For ctr As Integer = 0 To 5
        value = RoundValueAndAdd(value)
    Next
    Console.WriteLine()

    value = 11.5
    RoundValueAndAdd(value)
End Sub

Private Function RoundValueAndAdd(value As Double) As Double
    Console.WriteLine("{0,5:N1} {0,20:R}  {1,12} {2,15}",
                    value, Math.Round(value, MidpointRounding.ToEven),
                    Math.Round(value, MidpointRounding.AwayFromZero))
    Return value + 0.1
End Function

' The example displays the following output:
'       Value       Full Precision        ToEven    AwayFromZero
'       
'        11.1                 11.1            11              11
'        11.2                 11.2            11              11
'        11.3   11.299999999999999            11              11
'        11.4   11.399999999999999            11              11
'        11.5   11.499999999999998            11              11
'        11.6   11.599999999999998            12              12
'       
'        11.5                 11.5            12              12

Es más probable que surjan problemas de precisión en los valores de punto medio de redondeo en las siguientes condiciones:

• Cuando un valor fraccional no se puede expresar con precisión en el formato binario del tipo de punto flotante.

• Cuando el valor que se va a redondear se calcula a partir de una o varias operaciones de punto flotante.

• Cuando el valor que se va a redondear es en Single lugar de un Double o Decimal. Para obtener más información, consulte la sección siguiente, Redondeo y valores de punto flotante de precisión sencilla.

En los casos en los que la falta de precisión en las operaciones de redondeo es problemática, puede hacer lo siguiente:

• Si la operación de redondeo llama a una sobrecarga que redondea un Double valor, puede cambiar a Double un Decimal valor y llamar a una sobrecarga que redondea un Decimal valor en su lugar. Aunque el Decimal tipo de datos también tiene problemas de representación y pérdida de precisión, estos problemas son mucho menos comunes.

• Defina un algoritmo de redondeo personalizado que realice una prueba "casi igual" para determinar si el valor que se va a redondear está aceptablemente cerca de un valor de punto medio. En el ejemplo siguiente se define un RoundApproximate método que examina si un valor fraccional está lo suficientemente cerca de un valor de punto medio que se va a someter al redondeo de punto medio. Como se muestra en la salida del ejemplo, corrige el problema de redondeo que se muestra en el ejemplo anterior.

  public static void Example()
  {
      Console.WriteLine("{0,5} {1,20:R}  {2,12} {3,15}\n",
                        "Value", "Full Precision", "ToEven",
                        "AwayFromZero");
      double value = 11.1;
      for (int ctr = 0; ctr <= 5; ctr++)
          value = RoundValueAndAdd(value);
  
      Console.WriteLine();
  
      value = 11.5;
      RoundValueAndAdd(value);
  }
  
  private static double RoundValueAndAdd(double value)
  {
      const double tolerance = 8e-14;
  
      Console.WriteLine("{0,5:N1} {0,20:R}  {1,12} {2,15}",
                        value,
                        RoundApproximate(value, 0, tolerance, MidpointRounding.ToEven),
                        RoundApproximate(value, 0, tolerance, MidpointRounding.AwayFromZero));
      return value + .1;
  }
  
  private static double RoundApproximate(double dbl, int digits, double margin,
                                    MidpointRounding mode)
  {
      double fraction = dbl * Math.Pow(10, digits);
      double value = Math.Truncate(fraction);
      fraction = fraction - value;
      if (fraction == 0)
          return dbl;
  
      double tolerance = margin * dbl;
      // Determine whether this is a midpoint value.
      if ((fraction >= .5 - tolerance) & (fraction <= .5 + tolerance))
      {
          if (mode == MidpointRounding.AwayFromZero)
              return (value + 1) / Math.Pow(10, digits);
          else
             if (value % 2 != 0)
              return (value + 1) / Math.Pow(10, digits);
          else
              return value / Math.Pow(10, digits);
      }
      // Any remaining fractional value greater than .5 is not a midpoint value.
      if (fraction > .5)
          return (value + 1) / Math.Pow(10, digits);
      else
          return value / Math.Pow(10, digits);
  }
  
  // The example displays the following output:
  //       Value       Full Precision        ToEven    AwayFromZero
  //
  //        11.1                 11.1            11              11
  //        11.2                 11.2            11              11
  //        11.3   11.299999999999999            11              11
  //        11.4   11.399999999999999            11              11
  //        11.5   11.499999999999998            12              12
  //        11.6   11.599999999999998            12              12
  //
  //        11.5                 11.5            12              12
  

  open System
  
  let roundApproximate dbl digits margin mode =
      let fraction = dbl * Math.Pow(10, digits)
      let value = Math.Truncate fraction
      let fraction = fraction - value
      if fraction = 0 then
          dbl
      else
          let tolerance = margin * dbl
          // Determine whether this is a midpoint value.
          if (fraction >= 0.5 - tolerance) && (fraction <= 0.5 + tolerance) then
              if mode = MidpointRounding.AwayFromZero then
                  (value + 1.) / Math.Pow(10, digits)
              elif value % 2. <> 0 then
                  (value + 1.) / Math.Pow(10, digits)
              else
                  value / Math.Pow(10, digits)
          // Any remaining fractional value greater than .5 is not a midpoint value.
          elif fraction > 0.5 then
              (value + 1.) / Math.Pow(10, digits)
          else
              value / Math.Pow(10, digits)
  
  
  let roundValueAndAdd value =
      let tolerance = 8e-14
      let round = roundApproximate value 0 tolerance
  
      printfn $"{value,5:N1} {value,20:R}  {round MidpointRounding.ToEven,12} {round MidpointRounding.AwayFromZero,15}"
      value + 0.1
  
  printfn "%5s %20s  %12s %15s\n" "Value" "Full Precision" "ToEven" "AwayFromZero"
  let mutable value = 11.1
  for _ = 0 to 5 do
      value <- roundValueAndAdd value
  
  printfn ""
  
  value <- 11.5
  roundValueAndAdd value 
  |> ignore
  
  // The example displays the following output:
  //       Value       Full Precision        ToEven    AwayFromZero
  //
  //        11.1                 11.1            11              11
  //        11.2                 11.2            11              11
  //        11.3   11.299999999999999            11              11
  //        11.4   11.399999999999999            11              11
  //        11.5   11.499999999999998            12              12
  //        11.6   11.599999999999998            12              12
  //
  //        11.5                 11.5            12              12
  

  Public Sub Example()
      Dim value As Double = 11.1
  
      Console.WriteLine("{0,5} {1,20:R}  {2,12} {3,15}\n",
                      "Value", "Full Precision", "ToEven",
                      "AwayFromZero")
      For ctr As Integer = 0 To 5
          value = RoundValueAndAdd(value)
      Next
      Console.WriteLine()
  
      value = 11.5
      RoundValueAndAdd(value)
  End Sub
  
  Private Function RoundValueAndAdd(value As Double) As Double
      Const tolerance As Double = 0.00000000000008
      Console.WriteLine("{0,5:N1} {0,20:R}  {1,12} {2,15}",
                      value,
                      RoundApproximate(value, 0, tolerance, MidpointRounding.ToEven),
                      RoundApproximate(value, 0, tolerance, MidpointRounding.AwayFromZero))
      Return value + 0.1
  End Function
  
  Private Function RoundApproximate(dbl As Double, digits As Integer, margin As Double,
                                   mode As MidpointRounding) As Double
      Dim fraction As Double = dbl * Math.Pow(10, digits)
      Dim value As Double = Math.Truncate(fraction)
      fraction = fraction - value
      If fraction = 0 Then Return dbl
  
      Dim tolerance As Double = margin * dbl
      ' Determine whether this is a midpoint value.
      If (fraction >= 0.5 - tolerance) And (fraction <= 0.5 + tolerance) Then
          If mode = MidpointRounding.AwayFromZero Then
              Return (value + 1) / Math.Pow(10, digits)
          Else
              If value Mod 2 <> 0 Then
                  Return (value + 1) / Math.Pow(10, digits)
              Else
                  Return value / Math.Pow(10, digits)
              End If
          End If
      End If
      ' Any remaining fractional value greater than .5 is not a midpoint value.
      If fraction > 0.5 Then
          Return (value + 1) / Math.Pow(10, digits)
      Else
          Return value / Math.Pow(10, digits)
      End If
  End Function
  
  ' The example displays the following output:
  '       Value       Full Precision        ToEven    AwayFromZero
  '       
  '        11.1                 11.1            11              11
  '        11.2                 11.2            11              11
  '        11.3   11.299999999999999            11              11
  '        11.4   11.399999999999999            11              11
  '        11.5   11.499999999999998            12              12
  '        11.6   11.599999999999998            12              12
  '       
  '        11.5                 11.5            12              12
  

Redondeo y valores de punto flotante de precisión sencilla

El Round método incluye sobrecargas que aceptan argumentos de tipo Decimal y Double. No hay métodos que redondeen los valores de tipo Single. Si pasa un Single valor a una de las sobrecargas del Round método , se convierte (en C#) o se convierte (en Visual Basic) en , Doubley se llama a la sobrecarga correspondiente Round con un Double parámetro . Aunque se trata de una conversión de ampliación, a menudo implica una pérdida de precisión, como se muestra en el ejemplo siguiente. Cuando se pasa un Single valor de 16,325 al Round método y se redondea a dos posiciones decimales con la convención más cercana, el resultado es 16,33 y no el resultado esperado de 16,32.

Single value = 16.325f;
Console.WriteLine("Widening Conversion of {0:R} (type {1}) to {2:R} (type {3}): ",
                  value, value.GetType().Name, (double)value,
                  ((double)(value)).GetType().Name);
Console.WriteLine(Math.Round(value, 2));
Console.WriteLine(Math.Round(value, 2, MidpointRounding.AwayFromZero));
Console.WriteLine();

Decimal decValue = (decimal)value;
Console.WriteLine("Cast of {0:R} (type {1}) to {2} (type {3}): ",
                  value, value.GetType().Name, decValue,
                  decValue.GetType().Name);
Console.WriteLine(Math.Round(decValue, 2));
Console.WriteLine(Math.Round(decValue, 2, MidpointRounding.AwayFromZero));

// The example displays the following output:
//    Widening Conversion of 16.325 (type Single) to 16.325000762939453 (type Double):
//    16.33
//    16.33
//
//    Cast of 16.325 (type Single) to 16.325 (type Decimal):
//    16.32
//    16.33

// In F#, 'float', 'float64', and 'double' are aliases for System.Double...
// 'float32' and 'single' are aliases for System.Single
open System

let value = 16.325f
printfn $"Widening Conversion of {value:R} (type {value.GetType().Name}) to {double value:R} (type {(double value).GetType().Name}): "
printfn $"{Math.Round(decimal value, 2)}"
printfn $"{Math.Round(decimal value, 2, MidpointRounding.AwayFromZero)}"
printfn ""

let decValue = decimal value
printfn $"Cast of {value:R} (type {value.GetType().Name}) to {decValue} (type {decValue.GetType().Name}): "
printfn $"{Math.Round(decValue, 2)}"
printfn $"{Math.Round(decValue, 2, MidpointRounding.AwayFromZero)}"

// The example displays the following output:
//    Widening Conversion of 16.325 (type Single) to 16.325000762939453 (type Double):
//    16.33
//    16.33
//
//    Cast of 16.325 (type Single) to 16.325 (type Decimal):
//    16.32
//    16.33

Dim value As Single = 16.325
Console.WriteLine("Widening Conversion of {0:R} (type {1}) to {2:R} (type {3}): ",
                value, value.GetType().Name, CDbl(value),
                CDbl(value).GetType().Name)
Console.WriteLine(Math.Round(value, 2))
Console.WriteLine(Math.Round(value, 2, MidpointRounding.AwayFromZero))
Console.WriteLine()

Dim decValue As Decimal = CDec(value)
Console.WriteLine("Cast of {0:R} (type {1}) to {2} (type {3}): ",
                value, value.GetType().Name, decValue,
                decValue.GetType().Name)
Console.WriteLine(Math.Round(decValue, 2))
Console.WriteLine(Math.Round(decValue, 2, MidpointRounding.AwayFromZero))
Console.WriteLine()

' The example displays the following output:
'    Widening Conversion of 16.325 (type Single) to 16.325000762939453 (type Double):
'    16.33
'    16.33
'    
'    Cast of 16.325 (type Single) to 16.325 (type Decimal):
'    16.32
'    16.33

Este resultado inesperado se debe a una pérdida de precisión en la conversión del Single valor a .Double Dado que el valor resultante Double de 16,325000762939453 no es un valor de punto medio y es mayor que 16,325, siempre se redondea hacia arriba.

En muchos casos, como se muestra en el ejemplo, la pérdida de precisión se puede minimizar o eliminar mediante la conversión o conversión del Single valor en .Decimal Tenga en cuenta que, dado que se trata de una conversión de restricción, requiere usar un operador de conversión o llamar a un método de conversión.

Round(Double, Int32, MidpointRounding)

Source:

Math.cs

Redondea un valor de punto flotante de doble precisión a un número especificado de dígitos fraccionarios mediante la convención de redondeo especificada.

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

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

static member Round : double * int * MidpointRounding -> double

Public Shared Function Round (value As Double, digits As Integer, mode As MidpointRounding) As Double

Parámetros

value

Double

Número de punto flotante de precisión doble que se va a redondear.

digits

Int32

Número de dígitos fraccionarios del valor devuelto.

mode

MidpointRounding

Uno de los valores de enumeración que especifica qué estrategia de redondeo se va a usar.

Devoluciones

Double

Número con digits dígitos fraccionarios a los que value se redondea. Si value tiene menos dígitos fraccionarios que digits, value se devuelve sin modificar.

Excepciones

ArgumentOutOfRangeException

digits es menor que 0 o mayor que 15.

ArgumentException

mode no es un valor válido de MidpointRounding.

Comentarios

El valor del digits argumento puede oscilar entre 0 y 15. El número máximo de dígitos enteros y fraccionarios admitidos por el Double tipo es 15.

Vea Valores de punto medio y convenciones de redondeo para obtener información sobre los números de redondeo con valores de punto medio.

Importante

Cuando se redondean los valores de punto medio, el algoritmo de redondeo realiza una prueba de igualdad. Debido a problemas de representación binaria y de precisión en el formato de punto flotante, es posible que el valor que el método devuelva no sea el esperado. Para obtener más información, consulte Redondeo y precisión.

Si el valor del value argumento es Double.NaN, el método devuelve Double.NaN. Si value es Double.PositiveInfinity o Double.NegativeInfinity, el método devuelve Double.PositiveInfinity o Double.NegativeInfinity, respectivamente.

Ejemplo

En el ejemplo siguiente se muestra cómo usar el Round(Double, Int32, MidpointRounding) método con la MidpointRounding enumeración .

// Round a positive and a negative value using the default.
double result = Math.Round(3.45, 1);
Console.WriteLine($"{result,4} = Math.Round({3.45,5}, 1)");
result = Math.Round(-3.45, 1);
Console.WriteLine($"{result,4} = Math.Round({-3.45,5}, 1)\n");

// Round a positive value using a MidpointRounding value.
result = Math.Round(3.45, 1, MidpointRounding.ToEven);
Console.WriteLine($"{result,4} = Math.Round({3.45,5}, 1, MidpointRounding.ToEven)");
result = Math.Round(3.45, 1, MidpointRounding.AwayFromZero);
Console.WriteLine($"{result,4} = Math.Round({3.45,5}, 1, MidpointRounding.AwayFromZero)");
result = Math.Round(3.47, 1, MidpointRounding.ToZero);
Console.WriteLine($"{result,4} = Math.Round({3.47,5}, 1, MidpointRounding.ToZero)\n");

// Round a negative value using a MidpointRounding value.
result = Math.Round(-3.45, 1, MidpointRounding.ToEven);
Console.WriteLine($"{result,4} = Math.Round({-3.45,5}, 1, MidpointRounding.ToEven)");
result = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero);
Console.WriteLine($"{result,4} = Math.Round({-3.45,5}, 1, MidpointRounding.AwayFromZero)");
result = Math.Round(-3.47, 1, MidpointRounding.ToZero);
Console.WriteLine($"{result,4} = Math.Round({-3.47,5}, 1, MidpointRounding.ToZero)\n");

// The example displays the following output:

//         3.4 = Math.Round( 3.45, 1)
//         -3.4 = Math.Round(-3.45, 1)

//         3.4 = Math.Round(3.45, 1, MidpointRounding.ToEven)
//         3.5 = Math.Round(3.45, 1, MidpointRounding.AwayFromZero)
//         3.4 = Math.Round(3.47, 1, MidpointRounding.ToZero)

//         -3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
//         -3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)
//         -3.4 = Math.Round(-3.47, 1, MidpointRounding.ToZero)

// Round a positive and a negative value using the default.
let result = Math.Round(3.45, 1)
printfn $"{result,4} = Math.Round({3.45,5}, 1)"
let result = Math.Round(-3.45, 1)
printfn $"{result,4} = Math.Round({-3.45,5}, 1)\n"

// Round a positive value using a MidpointRounding value.
let result = Math.Round(3.45, 1, MidpointRounding.ToEven)
printfn $"{result,4} = Math.Round({3.45,5}, 1, MidpointRounding.ToEven)"
let result = Math.Round(3.45, 1, MidpointRounding.AwayFromZero)
printfn $"{result,4} = Math.Round({3.45,5}, 1, MidpointRounding.AwayFromZero)"
let result = Math.Round(3.47, 1, MidpointRounding.ToZero)
printfn $"{result,4} = Math.Round({3.47,5}, 1, MidpointRounding.ToZero)\n"

// Round a negative value using a MidpointRounding value.
let result = Math.Round(-3.45, 1, MidpointRounding.ToEven)
printfn $"{result,4} = Math.Round({-3.45,5}, 1, MidpointRounding.ToEven)"
let result = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)
printfn $"{result,4} = Math.Round({-3.45,5}, 1, MidpointRounding.AwayFromZero)"
let result = Math.Round(-3.47, 1, MidpointRounding.ToZero)
printfn $"{result,4} = Math.Round({-3.47,5}, 1, MidpointRounding.ToZero)\n"

// The example displays the following output:

//         3.4 = Math.Round( 3.45, 1)
//         -3.4 = Math.Round(-3.45, 1)

//         3.4 = Math.Round(3.45, 1, MidpointRounding.ToEven)
//         3.5 = Math.Round(3.45, 1, MidpointRounding.AwayFromZero)
//         3.4 = Math.Round(3.47, 1, MidpointRounding.ToZero)

//         -3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
//         -3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)
//         -3.4 = Math.Round(-3.47, 1, MidpointRounding.ToZero)

Dim posValue As Double = 3.45
Dim negValue As Double = -3.45

' Round a positive and a negative value using the default.  
Dim result As Double = Math.Round(posValue, 1)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1)", result, posValue)
result = Math.Round(negValue, 1)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1)", result, negValue)
Console.WriteLine()

' Round a positive value using a MidpointRounding value. 
result = Math.Round(posValue, 1, MidpointRounding.ToEven)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)",
                   result, posValue)
result = Math.Round(posValue, 1, MidpointRounding.AwayFromZero)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)",
                   result, posValue)
Console.WriteLine()

' Round a positive value using a MidpointRounding value. 
result = Math.Round(negValue, 1, MidpointRounding.ToEven)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)",
                    result, negValue)
result = Math.Round(negValue, 1, MidpointRounding.AwayFromZero)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)",
                   result, negValue)
Console.WriteLine()

'This code example produces the following results:

'  3.4 = Math.Round( 3.45, 1)
' -3.4 = Math.Round(-3.45, 1)

' 3.4 = Math.Round( 3.45, 1, MidpointRounding.ToEven)
' 3.5 = Math.Round( 3.45, 1, MidpointRounding.AwayFromZero)

' -3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
' -3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)

Notas a los autores de las llamadas

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 algunos casos, es posible que el Round(Double, Int32, MidpointRounding) método no parezca redondear los valores de punto medio según lo especificado por el mode parámetro . Esto se muestra en el ejemplo siguiente, donde 2.135 se redondea a 2.13 en lugar de 2.14. Esto ocurre porque internamente el método multiplica value por 10^dígitos y la operación de multiplicación en este caso sufre una pérdida de precisión.

double[] values = { 2.125, 2.135, 2.145, 3.125, 3.135, 3.145 };
foreach (double value in values)
   Console.WriteLine("{0} --> {1}", value,
                     Math.Round(value, 2, MidpointRounding.AwayFromZero));

// The example displays the following output:
//       2.125 --> 2.13
//       2.135 --> 2.13
//       2.145 --> 2.15
//       3.125 --> 3.13
//       3.135 --> 3.14
//       3.145 --> 3.15

open System

let values = [| 2.125; 2.135; 2.145; 3.125; 3.135; 3.145 |]
for value in values do
    printfn $"{value} --> {Math.Round(value, 2, MidpointRounding.AwayFromZero)}"
// The example displays the following output:
//       2.125 --> 2.13
//       2.135 --> 2.13
//       2.145 --> 2.15
//       3.125 --> 3.13
//       3.135 --> 3.14
//       3.145 --> 3.15

Module Example
   Public Sub Main()
      Dim values() As Double = { 2.125, 2.135, 2.145, 3.125, 3.135, 3.145 }
      For Each value As Double In values
         Console.WriteLine("{0} --> {1}", value, 
                           Math.Round(value, 2, MidpointRounding.AwayFromZero))
      Next
   End Sub
End Module
' The example displays the following output:
'       2.125 --> 2.13
'       2.135 --> 2.13
'       2.145 --> 2.15
'       3.125 --> 3.13
'       3.135 --> 3.14
'       3.145 --> 3.15

Consulte también

• Ceiling(Double)
• Floor(Double)
• Round(Decimal, Int32, MidpointRounding)

Round(Decimal, Int32, MidpointRounding)

Source:

Math.cs

Redondea un valor decimal a un número especificado de dígitos fraccionarios mediante la convención de redondeo especificada.

public:
 static System::Decimal Round(System::Decimal d, int decimals, MidpointRounding mode);

public static decimal Round (decimal d, int decimals, MidpointRounding mode);

static member Round : decimal * int * MidpointRounding -> decimal

Public Shared Function Round (d As Decimal, decimals As Integer, mode As MidpointRounding) As Decimal

Parámetros

d

Decimal

Número decimal que se va a redondear.

decimals

Int32

Número de posiciones decimales del valor devuelto.

mode

MidpointRounding

Uno de los valores de enumeración que especifica qué estrategia de redondeo se va a usar.

Devoluciones

Decimal

Número con decimals dígitos fraccionarios a los que d se redondea. Si d tiene menos dígitos fraccionarios que decimals, d se devuelve sin modificar.

Excepciones

ArgumentOutOfRangeException

decimals es menor que 0 o mayor que 28.

ArgumentException

mode no es un valor válido de MidpointRounding.

OverflowException

El resultado está fuera del intervalo de Decimal.

Comentarios

Vea Valores de punto medio y convenciones de redondeo para obtener información sobre los números de redondeo con valores de punto medio.

Importante

Cuando se redondean los valores de punto medio, el algoritmo de redondeo realiza una prueba de igualdad. Debido a problemas de representación binaria y de precisión en el formato de punto flotante, es posible que el valor que el método devuelva no sea el esperado. Para obtener más información, consulte Redondeo y precisión.

El valor del decimals argumento puede oscilar entre 0 y 28.

Ejemplo

En el ejemplo siguiente se muestra cómo usar el Round método con la MidpointRounding enumeración .

decimal result;

// Round a positive value using different strategies.
// The precision of the result is 1 decimal place.

result = Math.Round(3.45m, 1, MidpointRounding.ToEven);
Console.WriteLine($"{result} = Math.Round({3.45m}, 1, MidpointRounding.ToEven)");
result = Math.Round(3.45m, 1, MidpointRounding.AwayFromZero);
Console.WriteLine($"{result} = Math.Round({3.45m}, 1, MidpointRounding.AwayFromZero)");
result = Math.Round(3.47m, 1, MidpointRounding.ToZero);
Console.WriteLine($"{result} = Math.Round({3.47m}, 1, MidpointRounding.ToZero)\n");

// Round a negative value using different strategies.
// The precision of the result is 1 decimal place.

result = Math.Round(-3.45m, 1, MidpointRounding.ToEven);
Console.WriteLine($"{result} = Math.Round({-3.45m}, 1, MidpointRounding.ToEven)");
result = Math.Round(-3.45m, 1, MidpointRounding.AwayFromZero);
Console.WriteLine($"{result} = Math.Round({-3.45m}, 1, MidpointRounding.AwayFromZero)");
result = Math.Round(-3.47m, 1, MidpointRounding.ToZero);
Console.WriteLine($"{result} = Math.Round({-3.47m}, 1, MidpointRounding.ToZero)\n");

/*
This code example produces the following results:

3.4 = Math.Round(3.45, 1, MidpointRounding.ToEven)
3.5 = Math.Round(3.45, 1, MidpointRounding.AwayFromZero)
3.4 = Math.Round(3.47, 1, MidpointRounding.ToZero)

-3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
-3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)
-3.4 = Math.Round(-3.47, 1, MidpointRounding.ToZero)
*/

// Round a positive value using different strategies.
// The precision of the result is 1 decimal place.

let result = Math.Round(3.45m, 1, MidpointRounding.ToEven)
printfn $"{result} = Math.Round({3.45m}, 1, MidpointRounding.ToEven)"
let result = Math.Round(3.45m, 1, MidpointRounding.AwayFromZero)
printfn $"{result} = Math.Round({3.45m}, 1, MidpointRounding.AwayFromZero)"
let result = Math.Round(3.47m, 1, MidpointRounding.ToZero)
printfn $"{result} = Math.Round({3.47m}, 1, MidpointRounding.ToZero)\n"

// Round a negative value using different strategies.
// The precision of the result is 1 decimal place.

let result = Math.Round(-3.45m, 1, MidpointRounding.ToEven)
printfn $"{result} = Math.Round({-3.45m}, 1, MidpointRounding.ToEven)"
let result = Math.Round(-3.45m, 1, MidpointRounding.AwayFromZero)
printfn $"{result} = Math.Round({-3.45m}, 1, MidpointRounding.AwayFromZero)"
let result = Math.Round(-3.47m, 1, MidpointRounding.ToZero)
printfn $"{result} = Math.Round({-3.47m}, 1, MidpointRounding.ToZero)\n"

// This code example produces the following results:

// 3.4 = Math.Round(3.45, 1, MidpointRounding.ToEven)
// 3.5 = Math.Round(3.45, 1, MidpointRounding.AwayFromZero)
// 3.4 = Math.Round(3.47, 1, MidpointRounding.ToZero)

// -3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
// -3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)
// -3.4 = Math.Round(-3.47, 1, MidpointRounding.ToZero)

Dim result As Decimal = 0D
Dim posValue As Decimal = 3.45D
Dim negValue As Decimal = -3.45D

' Round a positive value using different strategies.
' The precision of the result is 1 decimal place.
result = Math.Round(posValue, 1, MidpointRounding.ToEven)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)",
                   result, posValue)
result = Math.Round(posValue, 1, MidpointRounding.AwayFromZero)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)",
                   result, posValue)
result = Math.Round(posValue, 1, MidpointRounding.ToZero)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToZero)",
                   result, posValue)
Console.WriteLine()

' Round a negative value using different strategies.
' The precision of the result is 1 decimal place.
result = Math.Round(negValue, 1, MidpointRounding.ToEven)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToEven)",
                    result, negValue)
result = Math.Round(negValue, 1, MidpointRounding.AwayFromZero)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.AwayFromZero)",
                   result, negValue)
result = Math.Round(negValue, 1, MidpointRounding.ToZero)
Console.WriteLine("{0,4} = Math.Round({1,5}, 1, MidpointRounding.ToZero)",
                   result, negValue)
Console.WriteLine()

'This code example produces the following results:
'
'        3.4 = Math.Round(3.45, 1, MidpointRounding.ToEven)
'        3.5 = Math.Round(3.45, 1, MidpointRounding.AwayFromZero)
'        3.4 = Math.Round(3.45, 1, MidpointRounding.ToZero)
'
'        -3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)
'        -3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)
'        -3.4 = Math.Round(-3.45, 1, MidpointRounding.ToZero)
'

Consulte también

• Ceiling(Double)
• Floor(Double)
• Round(Decimal, Int32, MidpointRounding)

Round(Double, MidpointRounding)

Source:

Math.cs

Redondea un valor de punto flotante de doble precisión a un entero mediante la convención de redondeo especificada.

public:
 static double Round(double value, MidpointRounding mode);

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

static member Round : double * MidpointRounding -> double

Public Shared Function Round (value As Double, mode As MidpointRounding) As Double

Parámetros

value

Double

Número de punto flotante de precisión doble que se va a redondear.

mode

MidpointRounding

Uno de los valores de enumeración que especifica qué estrategia de redondeo se va a usar.

Devoluciones

Double

Entero al que value se redondea. Este método devuelve en Double lugar de un tipo entero.

Excepciones

ArgumentException

mode no es un valor válido de MidpointRounding.

Comentarios

Vea Valores de punto medio y convenciones de redondeo para obtener información sobre los números de redondeo con valores de punto medio.

Importante

Cuando se redondean los valores de punto medio, el algoritmo de redondeo realiza una prueba de igualdad. Debido a problemas de representación binaria y de precisión en el formato de punto flotante, es posible que el valor que el método devuelva no sea el esperado. Para obtener más información, consulte Redondeo y precisión.

Si el valor del value argumento es Double.NaN, el método devuelve Double.NaN. Si value es Double.PositiveInfinity o Double.NegativeInfinity, el método devuelve Double.PositiveInfinity o Double.NegativeInfinity, respectivamente.

Ejemplo

En el ejemplo siguiente se muestran los valores devueltos por el Round(Double, MidpointRounding) método con valores diferentes mode .

Double[] values = { 12.0, 12.1, 12.2, 12.3, 12.4, 12.5, 12.6,
                  12.7, 12.8, 12.9, 13.0 };
Console.WriteLine($"{"Value",-10} {"Default",-10} {"ToEven",-10} {"AwayFromZero",-15} {"ToZero",-15}");

foreach (var value in values)
    Console.WriteLine($"{value,-10:R} {Math.Round(value),-10} " +
        $"{Math.Round(value, MidpointRounding.ToEven),-10} " +
        $"{Math.Round(value, MidpointRounding.AwayFromZero),-15} " +
        $"{Math.Round(value, MidpointRounding.ToZero),-15}");

// The example displays the following output:
//       Value      Default    ToEven     AwayFromZero    ToZero
//       12         12         12         12              12
//       12.1       12         12         12              12
//       12.2       12         12         12              12
//       12.3       12         12         12              12
//       12.4       12         12         12              12
//       12.5       12         12         13              12
//       12.6       13         13         13              12
//       12.7       13         13         13              12
//       12.8       13         13         13              12
//       12.9       13         13         13              12
//       13         13         13         13              13

open System

let values = 
    [| 12.; 12.1; 12.2; 12.3; 12.4; 12.5
       12.6; 12.7; 12.8; 12.9; 13. |]

printfn "%-10s %-10s %-10s %-15s %-15s" "Value" "Default" "ToEven" "AwayFromZero" "ToZero"

for value in values do
    $"{value,-10:R} {Math.Round(value),-10} " +
    $"{Math.Round(value, MidpointRounding.ToEven),-10} " +
    $"{Math.Round(value, MidpointRounding.AwayFromZero),-15} " +
    $"{Math.Round(value, MidpointRounding.ToZero),-15}"
    |> printfn "%s"
    
// The example displays the following output:
//       Value      Default    ToEven     AwayFromZero    ToZero
//       12         12         12         12              12
//       12.1       12         12         12              12
//       12.2       12         12         12              12
//       12.3       12         12         12              12
//       12.4       12         12         12              12
//       12.5       12         12         13              12
//       12.6       13         13         13              12
//       12.7       13         13         13              12
//       12.8       13         13         13              12
//       12.9       13         13         13              12
//       13         13         13         13              13

Dim values() As Double = {12.0, 12.1, 12.2, 12.3, 12.4, 12.5, 12.6,
                         12.7, 12.8, 12.9, 13.0}
Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15} {4,-15}", "Value", "Default",
                "ToEven", "AwayFromZero", "ToZero")
For Each value In values
    Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15} {4,-15}",
                   value, Math.Round(value),
                   Math.Round(value, MidpointRounding.ToEven),
                   Math.Round(value, MidpointRounding.AwayFromZero),
                   Math.Round(value, MidpointRounding.ToZero))
Next

' The example displays the following output:
'       Value      Default    ToEven     AwayFromZero     ToZero
'       12         12         12         12               12
'       12.1       12         12         12               12
'       12.2       12         12         12               12
'       12.3       12         12         12               12
'       12.4       12         12         12               12
'       12.5       12         12         13               12
'       12.6       13         13         13               12
'       12.7       13         13         13               12
'       12.8       13         13         13               12
'       12.9       13         13         13               12
'       13         13         13         13               13

Notas a los autores de las llamadas

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 algunos casos, es posible que el Round(Double, MidpointRounding) método no parezca redondear los valores de punto medio al entero par más cercano. En el ejemplo siguiente, dado que el valor de punto flotante .1 no tiene ninguna representación binaria finita, la primera llamada al Round(Double) método con un valor de 11,5 devuelve 11 en lugar de 12.

using System;

public class Example
{
   public static void Main()
   {
      double value = 11.1;
      for (int ctr = 0; ctr <= 5; ctr++)
         value = RoundValueAndAdd(value);

      Console.WriteLine();

      value = 11.5;
      RoundValueAndAdd(value);
   }

   private static double RoundValueAndAdd(double value)
   {
      Console.WriteLine("{0} --> {1}", value, Math.Round(value,
                        MidpointRounding.AwayFromZero));
      return value + .1;
   }
}
// The example displays the following output:
//       11.1 --> 11
//       11.2 --> 11
//       11.3 --> 11
//       11.4 --> 11
//       11.5 --> 11
//       11.6 --> 12
//
//       11.5 --> 12

open System

let roundValueAndAdd (value: float) =
      printfn $"{value} --> {Math.Round(value, MidpointRounding.AwayFromZero)}"
      value + 0.1

let mutable value = 11.1
for _ = 0 to 5 do
    value <- roundValueAndAdd value

printfn ""

value <- 11.5
roundValueAndAdd value
|> ignore

// The example displays the following output:
//       11.1 --> 11
//       11.2 --> 11
//       11.3 --> 11
//       11.4 --> 11
//       11.5 --> 11
//       11.6 --> 12
//
//       11.5 --> 12

Module Example
   Public Sub Main()
      Dim value As Double = 11.1
      For ctr As Integer = 0 To 5    
         value = RoundValueAndAdd(value)
      Next
      Console.WriteLine()

      value = 11.5
      RoundValueAndAdd(value)
   End Sub
   
   Private Function RoundValueAndAdd(value As Double) As Double
      Console.WriteLine("{0} --> {1}", value, Math.Round(value, 
                        MidpointRounding.AwayFromZero))
      Return value + .1
   End Function   
End Module
' The example displays the following output:
'       11.1 --> 11
'       11.2 --> 11
'       11.3 --> 11
'       11.4 --> 11
'       11.5 --> 11
'       11.6 --> 12
'       
'       11.5 --> 12

Consulte también

• Ceiling(Double)
• Floor(Double)
• Round(Decimal, MidpointRounding)

Round(Double, Int32)

Source:

Math.cs

Redondea un valor de punto flotante de precisión doble a un número especificado de dígitos fraccionarios y los valores de punto medio al número par más cercano.

public:
 static double Round(double value, int digits);

public static double Round (double value, int digits);

static member Round : double * int -> double

Public Shared Function Round (value As Double, digits As Integer) As Double

Parámetros

value

Double

Número de punto flotante de precisión doble que se va a redondear.

digits

Int32

Número de dígitos fraccionarios del valor devuelto.

Devoluciones

Double

Número más cercano a value que contiene varios dígitos fraccionarios iguales a digits.

Excepciones

ArgumentOutOfRangeException

digits es menor que 0 o mayor que 15.

Comentarios

El valor del digits argumento puede oscilar entre 0 y 15. El número máximo de dígitos enteros y fraccionarios admitidos por el Double tipo es 15.

Este método usa la convención de redondeo predeterminada de MidpointRounding.ToEven. Vea Valores de punto medio y convenciones de redondeo para obtener información sobre los números de redondeo con valores de punto medio.

Importante

Cuando se redondean los valores de punto medio, el algoritmo de redondeo realiza una prueba de igualdad. Debido a problemas de representación binaria y de precisión en el formato de punto flotante, es posible que el valor que el método devuelva no sea el esperado. Para obtener más información, consulte Redondeo y precisión.

Si el valor del value argumento es Double.NaN, el método devuelve Double.NaN. Si value es Double.PositiveInfinity o Double.NegativeInfinity, el método devuelve Double.PositiveInfinity o Double.NegativeInfinity, respectivamente.

Ejemplo

En el ejemplo siguiente se redondea los valores dobles con dos dígitos fraccionarios a dobles que tienen un solo dígito fraccionario.

Math::Round(3.44, 1); //Returns 3.4.
Math::Round(3.45, 1); //Returns 3.4.
Math::Round(3.46, 1); //Returns 3.5.

Math::Round(4.34, 1); // Returns 4.3
Math::Round(4.35, 1); // Returns 4.4
Math::Round(4.36, 1); // Returns 4.4

Math.Round(3.44, 1); //Returns 3.4.
Math.Round(3.45, 1); //Returns 3.4.
Math.Round(3.46, 1); //Returns 3.5.

Math.Round(4.34, 1); // Returns 4.3
Math.Round(4.35, 1); // Returns 4.4
Math.Round(4.36, 1); // Returns 4.4

open System

printfn $"{Math.Round(3.44, 1)}" //Returns 3.4.
printfn $"{Math.Round(3.45, 1)}" //Returns 3.4.
printfn $"{Math.Round(3.46, 1)}" //Returns 3.5.

printfn $"{Math.Round(4.34, 1)}" // Returns 4.3
printfn $"{Math.Round(4.35, 1)}" // Returns 4.4
printfn $"{Math.Round(4.36, 1)}" // Returns 4.4

Math.Round(3.44, 1) 'Returns 3.4.
Math.Round(3.45, 1) 'Returns 3.4.
Math.Round(3.46, 1) 'Returns 3.5.

Math.Round(4.34, 1) ' Returns 4.3
Math.Round(4.35, 1) ' Returns 4.4
Math.Round(4.36, 1) ' Returns 4.4

Notas a los autores de las llamadas

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 algunos casos, es posible que el Round(Double, Int32) método no parezca redondear los valores de punto medio al valor par más cercano en la digits posición decimal. Esto se muestra en el ejemplo siguiente, donde 2.135 se redondea a 2.13 en lugar de 2.14. Esto ocurre porque internamente el método multiplica value por 10^dígitos y la operación de multiplicación en este caso sufre una pérdida de precisión.

using System;

public class Example
{
   public static void Main()
   {
      double[] values = { 2.125, 2.135, 2.145, 3.125, 3.135, 3.145 };
      foreach (double value in values)
         Console.WriteLine("{0} --> {1}", value, Math.Round(value, 2));
   }
}
// The example displays the following output:
//       2.125 --> 2.12
//       2.135 --> 2.13
//       2.145 --> 2.14
//       3.125 --> 3.12
//       3.135 --> 3.14
//       3.145 --> 3.14

open System

let values = [| 2.125; 2.135; 2.145; 3.125; 3.135; 3.145 |]
for value in values do
    printfn $"{value} --> {Math.Round(value, 2)}"
// The example displays the following output:
//       2.125 --> 2.12
//       2.135 --> 2.13
//       2.145 --> 2.14
//       3.125 --> 3.12
//       3.135 --> 3.14
//       3.145 --> 3.14

Module Example
   Public Sub Main()
      Dim values() As Double = { 2.125, 2.135, 2.145, 3.125, 3.135, 3.145 }
      For Each value As Double In values
         Console.WriteLine("{0} --> {1}", value, Math.Round(value, 2))
      Next
   End Sub
End Module
' The example displays the following output:
'       2.125 --> 2.12
'       2.135 --> 2.13
'       2.145 --> 2.14
'       3.125 --> 3.12
'       3.135 --> 3.14
'       3.145 --> 3.14

Consulte también

• Ceiling(Double)
• Floor(Double)
• Round(Decimal, Int32)

Round(Decimal, Int32)

Source:

Math.cs

Redondea un valor decimal a un número especificado de dígitos fraccionarios y los valores de punto medio al número par más cercano.

public:
 static System::Decimal Round(System::Decimal d, int decimals);

public static decimal Round (decimal d, int decimals);

static member Round : decimal * int -> decimal

Public Shared Function Round (d As Decimal, decimals As Integer) As Decimal

Parámetros

d

Decimal

Número decimal que se va a redondear.

decimals

Int32

Número de posiciones decimales del valor devuelto.

Devoluciones

Decimal

Número más cercano a d que contiene varios dígitos fraccionarios iguales a decimals.

Excepciones

ArgumentOutOfRangeException

decimals es menor que 0 o mayor que 28.

OverflowException

El resultado está fuera del intervalo de Decimal.

Comentarios

El valor del decimals argumento puede oscilar entre 0 y 28.

Este método usa la convención de redondeo predeterminada de MidpointRounding.ToEven. Para obtener información sobre el redondeo de números con valores de punto medio, vea Valores de punto medio y convenciones de redondeo.

Importante

Cuando se redondean los valores de punto medio, el algoritmo de redondeo realiza una prueba de igualdad. Debido a problemas de representación binaria y de precisión en el formato de punto flotante, es posible que el valor que el método devuelva no sea el esperado. Para obtener más información, consulte Redondeo y precisión.

Ejemplo

En el ejemplo siguiente se redondea los valores decimales con dos dígitos fraccionarios a valores que tienen un solo dígito fraccionario.

Console.WriteLine(Math.Round(3.44m, 1));
Console.WriteLine(Math.Round(3.45m, 1));
Console.WriteLine(Math.Round(3.46m, 1));
Console.WriteLine();

Console.WriteLine(Math.Round(4.34m, 1));
Console.WriteLine(Math.Round(4.35m, 1));
Console.WriteLine(Math.Round(4.36m, 1));

// The example displays the following output:
//       3.4
//       3.4
//       3.5
//
//       4.3
//       4.4
//       4.4

open System

printfn 
    $"""{Math.Round(3.44m, 1)}
{Math.Round(3.45m, 1)}
{Math.Round(3.46m, 1)}

{Math.Round(4.34m, 1)}
{Math.Round(4.35m, 1)}
{Math.Round(4.36m, 1)}"""

// The example displays the following output:
//       3.4
//       3.4
//       3.5
//
//       4.3
//       4.4
//       4.4

Console.WriteLine(Math.Round(3.44, 1))
Console.WriteLine(Math.Round(3.45, 1))
Console.WriteLine(Math.Round(3.46, 1))
Console.WriteLine()

Console.WriteLine(Math.Round(4.34, 1))
Console.WriteLine(Math.Round(4.35, 1))
Console.WriteLine(Math.Round(4.36, 1))

' The example displays the following output:
'       3.4
'       3.4
'       3.5
'       
'       4.3
'       4.4
'       4.4

Consulte también

• Ceiling(Double)
• Floor(Double)
• Round(Decimal, Int32)

Round(Double)

Source:

Math.cs

Redondea un valor de punto flotante de precisión doble al valor entero más cercano y los valores de punto medio al número par más cercano.

public:
 static double Round(double a);

public static double Round (double a);

static member Round : double -> double

Public Shared Function Round (a As Double) As Double

Parámetros

a

Double

Número de punto flotante de precisión doble que se va a redondear.

Devoluciones

Double

a entero más cercano. Si el componente fraccionario de a se encuentra en medio del intervalo entre dos números, uno par y el otro impar, se devuelve el número impar. Tenga en cuenta que este método devuelve un valor Double en lugar de un tipo entero.

Comentarios

Este método usa la convención de redondeo predeterminada de MidpointRounding.ToEven. Para obtener información sobre el redondeo de números con valores de punto medio, vea Valores de punto medio y convenciones de redondeo.

Importante

Cuando se redondean los valores de punto medio, el algoritmo de redondeo realiza una prueba de igualdad. Debido a problemas de representación binaria y de precisión en el formato de punto flotante, es posible que el valor que el método devuelva no sea el esperado. Para obtener más información, consulte Redondeo y precisión.

Si el valor del a argumento es Double.NaN, el método devuelve Double.NaN. Si a es Double.PositiveInfinity o Double.NegativeInfinity, el método devuelve Double.PositiveInfinity o Double.NegativeInfinity, respectivamente.

A partir de Visual Basic 15.8, el rendimiento de la conversión doble a entero se optimiza si pasa el valor devuelto por el Round método a cualquiera de las funciones de conversión integral, o si el valor Double devuelto por Round se convierte automáticamente en un entero con Option Strict establecido en Off. Esta optimización permite que el código se ejecute más rápido, hasta el doble de rápido para código que realiza un gran número de conversiones a tipos enteros. En el ejemplo siguiente se muestran estas conversiones optimizadas:

Dim d1 As Double = 1043.75133
Dim i1 As Integer = CInt(Math.Ceiling(d1))        ' Result: 1044

Dim d2 As Double = 7968.4136
Dim i2 As Integer = CInt(Math.Ceiling(d2))        ' Result: 7968

Ejemplo

En el ejemplo siguiente se muestra el redondeo al valor entero más cercano.

using namespace System;

void main()
{
    Console::WriteLine("Classic Math.Round in CPP");
    Console::WriteLine(Math::Round(4.4));     // 4
    Console::WriteLine(Math::Round(4.5));     // 4
    Console::WriteLine(Math::Round(4.6));     // 5
    Console::WriteLine(Math::Round(5.5));     // 6
}

Console.WriteLine("Classic Math.Round in CSharp");
Console.WriteLine(Math.Round(4.4)); // 4
Console.WriteLine(Math.Round(4.5)); // 4
Console.WriteLine(Math.Round(4.6)); // 5
Console.WriteLine(Math.Round(5.5)); // 6

open System

printfn "Classic Math.Round in F#"
printfn $"{Math.Round(4.4)}" // 4
printfn $"{Math.Round(4.5)}" // 4
printfn $"{Math.Round(4.6)}" // 5
printfn $"{Math.Round(5.5)}" // 6

Module Module1

    Sub Main()
    Console.WriteLine("Classic Math.Round in Visual Basic")
    Console.WriteLine(Math.Round(4.4)) ' 4
    Console.WriteLine(Math.Round(4.5)) ' 4
    Console.WriteLine(Math.Round(4.6)) ' 5
    Console.WriteLine(Math.Round(5.5)) ' 6
    End Sub

End Module

Notas a los autores de las llamadas

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 algunos casos, es posible que el Round(Double) método no parezca redondear los valores de punto medio al entero par más cercano. En el ejemplo siguiente, dado que el valor de punto flotante .1 no tiene ninguna representación binaria finita, la primera llamada al Round(Double) método con un valor de 11,5 devuelve 11 en lugar de 12.

using System;

public class Example
{
   public static void Main()
   {
      double value = 11.1;
      for (int ctr = 0; ctr <= 5; ctr++)
         value = RoundValueAndAdd(value);

      Console.WriteLine();

      value = 11.5;
      RoundValueAndAdd(value);
   }

   private static double RoundValueAndAdd(double value)
   {
      Console.WriteLine("{0} --> {1}", value, Math.Round(value));
      return value + .1;
   }
}
// The example displays the following output:
//       11.1 --> 11
//       11.2 --> 11
//       11.3 --> 11
//       11.4 --> 11
//       11.5 --> 11
//       11.6 --> 12
//
//       11.5 --> 12

open System

let roundValueAndAdd (value: float) =
    printfn $"{value} --> {Math.Round value}"
    value + 0.1

let mutable value = 11.1

for _ = 0 to 5 do
    value <- roundValueAndAdd value

printfn ""

value <- 11.5
roundValueAndAdd value
|> ignore

// The example displays the following output:
//       11.1 --> 11
//       11.2 --> 11
//       11.3 --> 11
//       11.4 --> 11
//       11.5 --> 11
//       11.6 --> 12
//
//       11.5 --> 12

Module Example
   Public Sub Main()
      Dim value As Double = 11.1
      For ctr As Integer = 0 To 5    
         value = RoundValueAndAdd(value)
      Next
      Console.WriteLine()

      value = 11.5
      RoundValueAndAdd(value)
   End Sub
   
   Private Function RoundValueAndAdd(value As Double) As Double
      Console.WriteLine("{0} --> {1}", value, Math.Round(value))
      Return value + .1
   End Function   
End Module
' The example displays the following output:
'       11.1 --> 11
'       11.2 --> 11
'       11.3 --> 11
'       11.4 --> 11
'       11.5 --> 11
'       11.6 --> 12
'       
'       11.5 --> 12

Consulte también

• Ceiling(Double)
• Floor(Double)
• Round(Decimal)

Round(Decimal)

Source:

Math.cs

Redondea un valor decimal al valor entero más cercano y los valores de punto medio al número par más cercano.

public:
 static System::Decimal Round(System::Decimal d);

public static decimal Round (decimal d);

static member Round : decimal -> decimal

Public Shared Function Round (d As Decimal) As Decimal

Parámetros

d

Decimal

Número decimal que se va a redondear.

Devoluciones

Decimal

El entero más cercano al parámetro d. Si el componente fraccionario de d se encuentra en medio del intervalo entre dos números, uno par y el otro impar, se devuelve el número impar. Tenga en cuenta que este método devuelve un valor Decimal en lugar de un tipo entero.

Excepciones

OverflowException

El resultado está fuera del intervalo de Decimal.

Ejemplos

En el siguiente ejemplo se muestra el Round(Decimal) método. El Decimal valor de 4,5 redondea a 4 en lugar de 5, porque esta sobrecarga usa la convención predeterminada ToEven .

for (decimal value = 4.2m; value <= 4.8m; value+=.1m )
   Console.WriteLine("{0} --> {1}", value, Math.Round(value));
// The example displays the following output:
//       4.2 --> 4
//       4.3 --> 4
//       4.4 --> 4
//       4.5 --> 4
//       4.6 --> 5
//       4.7 --> 5
//       4.8 --> 5

open System

for value in 4.2m .. 0.1m .. 4.8m do
    printfn $"{value} --> {Math.Round value}"
// The example displays the following output:
//       4.2 --> 4
//       4.3 --> 4
//       4.4 --> 4
//       4.5 --> 4
//       4.6 --> 5
//       4.7 --> 5
//       4.8 --> 5

Module Example
   Public Sub Main()
      For value As Decimal = 4.2d To 4.8d Step .1d
         Console.WriteLine("{0} --> {1}", value, Math.Round(value))
      Next   
   End Sub                                                                 
End Module
' The example displays the following output:
'       4.2 --> 4
'       4.3 --> 4
'       4.4 --> 4
'       4.5 --> 4
'       4.6 --> 5
'       4.7 --> 5
'       4.8 --> 5

Comentarios

Este método usa la convención de redondeo predeterminada de MidpointRounding.ToEven. Para obtener información sobre el redondeo de números con valores de punto medio, vea Valores de punto medio y convenciones de redondeo.

Importante

Cuando se redondean los valores de punto medio, el algoritmo de redondeo realiza una prueba de igualdad. Debido a problemas de representación binaria y de precisión en el formato de punto flotante, es posible que el valor que el método devuelva no sea el esperado. Para obtener más información, consulte Redondeo y precisión.

Consulte también

• Ceiling(Double)
• Floor(Double)
• Round(Decimal)

Round(Decimal, MidpointRounding)

Source:

Math.cs

Redondea un valor decimal un entero utilizando la convención de redondeo especificada.

public:
 static System::Decimal Round(System::Decimal d, MidpointRounding mode);

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

static member Round : decimal * MidpointRounding -> decimal

Public Shared Function Round (d As Decimal, mode As MidpointRounding) As Decimal

Parámetros

d

Decimal

Número decimal que se va a redondear.

mode

MidpointRounding

Uno de los valores de enumeración que especifica qué estrategia de redondeo se va a usar.

Devoluciones

Decimal

Entero al que d se redondea. Este método devuelve un Decimal en lugar de un tipo entero.

Excepciones

ArgumentException

mode no es un valor válido de MidpointRounding.

OverflowException

El resultado está fuera del intervalo de Decimal.

Comentarios

Para obtener información sobre el redondeo de números con valores de punto medio, vea Valores de punto medio y convenciones de redondeo.

Importante

Cuando se redondean los valores de punto medio, el algoritmo de redondeo realiza una prueba de igualdad. Debido a problemas de representación binaria y de precisión en el formato de punto flotante, es posible que el valor que el método devuelva no sea el esperado. Para obtener más información, consulte Redondeo y precisión.

Ejemplo

En el ejemplo siguiente se muestran los valores devueltos por el Round(Decimal, MidpointRounding) método con valores diferentes mode .

Console.WriteLine($"{"Value",-10} {"Default",-10} {"ToEven",-10} {"AwayFromZero",-15} {"ToZero",-15}");
for (decimal value = 12.0m; value <= 13.0m; value += 0.1m)
    Console.WriteLine($"{value,-10} {Math.Round(value),-10} " +
        $"{Math.Round(value, MidpointRounding.ToEven),-10} " +
        $"{Math.Round(value, MidpointRounding.AwayFromZero),-15} " +
        $"{Math.Round(value, MidpointRounding.ToZero),-15}");

// The example displays the following output:
//       Value      Default    ToEven     AwayFromZero    ToZero
//       12.0       12         12         12              12
//       12.1       12         12         12              12
//       12.2       12         12         12              12
//       12.3       12         12         12              12
//       12.4       12         12         12              12
//       12.5       12         12         13              12
//       12.6       13         13         13              12
//       12.7       13         13         13              12
//       12.8       13         13         13              12
//       12.9       13         13         13              12
//       13.0       13         13         13              13

printfn $"""{"Value",-10} {"Default",-10} {"ToEven",-10} {"AwayFromZero",-15} {"ToZero",-15}"""
for value in 12m .. 0.1m .. 13m do
    printfn "%-10O %-10O %-10O %-15O %-15O" 
        value
        (Math.Round value)
        (Math.Round(value, MidpointRounding.ToEven))
        (Math.Round(value, MidpointRounding.AwayFromZero))
        (Math.Round(value, MidpointRounding.ToZero))

// The example displays the following output:
//       Value      Default    ToEven     AwayFromZero    ToZero
//       12.0       12         12         12              12
//       12.1       12         12         12              12
//       12.2       12         12         12              12
//       12.3       12         12         12              12
//       12.4       12         12         12              12
//       12.5       12         12         13              12
//       12.6       13         13         13              12
//       12.7       13         13         13              12
//       12.8       13         13         13              12
//       12.9       13         13         13              12
//       13.0       13         13         13              13

Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15} {4,-15}", "Value", "Default",
                "ToEven", "AwayFromZero", "ToZero")
For value As Decimal = 12D To 13D Step 0.1D
    Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15} {4,-15}",
                   value, Math.Round(value),
                   Math.Round(value, MidpointRounding.ToEven),
                   Math.Round(value, MidpointRounding.AwayFromZero),
                   Math.Round(value, MidpointRounding.ToZero))
Next

' The example displays the following output:
'       Value      Default    ToEven     AwayFromZero     ToZero
'       12         12         12         12               12
'       12.1       12         12         12               12
'       12.2       12         12         12               12
'       12.3       12         12         12               12
'       12.4       12         12         12               12
'       12.5       12         12         13               12
'       12.6       13         13         13               12
'       12.7       13         13         13               12
'       12.8       13         13         13               12
'       12.9       13         13         13               12
'       13.0       13         13         13               13

Consulte también

• Ceiling(Double)
• Floor(Double)
• Round(Decimal, MidpointRounding)