I'm still a beginner at programming and I always have more questions than our book or internet searches can answer (unless I missed something). So I apologize in advance if this was answered but I couldn't find it.

I understand that float has a smaller range than double making it less precise, and from what I understand, long double is even more precise(?). So my question is why would you want to use a variable that is less precise in the first place? Does it have something to do with different platforms, different OS versions, different compilers? Or are there specific moments in programming where its strategically more advantageous to use a float over a double/long double?

Thanks everyone!

## Best Solution

In nearly all processors, "smaller" floating point numbers take the same or less clock-cycles in execution. Sometimes the difference isn't very big (or nothing), other times it can be literally twice the number of cycles for

`double`

vs.`float`

.Of course, memory foot-print, which is affecting cache-usage, will also be a factor.

`float`

takes half the size of`double`

, and`long double`

is bigger yet.Edit: Another side-effect of smaller size is that the processor's SIMD extensions (3DNow!, SSE, AVX in x86, and similar extensions are available in several other architectures) may either only work with

`float`

, or can take twice as many`float`

vs.`double`

(and as far as I know, no SIMD instructions are available for`long double`

in any processor). So this may improve performance if`float`

is used vs.`double`

, by processing twice as much data in one go. End edit.So, assuming 6-7 digits of precision is good enough for what you need, and the range of +/-10

^{+/-38}is sufficient, then`float`

should be used. If you need either more digits in the number, or a bigger range, move to`double`

, and if that's not good enough, use`long double`

. But for most things,`double`

should be perfectly adequate.Obviously, the importance of using "the right size" becomes more important when you have either lots of calculations, or lots of data to work with - if there are 5 variables, and you just use each a couple of times in a program that does a million other things, who cares? If you are doing fluid dynamics calculations for how well a Formula 1 car is doing at 200 mph, then you probably have several tens of million datapoints to calculate, and every data point needs to be calculated dozens of times per second of the cars travel, then using up just a few clockcycles extra in each calculation will make the whole simulation take noticeably longer.