Dear Forum,
I have experienced some strange behaviour using float/double values in a formula calculation.
Using the same static double values the result may differ each time I run the calculation?
I'm using a LPC824 (Cortex M0) with no FPU and KEIL-MDK. No MicroLIB and default compiler version 5
I'm aware of the usage of double/float precision issue. But this problem is when using the same values, the result is different each time I run a calculation.
I have a voltage (double) from a ADC, that is run through a formula, that uses 7 coefs (double).
The formula is this:
dResult = V0[paramIndex] + ( (dTemp-T0[paramIndex])*(P1[paramIndex]+(dTemp-T0[paramIndex])*(P2[paramIndex]+(dTemp-T0[paramIndex])*(P3[paramIndex]+P4[paramIndex]*(dTemp-T0[paramIndex]))))/( 1+(dTemp-T0[paramIndex])*(q1[paramIndex]+q2[paramIndex]*(dTemp-T0[paramIndex]))));
V0[], T0[], P1[], P2[], P3[], P4[], q1[] and q2[] contains static double values. So they do neve change.
dTemp is the double value (voltage) passed to the function containing the formula.
If I also keep the dTemp stable (fixed static value of 27.8125) the dResult is different each time I run the formula. If I use the value of 27.7812 it is the same value each time.
Why do I see this behavior? Why is the result not the same each time?
Thomas
You didn't say how you know that the value from the ADC isn't changing ?
Have you tried doing the same calculation on a PC ?
Or using a different compiler on the Target ?
Does Keil distinguish single/double precision ?
Hi,
Sorry. I know that because I have made a special build, where I don't use values from the ADC reading, but from a array with fixed double values (double dCJTemps[] = {27.7812, 27.7812, 27.8125, 27.8125, 27.8125} --> Fed to the function doing the calculations)
No, have not made a PC application doing the same.
Keil do distinguish single/double precision. But regarding the precision. If i feed the function with the same values again and again I would expect the function to return the same value each time. Not a new one each time.
Not tried a new compiler yet.
... I would expect the function to return the same value each time.
Indeed.
Is it a repeatable set of values that you get?
ie, if you run it a few times, then do a full reset, then run again - do you get the same sequence of results ?
Yes, they seems to be the same result sequence after a restart.
Also, if I compare values calculated with the segmented calculation and the full formula, I also get some differences:
Result with formula broken into pieces: 1.105545404646 Result using the complete formula: 1.105546324063
They are calculated in the same function at the same time, with the same data?
Also, compared to excel the value when the formula has been broken into pieces is the correct one.
I think that is to be expected?
Floating-point is prone to rounding errors as not all values can be exactly represented.
So doing the calculation in a different order could well give a slightly different result - as different roundings occur.
Yes, that makes sense.
But it does not explain why I do get different result with the same set of data when I run the calculation.
I have tried different compiler optimization settings without any luck.
Should I try keep values as float types? I know I lose precision, but I need consistency and not precision.