fixed-point output

[Abe Simpson]

Hello all,

The application I am working on must never output numbers in a
floating-point format, that is, something like

2e-002

is a big no-no. At the same time, it must output numbers in a compact way,
that is, it should only output significant digits, and only output a decimal
point if there are digits following it.

There seems to be no printf modifer to accomodate me.

%f is fixed-point but not compact:

printf("%f", 222) produces 222.000000 and I only need 222

%g is compact but not fixed-point:

printf("%g", 0.00001) produces 1e-005 and I want 0.000001

Any way I can do this with printf alone without writing my own 0-trimming
code?

TIA.

Abe

 

[Abe Simpson]

Thanks for a fast reply. I can write 0-trimming code, no problem, I was just
hoping for a cleaner solution based solely on printf's capabilities.

 

[Kevin Goodsell]

Hello all,

The application I am working on must never output numbers in a
floating-point format, that is, something like

2e-002

is a big no-no. At the same time, it must output numbers in a compact way,
that is, it should only output significant digits, and only output a decimal
point if there are digits following it.

There seems to be no printf modifer to accomodate me.

My advice would be to not use printf at all. Since you posted to a C++
group, I will assume you are using C++ and recommend type-safe iostream
classes instead.

%f is fixed-point but not compact:

printf("%f", 222) produces 222.000000 and I only need 222

Actually, this produces undefined behavior because you pass an int where
the format string indicates it will be a double. I really doubt you got
this to produce 222.000000. This is a nice example of why most people
should not use printf, scanf, or any function that defeats type-checking
(if it can be avoided).

%g is compact but not fixed-point:

printf("%g", 0.00001) produces 1e-005 and I want 0.000001

Any way I can do this with printf alone without writing my own 0-trimming
code?

I don't see a way to do it with printf alone.

-Kevin

 

[Eric Sosman]

Hello all,

The application I am working on must never output numbers in a
floating-point format, that is, something like

2e-002

is a big no-no. At the same time, it must output numbers in a compact way,
that is, it should only output significant digits, and only output a decimal
point if there are digits following it.

There seems to be no printf modifer to accomodate me.

%f is fixed-point but not compact:

printf("%f", 222) produces 222.000000 and I only need 222

Nit-pick: printf("%f", 222) produces undefined behavior,
because `222' is not a `double' quantity as required by "%f".

%g is compact but not fixed-point:

printf("%g", 0.00001) produces 1e-005 and I want 0.000001

Any way I can do this with printf alone without writing my own 0-trimming
code?

You need to decide how many digits to the right of the
decimal point you want. This will depend on the size of the
number (the log10() function may come in handy here) and on
your notion of how many digits are "significant." Armed with
this information you can then choose an appropriate precision
for the conversion, which you'll probably write as

printf ("%.*f", precision, value);

As an aside, note that printing values with very large or
very small magnitudes is not especially "compact."

-1e37 = -10000000000000000000000000000000000000
1e-37 = 0.0000000000000000000000000000000000001

.... and you don't even want to *think* about 1e308 ...

 

[Kevin Goodsell]

Nit-pick: printf("%f", 222) produces undefined behavior,
because `222' is not a `double' quantity as required by "%f".

I find it strange that you consider this nit-picking. This is pretty
serious case of undefined behavior, likely leading to a program crash,
and maybe even compromising security.

-Kevin

 

[Eric Sosman]

I find it strange that you consider this nit-picking. This is pretty
serious case of undefined behavior, likely leading to a program crash,
and maybe even compromising security.

In actual quoted code I'd have considered it more serious.
But it seemed to me that the O.P. had just typed the code in
without serious consideration -- for example, note the lack of
a newline character, and of a semicolon -- and was concentrating
on the issue of how to control the format of a converted `double'.
So I noted the problem in passing, but didn't spend many electrons
on it. You're entirely right, though: a mismatch like this can
be a serious matter. At least once a fortnight I'm grateful when
gcc prevents me from making just such an error ...