static void Main(string[] args)
{
// Classes
MiscFunctions MF = new MiscFunctions();
DiffEvoAlgo DE = new DiffEvoAlgo();
NelderMeadAlgo NM = new NelderMeadAlgo();
ObjectiveFunction OF = new ObjectiveFunction();
// 32-point Gauss-Laguerre Abscissas and weights
double[] X = new Double[32];
double[] W = new Double[32];
using (TextReader reader = File.OpenText("../../GaussLaguerre32.txt"))
for (int k = 0; k <= 31; k++)
{
string text = reader.ReadLine();
string[] bits = text.Split(' ');
X[k] = double.Parse(bits[0]);
W[k] = double.Parse(bits[1]);
}
// Option settings
OPSet opset;
opset.S = 137.14;
opset.r = 0.0010;
opset.q = 0.0068;
opset.trap = 1;
// Bisection algorithm settings
double a = 0.01;
double b = 3.0;
double Tol = 1e-5;
int MaxIter = 1000;
int ObjectiveFun = 1;
// Read in SP500 implied volatilities
int NT = 4;
int NK = 7;
double[,] MktIV = new Double[7, 4]
{
{ 0.2780, 0.2638, 0.2532, 0.2518 },
{ 0.2477, 0.2402, 0.2364, 0.2369 },
{ 0.2186, 0.2158, 0.2203, 0.2239 },
{ 0.1878, 0.1930, 0.2047, 0.2098 },
{ 0.1572, 0.1712, 0.1894, 0.1970 },
{ 0.1334, 0.1517, 0.1748, 0.1849 },
{ 0.1323, 0.1373, 0.1618, 0.1736 }
};
double[] K = new Double[7] {
120.0, 125.0, 130.0, 135.0, 140.0, 145.0, 150.0
};
double[] T = new Double[4] {
0.123287671232877, 0.268493150684932, 0.715068493150685, 0.953424657534247
};
// PutCall identifiers
string[,] PutCall = new String[NK, NT];
for (int k = 0; k <= NK - 1; k++)
{
for (int t = 0; t <= NT - 1; t++)
{
PutCall[k, t] = "C";
}
}
// Obtain the market prices
BlackScholesPrice BS = new BlackScholesPrice();
double[,] MktPrice = new Double[NK, NT];
for (int k = 0; k <= NK - 1; k++)
{
for (int t = 0; t <= NT - 1; t++)
{
MktPrice[k, t] = BS.BlackScholes(opset.S, K[k], T[t], opset.r, opset.q, MktIV[k, t], PutCall[k, t]);
}
}
// Place the market data in the structure
MktData data = new MktData();
data.MktIV = MktIV;
data.MktPrice = MktPrice;
data.K = K;
data.T = T;
data.PutCall = PutCall;
// Estimation bounds
double e = 1e-5;
double kappaL = e; double kappaU = 10;
double thetaL = e; double thetaU = 5;
double sigmaL = e; double sigmaU = 5;
double v0L = e; double v0U = 1;
double rhoL = -.9; double rhoU = 0;
double[] ub = new double[5] {
kappaU, thetaU, sigmaU, v0U, rhoU
};
double[] lb = new double[5] {
kappaL, thetaL, sigmaL, v0L, rhoL
};
// Objective function settings;
OFSet ofset;
ofset.opset = opset;
ofset.data = data;
ofset.X = X;
ofset.W = W;
ofset.LossFunction = 4; // Choice of loss function 1=MSE, 2=RMSE, 3=IVMSE, 4=Christoffersen et al.
ofset.lb = lb;
ofset.ub = ub;
ofset.CF = "Heston"; // Choice of c.f. "Heston" or "Attari"
// Settings for the Differential Evolution algorithm
DEParam ParamLim = new DEParam();
ParamLim.ub = ub;
ParamLim.lb = lb;
ParamLim.NG = 500;
ParamLim.NP = 75;
ParamLim.F = 0.5;
ParamLim.CR = 0.8;
// Run the differential evolution algorithm
HParam DEparam = DE.HestonDE(ParamLim, opset, data, ObjectiveFun, a, b, Tol, MaxIter, X, W, ofset.CF);
// Starting values (vertices) in vector form. Add random increment about each starting value
double kappaS = 9;
double thetaS = 0.05;
double sigmaS = 0.3;
double v0S = 0.05;
double rhoS = -0.8;
int N = 5;
double[,] s = new double[N, N + 1];
for (int j = 0; j <= N; j++)
{
s[0, j] = kappaS + MF.RandomNum(-0.10, 0.10);
s[1, j] = thetaS + MF.RandomNum(-0.01, 0.01);
s[2, j] = sigmaS + MF.RandomNum(-0.05, 0.05);
s[3, j] = v0S + MF.RandomNum(-0.01, 0.01);
s[4, j] = rhoS + MF.RandomNum(-0.05, 0.05);
}
// Nelder Mead settings
NMSet nmset;
nmset.ofset = ofset;
nmset.N = 5; // Number of Heston parameters
nmset.MaxIters = 1000; // Maximum number of iterations
nmset.Tolerance = 1e-4; // Tolerance on best and worst function values
// Run the Nelder Mead algorithm
double[] B = NM.NelderMead(OF.f, nmset, s);
HParam NMparam = new HParam();
NMparam.kappa = B[0];
NMparam.theta = B[1];
NMparam.sigma = B[2];
NMparam.v0 = B[3];
NMparam.rho = B[4];
// Calculate IVMSE under both parameter estimates
double[,] NMPrice = new double[NK, NT];
double[,] DEPrice = new double[NK, NT];
double[,] NMIV = new double[NK, NT];
double[,] DEIV = new double[NK, NT];
double NMIVMSE = 0.0;
double DEIVMSE = 0.0;
double S = opset.S;
double r = opset.r;
double q = opset.q;
int trap = opset.trap;
HestonPrice HP = new HestonPrice();
Bisection BA = new Bisection();
for (int t = 0; t < NT; t++)
{
for (int k = 0; k < NK; k++)
{
NMPrice[k, t] = HP.HestonPriceGaussLaguerre(NMparam, S, K[k], r, q, T[t], trap, PutCall[k, t], X, W);
NMIV[k, t] = BA.BisecBSIV(PutCall[k, t], S, K[k], r, q, T[t], a, b, NMPrice[k, t], Tol, MaxIter);
NMIVMSE += Math.Pow(MktIV[k, t] - NMIV[k, t], 2) / Convert.ToDouble(NT * NK);
DEPrice[k, t] = HP.HestonPriceGaussLaguerre(DEparam, S, K[k], r, q, T[t], trap, PutCall[k, t], X, W);
DEIV[k, t] = BA.BisecBSIV(PutCall[k, t], S, K[k], r, q, T[t], a, b, DEPrice[k, t], Tol, MaxIter);
DEIVMSE += Math.Pow(MktIV[k, t] - DEIV[k, t], 2) / Convert.ToDouble(NT * NK);
}
}
// Output the result
Console.WriteLine(" ");
Console.WriteLine("Parameter Estimates --------------------");
Console.WriteLine(" Differential Evolution Nelder Mead");
Console.WriteLine("kappa {0,10:F4} {1,25:F4}", DEparam.kappa, NMparam.kappa);
Console.WriteLine("theta {0,10:F4} {1,25:F4}", DEparam.theta, NMparam.theta);
Console.WriteLine("sigma {0,10:F4} {1,25:F4}", DEparam.sigma, NMparam.sigma);
Console.WriteLine("v0 {0,10:F4} {1,25:F4}", DEparam.v0, NMparam.v0);
Console.WriteLine("rho {0,10:F4} {1,25:F4}", DEparam.rho, NMparam.rho);
Console.WriteLine(" ");
Console.WriteLine("IV MSE ---------------------------------");
Console.WriteLine("Differential Evolution IVMSE {0:E8}", DEIVMSE);
Console.WriteLine("Nelder Mead IVMSE {0:E8}", NMIVMSE);
Console.WriteLine(" ");
}
// Differential evolution algorithm
public HParam HestonDE(DEParam DEsettings, OPSet settings, MktData data, int LossFunction, double a, double b, double Tol, int MaxIter, double[] X, double[] W, string CF)
{
// NG = Number of generations (iterations)
// NP = Number of population members
// CR = Crossover ratio (=0.5)
// F = Threshold (=0.8)
// Hi = Vector of upper bounds for the parameters
// Lo = Vector of lower bounds for the parameters
// S = Spot Price
// K1 = First strike point for the FRFT
// rf = Risk free rate
// q = Dividend Yield
// MktPrice = Market quotes for prices
// K = Vector of Strikes
// T = Vector of Maturities
// PutCall = Matrix of 'P'ut or 'C'all
// MktIV = Market quotes for implied volatilities
// LossFunction = Type of Objective Function 1 = MSE; 2 = RMSE; 3 = IVMSE; 4 = Christoffersen, Jacobs, Heston (2009)
// Bisection method settings; a = Lower limit; b = upper limit; Tol = Tolerance; MaxIter = Max number of iterations
// trap = 1 is "Little Trap" c.f., 0 is Heston c.f.
// X, W = Gauss Laguerre abscissas and weights
// CF = "Heston" or "Attari" characteristic function
ObjectiveFunction OF = new ObjectiveFunction();
MiscFunctions MF = new MiscFunctions();
double[] Hi = DEsettings.ub;
double[] Lo = DEsettings.lb;
double CR = DEsettings.CR;
double kappaU = Hi[0]; double kappaL = Lo[0];
double thetaU = Hi[1]; double thetaL = Lo[1];
double sigmaU = Hi[2]; double sigmaL = Lo[2];
double v0U = Hi[3]; double v0L = Lo[3];
double rhoU = Hi[4]; double rhoL = Lo[4];
// Create the structure for the objective function;
OFSet ofset;
ofset.opset = settings;
ofset.data = data;
ofset.X = X;
ofset.W = W;
ofset.LossFunction = LossFunction;
ofset.lb = DEsettings.lb;
ofset.ub = DEsettings.ub;
ofset.CF = CF;
// Step1. Generate the population matrix of random parameters
int NP = DEsettings.NP;
int NG = DEsettings.NG;
double F = DEsettings.F;
double[,] P = new double[5, NP];
for (int j = 0; j <= NP - 1; j++)
{
P[0, j] = kappaL + (kappaU - kappaL) * MF.RandomNum(0.0, 1.0);
P[1, j] = thetaL + (thetaU - thetaL) * MF.RandomNum(0.0, 1.0);
P[2, j] = sigmaL + (sigmaU - sigmaL) * MF.RandomNum(0.0, 1.0);
P[3, j] = v0L + (v0U - v0L) * MF.RandomNum(0.0, 1.0);
P[4, j] = rhoL + (rhoU - rhoL) * MF.RandomNum(0.0, 1.0);
}
// Generate the random numbers outside the loop
double[, ,] U = new double[5, NP, NG];
for (int k = 0; k <= NG - 1; k++)
{
for (int j = 0; j <= NP - 1; j++)
{
for (int i = 0; i <= 4; i++)
{
U[i, j, k] = MF.RandomNum(0.0, 1.0);
}
}
}
// Initialize the variables
double[] Pr1 = new double[5];
double[] Pr2 = new double[5];
double[] Pr3 = new double[5];
double[] P0 = new double[5];
// Loop through the generations
for (int k = 0; k <= NG - 1; k++)
{
Console.Write("Differential Evolution iteration "); Console.WriteLine(k);
// Loop through the population
for (int i = 0; i <= NP - 1; i++)
{
// Select the i-th member of the population
for (int s = 0; s <= 4; s++)
{
P0[s] = P[s, i];
}
Step0:
// Select random indices for three other distinct members
int[] Integers0toNP1 = new int[NP];
for (int s = 0; s <= NP - 1; s++)
{
Integers0toNP1[s] = s;
}
// Random perumation of the indices (0,1,...,NP-1)
int[] I = MF.RandomPerm(Integers0toNP1);
// Find the index in I that is not equal to i and keep the first 3 positions
int[] L = MF.RemoveIndex(I, i);
int[] r = new int[3];
for (int s = 0; s <= 2; s++)
{
r[s] = L[s];
}
// The three distinct members of the population
for (int s = 0; s <= 4; s++)
{
Pr1[s] = P[s, r[0]];
Pr2[s] = P[s, r[1]];
Pr3[s] = P[s, r[2]];
}
int[] Integers1to5 = { 1, 2, 3, 4, 5 };
int[] R = MF.RandomPerm(Integers1to5);
double[] Pnew = { 0.0, 0.0, 0.0, 0.0, 0.0 };
// Steps 2 and 3. Mutation and recombination
double Ri;
double u;
for (int j = 0; j <= 4; j++)
{
Ri = R[0];
u = U[j, i, k];
if ((u <= CR) | (j == Ri))
{
Pnew[j] = Pr1[j] + F * (Pr2[j] - Pr3[j]);
}
else
{
Pnew[j] = P0[j];
}
}
// Repeat above to code to ensure new members fall within the
// range of acceptable parameter values
int[] Flag = new int[5] {
0, 0, 0, 0, 0
};
for (int s = 0; s <= 4; s++)
{
if (Pnew[s] <= Lo[s] | Pnew[s] >= Hi[s])
{
Flag[s] = 1;
}
}
int Condition = Flag.Sum();
if (Condition > 0)
{
goto Step0;
}
// Step 4. Selection
// Calculate the objective function for the ith member and for the candidate
double f0 = OF.f(P0, ofset);
double fnew = OF.f(Pnew, ofset);
// Verify whether the candidate should replace the i-th member
// in the population and replace if conditions are satisfied
if (fnew < f0)
{
for (int s = 0; s <= 4; s++)
{
P[s, i] = Pnew[s];
}
}
}
}
// Calculate the objective function for each member in the updated population
double[] fs = new double[NP];
double[] Pmember = new double[5];
for (int s = 0; s <= NP - 1; s++)
{
for (int t = 0; t <= 4; t++)
{
Pmember[t] = P[t, s];
}
fs[s] = OF.f(Pmember, ofset);
}
// Find the member with the lowest objective function
double Minf = fs[0];
int Minpos = 0;
for (int s = 0; s <= NP - 1; s++)
{
if (fs[s] < Minf)
{
Minf = fs[s];
Minpos = s;
}
}
// Return the selected member/parameter
HParam Pfinal = new HParam();
Pfinal.kappa = P[0, Minpos];
Pfinal.theta = P[1, Minpos];
Pfinal.sigma = P[2, Minpos];
Pfinal.v0 = P[3, Minpos];
Pfinal.rho = P[4, Minpos];
return(Pfinal);
}