Finding Zeros of Functions :: Function Functions (Mathematics)

Mathematics

Finding Zeros of Functions

The fzero function attempts to find a zero of one equation with one variable. You can call this function with either a one-element starting point or a two-element vector that designates a starting interval. If you give fzero a starting point x0, fzero first searches for an interval around this point where the function changes sign. If the interval is found, fzero returns a value near where the function changes sign. If no such interval is found, fzero returns NaN. Alternatively, if you know two points where the function value differs in sign, you can specify this starting interval using a two-element vector; fzero is guaranteed to narrow down the interval and return a value near a sign change.

The following sections contain two examples that illustrate how to find a zero of a function using a starting interval and a starting point. The examples use the function humps, which is provided with MATLAB. The following figure shows the graph of humps.

Using a Starting Interval

The graph of humps indicates that the function is negative at x = -1 and positive at x = 1. You can confirm this by calculating humps at these two points.

humps(1)

ans =
    16

humps(-1)

ans =
   -5.1378

Consequently, you can use [-1 1] as a starting interval for fzero.

The iterative algorithm for fzero finds smaller and smaller subintervals of [-1 1]. For each subinterval, the sign of humps differs at the two endpoints. As the endpoints of the subintervals get closer and closer, they converge to a zero for humps.

To show the progress of fzero at each iteration, set the Display option to iter using the function optimset.

```
options = optimset('Display','iter');
```

Then call fzero as follows:

```
a = fzero(@humps,[-1 1],options)
```

This returns the following iterative output:

a = fzero(@humps,[-1 1],options)
 
 Func-count    x          f(x)             Procedure
    2              -1      -5.13779        initial
    3       -0.513876      -4.02235        interpolation
    4       -0.513876      -4.02235        bisection
    5       -0.473635      -3.83767        interpolation
    6       -0.115287      0.414441        bisection
    7       -0.115287      0.414441        interpolation
    8       -0.132562    -0.0226907        interpolation
    9       -0.131666    -0.0011492        interpolation
   10       -0.131618  1.88371e-007        interpolation
   11       -0.131618  -2.7935e-011        interpolation
   12       -0.131618  8.88178e-016        interpolation
   13       -0.131618  8.88178e-016        interpolation
 
Zero found in the interval [-1, 1]

a =

   -0.1316

Each value x represents the best endpoint so far. The Procedure column tells you whether each step of the algorithm uses bisection or interpolation.

You can verify that the function value at a is close to zero by entering

```
humps(a)

ans =

  8.8818e-016
```

Using a Starting Point

Suppose you do not know two points at which the function values of humps differ in sign. In that case, you can choose a scalar x0 as the starting point for fzero. fzero first searches for an interval around this point on which the function changes sign. If fzero finds such an interval, it proceeds with the algorithm described in the previous section. If no such interval is found, fzero returns NaN.

For example, if you set the starting point to -0.2, the Display option to Iter, and call fzero by

```
a = fzero(@humps,-0.2,options)
```

fzero returns the following output:

Search for an interval around -0.2 containing a sign change:
 Func-count    a          f(a)             b          f(b)        Procedure
    1            -0.2      -1.35385          -0.2      -1.35385   initial interval
    3       -0.194343      -1.26077     -0.205657      -1.44411   search
    5          -0.192      -1.22137        -0.208       -1.4807   search
    7       -0.188686      -1.16477     -0.211314      -1.53167   search
    9          -0.184      -1.08293        -0.216      -1.60224   search
   11       -0.177373     -0.963455     -0.222627      -1.69911   search
   13          -0.168     -0.786636        -0.232      -1.83055   search
   15       -0.154745      -0.51962     -0.245255      -2.00602   search
   17          -0.136     -0.104165        -0.264      -2.23521   search
   18        -0.10949      0.572246        -0.264      -2.23521   search
 
Search for a zero in the interval [-0.10949, -0.264]:
 Func-count    x          f(x)             Procedure
   18        -0.10949      0.572246        initial
   19       -0.140984     -0.219277        interpolation
   20       -0.132259    -0.0154224        interpolation
   21       -0.131617  3.40729e-005        interpolation
   22       -0.131618 -6.79505e-008        interpolation
   23       -0.131618 -2.98428e-013        interpolation
   24       -0.131618  8.88178e-016        interpolation
   25       -0.131618  8.88178e-016        interpolation
 
Zero found in the interval [-0.10949, -0.264]

a =

   -0.1316

The endpoints of the current subinterval at each iteration are listed under the headings a and b, while the corresponding values of humps at the endpoints are listed under f(a) and f(b), respectively.

Note The endpoints a and b are not listed in any specific order: a can be greater than b or less than b.

For the first nine steps, the sign of humps is negative at both endpoints of the current subinterval, which are listed under in the output. At the tenth step, the sign of humps is positive at the endpoint, -0.10949, but negative at the endpoint, -0.264. From this point on, the algorithm continues to narrow down the interval [-0.10949 -0.264], as described in the previous section, until it reaches the value -0.1316.

Output Functions Tips