Appendix: A little more about our exponential function
Comments and questions to John Rowe.
The occasional appendices and optional
examples in this module are for advanced material that you will not
need for this module. They are intended for enthusiastic students who
are interested in going further in programming for its own sake.
Our function includes the test:
if (value == 0.0 && exponent < 0 )
where value is a double. But we have already warned against
testing floating-point values for exact equality (and the additional
compiler warnings we have enables on Code::Blocks will object to this).
So how do we get round this?
Check if value is "too small"
if (fabs(value) < 1e-99 && exponent < 0 )
This sort of works but how do we decide on the minimum limit?
Check the answer at the end, not the value at the beginning
isfinite()
Overall, the best answer is to use a feature we have not met yet
(but will cover in the lecture on debugging): isfinite(),
defined inside math.h, which checks if its argument is a
"proper" number.
If we remove the test on value at the beginning
of the function we can test the final
result at the end:
while (exponent < 0) {
result /= base;
++exponent;
}
if ( ! isfinite(base))
printf("WARNING: underflow for negative exponent\n");
return base;
}
Notice here we have not returned zero but just passed the value
back up to the calling function (so we should change the comment at
the top of the function).
And finally...
- We may ask: "why bother?". Well, one answer is that we may be programing
a small "embedded" system, say in a fridge where the exp()
function may not be available.
- Speed: if exponent is very large this function could be very
slow. We could come up with a neat algorithm where we calculated
exponent squared, exponent to the fourth, to the eighth, etc
and multipled them together. We will show an example of this later
in the course.
- It's tedious! Dealing with errors
and edge cases takes a lot of time and effort. The usual rule
applies: the larger the number of people using the program the larger
the amount of time we will spend looking for errors.