Math.Round Metodo

Definizione

Spazio dei nomi:: System

Assembly:: mscorlib.dll, System.Runtime.Extensions.dll

Assembly:: netstandard.dll, System.Runtime.dll

Assembly:: System.Runtime.Extensions.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

Nome	Descrizione
Round(Double, Int32, MidpointRounding)	Arrotonda un valore a virgola mobile e precisione doppia a un numero specificato di cifre frazionarie usando la convenzione di arrotondamento specificata.
Round(Decimal, Int32, MidpointRounding)	Arrotonda un valore decimale a un numero specificato di cifre frazionarie usando la convenzione di arrotondamento specificata.
Round(Double, MidpointRounding)	Arrotonda un valore a virgola mobile e precisione doppia a un intero usando la convenzione di arrotondamento specificata.
Round(Double, Int32)	Arrotonda un valore a virgola mobile e precisione doppia a un numero specificato di cifre frazionarie e arrotonda i valori del punto medio al numero pari più vicino.
Round(Decimal, Int32)	Arrotonda un valore decimale a un numero specificato di cifre frazionarie e arrotonda i valori del punto medio 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 del punto medio al numero pari più vicino.
Round(Decimal)	Arrotonda un valore decimale al valore integrale più vicino e arrotonda i valori del punto medio 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 , sono disponibili esempi in ogni overload del Math.Round metodo .

Commenti

In questa sezione:

Quale metodo chiamare?
Valori del punto intermedio e convenzioni di arrotondamento
Arrotondamento e precisione
Arrotondamento e valori a virgola mobile a precisione singola

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.

Ora di fine	Call
Arrotondare un numero a un numero intero usando la convenzione di arrotondamento più vicino.	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 alla 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 in Single e Decimal chiamare Round(Decimal, Int32, MidpointRounding).
Arrotondare un numero a un numero specificato di cifre frazionarie riducendo al minimo i problemi di precisione nell'arrotondamento dei valori del punto intermedio.	Chiamare un metodo di arrotondamento che implementa un confronto "maggiore o approssimativamente uguale a". Vedere Arrotondamento e precisione.
Arrotondare un valore frazionaria a un numero intero maggiore del valore frazionaria. Ad esempio, arrotondare da 3,1 a 4.	Ceiling
Arrotondare un valore frazionaria a un numero intero minore del valore frazionaria. Ad esempio, arrotondare da 3,9 a 3.	Floor

Valori del punto intermedio 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 compreso tra 3,4 e 3,0 e il Round(Double, Int32) metodo per arrotondare un valore compreso tra 3,579 e 3,58.

In un valore medio, il valore dopo la cifra meno significativa nel risultato è esattamente a metà strada tra due numeri. Ad esempio, 3.47500 è un valore di punto intermedio se deve essere arrotondato a due posizioni decimali e 7,500 è un valore di punto intermedio se deve essere arrotondato a un numero 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 del punto intermedio:

Arrotondamento da zero

I valori del punto intermedio 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 al più vicino, o arrotondamento del banchiere

I valori del punto intermedio vengono arrotondati al numero pari più vicino. Ad esempio, sia 3,75 che 3,85 arrotondamento a 3,8 e -3,75 e -3,85 a -3,8. Questa forma di arrotondamento è rappresentata dal MidpointRounding.ToEven membro di enumerazione .

Note

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 del punto intermedio così 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 allo standard IEEE 754, sezione 4. Se usato in più operazioni di arrotondamento, l'arrotondamento al più vicino riduce anche l'errore di arrotondamento costante dei valori del punto intermedio in una singola direzione. In alcuni casi, questo errore di arrotondamento può essere significativo.

Nell'esempio seguente viene illustrata la distorsione che può derivare dall'arrotondamento coerente dei valori del punto intermedio in una singola direzione. Nell'esempio viene calcolata la media vera di una matrice di Decimal valori e quindi viene calcolata la media quando i valori nella matrice vengono arrotondati usando le due convenzioni. In questo esempio, la media vera e la media che determina l'arrotondamento al più vicino sono uguali. Tuttavia, la media che determina l'arrotondamento da zero è diversa da 05 (o da 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 la convenzione di arrotondamento per raggiungere la convenzione pari più vicina. Nella tabella seguente sono elencati gli overload del Round metodo e la convenzione di arrotondamento usati da ognuno di essi.

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 prevede un valore di punto intermedio, il Round metodo moltiplica il valore originale da arrotondare 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 di un test di uguaglianza e, come illustrato nella sezione "Testing for Equality" dell'argomento Double di riferimento, i test per verificare l'uguaglianza con i valori a virgola mobile sono problematici a causa dei problemi del formato a virgola mobile con la rappresentazione binaria e la precisione. Ciò significa che qualsiasi parte frazionaria di un numero leggermente inferiore a 5 (a causa di una perdita di precisione) non verrà arrotondata verso l'alto.

Nell'esempio seguente viene illustrato il problema. Aggiunge ripetutamente .1 a 11.0 e arrotonda il risultato all'intero più vicino. 11.5 deve arrotondare a 12 usando una delle convenzioni di arrotondamento intermedio (ToEven o AwayFromZero). Tuttavia, come mostra l'output dell'esempio, non lo è. 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 arrotondare ha perso precisione durante le aggiunte ripetute e il relativo valore è effettivamente 11,499999999999999999998. Poiché .499999999999998 è minore di .5, le convenzioni di arrotondamento intermedio non vengono in gioco e il valore viene arrotondato per difetto. Come illustrato 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 nell'arrotondamento dei valori del punto medio sono molto probabili nelle condizioni seguenti:

Quando un valore frazionario non può essere espresso esattamente nel formato binario del tipo a virgola mobile.
Quando il valore da arrotondare viene calcolato da una o più operazioni a virgola mobile.
Quando il valore da arrotondare è piuttosto Single che un Double oggetto o Decimal. Per altre informazioni, vedere la sezione successiva, arrotondamento e 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 in Double un Decimal valore e chiamare un overload che arrotonda un Decimal 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 arrotondare è accettatamente vicino a un valore medio. Nell'esempio seguente viene definito un RoundApproximate metodo che esamina se un valore frazionario è sufficientemente vicino a un valore di punto medio da essere soggetto all'arrotondamento a metà punto. Come illustrato nell'output dell'esempio, corregge il problema di arrotondamento illustrato 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 e 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 valore Single a uno degli overload del metodo Round, viene eseguito il cast (in C#) o convertito (in Visual Basic) in un Double e viene chiamato l'overload Round corrispondente con un parametro Double. Anche se si tratta di una conversione più ampia, spesso comporta una perdita di precisione, come illustrato nell'esempio seguente. Quando un Single valore 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 oggetto Double. Poiché il valore risultante Double di 16,325000762939453 non è un valore medio 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 a icona o eliminata eseguendo il cast o convertendo il Single valore in un oggetto Decimal. Si noti che, poiché si tratta di una conversione di tipo narrowing, è necessario usare un operatore cast o chiamare un metodo di conversione.

Round(Double, Int32, MidpointRounding)

Origine:: Math.cs

Origine:: Math.cs

Origine:: Math.cs

Origine:: Math.cs

Origine:: Math.cs

Arrotonda un valore a virgola mobile e precisione doppia a un numero specificato di cifre frazionarie usando 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 utilizzare.

Valori restituiti

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 midpoint e convenzioni di arrotondamento .

Importante

Quando si arrotondano i valori del punto intermedio, l'algoritmo di arrotondamento esegue un test di uguaglianza. A causa di problemi di rappresentazione binaria e 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 apparire 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 soffre di 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)

Origine:: Math.cs

Origine:: Math.cs

Origine:: Math.cs

Origine:: Math.cs

Origine:: Math.cs

Arrotonda un valore decimale a un numero specificato di cifre frazionarie usando 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 utilizzare.

Valori restituiti

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

Origine:: Math.cs

Origine:: Math.cs

Origine:: Math.cs

Origine:: Math.cs

Origine:: Math.cs

Arrotonda un valore a virgola mobile e precisione doppia a un intero usando 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 utilizzare.

Valori restituiti

Double

Intero value arrotondato a. Questo metodo restituisce un oggetto Double 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 midpoint 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 su valori a virgola mobile, in alcuni casi il Round(Double, MidpointRounding) metodo potrebbe non apparire 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)

Origine:: Math.cs

Origine:: Math.cs

Origine:: Math.cs

Origine:: Math.cs

Origine:: Math.cs

Arrotonda un valore a virgola mobile e precisione doppia a un numero specificato di cifre frazionarie e arrotonda i valori del punto medio 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.

Valori restituiti

Double

Numero più vicino a value che contiene un numero di cifre frazionarie uguali 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 midpoint e convenzioni di arrotondamento .

Importante

Esempio

Nell'esempio seguente vengono arrotondati 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

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 su valori a virgola mobile, in alcuni casi il Round(Double, Int32) metodo potrebbe non apparire 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 soffre di 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)

Origine:: Math.cs

Origine:: Math.cs

Origine:: Math.cs

Origine:: Math.cs

Origine:: Math.cs

Arrotonda un valore decimale a un numero specificato di cifre frazionarie e arrotonda i valori del punto medio 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.

Valori restituiti

Decimal

Numero più vicino a d che contiene un numero di cifre frazionarie uguali 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ò variare da 0 a 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 a 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)

Origine:: Math.cs

Origine:: Math.cs

Origine:: Math.cs

Origine:: Math.cs

Origine:: Math.cs

Arrotonda un valore a virgola mobile e precisione doppia al valore integrale più vicino e arrotonda i valori del punto medio 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.

Valori restituiti

Double

Intero più avicino. Se il componente frazionaria di a è a metà tra due interi, uno dei quali è pari e l'altro dispari, viene restituito il numero pari. Si noti che questo metodo restituisce un oggetto 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 rispettivamente o Double.NegativeInfinity.

A partire da Visual Basic 15.8, le prestazioni della conversione da double a integer vengono ottimizzate se si passa il valore restituito dal metodo Round a uno qualsiasi delle funzioni di conversione integral oppure se il valore Double restituito da Round viene convertito automaticamente in un intero con Option Strict impostato su Off. Questa ottimizzazione consente l'esecuzione del codice più veloce, fino al doppio del doppio per il codice che esegue un numero elevato di conversioni in tipi integer. L'esempio seguente illustra tali 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.

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ò derivare dalla rappresentazione di valori decimali come numeri a virgola mobile o dall'esecuzione di operazioni aritmetiche su valori a virgola mobile, in alcuni casi il Round(Double) metodo potrebbe non apparire 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));
      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)

Origine:: Math.cs

Origine:: Math.cs

Origine:: Math.cs

Origine:: Math.cs

Origine:: Math.cs

Arrotonda un valore decimale al valore integrale più vicino e arrotonda i valori del punto medio 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.

Valori restituiti

Decimal

Intero più vicino al d parametro. Se il componente frazionaria di d è a metà tra due interi, uno dei quali è pari e l'altro dispari, viene restituito il numero pari. Si noti che questo metodo restituisce un oggetto 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 arrotonda 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)

Origine:: Math.cs

Origine:: Math.cs

Origine:: Math.cs

Origine:: Math.cs

Origine:: Math.cs

Arrotonda un valore decimale un numero intero utilizzando 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 utilizzare.

Valori restituiti

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 seguente vengono visualizzati i valori restituiti dal Round(Decimal, MidpointRounding) 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

Commenti e suggerimenti

Questa pagina è stata utile?