Math.Round Metodo

Riferimento

Definizione

Spazio dei nomi:: System

Assembly:: System.Runtime.Extensions.dll

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Arrotonda un valore all'intero più vicino o al numero specificato di cifre frazionarie.

Overload

Round(Double, Int32, MidpointRounding)	Arrotonda un valore a virgola mobile e precisione doppia a un numero specificato di cifre frazionarie utilizzando la convenzione di arrotondamento specificata.
Round(Decimal, Int32, MidpointRounding)	Arrotonda un valore decimale a un numero specificato di cifre frazionarie utilizzando la convenzione di arrotondamento specificata.
Round(Double, MidpointRounding)	Arrotonda un valore a virgola mobile e precisione doppia a un numero intero utilizzando la convenzione di arrotondamento specificata.
Round(Double, Int32)	Arrotonda un valore a virgola mobile e precisione doppia del numero di cifre frazionarie specificato e arrotonda i valori che si trovano a metà tra due numeri al numero pari più vicino.
Round(Decimal, Int32)	Arrotonda un valore decimale del numero di cifre frazionarie specificato e arrotonda i valori che si trovano a metà tra due numeri al numero pari più vicino.
Round(Double)	Arrotonda un valore a virgola mobile e precisione doppia al valore integrale più vicino e arrotonda i valori che si trovano a metà tra due numeri al numero pari più vicino.
Round(Decimal)	Arrotonda un valore decimale al valore integrale più vicino e arrotonda i valori che si trovano a metà tra due numeri al numero pari più vicino.
Round(Decimal, MidpointRounding)	Arrotonda un valore decimale un numero intero utilizzando la convenzione di arrotondamento specificata.

Esempio

Oltre agli esempi nella sezione Osservazioni , questo articolo include esempi che illustrano gli overload seguenti del Math.Round metodo :

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)

Commenti

Contenuto della sezione:

Quale metodo chiamare?
Valori midpoint e convenzioni di arrotondamento
Arrotondamento e precisione
Arrotondamento e valori a virgola mobile a precisione singola
Esempi di overload singoli

Quale metodo chiamare?

È possibile usare la tabella seguente per selezionare un metodo di arrotondamento appropriato. Oltre ai Math.Round metodi, include Math.Ceiling anche e Math.Floor.

A	Call
Arrotondare un numero a un numero intero usando la convenzione arrotondamento da arrotondamento.	Round(Decimal) -oppure- Round(Double)
Arrotondare un numero a un numero intero usando una convenzione di arrotondamento specificata.	Round(Decimal, MidpointRounding) -oppure- Round(Double, MidpointRounding)
Arrotondare un numero a un numero specificato di cifre frazionarie usando l'arrotondamento per la convenzione più vicina.	Round(Decimal, Int32) -oppure- Round(Double, Int32)
Arrotondare un numero a un numero specificato di cifre frazionarie usando una convenzione di arrotondamento specificata.	Round(Decimal, Int32, MidpointRounding) -oppure- Round(Double, Int32, MidpointRounding)
Arrotondare un Single valore a un numero specificato di cifre frazionarie usando una convenzione di arrotondamento specificata e riducendo al minimo la perdita di precisione.	Convertire l'oggetto Single in un Decimal oggetto e chiamare Round(Decimal, Int32, MidpointRounding).
Arrotondare un numero a un numero specificato di cifre frazionarie riducendo al minimo i problemi di precisione nei valori a metà punto.	Chiamare un metodo di arrotondamento che implementa un confronto "maggiore o approssimativamente uguale a". Vedere Arrotondamento e precisione.
Arrotondare un valore frazionaria a un intero maggiore del valore frazionaria. Ad esempio, arrotondare da 3,1 a 4.	Ceiling
Arrotondare un valore frazionaria a un intero minore del valore frazionaria. Ad esempio, arrotondare da 3,9 a 3.	Floor

Valori midpoint e convenzioni di arrotondamento

L'arrotondamento comporta la conversione di un valore numerico con una precisione specificata in un valore con minore precisione. Ad esempio, è possibile usare il Round(Double) metodo per arrotondare un valore pari a 3,4 a 3,0 e il Round(Double, Int32) metodo per arrotondare un valore pari a 3,579 a 3,58.

In un valore a metà punto, il valore dopo la cifra meno significativa nel risultato è esattamente metà tra due numeri. Ad esempio, 3.47500 è un valore a metà punto se deve essere arrotondato a due posizioni decimali e 7,500 è un valore a metà punto se deve essere arrotondato a un intero. In questi casi, se viene usata la strategia round-to-near più vicina, il valore più vicino non può essere facilmente identificato senza una convenzione di arrotondamento.

Il Round metodo supporta due convenzioni di arrotondamento per la gestione dei valori midpoint:

Arrotondamento da zero

I valori midpoint vengono arrotondati al numero successivo lontano da zero. Ad esempio, 3,75 round a 3,8, 3,85 round a 3,9, -3,75 round a -3,8 e -3,85 round a -3,9. Questa forma di arrotondamento è rappresentata dal MidpointRounding.AwayFromZero membro di enumerazione.
Arrotondamento verso il più vicino, o il rounding del banchiere

I valori midpoint vengono arrotondati al numero di pari più vicino. Ad esempio, sia 3.75 che 3.85 round su 3.8, e sia -3.75 che -3.85 round to -3.8. Questa forma di arrotondamento è rappresentata dal MidpointRounding.ToEven membro di enumerazione.

Nota

In .NET Core 3.0 e versioni successive sono disponibili tre strategie di arrotondamento aggiuntive tramite l'enumerazione MidpointRounding . Queste strategie vengono usate in tutti i casi, non solo per i valori midpoint come MidpointRounding.ToEven e MidpointRounding.AwayFromZero sono.

L'arrotondamento da zero è la forma più nota di arrotondamento, mentre l'arrotondamento al più vicino è lo standard nelle operazioni finanziarie e statistiche. È conforme a IEEE Standard 754, sezione 4. Se usato in più operazioni di arrotondamento, l'arrotondamento verso il più vicino riduce anche l'errore di arrotondamento costante dei valori a metà punto in una singola direzione. In alcuni casi, questo errore di arrotondamento può essere significativo.

Nell'esempio seguente viene illustrato il pregiudizio che può comportare l'arrotondamento coerente dei valori del punto intermedio in una singola direzione. L'esempio calcola la media vera di una matrice di Decimal valori e quindi calcola la media quando i valori della matrice vengono arrotondati usando le due convenzioni. In questo esempio, la media vera e la media che determina l'arrotondamento verso il più vicino sono uguali. Tuttavia, la media che determina l'arrotondamento da zero differisce da .05 (o dal 3,6%) dalla media vera.

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

Per impostazione predefinita, il Round metodo usa l'arrotondamento per la convenzione di persino più vicina. Nella tabella seguente sono elencati gli overload del Round metodo e la convenzione di arrotondamento usati da ogni oggetto.

Overload	Convenzione di arrotondamento
Round(Decimal)	ToEven
Round(Double)	ToEven
Round(Decimal, Int32)	ToEven
Round(Double, Int32)	ToEven
Round(Decimal, MidpointRounding)	Determinato dal `mode` parametro.
Round(Double, MidpointRounding)	Determinato dal `mode` parametro
Round(Decimal, Int32, MidpointRounding)	Determinato dal `mode` parametro
Round(Double, Int32, MidpointRounding)	Determinato dal `mode` parametro

Arrotondamento e precisione

Per determinare se un'operazione di arrotondamento implica un valore a metà punto, il Round metodo moltiplica il valore originale da arrotondato per 10ⁿ, dove n è il numero desiderato di cifre frazionarie nel valore restituito e quindi determina se la parte frazionaria rimanente del valore è maggiore o uguale a .5. Si tratta di una leggera variazione su un test per l'uguaglianza e come illustrato nella sezione "Testing for Equality" dell'argomento Double di riferimento, i test per l'uguaglianza con i valori a virgola mobile sono problematici a causa dei problemi del formato a virgola mobile con rappresentazione binaria e precisione. Ciò significa che qualsiasi parte frazionaria di un numero che è leggermente minore di .5 (a causa di una perdita di precisione) non verrà arrotondata verso l'alto.

Nell'esempio che segue viene illustrato il problema. Aggiunge ripetutamente .1 a 11.0 e arrotonda il risultato al numero intero più vicino. 11.5 deve arrotondare a 12 usando le convenzioni di arrotondamento medio (ToEven o AwayFromZero). Tuttavia, come illustrato dall'output dell'esempio, non viene visualizzato. L'esempio usa la stringa di formato numerico standard "R" per visualizzare la precisione completa del valore a virgola mobile e mostra che il valore da arrotondato ha perso precisione durante le aggiunte ripetute e il relativo valore è effettivamente 11,49999999999999999999998. Poiché .499999999999998 è minore di .5, le convenzioni di arrotondamento intermedio non vengono in gioco e il valore viene arrotondato verso il basso. Come illustrato anche nell'esempio, questo problema non si verifica se si assegna il valore costante 11.5 a una Double variabile.

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

I problemi di precisione nei valori di arrotondamento medio sono più probabili nelle condizioni seguenti:

Quando un valore frazionato non può essere espresso esattamente nel formato binario del tipo a virgola mobile.
Quando il valore da arrotondato viene calcolato da una o più operazioni a virgola mobile.
Quando il valore da arrotondato è un Single oggetto anziché un Double oggetto o Decimal. Per altre informazioni, vedere la sezione successiva, l'arrotondamento e i valori a virgola mobile a precisione singola.

Nei casi in cui la mancanza di precisione nelle operazioni di arrotondamento è problematica, è possibile eseguire le operazioni seguenti:

Se l'operazione di arrotondamento chiama un overload che arrotonda un Double valore, è possibile modificare l'oggetto Double in un Decimal valore e chiamare un overload che arrotonda Decimal un valore. Anche se il Decimal tipo di dati presenta anche problemi di rappresentazione e perdita di precisione, questi problemi sono molto meno comuni.

Definire un algoritmo di arrotondamento personalizzato che esegue un test "quasi uguale" per determinare se il valore da arrotondato è ampiamente vicino a un valore a metà punto. Nell'esempio seguente viene definito un RoundApproximate metodo che esamina se un valore frazionato è sufficientemente vicino a un valore a metà punto da essere soggetto all'arrotondamento a metà punto. Come illustrato dall'output dell'esempio, corregge il problema di arrotondamento mostrato nell'esempio precedente.

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

Arrotondamento e valori a virgola mobile a precisione singola

Il Round metodo include overload che accettano argomenti di tipo Decimal e Double. Non esistono metodi che arrotondano i valori di tipo Single. Se si passa un Single valore a uno degli overload del Round metodo, viene eseguito il cast (in C#) o convertito (in Visual Basic) in un Doubleoggetto e viene chiamato l'overload corrispondente Round con un Double parametro. Anche se si tratta di una conversione più ampia, spesso comporta una perdita di precisione, come illustrato nell'esempio seguente. Quando un Single valore pari a 16,325 viene passato al Round metodo e arrotondato a due posizioni decimali usando l'arrotondamento alla convenzione più vicina, il risultato è 16,33 e non il risultato previsto di 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

Questo risultato imprevisto è dovuto a una perdita di precisione nella conversione del Single valore in un Doubleoggetto . Poiché il valore risultante Double di 16.3250000762939453 non è un valore a metà punto e è maggiore di 16,325, viene sempre arrotondato verso l'alto.

In molti casi, come illustrato nell'esempio, la perdita di precisione può essere ridotta al minimo o eliminata tramite cast o conversione del Single valore in un Decimaloggetto . Si noti che, poiché si tratta di una conversione ristretta, è necessario usare un operatore cast o chiamare un metodo di conversione.

Round(Double, Int32, MidpointRounding)

Source:: Math.cs

Source:: Math.cs

Source:: Math.cs

Arrotonda un valore a virgola mobile e precisione doppia a un numero specificato di cifre frazionarie utilizzando la convenzione di arrotondamento specificata.

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

Parametri

value: Double

Numero a virgola mobile e precisione doppia da arrotondare.

digits: Int32

Numero di cifre frazionarie nel valore restituito.

mode: MidpointRounding

Uno dei valori di enumerazione che specifica la strategia di arrotondamento da usare.

Restituisce

Double

Numero con digits cifre frazionarie value arrotondate a. Se value ha meno cifre frazionarie di digits, value viene restituito invariato.

Eccezioni

ArgumentOutOfRangeException

digits è minore di 0 o maggiore di 15.

ArgumentException

mode non è un valore valido di MidpointRounding.

Commenti

Il valore dell'argomento digits può variare da 0 a 15. Il numero massimo di cifre integrali e frazionarie supportate dal Double tipo è 15.

Per informazioni sull'arrotondamento dei numeri con valori di punto intermedio, vedere Valori di punto intermedio e convenzioni di arrotondamento .

Importante

Quando si arrotondano valori che si trovano a metà tra due numeri, l'algoritmo di arrotondamento esegue un test di uguaglianza. A causa di problemi della rappresentazione binaria e della precisione nel formato a virgola mobile, il valore restituito dal metodo può essere imprevisto. Per altre informazioni, vedere Arrotondamento e precisione.

Se il valore dell'argomento value è Double.NaN, il metodo restituisce Double.NaN. Se value è Double.PositiveInfinity o Double.NegativeInfinity, il metodo restituisce Double.PositiveInfinity rispettivamente o Double.NegativeInfinity.

Esempio

Nell'esempio seguente viene illustrato come utilizzare il Round(Double, Int32, MidpointRounding) metodo con l'enumerazione MidpointRounding .


// 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)

Note per i chiamanti

A causa della perdita di precisione che può derivare dalla rappresentazione di valori decimali come numeri a virgola mobile o dall'esecuzione di operazioni aritmetiche sui valori a virgola mobile, in alcuni casi il Round(Double, Int32, MidpointRounding) metodo potrebbe non sembrare arrotondare i valori del punto intermedio come specificato dal mode parametro . Questo è illustrato nell'esempio seguente, dove 2.135 viene arrotondato a 2.13 anziché a 2.14. Ciò si verifica perché il metodo moltiplica value internamente per 10^cifre e l'operazione di moltiplicazione in questo caso subisce una perdita di precisione.

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

Vedi anche

Si applica a

Round(Decimal, Int32, MidpointRounding)

Source:: Math.cs

Source:: Math.cs

Source:: Math.cs

Arrotonda un valore decimale a un numero specificato di cifre frazionarie utilizzando la convenzione di arrotondamento specificata.

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

Parametri

d: Decimal

Numero decimale da arrotondare.

decimals: Int32

Numero di posizioni decimali nel valore restituito.

mode: MidpointRounding

Uno dei valori di enumerazione che specifica la strategia di arrotondamento da usare.

Restituisce

Decimal

Numero con decimals cifre frazionarie d arrotondate a. Se d ha meno cifre frazionarie di decimals, d viene restituito invariato.

Eccezioni

ArgumentOutOfRangeException

decimals è minore di 0 o maggiore di 28.

ArgumentException

mode non è un valore valido di MidpointRounding.

OverflowException

Il risultato non è compreso nell'intervallo di un oggetto Decimal.

Commenti

Per informazioni sull'arrotondamento dei numeri con valori di punto intermedio, vedere Valori di punto intermedio e convenzioni di arrotondamento .

Importante

Il valore dell'argomento decimals può variare da 0 a 28.

Esempio

Nell'esempio seguente viene illustrato come utilizzare il Round metodo con l'enumerazione MidpointRounding .

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)
'

Vedi anche

Si applica a

Round(Double, MidpointRounding)

Source:: Math.cs

Source:: Math.cs

Source:: Math.cs

Arrotonda un valore a virgola mobile e precisione doppia a un numero intero utilizzando la convenzione di arrotondamento specificata.

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

Parametri

value: Double

Numero a virgola mobile e precisione doppia da arrotondare.

mode: MidpointRounding

Uno dei valori di enumerazione che specifica la strategia di arrotondamento da usare.

Restituisce

Double

Intero value arrotondato a. Questo metodo restituisce un Double oggetto anziché un tipo integrale.

Eccezioni

ArgumentException

mode non è un valore valido di MidpointRounding.

Commenti

Per informazioni sull'arrotondamento dei numeri con valori di punto intermedio, vedere Valori di punto intermedio e convenzioni di arrotondamento .

Importante

Esempio

Nell'esempio seguente vengono visualizzati i valori restituiti dal Round(Double, MidpointRounding) metodo con valori diversi 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

Note per i chiamanti

A causa della perdita di precisione che può derivare dalla rappresentazione di valori decimali come numeri a virgola mobile o dall'esecuzione di operazioni aritmetiche sui valori a virgola mobile, in alcuni casi il Round(Double, MidpointRounding) metodo potrebbe non sembrare arrotondare i valori di punto intermedio al numero intero pari più vicino. Nell'esempio seguente, poiché il valore a virgola mobile .1 non ha una rappresentazione binaria limitata, la prima chiamata al Round(Double) metodo con un valore 11,5 restituisce 11 anziché 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

Vedi anche

Si applica a

Round(Double, Int32)

Source:: Math.cs

Source:: Math.cs

Source:: Math.cs

Arrotonda un valore a virgola mobile e precisione doppia del numero di cifre frazionarie specificato e arrotonda i valori che si trovano a metà tra due numeri al numero pari più vicino.

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

Parametri

value: Double

Numero a virgola mobile e precisione doppia da arrotondare.

digits: Int32

Numero di cifre frazionarie nel valore restituito.

Restituisce

Double

Numero più vicino a value contenente un numero di cifre frazionarie pari a digits.

Eccezioni

ArgumentOutOfRangeException

digits è minore di 0 o maggiore di 15.

Commenti

Il valore dell'argomento digits può variare da 0 a 15. Il numero massimo di cifre integrali e frazionarie supportate dal Double tipo è 15.

Questo metodo usa la convenzione di arrotondamento predefinita di MidpointRounding.ToEven. Per informazioni sull'arrotondamento dei numeri con valori di punto intermedio, vedere Valori di punto intermedio e convenzioni di arrotondamento .

Importante

Esempio

L'esempio seguente arrotonda i valori double con due cifre frazionarie a doppie con una singola cifra frazionaria.

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

Note per i chiamanti

A causa della perdita di precisione che può derivare dalla rappresentazione di valori decimali come numeri a virgola mobile o dall'esecuzione di operazioni aritmetiche sui valori a virgola mobile, in alcuni casi il Round(Double, Int32) metodo potrebbe non sembrare arrotondare i valori di punto intermedio al valore pari più vicino nella digits posizione decimale. Questo è illustrato nell'esempio seguente, dove 2.135 viene arrotondato a 2.13 anziché a 2.14. Ciò si verifica perché il metodo moltiplica value internamente per 10^cifre e l'operazione di moltiplicazione in questo caso subisce una perdita di precisione.

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

Vedi anche

Si applica a

Round(Decimal, Int32)

Source:: Math.cs

Source:: Math.cs

Source:: Math.cs

Arrotonda un valore decimale del numero di cifre frazionarie specificato e arrotonda i valori che si trovano a metà tra due numeri al numero pari più vicino.

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

Parametri

d: Decimal

Numero decimale da arrotondare.

decimals: Int32

Numero di posizioni decimali nel valore restituito.

Restituisce

Decimal

Numero più vicino a d contenente un numero di cifre frazionarie pari a decimals.

Eccezioni

ArgumentOutOfRangeException

decimals è minore di 0 o maggiore di 28.

OverflowException

Il risultato non è compreso nell'intervallo di un oggetto Decimal.

Commenti

Il valore dell'argomento decimals può essere compreso tra 0 e 28.

Questo metodo usa la convenzione di arrotondamento predefinita di MidpointRounding.ToEven. Per informazioni sull'arrotondamento dei numeri con valori midpoint, vedere Valori midpoint e convenzioni di arrotondamento.

Importante

Esempio

Nell'esempio seguente vengono arrotondati i valori decimali con due cifre frazionarie ai valori con una singola cifra frazionaria.

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

Vedi anche

Si applica a

Round(Double)

Source:: Math.cs

Source:: Math.cs

Source:: Math.cs

Arrotonda un valore a virgola mobile e precisione doppia al valore integrale più vicino e arrotonda i valori che si trovano a metà tra due numeri al numero pari più vicino.

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

Parametri

a: Double

Numero a virgola mobile e precisione doppia da arrotondare.

Restituisce

Double

Il a più vicino all'intero. Se il componente frazionario di a è compreso tra due interi, di cui uno è pari e l'altro dispari, allora viene restituito il numero pari. Si noti che questo metodo restituisce Double anziché un tipo integrale.

Commenti

Importante

Se il valore dell'argomento a è Double.NaN, il metodo restituisce Double.NaN. Se a è Double.PositiveInfinity o Double.NegativeInfinity, il metodo restituisce Double.PositiveInfinity o Double.NegativeInfinity, rispettivamente.

A partire da Visual Basic 15.8, le prestazioni della conversione double-to-integer vengono ottimizzate se si passa il valore restituito dal metodo a una delle funzioni di conversione integrale o se il valore Double restituito da RoundRound viene convertito automaticamente in un intero con Option Strict impostato su Off. Questa ottimizzazione consente un'esecuzione più rapida del codice, fino a due volte più rapida nei casi di esecuzione di un numero elevato di conversioni a tipi Integer. Nell'esempio seguente vengono illustrate le conversioni ottimizzate:

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

Esempio

Nell'esempio seguente viene illustrato l'arrotondamento al valore intero più vicino.

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

Note per i chiamanti

A causa della perdita di precisione che può comportare la rappresentazione di valori decimali come numeri a virgola mobile o di esecuzione di operazioni aritmetiche sui valori a virgola mobile, in alcuni casi il Round(Double) metodo potrebbe non apparire arrotondare i valori a punti intermedi al numero intero uniforme più vicino. Nell'esempio seguente, poiché il valore a virgola mobile .1 non ha rappresentazione binaria finita, la prima chiamata al Round(Double) metodo con un valore 11.5 restituisce 11 anziché 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

Vedi anche

Si applica a

Round(Decimal)

Source:: Math.cs

Source:: Math.cs

Source:: Math.cs

Arrotonda un valore decimale al valore integrale più vicino e arrotonda i valori che si trovano a metà tra due numeri al numero pari più vicino.

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

Parametri

d: Decimal

Numero decimale da arrotondare.

Restituisce

Decimal

Intero più vicino al parametro d. Se il componente frazionario di d è a metà fra due interi, uno pari e uno dispari, viene restituito il numero pari. Si noti che questo metodo restituisce Decimal anziché un tipo integrale.

Eccezioni

OverflowException

Il risultato non è compreso nell'intervallo di un oggetto Decimal.

Esempio

Nell'esempio seguente viene illustrato il Round(Decimal) metodo. Il Decimal valore di 4.5 round su 4 anziché 5, perché questo overload usa la convenzione predefinita 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

Commenti

Importante

Vedi anche

Si applica a

Round(Decimal, MidpointRounding)

Source:: Math.cs

Source:: Math.cs

Source:: Math.cs

Arrotonda un valore decimale usando la convenzione di arrotondamento specificata.

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

Parametri

d: Decimal

Numero decimale da arrotondare.

mode: MidpointRounding

Uno dei valori di enumerazione che specifica la strategia di arrotondamento da usare.

Restituisce

Decimal

Intero d arrotondato a. Questo metodo restituisce un oggetto Decimal anziché un tipo integrale.

Eccezioni

ArgumentException

mode non è un valore valido di MidpointRounding.

OverflowException

Il risultato non è compreso nell'intervallo di un oggetto Decimal.

Commenti

Per informazioni sull'arrotondamento dei numeri con valori midpoint, vedere Valori midpoint e convenzioni di arrotondamento.

Importante

Esempio

Nell'esempio Round(Decimal, MidpointRounding) seguente vengono visualizzati i valori restituiti dal metodo con valori diversi 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

Vedi anche

Si applica a

Math.Round Metodo

Definizione

Overload

Esempio

Commenti

Quale metodo chiamare?

Valori midpoint e convenzioni di arrotondamento

Arrotondamento e precisione

Arrotondamento e valori a virgola mobile a precisione singola

Round(Double, Int32, MidpointRounding)

Parametri

Restituisce

Eccezioni

Commenti

Esempio

Note per i chiamanti

Vedi anche

Si applica a

Round(Decimal, Int32, MidpointRounding)

Parametri

Restituisce

Eccezioni

Commenti

Esempio

Vedi anche

Si applica a

Round(Double, MidpointRounding)

Parametri

Restituisce

Eccezioni

Commenti

Esempio

Note per i chiamanti

Vedi anche

Si applica a

Round(Double, Int32)

Parametri

Restituisce

Eccezioni

Commenti

Esempio

Note per i chiamanti

Vedi anche

Si applica a

Round(Decimal, Int32)

Parametri

Restituisce

Eccezioni

Commenti

Esempio

Vedi anche

Si applica a

Round(Double)

Parametri

Restituisce

Commenti

Esempio

Note per i chiamanti

Vedi anche

Si applica a

Round(Decimal)

Parametri

Restituisce

Eccezioni

Esempio

Commenti

Vedi anche

Si applica a

Round(Decimal, MidpointRounding)

Parametri

Restituisce

Eccezioni

Commenti

Esempio

Vedi anche

Si applica a

Commenti e suggerimenti

Risorse aggiuntive