|On this page…|
The following example creates a handle for a function supplied by MATLAB® called humps and assigns it to the variable h. (The humps function 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 fminbnd. 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 for 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.
Run the integral function on varying input functions:
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
Run 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 integral with 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, b]:
a = 0; b = 10; int1 = integral(@cos,a,b) int1 = -0.5440
with the integral over the same interval of the piecewise polynomial pp that approximates the cosine function by interpolating the computed values x and y:
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 function called 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 draw_plot as an anonymous function to be called by a function handle, h. The draw_plot function has only two inputs now; the remaining five are specified only on a call to the handle constructor function, get_plot_handle:
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 draw_plot function but are not made available in its argument list, MATLAB supplies them by storing them in the function handle for draw_plot at the time it is constructed. Construct the function handle h, 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 and y inputs:
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 addOne. 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
The addOne function that is associated with handle h increments variable x each 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, and initialize x to 300. The value of x within the function handle remains constant regardless of how you modify x external 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.