Got it to work by adding

#include

at the top.

Also changed the second to last line from

100*annual(Moment(Returns[i],LookBack,1)),

to

252*100*Moment(Returns[i],LookBack,1),

Just passing this along in case any one else is stuck.

This is just from my game programming background. We game programmers use always one-dimensional arrays and always address them with [N*i+j] for gaining a few microseconds. But speed does not matter much for this system, so you can also use the conventional [i][j] addressing if you want.

Covariances[N*i+j] = Covariance(Returns[i],Returns[j],LookBack);

Why N*i+j? We declared Covariances[NN][NN] (NN defined 30) as two-dimensional array and here we use only one dimension and with strange math as Covariances[6*6+6].

Thank you in advance

I ran some tests, and I have some observations:

1) In terms of profits, your original simple average formula tended to be more profitable, per the modified MVOTest script.
2) The deviation of Geometric Means tend to be large when variance is large. I modified the Heatmap script, and here’s the log output (five years of lookback):

1 – TLT: GeoMean 8.58% Mean 9.68% Variance 2.01% M/GM = 1.1216
2 – LQD: GeoMean 4.87% Mean 5.26% Variance 0.73% M/GM = 1.0762
3 – SPY: GeoMean 8.45% Mean 10.35% Variance 3.45% M/GM = 1.2141
4 – GLD: GeoMean 7.08% Mean 8.04% Variance 1.78% M/GM = 1.1295
5 – VGLT: GeoMean 8.44% Mean 9.39% Variance 1.74% M/GM = 1.1072
6 – AOK: GeoMean 3.67% Mean 3.86% Variance 0.38% M/GM = 1.0526

In the right column, I checked to see how much larger the mean was than the geometric mean.

OK, one more, but with one year of lookback:

1 – TLT: GeoMean 39.01% Mean 42.29% Variance 4.71% M/GM = 1.0710
2 – LQD: GeoMean 11.96% Mean 13.52% Variance 2.79% M/GM = 1.1223
3 – SPY: GeoMean -0.87% Mean 4.19% Variance 9.90% M/GM = -4.7005
4 – GLD: GeoMean 33.22% Mean 35.16% Variance 2.91% M/GM = 1.0504
5 – VGLT: GeoMean 38.18% Mean 40.92% Variance 3.97% M/GM = 1.0609
6 – AOK: GeoMean 3.50% Mean 4.05% Variance 1.07% M/GM = 1.1556

Here, you can see a huge discrepancy between SPY’s geometric mean and simple mean. Also, TLT and VGLT were wildly profitable in lookback, so their means were somewhat close together despite high volatility.

I have a hypothesis that your script is more aggressive/”fearless” than mine (more emphasis on volatile assets), and it’s somehow reaping extra profit from it.

At this point, I’m mostly curious to know how the resulting sharpe ratios compare. Perhaps the geometric equity curves are less volatile? More research required.

For your reference, here’s the geometric average function:

// Geometric Average of Returns.
// Data input: relative returns, e.g. 0.12 for 12% return, -0.054 for -5.4% return, etc.
// len: Number of elements to be averaged.
var GeometricAvg(vars Data, int len){
len = max(1,len);
int i;
var scaleup = 1;
for(i=0;i<len;i++){
scaleup *= Data[i] + 1;
}
return pow(scaleup,((var)1)/len)-1;
}

I see that you are using the first moment to evaluate average returns. If I’m not mistaken, this is a simple average.

Wouldn’t a geometric average of returns be more appropriate here?

An extreme example: An asset returns +200%, +200%, -99%, and 200%. A simple average will calculate an amazing return of 125%, whereas a geometric average calculates a -73% return.

It seems that simple average of returns will tend to overrate volatile assets, whereas a geometric average return will always better reflect actual returns of the sample period.