# Decimal.RoundDecimal.RoundDecimal.RoundDecimal.Round Method

## Definition

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

 Round(Decimal) Round(Decimal) Round(Decimal) Round(Decimal) Rounds a decimal value to the nearest integer. Round(Decimal, Int32) Round(Decimal, Int32) Round(Decimal, Int32) Round(Decimal, Int32) Rounds a Decimal value to a specified number of decimal places. Round(Decimal, MidpointRounding) Round(Decimal, MidpointRounding) Round(Decimal, MidpointRounding) Round(Decimal, MidpointRounding) Rounds a decimal value to the nearest integer. A parameter specifies how to round the value if it is midway between two other numbers. Round(Decimal, Int32, MidpointRounding) Round(Decimal, Int32, MidpointRounding) Round(Decimal, Int32, MidpointRounding) Round(Decimal, Int32, MidpointRounding) Rounds a decimal value to a specified precision. A parameter specifies how to round the value if it is midway between two other numbers.

## Round(Decimal)Round(Decimal)Round(Decimal)Round(Decimal)

Rounds a decimal value to the nearest integer.

``````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``

#### Parameters

d
Decimal Decimal Decimal 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, note that 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
``````
``````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.

## Round(Decimal, Int32)Round(Decimal, Int32)Round(Decimal, Int32)Round(Decimal, Int32)

Rounds a Decimal value to a specified number of decimal places.

``````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``

#### Parameters

d
Decimal Decimal Decimal Decimal

A decimal number to round.

decimals
Int32 Int32 Int32 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` number of decimal places.

#### 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 Example
{
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
``````
``````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.

## Round(Decimal, MidpointRounding)Round(Decimal, MidpointRounding)Round(Decimal, MidpointRounding)Round(Decimal, MidpointRounding)

Rounds a decimal value to the nearest integer. A parameter specifies how to round the value if it is midway between two other numbers.

``````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``

#### Parameters

d
Decimal Decimal Decimal Decimal

A decimal number to round.

mode
MidpointRounding MidpointRounding MidpointRounding MidpointRounding

A value that specifies how to round `d` if it is midway between two other numbers.

#### Returns

The integer that is nearest to the `d` parameter. If `d` is halfway between two numbers, one of which is even and the other odd, the `mode` parameter determines which of the two numbers is returned.

#### 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) method, the Round(Decimal, MidpointRounding) method with a `mode` argument of ToEven, and the Round(Decimal, MidpointRounding) method with a `mode` argument of AwayFromZero.

``````Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15}", "Value", "Default",
"ToEven", "AwayFromZero");
for (decimal value = 12.0m; value <= 13.0m; value += 0.1m)
Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15}",
value, Math.Round(value),
Math.Round(value, MidpointRounding.ToEven),
Math.Round(value, MidpointRounding.AwayFromZero));
// The example displays the following output:
//       Value      Default    ToEven     AwayFromZero
//       12         12         12         12
//       12.1       12         12         12
//       12.2       12         12         12
//       12.3       12         12         12
//       12.4       12         12         12
//       12.5       12         12         13
//       12.6       13         13         13
//       12.7       13         13         13
//       12.8       13         13         13
//       12.9       13         13         13
//       13.0       13         13         13
``````
``````Module Example
Public Sub Main()
Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15}", "Value", "Default",
"ToEven", "AwayFromZero")
For value As Decimal = 12.0d To 13.0d Step .1d
Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-15}",
value, Math.Round(value),
Math.Round(value, MidpointRounding.ToEven),
Math.Round(value, MidpointRounding.AwayFromZero))
Next
End Sub
End Module
' The example displays the following output:
'       Value      Default    ToEven     AwayFromZero
'       12         12         12         12
'       12.1       12         12         12
'       12.2       12         12         12
'       12.3       12         12         12
'       12.4       12         12         12
'       12.5       12         12         13
'       12.6       13         13         13
'       12.7       13         13         13
'       12.8       13         13         13
'       12.9       13         13         13
'       13.0       13         13         13
``````

### Remarks

In a midpoint value, the value after the least significant digit in the result is precisely half way between two numbers. For example, 7.5 is a midpoint value if it is to be rounded to an integer. For midpoint values, the nearest value can't be easily identified without a rounding convention, which is specified by the `mode` argument. The Round method supports two rounding conventions for handling midpoint values.

Rounding away from zero.
Midpoint values are rounded to the next number away from zero. For example, 3.5 rounds to 4, 4.5 rounds to 5, -3.5 rounds to -4, and -4.5 rounds to -5. This form of rounding is represented by the MidpointRounding.AwayFromZero enumeration member.

Rounding away from zero is the most widely known form of rounding.

Rounding to even, or banker's rounding
Midpoint values are rounded to the nearest even number. For example, both 3.5 and 4.5 round to 4, and both -3.5 and -4.5 round to -4. This form of rounding is represented by the MidpointRounding.ToEven enumeration member.

Rounding to nearest is the standard form of rounding used in financial and statistical operations. It conforms to IEEE Standard 754, section 4. When used in multiple rounding operations, it reduces the rounding error that is caused by consistently rounding midpoint values in a single direction. In some cases, this rounding error can be significant.

## Round(Decimal, Int32, MidpointRounding)Round(Decimal, Int32, MidpointRounding)Round(Decimal, Int32, MidpointRounding)Round(Decimal, Int32, MidpointRounding)

Rounds a decimal value to a specified precision. A parameter specifies how to round the value if it is midway between two other numbers.

``````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``

#### Parameters

d
Decimal Decimal Decimal Decimal

A decimal number to round.

decimals
Int32 Int32 Int32 Int32

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

mode
MidpointRounding MidpointRounding MidpointRounding MidpointRounding

A value that specifies how to round `d` if it is midway between two other numbers.

#### Returns

The number that is nearest to the `d` parameter with a precision equal to the `decimals` parameter. If `d` is halfway between two numbers, one of which is even and the other odd, the `mode` parameter determines which of the two numbers is returned. 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.

``````// This example demonstrates the Math.Round() method in conjunction
// with the MidpointRounding enumeration.
using namespace System;

void main()
{
Decimal result = (Decimal) 0.0;
Decimal posValue = (Decimal) 3.45;
Decimal negValue = (Decimal) -3.45;

// By default, round a positive and a negative value to the nearest
// even number. The precision of the result is 1 decimal place.
result = 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 to the nearest even number, then to the
// nearest number away from zero. 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);
Console::WriteLine();

// Round a negative value to the nearest even number, then to the
// nearest number away from zero. 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);
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)

*/
``````
``````decimal result = 0.0m;
decimal posValue =  3.45m;
decimal negValue = -3.45m;

// By default, round a positive and a negative value to the nearest even number.
// The precision of the result is 1 decimal place.

result = 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 to the nearest even number, then to the nearest number away from zero.
// 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);
Console.WriteLine();

// Round a negative value to the nearest even number, then to the nearest number away from zero.
// 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);
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)

*/
``````
``````' This example demonstrates the Math.Round() method in conjunction
' with the MidpointRounding enumeration.
Class Sample
Public Shared Sub Main()
Dim result As Decimal = 0D
Dim posValue As Decimal = 3.45D
Dim negValue As Decimal = -3.45D

' By default, round a positive and a negative value to the nearest even number.
' The precision of the result is 1 decimal place.
result = 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 to the nearest even number, then to the nearest number
' away from zero. 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)
Console.WriteLine()

' Round a negative value to the nearest even number, then to the nearest number
' away from zero. 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)
Console.WriteLine()

End Sub
End Class
'
'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)
'
``````

### 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.

In a midpoint value, the value after the least significant digit in the result is precisely half way between two numbers. For example, 3.47500 is a midpoint value if it is to be rounded two decimal places, and 7.500 is a midpoint value if it is to be rounded to an integer. In these cases, the nearest value can't be easily identified without a rounding convention, which is specified by the `mode` argument. The Round(Decimal, Int32, MidpointRounding) method supports two rounding conventions for handling midpoint values.

Rounding away from zero.
Midpoint values are rounded to the next number away from zero. For example, 3.75 rounds to 3.8, 3.85 rounds to 3.9, -3.75 rounds to -3.8, and -3.85 rounds to -3.9. This form of rounding is represented by the MidpointRounding.AwayFromZero enumeration member.

Rounding away from zero is the most widely known form of rounding.

Rounding to even, or banker's rounding
Midpoint values are rounded to the nearest even number. For example, both 3.75 and 3.85 round to 3.8, and both -3.75 and -3.85 round to -3.8. This form of rounding is represented by the MidpointRounding.ToEven enumeration member.

Rounding to nearest is the standard form of rounding used in financial and statistical operations. It conforms to IEEE Standard 754, section 4. When used in multiple rounding operations, it reduces the rounding error that is caused by consistently rounding midpoint values in a single direction. In some cases, this rounding error can be significant.