# Decimal.Round Method

## Definition

Rounds a value to the nearest integer or specified number of decimal places.

 Round(Decimal, Int32, MidpointRounding) Rounds a decimal value to the specified precision using the specified rounding strategy. Round(Decimal, MidpointRounding) Rounds a decimal value to an integer using the specified rounding strategy. Round(Decimal) Rounds a decimal value to the nearest integer. Round(Decimal, Int32) Rounds a Decimal value to a specified number of decimal places.

## Round(Decimal, Int32, MidpointRounding)

Source:
Decimal.cs
Source:
Decimal.cs
Source:
Decimal.cs

Rounds a decimal value to the specified precision using the specified rounding strategy.

public:
static System::Decimal Round(System::Decimal d, int decimals, MidpointRounding mode);
public:
static System::Decimal Round(System::Decimal d, int decimals, MidpointRounding mode) = System::Numerics::IFloatingPoint<System::Decimal>::Round;
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

#### Parameters

d
Decimal

A decimal number to round.

decimals
Int32

The number of significant decimal places (precision) in the return value.

mode
MidpointRounding

One of the enumeration values that specifies which rounding strategy to use.

#### Returns

The number that d is rounded to using the mode rounding strategy and with a precision of decimals. If the precision of d is less than decimals, d is returned unchanged.

#### Exceptions

decimals is less than 0 or greater than 28.

mode is not a MidpointRounding value.

The result is outside the range of a Decimal object.

### Examples

The following example demonstrates how to use the Round(Decimal, Int32, MidpointRounding) method with the MidpointRounding enumeration.

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


### Remarks

The decimals parameter specifies the number of significant decimal places in the return value and ranges from 0 to 28. If decimals is zero, an integer is returned.

If you specify ToEven or AwayFromZero for the mode parameter, those rounding strategies are only applied for midpoint values, that is, values whose least significant digit is 5.

## Round(Decimal, MidpointRounding)

Source:
Decimal.cs
Source:
Decimal.cs
Source:
Decimal.cs

Rounds a decimal value to an integer using the specified rounding strategy.

public:
static System::Decimal Round(System::Decimal d, MidpointRounding mode);
public:
static System::Decimal Round(System::Decimal d, MidpointRounding mode) = System::Numerics::IFloatingPoint<System::Decimal>::Round;
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

#### Parameters

d
Decimal

A decimal number to round.

mode
MidpointRounding

One of the enumeration values that specifies which rounding strategy to use.

#### Returns

The integer that d is rounded to using the mode rounding strategy.

#### Exceptions

mode is not a MidpointRounding value.

The result is outside the range of a Decimal object.

### Examples

The following example displays values returned by the Round(Decimal, MidpointRounding) method with different mode arguments.

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


### Remarks

If you specify ToEven or AwayFromZero for the mode parameter, those rounding strategies are only applied for midpoint values, that is, values whose least significant digit is 5.

## Round(Decimal)

Source:
Decimal.cs
Source:
Decimal.cs
Source:
Decimal.cs

Rounds a decimal value to the nearest integer.

public:
static System::Decimal Round(System::Decimal d);
public:
static System::Decimal Round(System::Decimal d) = System::Numerics::IFloatingPoint<System::Decimal>::Round;
public static decimal Round (decimal d);
static member Round : decimal -> decimal
Public Shared Function Round (d As Decimal) As Decimal

#### Parameters

d
Decimal

A decimal number to round.

#### Returns

The integer that is nearest to the d parameter. If d is halfway between two integers, one of which is even and the other odd, the even number is returned.

#### Exceptions

The result is outside the range of a Decimal value.

### Examples

The following example rounds a range of Decimal values between 100 and 102 to the nearest integer. Because the method uses banker's rounding, 100.5 rounds to 100 and 101.5 rounds to 102.

using System;

public class Example
{
public static void Main()
{
for (decimal value = 100m; value <= 102m; value += .1m)
Console.WriteLine("{0} --> {1}", value, Decimal.Round(value));
}
}
// The example displays the following output:
//     100 --> 100
//     100.1 --> 100
//     100.2 --> 100
//     100.3 --> 100
//     100.4 --> 100
//     100.5 --> 100
//     100.6 --> 101
//     100.7 --> 101
//     100.8 --> 101
//     100.9 --> 101
//     101.0 --> 101
//     101.1 --> 101
//     101.2 --> 101
//     101.3 --> 101
//     101.4 --> 101
//     101.5 --> 102
//     101.6 --> 102
//     101.7 --> 102
//     101.8 --> 102
//     101.9 --> 102
//     102.0 --> 102

open System

for value in 100m .. 0.1m .. 102m do
printfn $"{value} --> {Decimal.Round value}" // The example displays the following output: // 100 --> 100 // 100.1 --> 100 // 100.2 --> 100 // 100.3 --> 100 // 100.4 --> 100 // 100.5 --> 100 // 100.6 --> 101 // 100.7 --> 101 // 100.8 --> 101 // 100.9 --> 101 // 101.0 --> 101 // 101.1 --> 101 // 101.2 --> 101 // 101.3 --> 101 // 101.4 --> 101 // 101.5 --> 102 // 101.6 --> 102 // 101.7 --> 102 // 101.8 --> 102 // 101.9 --> 102 // 102.0 --> 102  Module Example Public Sub Main() For value As Decimal = 100d To 102d Step .1d Console.WriteLine("{0} --> {1}", value, Decimal.Round(value)) Next End Sub End Module ' The example displays the following output: ' 100 --> 100 ' 100.1 --> 100 ' 100.2 --> 100 ' 100.3 --> 100 ' 100.4 --> 100 ' 100.5 --> 100 ' 100.6 --> 101 ' 100.7 --> 101 ' 100.8 --> 101 ' 100.9 --> 101 ' 101.0 --> 101 ' 101.1 --> 101 ' 101.2 --> 101 ' 101.3 --> 101 ' 101.4 --> 101 ' 101.5 --> 102 ' 101.6 --> 102 ' 101.7 --> 102 ' 101.8 --> 102 ' 101.9 --> 102 ' 102.0 --> 102  ### Remarks The behavior of this method follows IEEE Standard 754, section 4. This kind of rounding is sometimes called round half to even or banker's rounding. It minimizes rounding errors that result from consistently rounding a midpoint value in a single direction. It is equivalent to calling the Round(Decimal, MidpointRounding) method with a mode argument of MidpointRounding.ToEven. ### See also ### Applies to ## Round(Decimal, Int32) Source: Decimal.cs Source: Decimal.cs Source: Decimal.cs Rounds a Decimal value to a specified number of decimal places. public: static System::Decimal Round(System::Decimal d, int decimals); public: static System::Decimal Round(System::Decimal d, int decimals) = System::Numerics::IFloatingPoint<System::Decimal>::Round; 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 #### Parameters d Decimal A decimal number to round. decimals Int32 A value from 0 to 28 that specifies the number of decimal places to round to. #### Returns The decimal number equivalent to d rounded to decimals decimal places. #### Implements #### Exceptions decimals is not a value from 0 to 28. ### Examples The following example rounds several Decimal values to a specified number of decimal places using the Round method. using System; class Example12 { public static void Main() { // Define a set of Decimal values. decimal[] values = { 1.45m, 1.55m, 123.456789m, 123.456789m, 123.456789m, -123.456m, new Decimal(1230000000, 0, 0, true, 7 ), new Decimal(1230000000, 0, 0, true, 7 ), -9999999999.9999999999m, -9999999999.9999999999m }; // Define a set of integers to for decimals argument. int[] decimals = { 1, 1, 4, 6, 8, 0, 3, 11, 9, 10}; Console.WriteLine("{0,26}{1,8}{2,26}", "Argument", "Digits", "Result" ); Console.WriteLine("{0,26}{1,8}{2,26}", "--------", "------", "------" ); for (int ctr = 0; ctr < values.Length; ctr++) Console.WriteLine("{0,26}{1,8}{2,26}", values[ctr], decimals[ctr], Decimal.Round(values[ctr], decimals[ctr])); } } // The example displays the following output: // Argument Digits Result // -------- ------ ------ // 1.45 1 1.4 // 1.55 1 1.6 // 123.456789 4 123.4568 // 123.456789 6 123.456789 // 123.456789 8 123.456789 // -123.456 0 -123 // -123.0000000 3 -123.000 // -123.0000000 11 -123.0000000 // -9999999999.9999999999 9 -10000000000.000000000 // -9999999999.9999999999 10 -9999999999.9999999999  open System // Define a set of Decimal values. let values = [ 1.45m; 1.55m; 123.456789m; 123.456789m 123.456789m; -123.456m Decimal(1230000000, 0, 0, true, 7uy) Decimal(1230000000, 0, 0, true, 7uy) -9999999999.9999999999m -9999999999.9999999999m ] // Define a set of integers to for decimals argument. let decimals = [ 1; 1; 4; 6; 8; 0; 3; 11; 9; 10 ] printfn$"""{"Argument",26}{"Digits",8}{"Result",26}"""
printfn $"""{"--------",26}{"------",8}{"------",26}""" for i = 0 to values.Length - 1 do printfn$"{values[i],26}{decimals[i],8}{Decimal.Round(values[i], decimals[i]),26}"

// The example displays the following output:
//                   Argument  Digits                    Result
//                   --------  ------                    ------
//                       1.45       1                       1.4
//                       1.55       1                       1.6
//                 123.456789       4                  123.4568
//                 123.456789       6                123.456789
//                 123.456789       8                123.456789
//                   -123.456       0                      -123
//               -123.0000000       3                  -123.000
//               -123.0000000      11              -123.0000000
//     -9999999999.9999999999       9    -10000000000.000000000
//     -9999999999.9999999999      10    -9999999999.9999999999

Public Module Example
Public Sub Main()
' Define a set of Decimal values.
Dim values() As Decimal = { 1.45d, 1.55d, 123.456789d, 123.456789d,
123.456789d, -123.456d,
New Decimal(1230000000, 0, 0, true, 7 ),
New Decimal(1230000000, 0, 0, true, 7 ),
-9999999999.9999999999d,
-9999999999.9999999999d }
' Define a set of integers to for decimals argument.
Dim decimals() As Integer = { 1, 1, 4, 6, 8, 0, 3, 11, 9, 10}

Console.WriteLine("{0,26}{1,8}{2,26}",
"Argument", "Digits", "Result" )
Console.WriteLine("{0,26}{1,8}{2,26}",
"--------", "------", "------" )
For ctr As Integer = 0 To values.Length - 1
Console.WriteLine("{0,26}{1,8}{2,26}",
values(ctr), decimals(ctr),
Decimal.Round(values(ctr), decimals(ctr)))
Next
End Sub
End Module
' The example displays the following output:
'                   Argument  Digits                    Result
'                   --------  ------                    ------
'                       1.45       1                       1.4
'                       1.55       1                       1.6
'                 123.456789       4                  123.4568
'                 123.456789       6                123.456789
'                 123.456789       8                123.456789
'                   -123.456       0                      -123
'               -123.0000000       3                  -123.000
'               -123.0000000      11              -123.0000000
'     -9999999999.9999999999       9    -10000000000.000000000
'     -9999999999.9999999999      10    -9999999999.9999999999


### Remarks

This method is equivalent to calling the Round(Decimal, Int32, MidpointRounding) method with a mode argument of MidpointRounding.ToEven. When d is exactly halfway between two rounded values, the result is the rounded value that has an even digit in the far right decimal position. For example, when rounded to two decimals, the value 2.345 becomes 2.34 and the value 2.355 becomes 2.36. This process is known as rounding toward even, or banker's rounding. It minimizes rounding errors that result from consistently rounding a midpoint value in a single direction.