How do I round doubles in human-friendly manner in C#?

Question

In my C# program I have a double obtained from some computation and its value is something like 0,13999 or 0,0079996 but this value has to be presented to a human so it's better displayed as 0,14 or 0,008 respectively.

So I need to round the value, but have no idea to which precision - I just need to "throw away those noise digits".

How could I do that in my code?

To clarify - I need to round the double values to a precision that is unknown at compile time - this needs to be determined at runtime. What would be a good heuristic to achieve this?

Answer 1

private double PrettyRound(double inp)
{
    string d = inp.ToString();
    d = d.Remove(0,d.IndexOf(',') + 1);
    int decRound = 1;
    bool onStartZeroes = true;
    for (int c = 1; c < d.Length; c++ )
    {
        if (!onStartZeroes && d[c] == d[c - 1])
            break;
        else
            decRound++;
        if (d[c] != '0')
            onStartZeroes = false;
    }

    inp = Math.Round(inp, decRound);
    return inp;
}

Test:

    double d1 = 0.13999; //no zeroes
    double d2 = 0.0079996; //zeroes
    double d3 = 0.00700956; //zeroes within decimal

    Response.Write(d1 + "<br/>" + d2 + "<br/>" + d3 + "<br/><br/>");

    d1 = PrettyRound(d1);
    d2 = PrettyRound(d2);
    d3 = PrettyRound(d3);

    Response.Write(d1 + "<br/>" + d2 + "<br/>" + d3 +"<br/><br/>");

Prints:

0,13999
0,0079996
0,00700956

0,14
0,008
0,007

Rounds your numbers as you wrote in your example..

Answer 2

You seem to want to output a value which is not very different to the input value, so try increasing numbers of digits until a given error is achieved:

    static double Round(double input, double errorDesired)
    {
        if (input == 0.0) 
            return 0.0;

        for (int decimals = 0; decimals < 17; ++decimals)
        {
            var output = Math.Round(input, decimals);
            var errorAchieved = Math.Abs((output - input) / input);

            if (errorAchieved <= errorDesired)
                return output;
        }

        return input;
    }
}


    static void Main(string[] args)
    {
        foreach (var input in new[] { 0.13999, 0.0079996, 0.12345 })
        {
            Console.WriteLine("{0} -> {1}         (.1%)", input, Round(input, 0.001));
            Console.WriteLine("{0} -> {1}         (1%)", input, Round(input, 0.01));
            Console.WriteLine("{0} -> {1}         (10%)", input, Round(input, 0.1));
        }
    }

Answer 3

You can do it without converting to string. This is what I created fast:

private static double RoundDecimal(double number)
{
   double temp2 = number;
   int temp, counter = 0;

   do
   {
      temp2 = 10 * temp2;
      temp = (int)temp2;

      counter++;
   } while (temp < 1);

   return Math.Round(number, counter < 2 ? 2 : counter);
}

or

private static double RoundDecimal(double number)
{
       int counter = 0;

       if (number > 0) { 
          counter = Math.Abs((int) Math.Log10(number)) + 1;

       return Math.Round(arv, counter < 2 ? 2 : counter);
}

Answer 4

I can think of a solution though it isn't very efficient...

My assumption is that you can tell when a number is in the "best" human readable format when extra digits make no difference to how it is rounded.

eg in the example of 0,13999 rounding it to various numbers of decimal places gives:

0
0.1
0.14
0.14
0.14
0.13999

I'd suggest that you could loop through and detect that stable patch and cut off there.

This method seems to do this:

public double CustomRound(double d)
{
    double currentRound = 0;
    int stability = 0;
    int roundLevel = 0;
    while (stability < 3)
    {
        roundLevel++;
        double current = Math.Round(d, roundLevel);
        if (current == currentRound)
        {
            stability++;
        }
        else
        {
            stability = 1;
            currentRound=current;
        }
    }
    return Math.Round(d, roundLevel);
}

This code might be cleanable but it does the job and is a sufficient proof of concept. :)

I should emphasise that that initial assumption (that no change when rounding) is the criteria we are looking at which means that something like 0.3333333333 will not get rounded at all. With the examples given I'm unable to say if this is correct or not but I assume if this is a double issues that the problem is with the very slight variations from the "right" value and the value as a double.

Answer 5

Heres what I tried:

public decimal myRounding(decimal number)
{
   double log10 = Math.Log10((double) number);
   int precision = (int)(log10 >= 0 ? 0 : Math.Abs(log10)) + (number < 0.01m ? 1 : 2);
   return  Math.Round(number, precision);
}

test:

Console.WriteLine(myRounding(0.0000019999m)); //0.000002
Console.WriteLine(myRounding(0.0003019999m)); //0.0003
Console.WriteLine(myRounding(2.56777777m));   //2.57
Console.WriteLine(myRounding(0.13999m));      //0.14
Console.WriteLine(myRounding(0.0079996m));    //0.008

Answer 6

After giving it another thought I did the following and looks like it does what I want so far.

I iterate over the number of digits and compare Round( value, number ) and Round( value, number + 1 ). Once they are equal (not == of course - I compare the difference against a small number) then number is the number of digits I'm looking for.

Answer 7

Double.ToString() can take a string format as an argument. This will display as many characters as you require, rounding to the decimal place. E.G:

double Value = 1054.32179;
MessageBox.Show(Value.ToString("0.000"));

Will display "1054.322".

Source

Generic formats (i.e, pre-generated)

How to generate custom formats

Answer 8

You can use no of digits with Math.Round Function

Double doubleValue = 4.052102;
Math.Round(doubleValue, 2);

This will return 4.05 as your required answer.

This is tested code, can u explain me how i am wrong. So i need to change.