atof approximates the String, I need exact value of the string passed

[oksuresh]

Hi talents,

I have noticed that atof() function approximates the string I pass to
it.

when I use atof() , as atof(" 184.64")
and it returns 184.63999999999

But I would like to have the exact value that is passed.

Could anyone help me?

Thanks
Suresh Ooty

[Rolf Magnus]

ok******@gmail. com wrote:

Hi talents,

I have noticed that atof() function approximates the string I pass to
it.

when I use atof() , as atof(" 184.64")
and it returns 184.63999999999

But I would like to have the exact value that is passed.

Could anyone help me?

No. Floating point types are not exact types. They cannot represent every
possible value. So whenever you convert a number representation of a string
into a floating point value, or take the string representation of a
floating point value, some approxiamtion must be done.

[asterisc]

> when I use atof() , as atof(" 184.64")

and it returns 184.63999999999

But I would like to have the exact value that is passed.

For floating point operations you should specify some toleration like
EPSILON.
By the way, even the same number, can be represented in two different
representation, that it: if you have: double a = 10.5, b = 10.5; it's
very probable that a != b;
Alaways use: if( fabs ( a - b ) < EPSILON ) then they are equals.

[Victor Bazarov]

ok******@gmail. com wrote:

I have noticed that atof() function approximates the string I pass to
it.

when I use atof() , as atof(" 184.64")
and it returns 184.63999999999

Really? Try this:

#include <stdio.h>
#include <stdlib.h>
int main() {
double d = atof(" 184.64");
printf("%f\n", d);
}

Works for me...

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[Abdo Haji-Ali]

Really? Try this:

#include <stdio.h>
#include <stdlib.h>
int main() {
double d = atof(" 184.64");
printf("%f\n", d);
}

Works for me...

You are right, however looking at the value of d while debugging will
show that d has a value of 184.639999999. But as you can see this makes
no difference as a whole as the calculation would be affected by a very
small amount, if any, and all the printing function would consider
this...

Abdo Haji-Ali
Programmer
In|Framez

[Victor Bazarov]

asterisc wrote:

when I use atof() , as atof(" 184.64")
and it returns 184.63999999999

But I would like to have the exact value that is passed.
For floating point operations you should specify some toleration like
EPSILON.

If I try using "EPSILON" in my program, it says "undefined identifier".
Do I need to include some header for that?
By the way, even the same number, can be represented in two different
representation, that it: if you have: double a = 10.5, b = 10.5; it's
very probable that a != b;
Really? How "very probable" is that? 0.8? 0.9?
Alaways use: if( fabs ( a - b ) < EPSILON ) then they are equals.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[osmium]

<ok******@gmail .com> wrote:

I have noticed that atof() function approximates the string I pass to
it.

when I use atof() , as atof(" 184.64")
and it returns 184.63999999999

But I would like to have the exact value that is passed.

That *is* the exact value that was passed. It is the best approximation for
that number that the compiler could come up with and it doesn't look like
adding bits to the representation would help. It is analogous to the
problem of representing 1/3 exactly in the decimal number system. Compilers
commonly round the number to a more pleasing number when doing output. If
you can't get the compiler to do that you could round it yourself.

I would guess there are some helpful links or information on this problem in
the FAQ, or try Wikipedia.

[Victor Bazarov]

Abdo Haji-Ali wrote:

Really? Try this:

#include <stdio.h>
#include <stdlib.h>
int main() {
double d = atof(" 184.64");
printf("%f\n", d);
}

Works for me...
You are right, however looking at the value of d while debugging will
show that d has a value of 184.639999999.

I don't think it's irrelevant. Debugging is not defined in C++ language
Standard. Yes, I know, the world is a cruel place. But can't it be that
your debugger is wrong?

The point I was trying to make was simple: you cannot compare two different
representations . You need to compare two representations of the same kind.
External with external, for example. If you read five significant digits,
you need to compare it with the output that has only five significant digits
otherwise it's bogus.

OK, if you do atof("184.64000 000000000000") and then output 20 digits, it's
still possible that you will not get the same sequence of characters. Only
then we can talk about precision of the internal representation because the
number of digits actually exceeds the precision.
But as you can see this
makes no difference as a whole as the calculation would be affected
by a very small amount, if any, and all the printing function would
consider this...

I don't understand that statement, sorry.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[Pete Becker]

asterisc wrote:

when I use atof() , as atof(" 184.64")
and it returns 184.63999999999

But I would like to have the exact value that is passed.

For floating point operations you should specify some toleration like
EPSILON.
By the way, even the same number, can be represented in two different
representation, that it: if you have: double a = 10.5, b = 10.5; it's
very probable that a != b;

On the contrary: they're exactly the same. If you compute the values
differently you may get different results, but that's true of
fixed-width arithmetic in general. You can write examples of integer
arithmetic where computing what looks to us like the same thing produces
different results.
Alaways use: if( fabs ( a - b ) < EPSILON ) then they are equals.

Only do that if you know how the values were computed and that the
result you're getting with that rule makes sense. But keep in mind that
it's not transitive: there are many triples of values a, b, and c such
that a equals b and b equals c, but a does not equal c.

--

Pete Becker
Roundhouse Consulting, Ltd.

[Victor Bazarov]

osmium wrote:

<ok******@gmail .com> wrote:

I have noticed that atof() function approximates the string I pass to
it.

when I use atof() , as atof(" 184.64")
and it returns 184.63999999999

But I would like to have the exact value that is passed.
That *is* the exact value that was passed. It is the best
approximation for that number that the compiler could come up with
and it doesn't look like adding bits to the representation would
help.

Actually, it's the debugger's best approximation of the best approximation
that the run-time could come up with. The compiler doesn't get its hands
on the actual double value. It's a sequence of chars in the source.
[...]

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask