Compile-Time Recursion Limit Reached

Issue

You see a message such as:

Compile-time recursion limit reached. Size or type of
input #1 of function 'foo' may change at every call.

Compile-time recursion limit reached. Value of input #1
of function 'foo' may change at every call.

Cause

With compile-time recursion, the code generator produces multiple versions of the recursive function instead of producing a recursive function in the generated code. These versions are known as function specializations. The code generator is unable to use compile-time recursion for a recursive function in your MATLAB^® code because the number of function specializations exceeds the limit.

Solutions

To address the issue, try one of these solutions:

Force Run-Time Recursion

For this message:
```
Compile-time recursion limit reached. Value of input #1
of function 'foo' may change at every call.
```
Use this solution:
Force Run-Time Recursion by Treating the Input Value as Nonconstant.
For this message:
```
Compile-time recursion limit reached. Size or type of
input #1 of function 'foo' may change at every call.
```
In the MATLAB Function report, look at the function specializations. If you can see that the size of an argument is changing for each function specialization, then try this solution:
Force Run-Time Recursion by Making the Input Variable-Size.

Force Run-Time Recursion by Treating the Input Value as Nonconstant

Consider this function:

function y = call_recfcn(n)
A = ones(1,n);
x = 100;
y = recfcn(A,x);
end

function y = recfcn(A,x)
if size(A,2) == 1 || x == 1
    y = A(1);
else
    y = A(1)+recfcn(A(2:end),x-1);
end
end

The second input to recfcn has the constant value 100. The code generator determines that the number of recursive calls is finite and tries to produce 100 copies of recfcn. This number of specializations exceeds the compile-time recursion limit. To force run-time recursion, instruct the code generator to treat the second input as a nonconstant value by using coder.ignoreConst.

function y = call_recfcn(n)
A = ones(1,n);
x = coder.ignoreConst(100);
y = recfcn(A,x);
end

function y = recfcn(A,x)
if size(A,2) == 1 || x == 1
    y = A(1);
else
    y = A(1)+recfcn(A(2:end),x-1);
end
end

If the code generator cannot determine that the number of recursive calls is finite, it produces a run-time recursive function.

Force Run-Time Recursion by Making the Input Variable-Size

Consider this function:

function z = call_mysum(A)
%#codegen
z = mysum(A);
end

function y = mysum(A)
coder.inline('never');
if size(A,2) == 1
    y = A(1);
else
    y = A(1)+ mysum(A(2:end));
end
end

If the input to mysum is fixed-size, the code generator uses compile-time recursion. If A is large enough, the number of function specializations exceeds the compile-time limit. To cause the code generator to use run-time conversion, make the input to mysum variable-size by using coder.varsize.

function z = call_mysum(A)
%#codegen
B = A;
coder.varsize('B');
z = mysum(B);
end

function y = mysum(A)
coder.inline('never');
if size(A,2) == 1
    y = A(1);
else
    y = A(1)+ mysum(A(2:end));
end
end

Increase the Compile-Time Recursion Limit

The default compile-time recursion limit of 50 is large enough for most recursive functions that require compile-time recursion. Usually, increasing the limit does not fix the issue. However, if you can determine the number of recursive calls and you want compile-time recursion, increase the limit. For example, consider this function:

function z = call_mysum()
%#codegen
B = 1:125;
z = mysum(B);
end

function y = mysum(A)
coder.inline('never');
if size(A,2) == 1
    y = A(1);
else
    y = A(1)+ mysum(A(2:end));
end
end

You can determine that the code generator produces 125 copies of the mysum function. In this case, if you want compile-time recursion, increase the compile-time recursion limit to 125.

To increase the limit, increase the value of the Compile-time recursion limit for MATLAB functions configuration parameter.