Question

Background:

I have an opc tag whose value is a 32 bit floating point number. The tag represents a running tally – so at some point the total will hit the max value and start again at 0. An additional bit of information about the tag is that it’s data type is single float but it’s value is always a whole number ( I didn’t create the tag so I’m not sure why float was chosen ).

In my application when a certain event is fired I record the current value of this running total and when another event is fired I take the current value of the total and then need to calculate the difference.

The only issue I have is that if the value were to be near max value when I take the initial reading, and then rollover to 0+ before I take the second reading I will end up with a negative value for the difference.

I’ve got this so far (it’s in c#):

    float diff (float a, float b) {
        if (b < a) {
            float f = float.MaxValue - a;
            return f + b;
        }
        return b - a;
    }

but this doesn’t work since unless a is huge, float.MaxValue – a == 0. Does anyone know how I might work this out?

Answer 1

Floats don’t overflow the same way integers do.

If you add two floats that should add to a number larger than float.MaxValue, the result will be float.PositiveInfinity, not a large negative number as with signed integers or a small positive number as with unsigned integers.

But before that happens, you will most likely run into a different problem: If you add a small number to a large number, the result might be the large number, unchanged. So, if the score always increases by some (relatively) small number, you will most likely find that, after a certain point, the score doesn’t change anymore.

Because of all this, your “roll-over” will never happen and so maybe you don’t have to do anything. But even better solution would be to use an integer type to represent integers, thus avoiding all those pitfalls.