MATLAB - Nested Functions

MATLAB - Nested Functions and Function Handles

In MATLAB, you can define functions inside other functions. This is known as nesting. Nested functions are a powerful feature for creating more organized, readable, and robust code. They are particularly useful for creating helper functions that are only needed by a primary parent function, and for creating functions that ‘remember’ a certain state.

Understanding Function Scope

Before diving into nested functions, it’s important to understand function scope in MATLAB:

• Main Function: The first function in a .m file. It’s the only function that can be called from the command line or other files.
• Local Functions: Functions defined within the same .m file but after the main function’s end statement. They can only be called by other functions in the same file.
• Nested Functions: Functions defined inside another function, before its end statement. They have special scope rules.

Nested Functions: The Core Concept

A nested function shares a workspace with its parent. This has a crucial implication:

A nested function can access and modify variables that are defined in its parent function. The parent function, however, cannot access variables defined within the nested function’s own workspace.

Nested Function Syntax

function output = parentFunction(input1, input2)
    % Parent function's workspace
    parentVar = 10;

    % ... code ...

    % Call to the nested function
    output = nestedFunction(input1);

    % --- Nested Function Definition ---
    function nestedOut = nestedFunction(nestedInput)
        % This function can see 'parentVar', 'input1', and 'input2'
        nestedOut = nestedInput * parentVar;
    end
    % The parent function cannot see 'nestedOut'

end % End of parentFunction

Example 1: A Simple Parabola Calculator

Let’s create a main function calculateParabola that uses a nested helper function to compute y = ax^2 + bx + c. The coefficients a, b, and c will be part of the parent’s workspace.

% Save this in a file named 'calculateParabola.m'
function y = calculateParabola(x_values)
    % Coefficients are defined in the parent function's scope
    a = 2;
    b = 3;
    c = 5;

    % Initialize output array
    y = zeros(size(x_values));

    % Loop and call the nested function for each x
    for i = 1:numel(x_values)
        y(i) = evaluate(x_values(i));
    end

    % Nested function to perform the calculation
    function result = evaluate(x)
        % 'evaluate' automatically has access to a, b, and c
        result = a*x^2 + b*x + c;
    end

end

To use this, call the parent function from the command window:

x = [1, 2, 3];
y_results = calculateParabola(x)

y_results =

    10    19    32

Benefit: The logic is encapsulated. The evaluate function is hidden from the outside world, and we don’t need to pass a, b, and c as arguments every time we call it, which cleans up the code.

Returning Function Handles to Nested Functions (Closures)

One of the most powerful uses of nested functions is to create a ‘factory’ that generates customized functions. You can return a handle to a nested function. This handle ‘remembers’ the environment of the parent function where it was created. This concept is known as a closure.

Example 2: A Power Function Factory

Let’s create a function makePowerFunction that takes an exponent n and returns a new function that raises its input to the power of n.

% Save this in a file named 'makePowerFunction.m'
function powerFuncHandle = makePowerFunction(n)
    % The parent function takes 'n' as input.
    % The nested function will 'remember' this value of n.

    % Return a handle to the nested function
    powerFuncHandle = @powerCalc;

    % Nested function definition
    function result = powerCalc(x)
        % This function raises x to the power n, where n
        % is from the parent's workspace.
        result = x.^n;
    end

end

Now, we can use our factory to create specialized functions:

square = makePowerFunction(2); % Create a squaring function
cube = makePowerFunction(3);   % Create a cubing function

square(5)
ans =
    25

cube(5)
ans =
   125

% You can even use them with arrays
square(1:4)
ans =
     1     4     9    16

Application: This pattern is extremely useful in numerical methods, where you might need to pass a function with specific parameters to a solver or an integrator. It allows you to ‘bake’ parameters into a function before passing it on.

Best Practices and Considerations

• Clarity over Complexity: Use nested functions to improve organization, not to create overly complex, hard-to-debug code. If a helper function doesn’t need to share a workspace, a local function is often a simpler choice.
• Performance: While very convenient, extensive use of nested functions with complex shared workspaces can have a minor performance overhead compared to passing variables explicitly. For most applications, this is negligible and readability is more important.
• Debugging: Debugging nested functions can be tricky. Use the MATLAB debugger with breakpoints inside both the parent and nested functions to step through the code and inspect the workspaces.