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.Math Using 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.

Overload Double Decimal

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.

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.

The Dev Codes

.Net

.NET Array Dictionary List String 2D Async DataTable Dates DateTime Enum File For Foreach Format IEnumerable If IndexOf Lambda LINQ Parse Path Process Property Regex Replace Sort Split Static StringBuilder Substring Switch Tuple

Java

Core Array ArrayList HashMap String 2D Cast Character Console Deque Duplicates File For Format HashSet If IndexOf Lambda Math ParseInt Process Random Regex Replace Sort Split StringBuilder Substring Switch Vector While

TheDeveloperBlog.com

C# Math.Round Examples: MidpointRounding

Related Links:

.Net

Java

Related Links