incorrect printf o/p for doubles

[Yogesh Khanolkar]

Hi,

I am getting incorrect o/p from the code below:

#include<stdio. h>
#include<float. h>
#include<limits .h>
main()
{
double val,val1;
val=12345678901 2.123456;
val1=1234567890 12.123456;
val2=val*val1;
printf("%f\n",v al2);
}

The result I get is 152415787531839 67100000.000000 instead of the correct value.

I am running on HP-UX 11 with ansi c compiler.

Can anyone let me know why I am getting this result.

[Glen Herrmannsfeldt]

"Yogesh Khanolkar" <yo************ **@azuresolutio ns.com> wrote in message
news:b5******** *************** ***@posting.goo gle.com...

Hi,

I am getting incorrect o/p from the code below:

#include<stdio. h>
#include<float. h>
#include<limits .h>
main()
{
double val,val1;
val=12345678901 2.123456;
val1=1234567890 12.123456;
val2=val*val1;
printf("%f\n",v al2);
}

The result I get is 152415787531839 67100000.000000 instead of the correct value.
I am running on HP-UX 11 with ansi c compiler.

Can anyone let me know why I am getting this result.

It looks close enough for me. What answer did you expect?

-- glen

[James Hu]

On 2003-10-30, Yogesh Khanolkar <yo************ **@azuresolutio ns.com> wrote:

#include<stdio. h>
#include<float. h>
#include<limits .h>
main()
{
double val,val1;
val=12345678901 2.123456;
val1=1234567890 12.123456;
val2=val*val1;
printf("%f\n",v al2);
}

It looks like val2 is defaulting to an int type, and you are trying to
print it out like a double.

-- James

[Jens.Toerring]

Yogesh Khanolkar <yo************ **@azuresolutio ns.com> wrote:

I am getting incorrect o/p from the code below: #include<stdio. h>
#include<float. h>
#include<limits .h>
main()
{
double val,val1;
val=12345678901 2.123456;
val1=1234567890 12.123456;
val2=val*val1;
printf("%f\n",v al2);
}
This won't compile because 'val2' is never declared. Additional
problems are the missing 'int' in front of main() (you only get
away with this when you don't use a C99 compiler) and the
missing return statement at the end - main() always returns an int.
The result I get is 152415787531839 67100000.000000 instead of the correct value.

That seems to the best approximation your machine is able to come up
with - floating point variables have only a finite precision. And 18
digits doesn't look too bad. Welcome to the wonderful world of
floating point math ;-) And since you're already including <float.h>
check how many digits the compiler is promising you by printing out
the value of DBL_DIG.
Regards, Jens
--
_ _____ _____
| ||_ _||_ _| Je***********@p hysik.fu-berlin.de
_ | | | | | |
| |_| | | | | | http://www.physik.fu-berlin.de/~toerring
\___/ens|_|homs|_|oe rring

[Dan Pop]

In <b5************ **************@ posting.google. com> yo************* *@azuresolution s.com (Yogesh Khanolkar) writes:

Hi,

I am getting incorrect o/p from the code below:

#include<stdio .h>
#include<float .h>
What for?
#include<limit s.h>
What for?
main()
{
double val,val1;
val=1234567890 12.123456;
val1=123456789 012.123456;
val2=val*val 1; ^^^^
Huh?!? I can't believe that your compiler didn't complain!
printf("%f\n", val2);
}

The result I get is 152415787531839 67100000.000000 instead of the correct value.

HUGE clue: what is the "correct" value and why? Additional clue: make
sure to base your answer on the value of DBL_DIG as defined by your
implementation in <float.h>.

And next time, please post the actual code you have compiled.

Dan
--
Dan Pop
DESY Zeuthen, RZ group
Email: Da*****@ifh.de

[Wolfgang Riedel]

Glen Herrmannsfeldt wrote:

"Yogesh Khanolkar" <yo************ **@azuresolutio ns.com> wrote in message
news:b5******** *************** ***@posting.goo gle.com...

Hi,

I am getting incorrect o/p from the code below:

#include<stdio. h>
#include<float. h>
#include<limits .h>
main()
{
double val,val1;
val=12345678901 2.123456;
val1=1234567890 12.123456;
val2=val*val1;
printf("%f\n",v al2);
}

The result I get is 152415787531839 67100000.000000 instead of the correct

value.

like: 152415787531839 66898832.546185 383936

maybe float/double is not the best bet, doing scientific/financial calculations.
There are libraries and other languages, which do this natively.
Look them up after you've learned C (others have told you the main-thing and
more).

Wolfgang

I am running on HP-UX 11 with ansi c compiler.

Can anyone let me know why I am getting this result.

It looks close enough for me. What answer did you expect?

-- glen

[Glen Herrmannsfeldt]

"Wolfgang Riedel" <wo************ *@development.r etarus.de> wrote in message
news:3F******** *******@develop ment.retarus.de ...

Glen Herrmannsfeldt wrote:

"Yogesh Khanolkar" <yo************ **@azuresolutio ns.com> wrote in message

news:b5******** *************** ***@posting.goo gle.com...

(snip)

val=12345678901 2.123456;
val1=1234567890 12.123456;
val2=val*val1;
printf("%f\n",v al2); The result I get is 152415787531839 67100000.000000 instead
of the correct value.

like: 152415787531839 66898832.546185 383936

maybe float/double is not the best bet, doing scientific/financial

calculations. There are libraries and other languages, which do this natively.
Look them up after you've learned C (others have told you the main-thing and more).

Floating point was designed for, and works well for, scientific quantities
that have inherent uncertainty.

Possibly the most important constant for most people, Newton's G, is known
only to about four decimal digits. (That is what holds us down onto the
earth's surface.) For numbers with such relative uncertainty (relative to
the size of the number), especially when they can be very big or very small,
floating point is convenient and useful.

For numbers with absolute uncertainty (that doesn't depend on the size of
the number), such as financial or typesetting calculations, fixed point
values where the unit corresponds to the measuring unit in use, tend to give
better results.

The product above has 35 decimal digits, or about 112 bits of precision.
There are machines with floating point types that long, or close to that
long. If they are supported by C, they tend to be called long double.
(Some CDC machines came close with double, but I don't know of any are still
running.)

Otherwise, the usual implementation of float has six or seven digits of
precision, and double about 16.

-- glen

[Martin Ambuhl]

Yogesh Khanolkar wrote:

Hi,

I am getting incorrect o/p from the code below:

#include<stdio. h>
#include<float. h>
#include<limits .h>
main()
{
double val,val1;
val=12345678901 2.123456;
val1=1234567890 12.123456;
val2=val*val1;
ERROR! val2 never declared.
printf("%f\n",v al2);
}

The result I get is 152415787531839 67100000.000000 instead of the correct value.

The real mysteries are
(1) what your real code is, since yours doesn't compile, and
(2) what you might have been expecting.
Run the code below and see what your implementation gives you.
FLT_DIG may be as small as 6, and DBL_DIG and LDBL_DIG as small as 10.
Your assignment statements assume DBL_DIG to be 18 and the "right" answer
requires DBL_DIG to be at least 35. I doubt the you machine really has
doubles of more than 40 octets.

#include<stdio. h>
#include<float. h>

int main(void)
{
float f1 = 123456789012.12 3456, f2;
double d1 = 123456789012.12 3456f, d2;
long double ld1 = 123456789012.12 3456L, ld2;
f2 = f1 * f1;
printf("float: %.*g squared is %.*g\n", FLT_DIG, f1, FLT_DIG, f2);
d2 = d1 * d1;
printf("double: %.*g squared is %.*g\n", DBL_DIG, d1, DBL_DIG, d2);
ld2 = ld1 * ld1;
printf("long double: %.*Lg squared is %.*Lg\n", LDBL_DIG, ld1,
LDBL_DIG, ld2);
return 0;
}
float: 1.23457e+11 squared is 1.52416e+22
double: 123456790528 squared is 1.5241579127474 5e+22
long double: 123456789012.12 3456 squared is 1.5241578753183 9669e+22

--
Martin Ambuhl

[Yogesh Khanolkar]

Martin Ambuhl <ma*****@earthl ink.net> wrote in message news:<gr******* ***********@new sread2.news.atl .earthlink.net> ...

Yogesh Khanolkar wrote:

Hi,

I am getting incorrect o/p from the code below:

#include<stdio. h>
#include<float. h>
#include<limits .h>
main()
{
double val,val1;
val=12345678901 2.123456;
val1=1234567890 12.123456;
val2=val*val1;

ERROR! val2 never declared.

printf("%f\n",v al2);
}

The result I get is 152415787531839 67100000.000000 instead of the correct value.

The real mysteries are
(1) what your real code is, since yours doesn't compile, and
(2) what you might have been expecting.
Run the code below and see what your implementation gives you.
FLT_DIG may be as small as 6, and DBL_DIG and LDBL_DIG as small as 10.
Your assignment statements assume DBL_DIG to be 18 and the "right" answer
requires DBL_DIG to be at least 35. I doubt the you machine really has
doubles of more than 40 octets.

#include<stdio. h>
#include<float. h>

int main(void)
{
float f1 = 123456789012.12 3456, f2;
double d1 = 123456789012.12 3456f, d2;
long double ld1 = 123456789012.12 3456L, ld2;
f2 = f1 * f1;
printf("float: %.*g squared is %.*g\n", FLT_DIG, f1, FLT_DIG, f2);
d2 = d1 * d1;
printf("double: %.*g squared is %.*g\n", DBL_DIG, d1, DBL_DIG, d2);
ld2 = ld1 * ld1;
printf("long double: %.*Lg squared is %.*Lg\n", LDBL_DIG, ld1,
LDBL_DIG, ld2);
return 0;
}
float: 1.23457e+11 squared is 1.52416e+22
double: 123456790528 squared is 1.5241579127474 5e+22
long double: 123456789012.12 3456 squared is 1.5241578753183 9669e+22

I am extermely sorry for posting incorrect code. I forgot to paste the
val2 declaration of double.

[Keith Thompson]

James Hu <jx*@despammed. com> writes:

On 2003-10-30, Yogesh Khanolkar <yo************ **@azuresolutio ns.com> wrote:

#include<stdio. h>
#include<float. h>
#include<limits .h>
main()
{
double val,val1;
val=12345678901 2.123456;
val1=1234567890 12.123456;
val2=val*val1;
printf("%f\n",v al2);
}

It looks like val2 is defaulting to an int type, and you are trying to
print it out like a double.

Undeclared variables don't default to int. Some compilers, especially
old ones, might let you get away with

val2;

as a declaration for val2 with a default type of int, but it's never
been possible to omit the declaration altogether.

--
Keith Thompson (The_Other_Keit h) ks*@cts.com <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://www.sdsc.edu/~kst>
Schroedinger does Shakespeare: "To be *and* not to be"