Main Content

## Compute Objective Functions

### Objective (Fitness) Functions

To use Global Optimization Toolbox functions, first write a file (or an anonymous function) that computes the function you want to optimize. This is called an objective function for most solvers, or fitness function for `ga`. The function should accept a vector, whose length is the number of independent variables, and return a scalar. For `gamultiobj`, the function should return a row vector of objective function values. For vectorized solvers, the function should accept a matrix, where each row represents one input vector, and return a vector of objective function values. This section shows how to write the file.

### Write a Function File

This example shows how to write a file for the function you want to optimize. Suppose that you want to minimize the function

`$f\left(x\right)=\mathrm{exp}\left(-\left({x}_{1}^{2}+{x}_{2}^{2}\right)\right)\left({x}_{1}^{2}-2{x}_{1}{x}_{2}+6{x}_{1}+4{x}_{2}^{2}-3{x}_{2}\right).$`

The file that computes this function must accept a vector `x` of length 2, corresponding to the variables x1 and x2, and return a scalar equal to the value of the function at `x`.

1. Select New > Script (Ctrl+N) from the MATLAB® File menu. A new file opens in the editor.

2. Enter the following two lines of code:

```function z = my_fun(x) z = x(1)^2 - 2*x(1)*x(2) + 6*x(1) + 4*x(2)^2 - 3*x(2);```
3. Save the file in a folder on the MATLAB path.

Check that the file returns the correct value.

```my_fun([2 3]) ans = 31```

For `gamultiobj`, suppose you have three objectives. Your objective function returns a three-element vector consisting of the three objective function values:

```function z = my_fun(x) z = zeros(1,3); % allocate output z(1) = x(1)^2 - 2*x(1)*x(2) + 6*x(1) + 4*x(2)^2 - 3*x(2); z(2) = x(1)*x(2) + cos(3*x(2)/(2+x(1))); z(3) = tanh(x(1) + x(2));```

### Write a Vectorized Function

The `ga`, `gamultiobj`, `paretosearch`, `particleswarm`, and `patternsearch` solvers optionally compute the objective functions of a collection of vectors in one function call. This method can take less time than computing the objective functions of the vectors serially. This method is called a vectorized function call.

To compute in vectorized fashion:

• Write your objective function to:

• Accept a matrix with an arbitrary number of rows.

• Return the vector of function values of each row.

• For `gamultiobj` or `paretosearch`, return a matrix, where each row contains the objective function values of the corresponding input matrix row.

• If you have a nonlinear constraint, be sure to write the constraint in a vectorized fashion. For details, see Vectorized Constraints.

• Set the `UseVectorized` option to `true` using `optimoptions`. For `patternsearch` or `paretosearch`, also set `UseCompletePoll` to `true`. Be sure to pass the options to the solver.

For example, to write the objective function of Write a Function File in a vectorized fashion,

```function z = my_fun(x) z = x(:,1).^2 - 2*x(:,1).*x(:,2) + 6*x(:,1) + ... 4*x(:,2).^2 - 3*x(:,2);```

To use `my_fun` as a vectorized objective function for `patternsearch`:

```options = optimoptions('patternsearch','UseCompletePoll',true,'UseVectorized',true); [x fval] = patternsearch(@my_fun,[1 1],[],[],[],[],[],[],... [],options);```

To use `my_fun` as a vectorized objective function for `ga`:

```options = optimoptions('ga','UseVectorized',true); [x fval] = ga(@my_fun,2,[],[],[],[],[],[],[],options);```

For `gamultiobj` or `paretosearch`,

```function z = my_fun(x) z = zeros(size(x,1),3); % allocate output z(:,1) = x(:,1).^2 - 2*x(:,1).*x(:,2) + 6*x(:,1) + ... 4*x(:,2).^2 - 3*x(:,2); z(:,2) = x(:,1).*x(:,2) + cos(3*x(:,2)./(2+x(:,1))); z(:,3) = tanh(x(:,1) + x(:,2));```

To use `my_fun` as a vectorized objective function for `gamultiobj`:

```options = optimoptions('ga','UseVectorized',true); [x fval] = gamultiobj(@my_fun,2,[],[],[],[],[],[],options);```

For more information on writing vectorized functions for `patternsearch`, see Vectorize the Objective and Constraint Functions. For more information on writing vectorized functions for `ga`, see Vectorize the Fitness Function.

### Gradients and Hessians

If you use `GlobalSearch` or `MultiStart`, your objective function can return derivatives (gradient, Jacobian, or Hessian). For details on how to include this syntax in your objective function, see Including Gradients and Hessians. Use `optimoptions` to set options so that your solver uses the derivative information:

Local Solver = fmincon, fminunc

ConditionOption Setting
Objective function contains gradient`'SpecifyObjectiveGradient' = true`; see How to Include Gradients
Objective function contains Hessian`'HessianFcn' = 'objective'` or a function handle; see Including Hessians
Constraint function contains gradient`'SpecifyConstraintGradient' = true`; see Including Gradients in Constraint Functions

Local Solver = lsqcurvefit, lsqnonlin

ConditionOption Setting
Objective function contains Jacobian`'SpecifyObjectiveGradient' = true`

Watch now