# Value at Risk: Matricies

We define a number of methods for producing matrices in VolatilityAbstract.java.

• getCorrelationMatrix(double[][] matrix)
• getCovarianceMatrix(double[][] matrix)
• getCholeskyDecompositionMatrix(double[][] matrix)

All of these methods returns an $N \times N$ matrix for a portfolio of $N$ stocks.

## Percentage Changes

Suppose our portfolio contains multiple stocks, say GOOG, MSFT, and AAPL.

We will need to compute a vector of historical percentage changes for each of these. We can combine each of these vectors to produce a matrix of price changes.

In Analytical.java, HistoricalSimulation.java, and MonteCarlo.java we instantiate this matrix as a two dimensional array:

double[][] matrix = double[countAsset][size];


where countAsset is the number of stock symbols in our portfolio and size is the number of percentage changes in our data.

## Variance Covariance Matrix

The value of each element is simply the variance between two vectors of percentage changes.

In our implementation, we simply step through each element of our matrix and invoke getVariance().

public double[][] getCovarianceMatrix(double[][] matrix) {
int numCol = matrix.length;
double[][] covarianceMatrix = new double[numCol][numCol];

for (int i = 0; i < numCol; i++) {
for (int j = 0; j < numCol; j++)
covarianceMatrix[i][j] = getVariance(matrix[i], matrix[j]);
}
return covarianceMatrix;
}


The covariance matrix for a portfolio of GOOG, MSFT, and AAPL stocks looks something like:

Note that getVariance() is an abstract class and could be instantiated in a number of ways. The above output was computed from an equal weighted variance estimate.

## Correlation Matrix

In the below figure we illustrate the correlation of two stocks, $X$ and $Y$. Moving from left to right, we see examples of:

• full positive correlation
• independence
• full negative correlation

Each length is the volatility of the historical percentage change of each stock.

The correlation coefficient is calculated as:

In our implementation of getCorrelationMatrix(), we iterate through each matrix element and assign correlation by invoking both getVariance() and getVolatility() at each step.

public double[][] getCorrelationMatrix(double[][] matrix) {
int numCol = matrix.length;
double[][] correlationMatrix = new double[numCol][numCol];

for (int i = 0; i < numCol; i++) {
for (int j = 0; j < numCol; j++) {
double covXY = getVariance(matrix[i], matrix[j]);
double sigmaX = getVolatility(matrix[i], matrix[i]);
double sigmaY = getVolatility(matrix[j], matrix[j]);
correlationMatrix[i][j] = covXY / (sigmaX * (sigmaY));
}
}
return correlationMatrix;
}


The correlation matrix for a portfolio of GOOG, MSFT, and AAPL stocks looks something like:

The unit diagonal makes sense - any random variable is fully correlated with itself.

## Cholesky Decomposition

In all our scalar volatility estimates, we have been computing volatility as the square root of variance. But what if we need to return a multivariate (i.e. a matrix) estimate of volatility? We do in fact need this when simulating multiple stock price changes in MonteCarlo.java.

We need a way of finding the square root of a matrix $\Sigma$. But there is no direct way of doing this.

Our approach is to take the Cholesky decomposition to approximate $\Sigma$. This gives us a lower triangular matrix $L$ in which all elements above the diagonal are zero. The product of $L$ with its transpose is $\Sigma$.

Consider the following matrix $A$, which is symmetric and positive definite as an example:

We need to find $L$ such that $A=LL^T$. Writing this out looks like:

Then we obtain the following formulas for $L$:

above the diagonal

below the diagonal

Our implementation is as follows:

public double[][] getCholeskyDecomposition(double[][] matrix) {
double[][] covarianceMatrix = getCovarianceMatrix(matrix);
int numCol = matrix.length;
double[][] choleskyMatrix = new double[numCol][numCol];

for (int i = 0; i < covarianceMatrix.length; i++)
for (int j = 0; j <= i; j++) {
Double sum = 0.0;
for (int k = 0; k < j; k++)
sum += choleskyMatrix[i][k] * choleskyMatrix[j][k];
if (i == j)
choleskyMatrix[i][j] = Math.sqrt(covarianceMatrix[i][j] - sum);
else
choleskyMatrix[i][j] = (covarianceMatrix[i][j] - sum) / choleskyMatrix[j][j];
}
return choleskyMatrix;
}


The Cholesky decomposition for a portfolio of GOOG, MSFT, and AAPL stocks looks something like: