internal static Matrix CovarianceMatrixSerialCorrelationCorrected(double[] array1, double[] array2, double decayFactor, int length)
{
double[] array1Len = Tools.MostRecentValues(array1, length);
double[] array2Len = Tools.MostRecentValues(array2, length);
double[] array1Lag = Tools.LagArray(array1, length, 1);
double[] array2Lag = Tools.LagArray(array2, length, 1);
double[,] lagArray = new double[length, 2];
for (int i = 0; i < length; i++)
{
lagArray[i, 0] = array1Lag[i];
lagArray[i, 1] = array2Lag[i];
}
WeightedLeastSquares wls1 = new WeightedLeastSquares(array1Len, lagArray, true, decayFactor);
WeightedLeastSquares wls2 = new WeightedLeastSquares(array2Len, lagArray, true, decayFactor);
Matrix D = new Matrix(2, 2);
D[0, 0] = wls1.Betas[1].Value;
D[0, 1] = wls1.Betas[2].Value;
D[1, 0] = wls2.Betas[1].Value;
D[1, 1] = wls2.Betas[2].Value;
Matrix C = new Matrix(2, 2);
C[0, 0] = Variance(array1Len, decayFactor);
C[0, 1] = Covariance(array1Len, array2Len, decayFactor);
C[1, 0] = C[0, 1];
C[1, 1] = Variance(array2Len, decayFactor);
Matrix M = SerialCorrelationCorrection.SerialCorrelationVarianceCorrection(D, C);
Matrix CStar = M.Multiply(C);
return(CStar);
}
/// <summary>
/// Hybrid VaR is based on historical data, but weights more recent data more heavily.
/// </summary>
/// <param name="returnArray">Historical returns from which VaR is to be calculated. The last value, with the highest index is assumed to be the most recent data point.</param>
/// <param name="windowLength">Length of the VaR window. The number of historical returns that will be used to calculate the VaR.</param>
/// <param name="confidenceLevel">VaR confidence level. 95% and 99% are typical values. If confidenceLevel is 95% then we expect 95% of days to be better (have a more positive return) than the VaR.</param>
/// <param name="decayFactor">For a decay factor d, the most recent data point has weight 1, the second d, the third d^2, ...</param>
/// <param name="correctSerialCorrelation">If true, correction is for infinite return length.</param>
public static double HybridValueAtRisk(double[] returnArray, int windowLength, double confidenceLevel, double decayFactor, bool correctSerialCorrelation)
{
double uncorrected = HybridValueAtRisk(returnArray, windowLength, confidenceLevel, decayFactor);
if (!correctSerialCorrelation)
{
return(uncorrected);
}
double[] subArray = Tools.MostRecentValues(returnArray, windowLength);
double serialCorrelation = Moments.SerialCorrelation(subArray, decayFactor);
double varianceCorrectionFactor = SerialCorrelationCorrection.SerialCorrelationVarianceCorrection(serialCorrelation); //don't use version w/ windowLength. windowLenght != length. Length is how far back we go to get data for the calculation. windowLenght is the return lenght that we are correcting to (infinite, by default).
return(uncorrected * Math.Sqrt(varianceCorrectionFactor));
}
/// <summary>
/// Returns the sample standard deviation of an array, corrected for serial correlation.
/// </summary>
/// <param name="array">Array of data for which we are calculating the variance. For time series, the last element (index = n-1), is the most recent.</param>
/// <param name="decayFactor">In most applications, the decay factor is between 0 and 1. Weigth on the last element in array is 1.0, the 2nd to last element d, 3rd to last d^2, ...</param>
/// <param name="length">Window length. Method uses the most recent n points, n = length.</param>
/// <param name="correctSerialCorrelation">If true, correction is for infinite return length.</param>
public static double StandardDeviation(double[] array, double decayFactor, int length, bool correctSerialCorrelation)
{
double uncorrected = StandardDeviation(array, decayFactor, length);
if (!correctSerialCorrelation)
{
return(uncorrected);
}
double[] subArray = Tools.MostRecentValues(array, length);
double serialCorrelation = SerialCorrelation(subArray, decayFactor);
double varianceCorrectionFactor = SerialCorrelationCorrection.SerialCorrelationVarianceCorrection(serialCorrelation); //don't use version w/ windowLength. windowLenght != length. Length is how far back we go to get data for the calculation. windowLenght is the return lenght that we are correcting to (infinite, by default).
return(uncorrected * Math.Sqrt(varianceCorrectionFactor));
}
