Function handles in MATLAB - Deep Dive

Overview - Function handles

What is it?

Function handles in MATLAB are special variables that store references to functions. They let you call a function indirectly, pass functions as inputs to other functions, or store them in data structures. This makes your code more flexible and powerful, especially when you want to use the same function in different places or customize behavior.

Why it matters

Without function handles, you would have to write repetitive code or hard-code function calls, making your programs less flexible and harder to maintain. Function handles allow you to write general code that can work with any function you choose, enabling dynamic behavior and cleaner designs. This is especially useful in data science for tasks like optimization, integration, or applying custom operations to data.

Where it fits

Before learning function handles, you should understand basic MATLAB functions and variables. After mastering function handles, you can explore advanced topics like anonymous functions, function handles with nested functions, and function handles in optimization and numerical methods.

Mental Model

Core Idea

A function handle is like a remote control that points to a function, allowing you to call it anytime without knowing its details upfront.

Think of it like...

Imagine a TV remote control that doesn’t contain the TV shows but lets you switch channels and control the TV from a distance. Similarly, a function handle doesn’t contain the function’s code but lets you run the function whenever you want.

Function Handle Concept:

+-------------------+
| Function Handle H  |
+---------+---------+
          |
          v
+-------------------+
| Actual Function f  |
+-------------------+

You use H to call f indirectly.

Build-Up - 7 Steps

1

Foundation

What is a function handle

Concept: Introducing the idea that a function handle is a variable that stores a reference to a function.

In MATLAB, you create a function handle by using the @ symbol followed by the function name. For example, h = @sin creates a handle to the sine function. You can then call the function using the handle like this: y = h(pi/2). This calls sin(pi/2) and returns 1.

Result

You get the output of the function called through the handle, e.g., 1 for sin(pi/2).

Understanding that functions can be treated like data allows you to write more flexible and reusable code.

2

Foundation

Calling functions via handles

Concept: How to use a function handle to call the referenced function with inputs.

Once you have a function handle, you call it by adding parentheses and passing arguments, just like a normal function call. For example, h = @cos; result = h(0); returns 1 because cos(0) = 1. This shows that the handle acts exactly like the function itself when called.

Result

The function executes and returns the expected output, e.g., 1 for cos(0).

Knowing that function handles behave like the original functions when called helps you trust and use them interchangeably.

3

Intermediate

Passing function handles as arguments

🤔Before reading on: do you think you can pass a function handle to another function like any other variable? Commit to your answer.

Concept: Function handles can be passed as inputs to other functions, enabling dynamic behavior.

Many MATLAB functions accept function handles as inputs. For example, the integral function can take a function handle to integrate any function you want. Example: result = integral(@sin, 0, pi) calculates the integral of sin(x) from 0 to pi. This shows how function handles let you customize behavior without rewriting code.

Result

The integral function returns 2, the exact integral of sin(x) over [0, pi].

Understanding that functions can be passed as arguments unlocks powerful programming patterns like callbacks and dynamic computations.

4

Intermediate

Anonymous functions with handles

🤔Before reading on: do you think function handles can only refer to existing named functions? Commit to your answer.

Concept: You can create small, unnamed functions on the fly using anonymous functions and assign them to handles.

Anonymous functions are defined using the @ symbol with input arguments and an expression. For example, f = @(x) x^2 + 3 creates a function handle to a function that squares x and adds 3. You can call f(2) to get 7. This lets you quickly create custom functions without separate files.

Result

Calling f(2) returns 7, showing the anonymous function works correctly.

Knowing you can create functions on the fly makes your code concise and adaptable, especially for quick calculations or passing custom behavior.

5

Intermediate

Storing function handles in data structures

Concept: Function handles can be stored in arrays or cell arrays to manage multiple functions together.

You can create a cell array of function handles like funcs = {@sin, @cos, @(x) x^2}. Then call funcs{1}(pi/2) to get sin(pi/2) = 1, funcs{3}(3) to get 9. This is useful when you want to apply different functions in a loop or select them dynamically.

Result

You get correct outputs for each function call from the array, e.g., 1 and 9.

Organizing function handles in collections allows flexible and scalable code designs.

6

Advanced

Nested functions and handles

🤔Before reading on: do you think function handles to nested functions can access variables outside their own scope? Commit to your answer.

Concept: Function handles to nested functions can capture and use variables from their parent function’s workspace.

In MATLAB, nested functions can access variables from the outer function. When you create a handle to a nested function, it remembers these variables. For example: function h = outer(a) function y = inner(x) y = x + a; end h = @inner; end Calling h = outer(5); h(3) returns 8 because inner uses a=5 from outer. This is called a closure.

Result

The handle remembers the variable a=5 and adds it to input x, returning 8 for h(3).

Understanding closures helps you write functions that carry their own data, enabling powerful patterns like function factories.

7

Expert

Performance and memory with function handles

🤔Before reading on: do you think using many function handles always improves performance? Commit to your answer.

Concept: Function handles add a small overhead and can capture workspace variables, affecting memory and speed in subtle ways.

While function handles are flexible, creating many handles, especially to nested or anonymous functions capturing large variables, can increase memory use. Also, calling functions via handles is slightly slower than direct calls. Profiling your code helps decide when to use handles. For high-performance needs, pre-compile or inline functions when possible.

Result

You observe small but measurable overhead in memory and speed when using many function handles capturing large data.

Knowing the tradeoffs of function handles prevents performance surprises in large or critical applications.

Under the Hood

A function handle in MATLAB is a data structure that stores a reference to the function's code and, if applicable, a snapshot of the workspace variables it needs (for nested or anonymous functions). When you call the handle, MATLAB looks up this reference and executes the function code with the stored context. This allows functions to behave like first-class objects, carrying both code and data.

Why designed this way?

MATLAB was designed to support flexible numerical computing. Function handles were introduced to allow passing functions as data, enabling dynamic programming patterns like callbacks and custom operations. The design balances ease of use with performance, capturing workspace variables only when needed to support closures.

+-------------------------+
| Function Handle Object   |
| +---------------------+ |
| | Pointer to Function  | |
| +---------------------+ |
| +---------------------+ |
| | Captured Variables   | |  <-- Only for nested/anonymous functions
| +---------------------+ |
+------------+------------+
             |
             v
+-------------------------+
| Actual Function Code     |
+-------------------------+

Myth Busters - 4 Common Misconceptions

Quick: Do you think function handles always copy the entire function code into memory? Commit yes or no.

Common Belief: Function handles copy the whole function code into memory when created.

Reality: Function handles only store a reference (pointer) to the function code, not the code itself. The actual code stays in its original place.

Why it matters: Believing handles copy code leads to unnecessary worry about memory use and misunderstanding how MATLAB manages functions.

Quick: Do you think anonymous functions cannot access variables outside their own input arguments? Commit yes or no.

Common Belief: Anonymous functions only use their input arguments and cannot see variables outside their definition.

Reality: Anonymous functions can capture and use variables from the workspace where they are created, forming closures.

Why it matters: Not knowing this limits your ability to write concise, powerful functions that carry context.

Quick: Do you think calling a function via a handle is always faster than calling it directly? Commit yes or no.

Common Belief: Using function handles makes function calls faster because they are more flexible.

Reality: Calling functions through handles adds a small overhead compared to direct calls, making them slightly slower.

Why it matters: Assuming handles are always faster can lead to performance issues in tight loops or large-scale computations.

Quick: Do you think function handles to nested functions lose access to outer variables once returned? Commit yes or no.

Common Belief: Once a function handle to a nested function is returned, it cannot access variables from the outer function anymore.

Reality: Function handles to nested functions keep access to the outer function’s variables, preserving their values as closures.

Why it matters: Misunderstanding this causes confusion when expected variables seem missing or when debugging closures.

Expert Zone

1

Function handles to nested functions create closures that capture variables by value, not by reference, meaning changes to outer variables after handle creation do not affect the handle.

2

Anonymous functions can capture large data unintentionally, causing hidden memory bloat if not managed carefully.

3

Function handles can be serialized and saved to files, but only if the referenced functions are on the MATLAB path and do not rely on transient workspace variables.

When NOT to use

Avoid function handles when performance is critical and the function is simple and called millions of times; inline or direct calls are better. Also, avoid using handles to functions that rely heavily on changing external state, as this can cause bugs. For very complex behaviors, consider object-oriented programming instead.

Production Patterns

In production, function handles are used to pass custom callbacks to optimization routines, event handlers in GUIs, or to define flexible data processing pipelines. They enable writing generic code that can adapt to different tasks without rewriting functions.

Connections

Callbacks in Event-Driven Programming

Function handles serve as callbacks, similar to how event-driven systems use function pointers or delegates.

Understanding function handles clarifies how programs respond dynamically to events by calling user-defined functions.

Closures in Functional Programming

Function handles to nested or anonymous functions behave like closures, capturing environment variables.

Recognizing this connection helps grasp advanced functional programming concepts and how MATLAB supports them.

Pointers in Low-Level Programming

Function handles are like pointers to functions in languages like C, referencing code locations.

Seeing function handles as safe, high-level pointers helps understand their role in indirect function calls and dynamic dispatch.

Common Pitfalls

#1 Trying to call a function handle without parentheses.

Wrong approach:

h = @sin;
y = h; % Missing parentheses, does not call function

Correct approach:

h = @sin;
y = h(pi/2); % Correctly calls the function via handle

Root cause:

Confusing the function handle variable with the function call syntax.

#2 Creating an anonymous function that unintentionally captures large variables.

Wrong approach:

bigData = rand(1000);
f = @(x) sum(bigData(:)) + x; % Captures bigData inside handle

Correct approach:

bigData = rand(1000);
sumBigData = sum(bigData(:));
f = @(x) sumBigData + x; % Captures only the sum, not bigData

Root cause:

Not realizing that anonymous functions capture workspace variables by value, which can cause memory issues.

#3 Assuming function handles to nested functions update captured variables after creation.

Wrong approach:

function h = outer(a)
function y = inner(x)
y = x + a;
end
h = @inner;
end

h = outer(5);
a = 10;
y = h(3); % Expects 13 but gets 8

Correct approach:

function h = outer(a)
function y = inner(x)
y = x + a;
end
h = @inner;
end

h = outer(5);
y = h(3); % Correctly returns 8

Root cause:

Misunderstanding that closures capture variable values at handle creation, not references.

Key Takeaways

Function handles let you treat functions like data, enabling flexible and reusable code.

You create function handles with the @ symbol and call them like normal functions using parentheses.

Passing function handles as arguments allows dynamic behavior and customization in MATLAB functions.

Anonymous functions create quick, unnamed functions that can capture variables from their creation context.

Understanding closures and performance tradeoffs with function handles is key for writing efficient, maintainable MATLAB code.