# Symbolic calculation using Matlab

The thing is that some times running a simulation over and over again makes no sense. One have to see the mathematical formula that is being computed to make some safe assumptions and change his approach on a subject. Without getting in detail on where someone could use something like this, Matlab gives the possibility of symbolic calculation. That is, if I want to see how the output of function `call_func` affects the inputs `A` and `B` (for a really long list of reasons) I can use syms.

Thus the code:

```
syms A B
result = call_func(A,B);
```

The above code stores in result what would be the result but with A and B kept as symbols. So if function call_func computes the A^2 + 2*A*B + B^2 (that seems familiar…) we get:

```result =
A^2 + 2*A*B + B^2
```

Which is pretty straightforward but I could not come up with something more practical. I use the syms command lately to observe the impact of each coefficient in an FFT. Also I used in before to get the result of the multiplication between two large matrices so that I could use it as a formula instead.

# Matlab Start Up

It is often frustrating, distracting and demotivating when I start Matlab and I have to start a series of commands, most frustrating of all the current directory. In order to automate things a bit the use of `startup.m` as well as the `finish.m` comes in handy.

To use this (in Windows there are also similar ways to use in other OS but I haven’t one available right now) one should create a shortcut (e.g. the on in start menu which I prefer as the only thing to start matlab is pressing the windows button and type “`mat`”) and edit the `start in`, in the properties menu. The target should be the directory with the `startup.m` file. In the file one can find:

```
cd c:\...<desired start up path >
...<any other matlab operation>
```

Any other matlab operation can be another script or matlab code. Typically initialization of parameters that have to do with the workspace mostly, like the plot styles and font sizes. However if you use a script you can run immediately the desired code, although I don’t find any particular reason for someone to be so hasty…

`Finish.m` works the same way and can be used to store data after finishing a simulation. As far as this is concerned I find it useful sometimes to export data to excel (like mentioned in a previous post) for further manipulation as in the following code example.

```save results/testTIMES testTIMES
save results/testSNR testSNR
save results/testBITS testBITS

xlswrite('results',testBITS,1,'B1')
xlswrite('results',testSNR,1,'C1')
xlswrite('results',testTIMES,1,'D1')```

# Matlab profiler

A really useful tool for code optimization in Matlab is the profiler. Using the profiler we can find the really computational intensive parts of our model and by trying to optimize them we can reduce heavily the computation time of the simulation. We can find the profiler on the desktop –> profiler (as seen below):

Once opened we can run any code we want through the profiler from the “Run this code:’” bar as seen below. I run a script of my own called prediction_script.

Once the code is ran we get a detailed report of how much time each function we use is called and how many times it is called throughout the simulation.

In the above picture we can see that the total time of the predictor script is `52.865` seconds. However only `0.031` seconds are used to run the code in the predictor script (this is the self time). so in my case the prediction script calls the predictor twice. and the predictor calls any other function.

The most computational intensive function in my case is the ` get_value ` which is called `739180` times and lasts for `18.697` seconds. It does not call any other function (both the total and the self time are the same).

By clicking on the get_value we get the detailed information on where the most computations are done. By using the profiler often we get to know which operations are time consuming in Matlab and end up writing better code.

As we can get information on which functions call the selected function the profiler can also be used for reverse engineering in case of unknown code.

So if I get to make the get_value function faster or I manage to call it less times then the simulation will end up faster overall. Easy as pie. A really useful tool!