**First example.** Math.Round has several overloads and 2 rounding modes defined on the MidpointRounding enum. Here we round an example double and decimal type.

**Return:** We see what Math.Round will return with different arguments. We use 1, 2 and 3 arguments.

OverloadDoubleDecimal**Argument 1:** The first argument is the number you are rounding. This can be a double or decimal type.

**Argument 2:** The second argument is the number of digits after the decimal place you want to keep.

**Argument 3:** And the third argument is an optional rounding mode enumerated constant.

Enum**C# program that uses Math.Round**
using System;
class Program
{
static void Main()
{*
//
// Round double type in three ways.
//
*double before1 = *123.45*;
double after1 = __Math.Round__(before1, 1,
MidpointRounding.AwayFromZero);* // Rounds "up"
*double after2 = __Math.Round__(before1, 1,
MidpointRounding.ToEven);* // Rounds to even
*double after3 = __Math.Round__(before1);
Console.WriteLine(before1);* // Original
*Console.WriteLine(after1);
Console.WriteLine(after2);
Console.WriteLine(after3);*
//
// Round decimal type.
//
*decimal before2 = *125.101M*;
decimal after4 = __Math.Round__(before2);
decimal after5 = __Math.Round__(before2, 1);
Console.WriteLine(before2);* // Original
*Console.WriteLine(after4);
Console.WriteLine(after5);
}
}
**Output**
123.45
123.5 <-- MidpointRounding.AwayFromZero
123.4 <-- MidpointRounding.ToEven
123
125.101
125
125.1

**MidpointRounding.** What is the difference between MidpointRounding.ToEven and MidpointRounding.AwayFromZero? My testing indicates that the difference is found when rounding the number 0.5.

**Info:** MidpointRounding.ToEven will round 0.5 to 0—this is because zero is even.

**And:** MidpointRounding.AwayFromZero will round 0.5 to 1—this is because one is away from zero.

**C# program that demonstrates MidpointRounding**
using System;
class Program
{
static void Main()
{
for (double i = 0.1; i < 0.99; i += 0.1)
{
Console.WriteLine(*"{0}=({1},{2})"*, i,
Math.Round(i, __MidpointRounding.ToEven__),
Math.Round(i, __MidpointRounding.AwayFromZero__));
}
}
}
**Output**
0.1=(0,0)
0.2=(0,0)
0.3=(0,0)
0.4=(0,0)
0.5=(0,1)
0.6=(1,1)
0.7=(1,1)
0.8=(1,1)
0.9=(1,1)

**Performance.** How does Math.Round affect performance? Recently I added calls to Math.Round in a program that is performance-sensitive.

**Further:** How did this affect the overall efficiency of the program? I benchmarked Math.Round to get a general idea.

**C# program that benchmarks Math.Round**
using System;
using System.Diagnostics;
class Program
{
const int _max = 100000000;
static void Main()
{
var s1 = Stopwatch.StartNew();
for (int i = 0; i < _max; i++)
{
double d = __Math.Round__(1.3665, 0);
if (d == 1.5)
{
throw new Exception();
}
}
s1.Stop();
var s2 = Stopwatch.StartNew();
for (int i = 0; i < _max; i++)
{
double d = __Math.Round__(1.3665, 1);
if (d == 1.5)
{
throw new Exception();
}
}
s2.Stop();
Console.WriteLine(((double)(s1.Elapsed.TotalMilliseconds * 1000000) /
_max).ToString("0.00 ns"));
Console.WriteLine(((double)(s2.Elapsed.TotalMilliseconds * 1000000) /
_max).ToString("0.00 ns"));
Console.Read();
}
}
**Output**
*20.72 ns* Math.Round, 0
*25.26 ns* Math.Round, 1

**Notes, results.** Calls to Math.Round required about 20 nanoseconds. A call with zero decimal places required less time than a call with one decimal place.

**Tip:** It is possible that the more decimal places required, the slower the method becomes.

**Also:** Certain computations could be optimized by avoiding Math.Round. An if-statement would evaluate faster.

If**Cast:** Simply casting a double to an int rounds down. This requires only 2 nanoseconds. Using Math.Round requires 20 nanoseconds.

Cast, Int**Note:** This article had an error in its description of rounding behaviors on scientific data. Thanks to Gus Gustafson for a correction.