yeah

I'm not sure your guess is correct.

A number like 1.3 is double. To make it float one needs to write it as 1.3f . Small 'l' means long, but it's an integer long. I am not sure what capital L means - there are long doubles in C99. You better check it - this all is documented.

I looked it up and it says: "Floating point constants are assumed to be double. During calculations, other types are promoted (float), then after calculation, if the answer is stored as float, it is demoted (can reduce speed). To override this, add 'f' or 'F' suffix, ex. 2.3F, or if you want long double use 'L', ex. 54.3L. Otherwise it is of type double."

Actually this is from my notes on C Primer book.

Yes, as you say, double is the default - here are the relevant quotes from sections 2.13.3 and 3.9.1 of the ISO C++ standard:

If you work with (single precision) float, the compiler may or may not convert the intermediate results to double (it is neither required nor disallowed by the standard). In fact, you can get different results depending on whether optimization is turned on or not.

The GNU compiler implements the long double using the 80 bit floating point facility on the 32 bit x86 machines.

I feel certain that after having read the comments in this thread, that I will always, from here on, be able to distinguish accurately between ints, floats, and doubles.


As a side note - Yesterday's class went pretty well. We technically discussed programming, if you consider discussing the failures of certain governmental programs to be forms of programming. Terrorism was mentioned, too. Looked at us as if he was thinking, "You never can tell... Any one of em could be, but statistically, all of them are out to get me!"

That's closer than we've been so far.

They have to drive it into you like some demon. They do this with other things too, in case you haven't noticed. It they say something enough you will believe it. These things that they push so hard, these things must be questioned the most, in fact they should be assumed to be false at first and later proven to be true or otherwise.

Furthermore, the return type of atof() is double. And float gets promoted to double within varags. So double is really the "normal" floating-point type in C. Whoever named them screwed up: the 64-bit type should have been called "single precision" (so the 32-bit would be "half precision").

I disagree with an earlier poster that float is "totally useless" though. I used it last year to build millions-of-elements correlation matrices for the Netflix Prize. Had to save memory.

All you need is the last 4 of those. If you want to convert a measurement to miles, just convert it to meters, then convert meters to miles.

Losing precision at each step..

@Dan04

http://www.livinginternet.com/i/iw_unix_c.htm

http://www.alasir.com/articles/alpha_history/index.html

Just remember not to trust us and to recheck what we are saying in the official documentation - I am serious.

1 members found this post helpful.

Indeed you would, you should also take into account sig figs and rounding errors. But heck for programming class you probably don't care and neither does the teacher.

I find truly, the computer is only accurate to about 2 decimal places after the point.

0 members found this post helpful.

But, it all conversions are written in terms of a common base unit, there are only two steps: Multiply to convert from the source unit to the base unit, and divide to convert from the base unit to the destination unit.

Sure, this may mean getting 1 mile = 63360.00000000001 inches instead of 63360. But it has the huge advantage that you only have to write O(n) conversion factors instead of O(n²).

"float" (usually) has 24 significant bits. That's only 7.22 significant digits.

Suppose the value you're converting is between 65536 and 131072 meters (about 41-81 miles). Then you need 17 bits to store the integer portion of the meters, so that leaves you only 7 bits for the fractional part, giving you a resolution of 1/128 m.