Efficient check of float division by zero for embedded application - c

Question

For the embedded SW application on a microcontroller I have to write a some kind of customised division operator for float. The solution, I want to go with, is shortly described below.
In fact, I am not sure if this approach could be efficient enough in terms of execution time for the embedded application with high performance requirements.
Has anybody experience in diverse approaches to handle float division by zero, which can be efficient/optimised for embedded applications?
typedef union MyFloatType_
{
unsigned long Ulong;
float Float;
}MyFloatType;
float div_float(float a, float b)
{
float numerator = a;
MyFloatType denominator;
denominator.Float= b;
float result = 0.0f;
if((denominator.Ulong & 0x7fffffffUL) != 0UL)
{
result = numerator / denominator.Float;
} else
{
/*handle devision by zero, for example:*/
result = 0.0f;
}
return result;
}

Answer 1

In most applications, there will be some value below which a floating-point number "might as well be" zero. For example, consider something like:
float intensity(float dx, float dy)
{
float result = 1/(dx*dx + dy*dy);
if (result > 65535.0f) result = 65535.0f;
return result;
}
If the divisor is less than 1/65535.0f, then in cases where the distance isn't exactly zero the function should return 65535.0f regardless of the actual value of the divisor, and such behavior would probably be useful even if it is zero. Thus, the function could be rewritten as:
float intensity(float dx, float dy)
{
float distSq = dx*dx + dy*dy;
if (distSq <= (1.0f/65535.0f))
return 65535.0;
else
return 1/distSq;
}
Note that the corner-case handling of this sort of code may be very slightly imperfect. While not a problem for 65535.0f in particular, there may be cases where distSq is precisely equal to the reciprocal of the maximum value, but the reciprocal of that is less than the maximum value. For example, if the maximum value was 46470.0f and distSq was 0.0000215238924f, the correct result would be 46459.9961f but the function would return 46470.0f. Such issues are unlikely to pose problems in practice, but one should be aware of them. Note that if the comparison had used less-than rather than less-than-or-equal, and the maximum had been 46590.0f, a distSq value of 0.0000214642932f would yield a result of 46589.0039, which exceeds the maximum.
Incidentally, on many systems, the cost of computing an approximate reciprocal of the divisor and multiplying by the dividend may be much cheaper than the cost of performing a floating-point division. Such an approach may be useful in the many situations where its precision would be adequate.

Answer 2

It's not faster but potentially much slower. It has to move the float to an integer register (possible by writing it into memory and reading it back) and then perform the integer operation. Just perform == 0.0f and a floating point comparison is done instead and is the most efficient way.
If you want it to be "high performance" then try the following:
float div_float(float a, float b)
{
b = b == 0.0f ? 1.0f : b;
return a / b;
}
This can be optimized to few simple instructions without branching and is much faster overall as any branching kills performance. This is used in graphics drivers where if the user is supplying garbage data that will eventually result in division by zero then the results are already invalid but throwing a floating point exception is not desired.