Minimize Redundant Operations in Loops

This example shows how to minimize redundant operations in loops. When a loop operation does not depend on the loop index, performing it inside a loop is redundant. This redundancy often goes unnoticed when you are performing multiple operations in a single MATLAB^® statement inside a loop. For example, in the following code, the inverse of the matrix B is being calculated 100 times inside the loop although it does not depend on the loop index:

for i=1:100
     C=C + inv(B)*A^i*B;
  end

Performing such redundant loop operations can lead to unnecessary processing. To avoid unnecessary processing, move operations outside loops as long as they do not depend on the loop index.

Define a function, SeriesFunc(A,B,n), that calculates the sum of n terms in the following power series expansion:

$C = 1 + B^{- 1} A B + B^{- 1} A^{2} B + ...$

  function C=SeriesFunc(A,B,n) 

% Initialize C with a matrix having same dimensions as A
  C=zeros(size(A));

% Perform the series sum
  for i=1:n
     C=C+inv(B)*A^i*B;
  end

Generate code for SeriesFunc with 4-by-4 matrices passed as input arguments for A and B:
```
X = coder.typeof(zeros(4));
codegen -config:lib -launchreport SeriesFunc -args {X,X,10}
```
In the generated code, the inversion of B is performed n times inside the loop. It is more economical to perform the inversion operation once outside the loop because it does not depend on the loop index.

Modify SeriesFunc as follows:

  function C=SeriesFunc(A,B,n) 

% Initialize C with a matrix having same dimensions as A
  C=zeros(size(A));

% Perform the inversion outside the loop
  inv_B=inv(B); 

% Perform the series sum
  for i=1:n
     C=C+inv_B*A^i*B;
  end

This procedure performs the inversion of B only once, leading to faster execution of the generated code.