Anonymous Functions :: Types of Functions (Programming)

Programming

Anonymous Functions

Anonymous functions give you a quick means of creating simple functions without having to create M-files each time. You can construct an anonymous function either at the MATLAB command line or in any M-file function or script.

This section covers

Constructing an Anonymous Function

The syntax for creating an anonymous function from an expression is

```
fhandle = @(arglist) expr
```

Starting from the right of this syntax statement, the term expr represents the body of the function: the code that performs the main task your function is to accomplish. This consists of any single, valid MATLAB expression. Next is arglist, which is a comma-separated list of input arguments to be passed to the function. These two components are similar to the body and argument list components of any function.

Leading off the entire right side of this statement is an @ sign. The @ sign is the MATLAB operator that constructs a function handle. Creating a function handle for an anonymous function gives you a means of invoking the function. It is also useful when you want to pass your anonymous function in a call to some other function. The @ sign is a required part of an anonymous function definition.

Note Function handles not only provide access to anonymous functions. You can create a function handle to any MATLAB function. The constructor uses a different syntax: fhandle = @functionname (e.g., fhandle = @sin). To find out more about function handles, see Function Handles.

The syntax statement shown above constructs the anonymous function, returns a handle to this function, and stores the value of the handle in variable fhandle. You can use this function handle in the same way as any other MATLAB function handle.

Simple Example

The statement below creates an anonymous function that finds the square of a number. When you call this function, MATLAB assigns the value you pass in to variable x, and then uses x in the equation x.^2:

```
sqr = @(x) x.^2;
```

The @ operator constructs a function handle for this function, and assigns the handle to the output variable sqr. As with any function handle, you execute the function associated with it by specifying the variable that contains the handle, followed by a comma-separated argument list in parentheses. The syntax is

```
fhandle(arg1, arg2, ..., argN)
```

To execute the sqr function defined above, type

```
a = sqr(5)
a =
   25
```

Because sqr is a function handle, you can pass it in an argument list to other functions. The code shown here passes the sqr anonymous function to the MATLAB quad function to compute its integral from zero to one:

```
quad(sqr, 0, 1)
ans =
   0.3333
```

A Two-Input Example

As another example, you could create the following anonymous function that uses two input arguments, x and y. (The example assumes that variables A and B are already defined):

sumAxBy = @(x, y) (A*x + B*y);

whos sumAxBy
Name        Size                   Bytes  Class

sumAxBy     1x1                       16  function_handle

To call this function, assigning 5 to x and 7 to y, type

```
sumAxBy(5, 7)
```

Evaluating With No Input Arguments

For anonymous functions that do not take any input arguments, construct the function using empty parentheses for the input argument list:

```
t = @() datestr(now);
```

Also use empty parentheses when invoking the function:

```
t()

ans =
04-Sep-2003 10:17:59
```

You must include the parentheses. If you type the function handle name with no parentheses, MATLAB just identifies the handle; it does not execute the related function:

```
t

t = 
    @() datestr(now)
```

Overview of MATLAB Function Types Arrays of Anonymous Functions