Math::Round Method
Rounds a value to the nearest integer or to the specified number of fractional digits.
This member is overloaded. For complete information about this member, including syntax, usage, and examples, click a name in the overload list.
Name  Description  

Round(Decimal)  Rounds a decimal value to the nearest integral value.  
Round(Double)  Rounds a doubleprecision floatingpoint value to the nearest integral value.  
Round(Decimal, Int32)  Rounds a decimal value to a specified number of fractional digits.  
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 numbers.  
Round(Double, Int32)  Rounds a doubleprecision floatingpoint value to a specified number of fractional digits.  
Round(Double, MidpointRounding)  Rounds a doubleprecision floatingpoint value to the nearest integer. A parameter specifies how to round the value if it is midway between two numbers.  
Round(Decimal, Int32, MidpointRounding)  Rounds a decimal value to a specified number of fractional digits. A parameter specifies how to round the value if it is midway between two numbers.  
Round(Double, Int32, MidpointRounding)  Rounds a doubleprecision floatingpoint value to a specified number of fractional digits. A parameter specifies how to round the value if it is midway between two numbers. 
In this section:
Overloaded method syntax
Parameters
Return value
Exceptions
Which method do I call?
Midpoint values and rounding conventions
Rounding and precision
Rounding and singleprecision floatingpoint values
Examples:
Math.Round(Decimal)
Math.Round(Double)
Math.Round(Decimal, Int32)
Math.Round(Decimal, MidpointRounding)
Math.Round(Double, Int32)
Math.Round(Double, MidpointRounding)
Math.Round(Decimal, Int32, MidpointRounding)
Math.Round(Double, Int32, MidpointRounding)
Version information
Overloaded method syntax
For additional guidance on choosing an overload, see Which method do I call?
Parameters
This is a complete list of parameters for the Round method. For the parameters used by each overload, see the overload syntax above.
Parameter 
Type 
Description 

d 
A number to be rounded. 

a or value 
A doubleprecision floatingpoint number to be rounded. 

decimals or digits 
The number of fractional digits in the return value. For Decimal values, it can range from 0 to 28. For Double values, it can range from 0 to 15. Note that 15 is the maximum number of integral and fractional digits supported by the Double type. Default value: 0, which rounds to an integer 

mode 
A flag that specifies the convention to use for rounding midpoint values. See Midpoint values and rounding conventions. Default value: MidpointRounding::ToEven 
Return value
Type: Decimal or Double, depending on the type of the value to be rounded.
A numeric value of the same type as d, a, or value, but rounded either to an integer or to the specified number of decimal digits. See Midpoint values and rounding conventions for information about rounding numbers with midpoint values.
Caution 

When rounding midpoint values, the rounding algorithm performs an equality test. Because of problems of binary representation and precision in the floatingpoint format, the value returned by the method can be unexpected. For more information, see Rounding and precision. 
If an overload with a Double parameter is called with Double::NaN, the method returns Double::NaN. If it is called with Double::PositiveInfinity or Double::NegativeInfinity, the method returns Double::PositiveInfinity or Double::NegativeInfinity, respectively.
Exceptions
Exception 
Condition 
Thrown by 

The result is outside the range of the Decimal type. 

decimals is less than 0 or greater than 28. or digits is less than 0 or greater than 15. 

mode is not a valid value of MidpointRounding. 
Round(Decimal, MidpointRounding) Round(Double, MidpointRounding) 
Which method do I call?
To 
Call 

Round a number to an integer by using the rounding to nearest convention. 
or 
Round a number to an integer by using a specified rounding convention. 
Round(Decimal, MidpointRounding) or 
Round a number to a specified number of fractional digits by using the rounding to nearest convention. 
or 
Round a number to a specified number of fractional digits by using a specified rounding convention. 
Round(Decimal, Int32, MidpointRounding) or 
Round a Single value to a specified number of fractional digits by using a specified rounding convention and minimizing the loss of precision. 
Convert the Single to a Decimal and call Round(Decimal, Int32, MidpointRounding). 
Round a number to a specified number of fractional digits while minimizing problems of precision in rounding midpoint values. 
Call a rounding method that implements a "greater than or approximately equal to" comparison. See Rounding and precision. 
Round a fractional value to an integer that is greater than the fractional value. For example, round 3.1 to 4. 

Round a fractional value to an integer that is less than the fractional value. For example, round 3.9 to 3. 
Midpoint values and rounding conventions
Rounding involves converting a numeric value with a specified precision to the nearest value with less precision. For example, you can use the Round(Double) method to round a value of 3.4 to 3.0, and the Round(Double, Int32) method to round a value of 3.579 to 3.58.
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.
The Round method supports two rounding conventions for handling midpoint values:
The following example illustrates the bias that can result from consistently rounding midpoint values in a single direction. The example computes the true mean of an array of Decimal values, and then computes the mean when the values in the array are rounded by using the two conventions. In this example, the true mean and the mean that results when rounding to nearest are the same. However, the mean that results when rounding away from zero differs by .05 (or by 3.6%) from the true mean.
By default, the Round method uses the rounding to nearest convention. The following table lists the overloads of the Round method and the rounding convention that each uses.
Overload 
Rounding convention 

Determined by mode parameter. 

Determined by mode parameter 

Determined by mode parameter 

Determined by mode parameter 
Rounding and precision
In order to determine whether a rounding operation involves a midpoint value, the Round method multiplies the original value to be rounded by 10n, where n is the desired number of fractional digits in the return value, and then determines whether the remaining fractional portion of the value is greater than or equal to .5. This is a slight variation on a test for equality, and as discussed in the "Testing for Equality" section of the Double reference topic, tests for equality with floatingpoint values are problematic because of the floatingpoint format's issues with binary representation and precision. This means that any fractional portion of a number that is slightly less than .5 (because of a loss of precision) will not be rounded upward.
The following example illustrates the problem. It repeatedly adds .1 to 11.0 and rounds the result to the nearest integer. Regardless of the rounding convention, 11.5 should round to 12. However, as the output from the example shows, it does not. The example uses the "R" standard numeric format string to display the floating point value's full precision, and shows that the value to be rounded has lost precision during repeated additions, and its value is actually 11.499999999999998. Because .499999999999998 is less than .5, the value is not rounded to the next highest integer. As the example also shows, this problem does not occur if we simply assign the constant value 11.5 to a Double variable.
Problems of precision in rounding midpoint values are most likely to arise in the following conditions:

When a fractional value cannot be expressed precisely in the floatingpoint type's binary format.

When the value to be rounded is calculated from one or more floatingpoint operations.

When the value to be rounded is a Single rather than a Double or Decimal. For more information, see the next section, Rounding and singleprecision floatingpoint values.
In cases where the lack of precision in rounding operations is problematic, you can do the following:

If the rounding operation calls an overload that rounds a Double value, you can change the Double to a Decimal value and call an overload that rounds a Decimal value instead. Although the Decimal data type also has problems of representation and loss of precision, these issues are far less common.

Define a custom rounding algorithm that performs a "nearly equal" test to determine whether the value to be rounded is acceptably close to a midpoint value. The following example defines a RoundApproximate method that examines whether a fractional value is sufficiently near to a midpoint value to be subject to midpoint rounding. As the output from the example shows, it corrects the rounding problem shown in the previous example.
Rounding and singleprecision floatingpoint values
The Round method includes overloads that accept arguments of type Decimal and Double. There are no methods that round values of type Single. If you pass a Single value to one of the overloads of the Round method, it is cast (in C#) or converted (in Visual Basic) to a Double, and the corresponding Round overload with a Double parameter is called. Although this is a widening conversion, it often involves a loss of precision, as the following example illustrates. When a Single value of 16.325 is passed to the Round method and rounded to two decimal places using the rounding to nearest convention, the result is 16.33 and not the expected result of 16.32.
This unexpected result is due to a loss of precision in the conversion of the Single value to a Double. Because the resulting Double value of 16.325000762939453 is not a midpoint value and is greater than 16.325, it is always rounded upward.
In many cases, as the example illustrates, the loss of precision can be minimized or eliminated by casting or converting the Single value to a Decimal. Note that, because this is a narrowing conversion, it requires using a cast operator or calling a conversion method.
Math.Round(Decimal) example
The following example demonstrates the Round(Decimal) method. Note that the Decimal value of 4.5 rounds to 4 rather than 5, because this overload uses the default ToEven convention.
Math.Round(Double) example
The following example demonstrates rounding to the nearest integer value.
Math.Round(Decimal, Int32) example
The following example rounds decimal values with two fractional digits to values that have a single fractional digit.
Math.Round(Double, Int32) example
The following example rounds double values with two fractional digits to doubles that have a single fractional digit.
Math.Round(Decimal, MidpointRounding) example
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.
Math.Round(Double, MidpointRounding) example
The following example displays values returned by the Round(Double) method, the Round(Double, MidpointRounding) method with a mode argument of ToEven, and the Round(Double, MidpointRounding) method with a mode argument of AwayFromZero.
Math.Round(Decimal, Int32, MidpointRounding) example
The following example demonstrates how to use the Round 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) */
Math.Round(Double, Int32, MidpointRounding) example
The following example demonstrates how to use the Round(Double, Int32, MidpointRounding) method with the MidpointRounding enumeration.