fi's element-wise power a.^b
is not designed to give the same output data type for all possible values of b.
In general, the output data type can change for each value of b.
The implementation of fi's element-wise power special cases b == 0, and simply assigns the output to the optimal 1 bit representation of a.^0 = 1.
Your clever use of fimath appears to keep the output data type consistent for all positive values of b. But use of fimath on the input cannot impact the special case output assignment for b == 0.
I'm not aware of anyway to directly use fi's element-wise power operator to avoid the b == 0 special casing.
So you will not be able to fully control
y = a.^b
for all supported values of b.
If you are willing and able to replace the operator with a custom function,
y = some_custom_fi_power_function( a, b )
then it would be possible to achieve an output data type that does not change for all values of b.
If building off your use of fimath, the obvious solution is for the custom function to trap b == 0 and call a.^b for everything else.
Another approach to consider is the example shown here and attached.
The example is intended to illustrate some useful concepts such as employing the cast-like pattern. The example passed a very modest amount of spot testing. But "caveat emptor", this illustrative example has not gone through the rigorous testing process for simulation, code generation, etc.
function y = intPowerWrapLike( u, intPow, yLikeDesiredType) %#codegen
% intPowerWrapLike raise input element-wise to an integer power with a wrapping
% cast to a desired type at each step
%
% Usage:
% y = intPowerWrapLike(u,intPow,yLikeDesiredType)
% Input:
% u value to be raised to an integer power
% can be any integer or fi binary point type
% intPow the power to raise u to, must be non-negative, scalar, integer value
% yLikeDesiredType variable to whose type the output should be cast to
% with overflow wrapping and floor rounding
% DEFAULTs to u if yLikeDesiredType is not provided
%
% Example 1
% format compact
% a = int8([-10,2,9]);
% for b=0:3
% y1 = intPowerWrapLike( a, b )
% end
%
% Example 2
% format compact
% a = int8([-10,2,9]);
% yLike = int32(0);
% for b=0:3
% y2 = intPowerWrapLike( a, b, yLike )
% end
%
% Example 3
% format compact
% fp = fipref;
% fp.NumericTypeDisplay = 'short'
% a = fi([-3.375,-0.125,2.25,4],1,8,4);
% yLike = fi(0,1,12,6);
% for b=0:4
% y2 = intPowerWrapLike( a, b, yLike )
% end
% Copyright 2020 The MathWorks, Inc.
if nargin < 3
yLikeDesiredType = u;
end
validateattributes(u,{'embedded.fi','numeric'},{})
validateattributes(intPow,{'embedded.fi','numeric'},{'scalar','integer','nonnegative'})
validateattributes(yLikeDesiredType,{'embedded.fi','numeric'},{})
uFi = getLeanFiEquivalent(u);
intPowFi = valInIntType(intPow);
yLikeFi = getLeanFiEquivalent(yLikeDesiredType);
% For codegen, define the output type early
% The initialization value 1 will be the output if intPow == 0
%
yFi = ones(size(u),'like',yLikeFi);
if intPowFi > 0
one = cast(1,'like',intPowFi);
initialized = false;
runningInputPower = cast(uFi,'like',yLikeFi);
while intPowFi > 0
if bitand(intPowFi, one)
% Multiply in the odd power
if initialized
yFi(:) = mulLike(yFi,runningInputPower,yLikeFi);
else
yFi(:) = runningInputPower;
initialized = true;
end
end
% Divide k by 2 (shift off a bit at each iteration)
intPowFi = bitsrl(intPowFi,1);
if intPowFi ~= 0
% Squaring up the even powers
runningInputPower = mulLike(runningInputPower,runningInputPower,yLikeFi);
end
end
end
% Cast to the specified desired type.
% At most, this will change for fi type to it's
% MATLAB built-in integer equivalent
y = cast(yFi,'like',yLikeDesiredType);
end
function uFi = getLeanFiEquivalent(u)
%
% Get the fi equivalent of the input
% Give the output full precision fimath with lean math options
%
coder.inline('always');
uFi = castIntToFi(u);
assert(isfi(uFi));
assert(isfixed(uFi));
assert(uFi.isscalingbinarypoint);
fm = fimath('RoundingMethod', 'Floor', ...
'OverflowAction', 'Wrap');
uFi = setfimath(uFi,fm);
end
function y = valInIntType(u)
%
% Put value in an integer type, i.e. Fraction Length is zero
% removes unused fraction bits
% appends physical fraction bits if Fraction Length is negative
%
coder.inline('always');
u2 = castIntToFi(u);
if isfi(u2) && isfixed(u2) && u2.isscalingbinarypoint
u3 = u2;
else
u3 = fi(u2,0,32,0);
end
fmLean = fimath('RoundingMethod', 'Floor', ...
'OverflowAction', 'Wrap');
newWordLength = u3.WordLength + u3.FractionLength;
y = fi(u3, 0, newWordLength, 0, fmLean);
end
function y = mulLike(a,b,yLikeFi)
coder.inline('always');
a = removefimath(a);
b = removefimath(b);
if isreal(a) && isreal(b)
fm = fimath(...
'RoundingMethod', 'Floor', ...
'OverflowAction', 'Wrap', ...
'ProductMode', 'SpecifyPrecision', ...
'ProductWordLength', yLikeFi.WordLength, ...
'ProductFractionLength', yLikeFi.FractionLength, ...
'SumMode', 'SpecifyPrecision', ...
'SumWordLength', yLikeFi.WordLength, ...
'SumFractionLength', yLikeFi.FractionLength, ...
'CastBeforeSum', true);
y = mpy(fm,a,b);
else
tempFullPrecisionProduct = a .* b;
y = cast(tempFullPrecisionProduct,'like',yLikeFi);
end
y = removefimath(y);
fmLean = fimath('RoundingMethod', 'Floor', ...
'OverflowAction', 'Wrap');
y = setfimath(y,fmLean);
end
