By default, the fixedpoint conversion process generates files
in a folder named codegen/fcn_name/fixpt
in your
local working folder. fcn_name
is the name of
the MATLAB^{®} function that you are converting to fixed point.
File name  Description 

fcn_name_fixpt.m  Generated fixedpoint MATLAB code. To integrate this fixedpoint code into a larger application, consider generating a MEXfunction for the function and calling this MEXfunction in place of the original MATLAB code. 
fcn_name_fixpt_exVal.mat  MATfile containing:

fcn_name_fixpt_report.html  Link to the type proposal report that displays the generated fixedpoint code and the proposed type information. 
fcn_name_report.html  Link to the type proposal report that displays the original MATLAB code and the proposed type information. 
fcn_name_wrapper_fixpt.m  File that converts the floatingpoint data values supplied
by the test file to the fixedpoint types determined for the inputs
during the conversion step. These fixedpoint values are fed into
the converted fixedpoint function, 
fi
casts to Improve Code ReadabilityThe conversion process tries to reduce the number of fi
casts
by analyzing the floatingpoint code. If an arithmetic operation is
comprised of only compiletime constants, the conversion process does
not cast the operands to fixed point individually. Instead, it casts
the entire expression to fixed point.
For example, here is the fixedpoint code generated for the
constant expression x = 1/sqrt(2)
when the selected
word length is 14.
Original MATLAB Code  Generated FixedPoint Code 

x = 1/sqrt(2);  x = fi(1/sqrt(2), 0, 14, 14, fm);

The conversion process avoids overflows by:
Using fullprecision arithmetic unless you specify otherwise.
Avoiding arithmetic operations that involve double
and fi
data types. Otherwise, if the word length
of the fi
data type is not able to represent the
value in the double constant expression, overflows occur.
Avoiding overflows when adding and subtracting non fixedpoint variables and fixedpoint variables.
The fixedpoint conversion process casts nonfi
expressions
to the corresponding fi
type.
For example, consider the following MATLAB algorithm.
% A = 5; % B = ones(300, 1) function y = fi_plus_non_fi(A, B) % '1024' is nonfi, cast it y = A + 1024; % 'size(B, 1)*length(A)' is a nonfi, cast it y = A + size(B, 1)*length(A); end
The generated fixedpoint code is:
%#codegen % A = 5; % B = ones(300, 1) function y = fi_plus_non_fi_fixpt(A, B) % '1024' is nonfi, cast it fm = fimath('RoundingMethod', 'Floor', 'OverflowAction', 'Wrap', 'ProductMode', 'FullPrecision', 'MaxProductWordLength', 128, 'SumMode', 'FullPrecision', 'MaxSumWordLength', 128); y = fi(A + fi(1024, 0, 11, 0, fm), 0, 11, 0, fm); % 'size(B, 1)*length(A)' is a nonfi, cast it y(:) = A + fi(size(B, fi(1, 0, 1, 0, fm))*length(A), 0, 9, 0, fm); end
The conversion process controls bit growth by using subscripted assignments, that is, assignments that use the colon (:) operator, in the generated code. When you use subscripted assignments, MATLAB overwrites the value of the lefthand side argument but retains the existing data type and array size. Using subscripted assignment keeps fixedpoint variables fixed point rather than inadvertently turning them into doubles. Maintaining the fixedpoint type reduces the number of type declarations in the generated code. Subscripted assignment also prevents bit growth which is useful when you want to maintain a particular data type for the output.
When the result of the subtraction is negative, the conversion process promotes the left operand to a signed type.
For example, consider the following MATLAB algorithm.
% A = 1; % B = 5 function [y,z] = unsigned_subtraction(A,B) y = A  B; C = 20; z = C  B; end
In the original code, both A
and B
are
unsigned and the result of AB
can be negative.
In the generated fixedpoint code, A
is promoted
to signed. In the original code, C
is signed, so
does not require promotion in the generated code.
%#codegen % A = 1; % B = 5 function [y,z] = unsigned_subtraction_fixpt(A,B) fm = fimath('RoundingMethod', 'Floor', 'OverflowAction', 'Wrap', 'ProductMode', 'FullPrecision', 'MaxProductWordLength', 128, 'SumMode', 'FullPrecision', 'MaxSumWordLength', 128); y = fi(fi_signed(A)  B, 1, 3, 0, fm); C = fi(20, 1, 6, 0, fm); z = fi(C  B, 1, 6, 0, fm); end function y = fi_signed(a) coder.inline( 'always' ); if isfi( a ) && ~(issigned( a )) nt = numerictype( a ); new_nt = numerictype( 1, nt.WordLength + 1, nt.FractionLength ); y = fi( a, new_nt, fimath( a ) ); else y = a; end end
If you concatenate matrices using vertcat
and horzcat
,
the conversion process uses the largest numerictype among the expressions
of a row and casts the leftmost element to that type. This type is
then used for the concatenated matrix to avoid loss of range.
For example, consider the following MATLAB algorithm.
% A = 1, B = 100, C = 1000 function [y, z] = lb_node(A, B, C) %% single rows y = [A B C]; %% multiple rows z = [A 5; A B; A C]; end
In the generated fixedpoint code:
For the expression y = [A B C]
,
the leftmost element, A
, is cast to the type of C
because C
has
the largest type in the row.
For the expression [A 5; A B; A C]
:
In the first row, A
is cast to
the type of C
because C
has
the largest type of the whole expression.
In the second row, A
is cast to
the type of B
because B
has
the larger type in the row.
In the third row, A
is cast to
the type of C
because C
has
the larger type in the row.
%#codegen % A = 1, B = 100, C = 1000 function [y, z] = lb_node_fixpt(A, B, C) %% single rows fm = fimath('RoundingMethod', 'Floor', 'OverflowAction', 'Wrap', 'ProductMode', 'FullPrecision', 'MaxProductWordLength', 128, 'SumMode', 'FullPrecision', 'MaxSumWordLength', 128); y = fi([fi(A, 0, 10, 0, fm) B C], 0, 10, 0, fm); %% multiple rows z = fi([fi(A, 0, 10, 0, fm) 5; fi(A, 0, 7, 0, fm) B; fi(A, 0, 10, 0, fm) C], 0, 10, 0, fm); end
If the function that you are converting has a scalar input,
and the mpower
exponent input is not constant,
the conversion process sets the fimath
ProductMode
to SpecifyPrecision
in
the generated code. With this setting , the output data type can be
determined at compile time.
For example, consider the following MATLAB algorithm.
% a = 1 % b = 3 function y = exp_operator(a, b) % exponent is a constant so no need to specify precision y = a^3; % exponent is not a constant, use 'SpecifyPrecision' for 'ProductMode' y = b^a; end
In the generated fixedpoint code, for the expression y
= a^3
, the exponent is a constant, so there is no
need to specify precision. For the expression, y = b^a
,
the exponent is not constant, so the ProductMode
is
set to SpecifyPrecision
.
%#codegen % a = 1 % b = 3 function y = exp_operator_fixpt(a, b) % exponent is a constant so no need to specify precision fm = fimath('RoundingMethod', 'Floor', 'OverflowAction', 'Wrap', 'ProductMode', 'FullPrecision', 'MaxProductWordLength', 128, 'SumMode', 'FullPrecision', 'MaxSumWordLength', 128); y = fi(a^3, 0, 2, 0, fm); % exponent is not a constant, use 'SpecifyPrecision' for 'ProductMode' y(:) = fi(b, 'ProductMode', 'SpecifyPrecision', 'ProductWordLength', 2, 'ProductFractionLength', 0 )^a; end