Documentation

Define a function, RunningAverage, that calculates the running average of an N-element subset of an array:

  function avg=RunningAverage(N) 

% Array whose elements are to be averaged
  NumArray=[1 6 8 2 5 3]; 

% Initialize average:
% These will also be the first two elements of the function output
  avg=[0 0];

% Place a bound on the argument
  coder.varsize('avg',[1 8]);

% Loop to calculate running average
  for i=1:N
    s=0;
    s=s+sum(NumArray(1:i));
    avg=[avg s/i]; 
  % Increase the size of avg as required by concatenation
  end

The output, avg, is an array that you can expand as required to accommodate the running averages. As a new running average is calculated, it is added to the array avg through concatenation, thereby expanding the array.

Because the maximum number of running averages is equal to the number of elements in NumArray, you can supply an explicit upper bound for avg in the coder.varsize statement. In this example, the upper bound is 8 (the two initial elements plus the six elements of NumArray).

Generate code for RunningAverage with input argument of type double:

codegen -config:lib -report RunningAverage -args 2

In the generated code, avg is assigned an array of size 8 (static memory allocation). The function definition for RunningAverage appears as follows (using built-in C types):

void RunningAverage (double N, double avg_data[8], int avg_size[2])

By contrast, if you remove the explicit upper bound, the generated code dynamically allocates avg.

Replace the statement

coder.varsize('avg',[1 8]);

with:

coder.varsize('avg');

Generate code for RunningAverage with input argument of type double:

codegen -config:lib -report RunningAverage -args 2

In the generated code, avg is assigned a pointer to an array, thereby allowing dynamic memory allocation. The function definition for RunningAverage appears as follows (using built-in C types):

void Test(double N, emxArray_real_T *avg)

assert(N < 6);

Define a function, ReshapeMatrix, which takes an input variable, N, and reshapes a matrix, mat, to have N rows:

  function [out1,out2] = ReshapeMatrix(N)

  mat = [1 2 3 4 5; 4 5 6 7 8] 
% Since mat has 10 elements, N must be a factor of 10 
% to pass as argument to reshape

  out1 = reshape(mat,N,[]);   
% N is not restricted

  assert(N < numel(mat));
% N is restricted to number of elements in mat
  out2 = reshape(mat,N,[]);

Generate code for ReshapeArray using the codegen command (the input argument does not have to be a factor of 10):

codegen -config:lib -report ReshapeArray -args 3

While out1 is dynamically allocated, out2 is assigned an array with size 100 (=10 X 10) in the generated code.