Why cast to single has large quantization error.
The cast from fixed-point to single will use single precision for constants and single precision for all operations with one exception. The exception is the cast of the input stored integer value to single. That cast has integer input and single precision output.
Generating C Code using Simulink Coder or Embedded Coder will show the details.
Y1 = (real32_T)U1 * 0.0009765625F - 2.056192E+6F;
There CAN be precision losses at each an every step.
The representation of the Slope 0.0009765625F happens to be lossless in this case.
The representation of the Bias -2.056192E+6F also happens to be lossless in this case.
(real32_T)U1 chops the 32 bit input down to the 24-bit mantissa of singles lossing up to 8-bits of precision.
(real32_T)U1 * 0.0009765625F is 24-bit mantissa times 24-bit mantissa so full-precision can require up to 48-bits. That will be quantized down to 24-bits.
The subtraction can also lose some precision but that will be small in relative terms.
Quantitative Analysis of Errors
dt1 = fixdt(0,32,0.0009765625,-2056192);
uIdeal1 = 0.1;
u = fi(uIdeal1, dt1);
uStoredInteger = u.storedInteger
siInFloat = single(uStoredInteger)
errorInStoredIntegerCast = double(siInFloat) - double(uStoredInteger)
realWorldImpactOfErrorInStoredIntegerFloat = errorInStoredIntegerCast * dt1.Slope
The error converting the 32-bit integer to a 24-bit mantissa floating-point is the dominant error source in this case.
0.996 + 0.0254 = 0.125
To get higher precision cast to double first
To get higher precision in converting slope-bias fixed-point to single, an approach is to first cast to double and then downcast to single. This approach is unnecessary if the fixed-point type has binary-point scaling (bias is zero and slope is an exact power of two). This approach is most impactful if the fixed-point type uses more than 24-bits and the slope is not an exact power of two.
The downside of this approach is that casts to double could be very costly on an embedded processor like a ARM Cortex M4F that has single precision floating-point hardware, but not double precision floating-point hardware. The double math would need to be emulated in software which would be much slower. This is a key reason a large body of users requested that casts and operations that mix fixed-point and single precision floating-point should only use single and not use doubles. This group of users prefered to model an explicit cast up to double when greater precision was need.
