The following example creates a handle for a function supplied
by MATLAB® called
humps and assigns it to
returns a strong maxima near x = 0.3 and x = 0.9).
h = @humps;
After constructing the handle, you can pass it in the argument
list of a call to some other function, as shown here. This example
passes the function handle
h that was just created
as the first argument in a call to
This function then minimizes over the interval [0.3, 1].
x = fminbnd(h, 0.3, 1) x = 0.6370
Using a function handle enables you to pass different functions
fminbnd to use in determining its final result.
The ability to pass variables to a function enables you to run the function on different values. In the same way, you can pass function handles as input arguments to a function, thus allowing the called function to change the operations it runs on the input data.
integral function on varying input
a = 0; b = 5; integral(@log, a, b) ans = 3.0472 integral(@sin, a, b) ans = 0.7163 integral(@humps, a, b) ans = 12.3566
integral on a MATLAB built-in
function or an anonymous function:
n = integral(@log, 0, 3); n = integral(@(x)x.^2, 0, 3);
Change the parameters of the function you pass to
a simple modification of the anonymous function that is associated
with the function handle input:
a = 3.7; z = integral(@(x)x.^a, 0, 3);
Compare the integral of the cosine function over the interval
a = 0; b = 10; int1 = integral(@cos,a,b) int1 = -0.5440
with the integral over the same interval of the piecewise polynomial
approximates the cosine function by interpolating the computed values
x = a:b; y = cos(x); pp = spline(x,y); int2 = integral(@(x)ppval(pp,x), a, b) int2 = -0.5485
You can do more with a function handle than just create an association to a certain function. By using anonymous functions, you can also capture certain variables and their values from the function workspace and store them in the handle. These data values are stored in the handle at the time of its construction, and are contained within the handle for as long as it exists. Whenever you then invoke the function by means of its handle, MATLAB supplies the function with all variable inputs specified in the argument list of the function call, and also any constant inputs that were stored in the function handle at the time of its construction.
Storing some or all input data in a function handle enables you to reliably use the same set of data with that function regardless of where or when you invoke the handle. You can also interrupt your use of a function and resume it with the same data at a later time simply by saving the function handle to a MAT-file.
Compare the following two ways of implementing a simple plotting
draw_plot. The first case creates
the function as one that you would call by name and that accepts seven
inputs specifying coordinate and property information:
function draw_plot(x, y, lnSpec, lnWidth, mkEdge, mkFace, mkSize) plot(x, y, lnSpec, ... 'LineWidth', lnWidth, ... 'MarkerEdgeColor', mkEdge, ... 'MarkerFaceColor', mkFace, ... 'MarkerSize', mkSize)
The second case implements
an anonymous function to be called by a function handle,
draw_plot function has only two inputs now;
the remaining five are specified only on a call to the handle constructor
function h = get_plot_handle(lnSpec, lnWidth, mkEdge, ... mkFace, mkSize) h = @draw_plot; function draw_plot(x, y) plot(x, y, lnSpec, ... 'LineWidth', lnWidth, ... 'MarkerEdgeColor', mkEdge, ... 'MarkerFaceColor', mkFace, ... 'MarkerSize', mkSize) end end
Because these input values are required by the
but are not made available in its argument list, MATLAB supplies
them by storing them in the function handle for
the time it is constructed. Construct the function handle
also supplying the values to be stored in handle:
h = get_plot_handle('--rs', 2, 'k', 'g', 10);
Now call the function, specifying only the
x = -pi:pi/10:pi; y = tan(sin(x)) - sin(tan(x)); h(x, y) % Draw the plot
The later section on Examining a Function Handle continues this example by showing how you can examine the contents of the function and workspace contents of this function handle.
Values stored within a handle to a nested function do not have
to remain constant. The following function constructs and returns
a function handle
h to the anonymous function
In addition to associating the handle with
addOne, MATLAB also
stores the initial value of
x in the function handle:
function h = counter x = 0; h = @addOne; function y = addOne; x = x + 1; y = x; end end
addOne function that is associated
h increments variable
time you call it. This modifies the value of the variable stored in
the function handle:
h = counter; h() ans = 1 h() ans = 2
Unlike the example above, values stored within a handle to an
anonymous function do remain constant. Construct a handle to an anonymous
function that just returns the value of
x to 300. The value of
the function handle remains constant regardless of how you modify
to the handle:
x = 300; h = @()x; x = 50; h() ans = 300 clear x h() ans = 300
By design, only functions within a program file are permitted to access local functions defined within that file. However, if, in this same file, you were to construct a function handle for one of the internal local functions, and then pass that handle to a variable that exists outside of the file, access to that local function would be essentially unlimited. By capturing the access to the local function in a function handle, and then making that handle available to functions external to the file (or to the command line), the example extends that scope. An example of this is shown in the preceding section, Capture Data Values For Later Use By a Function.
Private functions also have specific access rules that limit their availability with the MATLAB environment. But, as with local functions, MATLAB allows you to construct a handle for a private function. Therefore, you can call it by means of that handle from any location or even from the MATLAB command line, should it be necessary.