It has been a long time since the last post about the use of Borg in Matlab, so this post pretends to be an update of Compiling the Borg Matlab Wrapper (Windows), and in an easier way.

The following steps were tested in Windows 10 and MATLAB R2017a, but should be valid for different versions too.

**Step 0: Get Borg source code from Bitbucket repository**

Check step 2 in the post Basic Borg MOEA use for the truly newbies (Part 1/2) (also check step 1 for a simplified explanation about Borg).

You will need to have the following files in the same directory:

- borg.c
- borg.h
- mt19937ar.c
- mt19937ar.h
- nativeborg.cpp
- borg.m
- DTLZ2.m (test problem code)

You can find the first four files in the main directory you downloaded from Bitbucket, and to get the last three you have to navigate to the “*plugins\Matlab”* directory.

**Step 1: Check compiler in Matlab**

At Matlab command line run:

mex -setup

to check if there is a compiler already installed. If there is not, install the one that Matlab suggests (depends on the version).

In 2017a and previous versions there could be a bug when trying to download the suggested compiler (e.g. MIN GW in 2017a). Follow Matlab instructions. They will take you through some steps, which basically are: downloading a folder and pasting it in the installation directory of Matlab, replacing an existing one.

Alternatively (outside Matlab), you could download and install Visual Studio (Community version for free). Once installed, Matlab should recognize it immediately (check with *mex -setup* command anyway).

**Step 2: Compile Borg in Matlab**

Make sure you are in the directory with the required files from Step 0 and run (again, at Matlab command line):

mex nativeborg.cpp borg.c mt19937ar.c

The file *nativeborg.mexw64* should be created (the extension should vary according to your system). Once you do that you are done, and you are ready to run the test problem.

**Step 3: Run a test problem (DTLZ2)**

Inside Matlab, make sure you are in the directory that contains:

- borg.m
- nativeborg.mexw64
- DTLZ2.m

The file *DTLZ2.m* is an example of how an objective function should be formatted for use with the Borg Matlab Wrapper. It should take a vector of decision variables as input, and return a vector of objectives (and optionally, constraints) as output.

From the command line, you can optimize the DTLZ2 function as follows:

[vars, objs, runtime] = borg(11, 2, 0, @DTLZ2, 100000, 0.01*ones(1,2), zeros(1,11), ones(1,11));

which returns the decision variables and objectives of the Pareto optimal solutions (i.e. the Pareto-approximate set), and runtime statistics. The first three inputs to the *borg* function are: the number of decision variables, number of objectives, and number of constraints. After that comes the handle for the objective function, the number of function evaluations to run in the optimization, the epsilon precision values for the objectives, and finally the lower and upper bounds of the decision variables. For a more detailed description of inputs and outputs you can run:

help borg

Finally, to see the resulting Pareto frontier run:

scatter(objs(:,1), objs(:,2))

it should be a very good approximation of the first quadrant of the unit circle.

Now you just need to replace DTLZ2 with an objective function or model of your choice, and you’ll be ready to go!

**Note:** to successfully use the Borg Matlab Wrapper in the future make sure to have *borg.m* and *nativeborg.mexw64* in the same directory you are working on, or in a directory whose path is saved in Matlab (you can manage your paths with *addpath* and *savepath* functions).

**Some tips:**

#### Tip 1:

When calling *borg(…)*, one of the most important inputs is the objective function (the *“@DTLZ2”* function handle in the test problem) since it contains the structure of the problem you are solving (i.e. the simulation model of your problem).

As mentioned before, this function should take the decision variables as input and return the value of the objectives as output. However, in some cases your function could need to take as inputs also other information in addition to the decision variables, for example:

% objective function example obj_values = simModel(decisions, params)

where *params* could be some data read from a text file or you had calculated before (e.g. streamflow scenarios) and remain unchanged during the optimization procedure. If that is your case, you can first define *params* and then define a function handle where *params* is fixed:

params = whatever_your_function_needs; % handle of simModel function that has the variable “params” fixed, so its input is just “decisions” simModelFixed = @(decisions) simModel(decisions, params); % call Borg [vars, objs, runtime] = borg(..., simModelFixed, ...);

Maybe you could be thinking on reading or generating your additional parameters inside your simulation model function, but doing that, the process will be repeated in every function evaluation when running Borg, which could be highly inefficient.

#### Tip 2:

Be careful with *NaN* and *Inf* values in your objective function when using Borg as they will cause Matlab to crash and close with no error message. These values could arise accidentally if you forgot to condition some particular cases in your calculations (e.g. division by zero).

#### Tip 3:

When you run *help borg* you can observe that an optional input to the function is *parameters*. This input lets you modify internal parameters of the algorithm. For details on how to do that you can refer to the post Setting Borg parameters from the Matlab wrapper, but make sure to understand how Borg works before thinking of tuning it.

To learn about Borg features and full details please refer to *“Hadka, D., and Reed, P.M. “Borg: An Auto-Adaptive Many-Objective Evolutionary Computing Framework.” Evolutionary Computation, 21(2):231-259, 2013.”* and references therein.