Accelerating the pace of engineering and science

# Documentation Center

• Trial Software
• Product Updates

## Parameterizing Functions

### Overview

This topic explains how to store or access extra parameters for mathematical functions that you pass to MATLAB® function functions, such as fzero or integral.

MATLAB function functions evaluate mathematical expressions over a range of values. They are called function functions because they are functions that accept a function handle (a pointer to a function) as an input. Each of these functions expects that your objective function has a specific number of input variables. For example, fzero and integral accept handles to functions that have exactly one input variable.

Suppose you want to find the zero of the cubic polynomial x3 + bx + c for different values of the coefficients b and c. Although you could create a function that accepts three input variables (x, b, and c), you cannot pass a function handle that requires all three of those inputs to fzero. However, you can take advantage of properties of anonymous or nested functions to define values for additional inputs.

### Parameterizing Using Nested Functions

One approach for defining parameters is to use a nested function—a function completely contained within another function in a program file. For this example, create a file named findzero.m that contains a parent function findzero and a nested function poly:

```function y = findzero(b,c,x0)

y = fzero(@poly,x0);

function y = poly(x)
y = x^3 + b*x + c;
end
end```

The nested function defines the cubic polynomial with one input variable, x. The parent function accepts the parameters b and c as input values. The reason to nest poly within findzero is that nested functions share the workspace of their parent functions. Therefore, the poly function can access the values of b and c that you pass to findzero.

To find a zero of the polynomial with b = 2 and c = 3.5, using the starting point x0 = 0, you can call findzero from the command line:

`x = findzero(2,3.5,0)`
```x =
-1.0945```

### Parameterizing Using Anonymous Functions

Another approach for accessing extra parameters is to use an anonymous function. Anonymous functions are functions that you can define in a single command, without creating a separate program file. They can use any variables that are available in the current workspace.

For example, create a handle to an anonymous function that describes the cubic polynomial, and find the zero:

```b = 2;
c = 3.5;
cubicpoly = @(x) x^3 + b*x + c;
x = fzero(cubicpoly,0)```
```x =
-1.0945```

Variable cubicpoly is a function handle for an anonymous function that has one input, x. Inputs for anonymous functions appear in parentheses immediately following the @ symbol that creates the function handle. Because b and c are in the workspace when you create cubicpoly, the anonymous function does not require inputs for those coefficients.

You do not need to create an intermediate variable, cubicpoly, for the anonymous function. Instead, you can include the entire definition of the function handle within the call to fzero:

```b = 2;
c = 3.5;
x = fzero(@(x) x^3 + b*x + c,0)```
```x =
-1.0945```

You also can use anonymous functions to call more complicated objective functions that you define in a function file. For example, suppose you have a file named cubicpoly.m with this function definition:

```function y = cubicpoly(x,b,c)
y = x^3 + b*x + c;
end```

At the command line, define b and c, and then call fzero with an anonymous function that invokes cubicpoly:

```b = 2;
c = 3.5;
x = fzero(@(x) cubicpoly(x,b,c),0)```
```x =
-1.0945```
 Note:   To change the values of the parameters, you must create a new anonymous function. For example:```b = 10; c = 25; x = fzero(@(x) x^3 + b*x + c,0);```

## More About

Was this topic helpful?