String.Format - How can I format to x digits (regardless of decimal place)?

Question

I need to format a floating point number to x characters (6 in my case including the decimal point). My output also needs to include the sign of the number

So given the inputs, here are the expected outputs

1.23456   => +1.2345

-12.34567 => -12.345

-0.123456 => -0.1234

1234.567  => +1234.5

Please assume there is always a decimal place before the last character. I.e. there will be no 12345.6 number input - the input will always be less than or equal to 9999.9.

I'm thinking this has to be done conditionally.

@BurundukXP A little more clarification : please assume there will be no input higher than 9999 — Simon, Aug 03 '12 at 04:35
@Simon, can you confirm that you desire truncation, and not rounding? — Jonathon Reinhart, Aug 03 '12 at 04:55
Either is fine, rounding or truncation wasn't the issue here, simply the formatting. — Simon, Aug 03 '12 at 05:06
@Simon I posted an answer that should work for all inputs, and all x. — Michael Graczyk, Aug 03 '12 at 05:19

Jonathon Reinhart · Answer 1 · 2012-08-03T05:03:53.273

4

You mention "x characters". So we can simplify that to "x-1 digits", and just write code that shows x digits.

I think passing the "G" numeric format specifier to Double.ToString() is as close to built-in as you can get.

double d = 1234.56789;
string s = d.ToString("G6");           // "1234.57"

So we just expand that to manually add the "+" at the front:

if (d > 0)
    s = "+" + s;

Putting it all together in an extension method:

EDIT: Includes optional parameter to truncate

public static string ToStringWithSign(this double d, int digits, bool truncate = false)
{
    if (truncate) {
        double factor = Math.Pow(10, digits - 1);
        d = Math.Truncate(d * factor) / factor;
    }

    string s = d.ToString("G" + digits);
    if (d > 0)
        s = "+" + s;
    return s;
}

Results:

(1234.56789).ToStringWithSign(4);      // "+1235"
(1234.56789).ToStringWithSign(5);      // "+1234.6"
(1234.56789).ToStringWithSign(6);      // "+1234.57"
(-1234.56789).ToStringWithSign(6);     // "-1234.57"

(1.2345678).ToStringWithSign(6);       // "+1.23457"
(1.2345678).ToStringWithSign(6, true); // "+1.23456"

edited Aug 03 '12 at 05:03

answered Aug 03 '12 at 04:38

Jonathon Reinhart

116,671
27
221
298

1

I'd change that check to do "if d > 0". Some cultures don't use "-" for the negative sign. – Esteban Araya Aug 03 '12 at 04:44
@EstebanAraya Good call. If nothing else, it's simpler :-P. But I think if we're bringing culture into this discussion, the OP is going to have other issues, because of this specific formatting he desires anyway. – Jonathon Reinhart Aug 03 '12 at 04:48
@JonathonReinhart This still isn't quite right because it rounds the value. – Michael Graczyk Aug 03 '12 at 04:50
@MichaelGraczyk rounding was never mentioned in the OP. – Jonathon Reinhart Aug 03 '12 at 04:51
@JonathonReinhart All of his examples truncate instead of rounding. – Michael Graczyk Aug 03 '12 at 04:52
This is fine people. Rounding wasn't the issue. Thanks to all that answered. – Simon Aug 03 '12 at 05:04
I'm not sure how the OP wants trailing 0s handled but it looks like your solution will just lob them off (0.1000 -> 0.1) – Parker Aug 03 '12 at 05:12
@Parker is correct, unfortunately this solution does chop em. I will look into it further, however while this is close, its not exactly right. – Simon Aug 03 '12 at 05:19

Eren Ersönmez · Answer 2 · 2012-08-03T13:19:37.227

2

If you want truncation:

string str = number.ToString("+0.00000;-0.00000").Substring(0,7);

If you want rounding:

string str = number.ToString("+0.0000;-0.0000");

EDIT: if you want, you can write a simple wrapper that takes the number of digits as a parameter:

string FormatDecimal(decimal value, int digits )
{
    return value
        .ToString(String.Format("+0.{0};-0.{0}", new string('0',digits - 2)))
        .Substring(0,digits+1);
}

edited Aug 03 '12 at 13:19

answered Aug 03 '12 at 05:06

Eren Ersönmez

36,276
7
63
88

Thanks Eren, This is very close and would actually work for my inputs, however Michaels is more generic. – Simon Aug 03 '12 at 11:13
@Simon Thank you. but I must say that answer unnecessarily and inefficiently duplicates what is already built-in to `ToString`. – Eren Ersönmez Aug 03 '12 at 12:26
1

But his takes an arbitrary number of digits as a parameter. – Jonathon Reinhart Aug 03 '12 at 12:57
@Simon you could just change the number of zeros, couldn't you? but even if you wanted a wrapper method, I wouldn't duplicate the built-in stuff. See my edit, is this better? – Eren Ersönmez Aug 03 '12 at 13:20

V4Vendetta · Answer 3 · 2012-08-03T11:45:24.483

1

I believe if you want to output to 6 character inclusive of the decimal point, you can have a look at this

double val1 = -99.56789;
//string strval = val1.ToString("+#.######;-#.######");// add # for additional decimal places
string strval = val1.ToString("+#.000000;-#.000000");    
Console.WriteLine(strval.Substring(0,strval.Length >= 7 ? 7 : strval.Length));
 //output -99.567 if positive would output +99.567

You just need to transform the value to a string and then pick up the relevant 6 characters (the additional one is for the sign) from the outputted string.

There is no rounding in this case and fits your need, hope this is what you are looking out for.

edited Aug 03 '12 at 11:45

answered Aug 03 '12 at 05:06

V4Vendetta

34,000
7
73
81

Would be good to know what is wrong here, so that it could be fixed – V4Vendetta Aug 03 '12 at 06:01
It should be fine when using `0` instead of `#` like `#.000000` – V4Vendetta Aug 03 '12 at 11:44

Michael Graczyk · Accepted Answer · 2012-08-03T05:21:38.320

Here's a transparent way to do it without format strings (except for "F"):

  static void Main()
  {
     double y = 1.23456;
     Console.WriteLine(FormatNumDigits(y,5));
     y= -12.34567;
     Console.WriteLine(FormatNumDigits(y,5));
     y = -0.123456;
     Console.WriteLine(FormatNumDigits(y,5));
     y = 1234.567;
     Console.WriteLine(FormatNumDigits(y,5));

     y = 0.00000234;
     Console.WriteLine(FormatNumDigits(y,5));

     y = 1.1;
     Console.WriteLine(FormatNumDigits(y,5));
  }


  public string FormatNumDigits(double number, int x) {
     string asString = (number >= 0? "+":"") + number.ToString("F50",System.Globalization.CultureInfo.InvariantCulture);

     if (asString.Contains('.')) {
        if (asString.Length > x + 2) {
           return asString.Substring(0, x + 2);
        } else {
           // Pad with zeros
           return asString.Insert(asString.Length, new String('0', x + 2 - asString.Length));
        }
     } else {
        if (asString.Length > x + 1) {
           return asString.Substring(0, x + 1);
        } else {
           // Pad with zeros
           return asString.Insert(1, new String('0', x + 1 - asString.Length));
        }
     }
  }

Output:

  +1.2345
  -12.345
  -0.1234
  +1234.5
  +0.0000
  +1.1000

EDIT

Notice that it does not chop off trailing zeros.

@JonathonReinhart Try this: `Console.WriteLine(FormatNumDigits(1.1, 5)); Console.WriteLine(ToStringWithSign(1.1, 5));` — Michael Graczyk, Aug 03 '12 at 05:43

Adil Mammadov · Answer 5 · 2012-08-03T11:13:41.297

0

Try this:

        double myDouble = 1546.25469874;
        string myStr = string.Empty;
        if (myDouble > 0)
        {
            myStr = myDouble.ToString("+0.0###");
        }
        else
        {
            myStr = myDouble.ToString("0.0####");
        }
        if (myStr.Length > 7)
        {
            myStr = myStr.Remove(7).TrimEnd('.');
        }

edited Aug 03 '12 at 11:13

answered Aug 03 '12 at 04:41

Adil Mammadov

7,996
4
26
55

it will return +1.0. Isn't it what you want? But 1.005 will return +1.005 – Adil Mammadov Aug 03 '12 at 11:36
No, unfortunately I always need a number with 6 characters, i.e. it should return 1.0000. It chops off the trailing zeroes – Simon Aug 03 '12 at 11:41
replace the #'s with zeroes and its virtually there. – Simon Aug 03 '12 at 11:42
yes if you need 0s to be shown also you should replace #'s with zeros ) – Adil Mammadov Aug 03 '12 at 12:18

Parker · Answer 6 · 2012-08-03T05:10:01.467

This should do what you want. It does round the last digit, though.

static string Format(double d)
{
    // define how many number should be visible
    int digits = 5;

    // Get the left part of the number (ignore negative sign for now)
    int s = Math.Abs(d).ToString("####0").Length;

    // Total size minus the amount of numbers left of the decimal point
    int precision = digits - s;

    // Left side for positive, right side for negative.
    // All it's doing is generating as many 0s as we need for precision.
    string format = String.Format("+###0.{0};-###0.{0}", new String('0', precision));
    return d.ToString(format);
}

Given your input this returns:

+1.2346
-12.346
-0.1235
+1234.6

It'll handle zeros no problem:

+0.1000
+0.0000
+1000.0

@Simon Try it with `Console.WriteLine(Format(9999.9));` – Michael Graczyk Aug 03 '12 at 05:25 — Michael Graczyk, Aug 03 '12 at 05:25
Or `Console.WriteLine(Format(-999.9));` – Michael Graczyk Aug 03 '12 at 05:26 — Michael Graczyk, Aug 03 '12 at 05:26

score -2 · Answer 7 · answered Aug 03 '12 at 04:32

-2

As stated here by MSDN, "0" is the place holder for a digit. So, all you need is:

myDecimal.ToString("000000");

or

myDecimal.ToString("######");

if you don't want a digit present instead of a zero.

answered Aug 03 '12 at 04:32

Esteban Araya

27,658
22
99
139

Yes, but considering the decimal place is in an unknown position, how many leading/trailing zeros are there? – Simon Aug 03 '12 at 04:35
@Simon, you can figure out the position of the decimal point by dividing by ten until you no longer get an integer. You could then build the format string as outlined above and putting the decimal place in the correct place. I don't know if you'll be able to do it with a predefined format string. I think you might have to build it every time. I'll keep thinking though. Good question! – Esteban Araya Aug 03 '12 at 04:37

String.Format - How can I format to x digits (regardless of decimal place)?

7 Answers7

Linked