Write a MATLAB script, mysum_test, that verifies the behavior of your algorithm using double data types.

n = 10;
rng default
x = 2*rand(n,1)-1;

% Algorithm
y = mysum(x);

% Verify results
y_expected = sum(double(x));

err = double(y) - y_expected

rng default puts the settings of the random number generator used by the rand function to its default value so that it produces the same random numbers as if you restarted MATLAB.

Run the test script.

mysum_test

err =

     0

The results obtained using mysum match those obtained using the MATLAB sum function.

Add the following line to the end of your test script to generate C code for mysum.

codegen mysum -args {x} -config:lib -report

Run the test script again.

MATLAB Coder generates C code for mysum function and provides a link to the code generation report.

Click the link to open the code generation report and view the generated C code for mysum.

/* Function Definitions */
double mysum(const double x[10])
{
  double y;
  int n;
  y = 0.0;
  for (n = 0; n < 10; n++) {
    y += x[n];
  }
  return y;
}

Because C does not allow floating-point indices, the loop counter, n, is automatically declared as an integer type. You do not need to convert n to fixed point.

Input x and output y are declared as double.

Modify your test file so that the data type of x is single.

n = 10;
rng default
x = single(2*rand(n,1)-1);

% Algorithm
y = mysum(x);

% Verify results
y_expected = sum(double(x));

err = double(y) - y_expected
codegen mysum -args {x} -config:lib -report

Run the test script again.

mysum_test

err =

  -4.4703e-08

Attempt to write a value of type 'single' into a variable defined
as type 'double'. Code generation does not support changing types 
through assignment. To investigate the cause of the type mismatch, 
check preceding assignments or input type specifications.

Code generation fails, reporting a data type mismatch on line y = y + x(n);.

To view the error, open the report.

In the report, on the line y = y + x(n), the report highlights the y on the left side of the assignment in red to indicate that there is an error. The issue is that y is declared as a double but is being assigned to a single. y + x(n) is the sum of a double and a single which is a single. If you place your cursor over variables and expressions in the report, you can see information about their types. Here, you can see that the expression, y + x(n) is a single.

To fix the type mismatch, update your algorithm to use subscripted assignment for the sum of elements. Change y = y + x(n) to y(:) = y + x(n).

function y = mysum(x) %#codegen
  y = 0;
  for n = 1:length(x)
    y(:) = y + x(n);
  end
end

Using subscripted assignment, you also prevent the bit growth which is the default behavior when you add fixed-point numbers. For more information, see Bit Growth. Preventing bit growth is important because you want to maintain your fixed-point types throughout your code. For more information, see Controlling Bit Growth.

Regenerate C code and open the code generation report. In the C code, the result is now cast to double to resolve the type mismatch.

Update the test script:

Run the test script again.

The showInstrumentationResults function proposes data types and opens a report to display the results.

In the report, click the Variables tab. showInstrumentationResults proposes a fraction length of 13 for y and 15 for x.

For the first run, check the connection between table and algorithm using doubles. Before you declare n, add T = mytypes('double');

Update the call to buildInstrumentedMex to use the type of T.x specified in the data types table: buildInstrumentedMex mysum -args {zeros(n,1,'like',T.x),T} -histogram

Cast x to use the type of T.x specified in the table: x = cast(2*rand(n,1)-1,'like',T.x);

Call the MEX function passing in T: y = mysum_mex(x,T);

Call codegen passing in T: codegen mysum -args {x,T} -config:lib -report

Here is the updated test script.

%% Build instrumented mex
T = mytypes('double');

n = 10;

buildInstrumentedMex mysum ...
    -args {zeros(n,1,'like',T.x),T} -histogram

%% Test inputs
rng default
x = cast(2*rand(n,1)-1,'like',T.x);

% Algorithm
y = mysum_mex(x,T);

% Verify results

showInstrumentationResults mysum_mex ...
    -defaultDT numerictype(1,16) -proposeFL

y_expected = sum(double(x));

err = double(y) - y_expected

%% Generate C code

codegen mysum -args {x,T} -config:lib -report

Run the test script and click the link to open the code generation report.

The generated C code is the same as the code generated for the original algorithm. Because the variable T is used to specify the types and these types are constant at code generation time; T is not used at run time and does not appear in the generated code.

Update the test script to use fixed-point types. Replace T = mytypes('double'); with T = mytypes('fixed'); and then save the script.

Run the test script and view the generated C code.

This version of C code is not very efficient; it contains a lot of overflow handling. The next step is to optimize the data types to avoid overflows.