HomeSearch

C# Math.Round Examples: MidpointRounding

Use the Math.Round method to the nearest desired value. Examine the MidpointRounding enum type.
Math.Round. This method rounds numbers to the nearest value. It receives the desired number of significant digits. It is part of the System namespace.MathUsing System
Method details. This Math.Round static method provides an accurate way to round double and decimal types. It reduces the risk of bugs.Static
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
Notes, program output. The program shows 3 outputs of Math.Round on a double with value 123.45. It uses the MidpointRounding.AwayFromZero and MidpointRounding.ToEven constants.
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.

A summary. We looked at the Math.Round method. We saw an example of the MidpointRounding enumerated type and how you can round numbers "away from zero" and to the nearest even number.
Home
Dot Net Perls
© 2007-2020 Sam Allen. Every person is special and unique. Send bug reports to info@dotnetperls.com.