Compare a fixed-point implementation vs. an "ideal math" implemenation.
Step 1: Determine some numerically rich inputs for the algorithm.
Helpful tools for picking rich inputs include
fixed.DataSpecification
fixed.DataGenerator
Step 1: Compute the fixed-point output.
Step 2: Get a reference value close to the "ideal math" output.
Most often this is done by converting inputs to double and redoing all the calculations in double.
Step 3: Determine the difference between the fixed-point value and the reference value.
Be careful to use a sufficiently high precision type to do the error calculations in, not a low precision calc type.
Traditionally, you'd cast both the fixed-point and the reference to double then do the calculations in double.
More recent releases have utilities that will compute the error in high precision for any combinations of data types.
fixed.unifiedErrorCalculator.absoluteError
fixed.unifiedErrorCalculator.relativeAbsoluteError
fixed.unifiedErrorCalculator.bitsOfError
Below is an example for the multiplication example you mentioned. For the 12 bit output, the 4 least significant bits of the full precision 16 bit product were discarded, so all of the quantization error will be due to rounding of the least significant bits. The default fixed-point fi object rounding to nearest is used, so the final output will be off by half a bit in the 12 bit output data type.
ntInput1 = numerictype(1,8,3);
ntInput2 = numerictype(1,8,3);
ntOutput = numerictype(1,12,2);
inputSelectionMethod = 'BruteForceGrid';
switch inputSelectionMethod
ds1 = fixed.DataSpecification(ntInput1);
ds2 = fixed.DataSpecification(ntInput2);
dataGen = fixed.DataGenerator('DataSpecifications', {ds1, ds2}, 'NumDataPointsLimit', nPoints);
[u1, u2] = dataGen.outputAllData('array');
n1 = ceil(sqrt(nPoints));
n1 = min(n1, 2^ntInput1.WordLength);
range1 = double(range(ntInput1));
v1 = fi( linspace( range1(1), range1(2), n1), ntInput1 );
n2 = min(n2, 2^ntInput2.WordLength);
range2 = double(range(ntInput2));
v2 = fi( linspace( range2(1), range2(2), n2), ntInput1 );
[u1,u2] = meshgrid(v1,v2);
yReferenceDouble = double(u1) .* double(u2);
[~,ii] = sort(yReferenceDouble);
productFullPrecision = u1 .* u2;
y = fi( productFullPrecision, ntOutput);
absErr = fixed.unifiedErrorCalculator.absoluteError(y,yReferenceDouble);
absBitsOfError = abs(fixed.unifiedErrorCalculator.bitsOfError(y,yReferenceDouble));
plot(yReferenceDouble(ii),yReferenceDouble(ii),'k-',yReferenceDouble(ii),y(ii),'b-')
xlabel('Product Value Reference')
legend({'Reference','Fixed-Point'},'Location','best')
Absolute Error in Real World Values
plot(yReferenceDouble(ii),absErr(ii),'r.')
xlabel('Product Value Reference')
Absolute Error in Bits of the Final Output Type
plot(yReferenceDouble(ii),absBitsOfError(ii),'r.')
xlabel('Product Value Reference')
ylabel('Abs Bits of Error')
