Explaining to students why to use double instead of float (unless there's a very good reason)

Question

I keep seeing students use float in lab lessons:

For example, a simple physics calculation of kinematics. Many, many students use float to hold the variables:

float y,g,t,v

etc.

In this specific lab, they idea is for them to see:

$$y(t_{n+1})=y(t_n)+\frac{\Delta y}{\Delta t}\Delta t\approx y(t_n)+v(t_n)\,(t_{n+1}-t_n)$$ with $$v(t_{n+1})\approx v(t_n)+g*(t_{n+1}-t_n)$$

and then run over times $\{t_i\}_{i=1}^n$ and see that the $y$ values they get are the same as:

$$y(t_n)\approx y(t_1)+v(t_1)\,t_n+\frac{1}{2}g\,t_n^2$$

However, because they use float, they get rounding errors when dealing with small time differences ($\Delta t$). I don't want to get into the whole floating point arithmetics field, because they won't understand that (the word "exponent" would frighten them, to say the least).

On the other hand, if they use double, then the rounding errors wouldn't be significant (because they aren't dealing with $\Delta t \le 10^{-5}$ of a second). So I try to explain that they should use double, but just stating it as a "rule of thumb" isn't a good idea (because there are cases where one would prefer float)

So, what explanation, as to why they should use double for these things, would be compelling?

Better yet, is there any way I can show the students such an explanation? (Perhaps an online, interactive demonstration of floating point precision etc. - I couldn't find one)

Answer 1

Better yet, is there any way I can show the students such an explanation? (Perhaps an online, interactive demonstration of floating point precision etc. - I couldn't find one)

Show them these bits of code:

float one = 16777291;
float two = one + 1;
System.out.println(one == two);

---

float one = 1.00000001f;
float two = one + .00000001f;
System.out.println(one == two);

---

Ask them what they expect these to print. They should print false, right? But when you run them, they print true!

Then explain that this is because float values can only hold a relatively small number of significant digits. Change the float values to be double values and run the code again, and you'll see that false is printed like we'd expect.

Explain that for many purposes float is enough precision, but not for this class. Explain that double has the same problem, but with much more precision. Explain that double precision is enough for this class, but if they need more precision in the future to use BigDecimal or something.

Answer 2

Luckily this is quite simple to make clear, even if you are steering clear of the IEEE standard. Honestly, even binary is not needed here.

I would start by borrowing a page from Scheme, and say that we can't make blanket guarantees about the exactness of decimal numbers. For instance, when we try to express $2/3$ in decimal, and it doesn't work!

All the more so when we are restricted to 10 digits. We write $0.666666667$. Why? It's not that 2/3 is $0.66666667$, it's just that we can't precisely represent $2/3$ in decimal, and at the 10th digit, we just round to get as close as we can.

This is really a problem with any number that has a decimal place. There are infinite numbers that we can't represent!

The computer has the same problem with decimal numbers as we do. This isn't a fault of the computer, it's just a feature of floating point numbers, and the computer has to work around it, just like we do.

Now, we do have a way of increasing that precision: we can increase the number of digits allowed. It doesn't solve the problem, exactly, but it does get us closer to the true numbers.

That's the difference between a float and a double. A double allows more digits. And that's why it's usually a better idea to use a double.

Answer 3

Tell the students they have seven decimal digits of precision in a float, and that the decimal point is placed "somewhere" within those seven digits, depending on the magnitude of the number.

Ask them to add 0.01 to 9,999,999 and express the result to seven digits. Ask what the answer would be if they performed the addition a thousand times.

Now ask them to do the same calculation using 15 digits of precision.

Answer 4

Actually, it isn't quite so clear. If I run this in Java:

// Simple computation with float and double
// Increment by a third three times is not the same as incrementing by one
// Float can actually be more accurate than Double in limited cases
public static void main(String[] args) {
    float oneThirdF = 1.0f/3.0f;
    float wholeF = 0.0f;
    float countF = wholeF; //initially equal
    while(countF == wholeF){
        wholeF = wholeF + oneThirdF + oneThirdF + oneThirdF;
        countF = countF + 1.0f;
    }
    System.out.println("Float: " + countF + " != " + wholeF);

    double oneThirdD = 1.0d/3.0d;
    double wholeD = 0.0d;
    double countD = wholeD; //initially equal
    while(countD == wholeD){
        wholeD = wholeD + oneThirdD + oneThirdD + oneThirdD;
        countD = countD + 1.0d;
    }
    System.out.println("Double: " + countD + " != " + wholeD);

}

I get:

Float: 3.0 != 2.9999998
Double: 2.0 != 1.9999999999999998

So, while doubles are certainly more precise than floats, the place in a "floating point" computation at which things go wrong depends on a lot more than which form you use. Here Float was a bit more "accurate" initially, since Double failed earlier.

Lessons: Don't use such things for counting. If you need to do computation use the form with more precision. Beware of the results. And testing for equality is pointless (it's why Zeus created Epsilon).

Finally, though this code doesn't illustrate it, there are situations in which the errors are larger than the answers, so saying x ± ε might be entirely meaningless if x is small and ε is large.

However, if your use is to take a physical reading from some sort of equipment (say temperature) and report it, with little computation, the shorter (float) type is almost certainly sufficient and likely has more precision than necessary. When there is a lot of computation, use double along with sophisticated error control techniques.

---

For a (long) explanation of floating point errors see: https://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html. This is valid for any language using the IEEE 754 standard (most modern languages and processors).

Answer 5

Many compilers will promote floats to doubles, do the calculation, and cast back. I see little or no reason to use floats unless one is dealing with huge matrices of floating-point numbers. I encourage my students to use doubles for most purposes.

Answer 6

Simple demonstration of "precision" using handheld calculators.

Get a pair of calculators. One cheap model that has a limited number of digits in its display. Models can be found built in to clipboards and other "office" things. One decent model, not necessarily a good model, that has double the digits of the other calculator. If it has exactly double the display size of the first, so much the better.

One point to be aware of is that many calculators, even the cheap disposable ones, will have at least one significant digit beyond the display to help hide/correct rounding errors. The demonstration will have to be tested on the specific models you use before class.

Develop some short, and simple, formulas that will develop rounding errors quickly. Thirds, and harmonics thereof, usually are corrected by the hidden digit(s), but higher factors tend to do better. It can be helpful to also avoid returns that go into scientific notation value range - six or seven digits left or right of the decimal place is probably the best range to stick with. Something involving 3 or 4 digit primes as numerators and denominators should do the trick.

Having the two calculators in hand, and your pre-tested formulas, have the students work out by hand, or follow you as you do, the formulas, so that they will know what the real answers are. Run the same formulas on the cheap calculator, showing where it starts to go wrong, and how fast it gets worse. Run the same formulas on the better calculator, showing how much farther into the formulas it gets before it starts to drift, and how much, less, it gets it wrong. If the demonstration has one formula that actually finishes correctly on the better calculator, but not the cheap one, so much the better.

Having the other formulas not come out completely correct, even on the better calculator, leaves room for you to explain why/how rounding errors in float/double can affect programs. Adding in a formula or two that can then be run on the computer (language of choice) that shows the error delta can help drive the point home. If it's also one where they might be tempted to opt for float that is even better.

Answer 7

I would highly recommend this Answer to question what the "Difference between float and double" is.

If not already done in introduction, i would show the math behind floating point representation on a computer (exponent, mantissa, ...). That shall clearly state the difference between those data types and explain why in physics it is not a good idea to CUT precision. If necessary and for fun reason use 64bit datatypes and calculation.

There is one thing where I have trouble with some answers. For good reason never ever teach the comparison of two floating point numbers or in loop counts, etc. The Reason for that can be found in the CERT C Guides Link!