public static void TestVasicekCalibration()
{
double r0 = 0.01;
double k = 0.5;
double theta = 0.01;
double sigma = 0.2;
VasicekModel model = new VasicekModel(r0, k, theta, sigma);
double[] bondMaturities = new double[] { 1, 2, 10 };
double[] optionExerciseTimes = new double[] { 0.5, 1, 2 };
double[] optionStrikes = new double[] { 0.9, 0.9, 0.9 };
double[] prices = new double[bondMaturities.Length];
//Console.WriteLine("European call options on ZCBs, prices");
for (int i = 0; i < bondMaturities.Length; ++i)
{
double T = bondMaturities[i], S = optionExerciseTimes[i], K = optionStrikes[i];
//prices[i] = model.PriceZCBCall(S, K, T);
prices[i] = 0.05;
}
VasicekCalibrator calibrator = new VasicekCalibrator(r0, 1e-15, 2000);
for (int i = 0; i < bondMaturities.Length; ++i)
{
calibrator.AddObservedOption(bondMaturities[i], optionExerciseTimes[i], optionStrikes[i], prices[i]);
}
calibrator.Calibrate();
double error = 0;
CalibrationOutcome outcome = CalibrationOutcome.NotStarted;
calibrator.GetCalibrationStatus(ref outcome, ref error);
Console.WriteLine("Calibration outcome: {0} and error: {1}", outcome, error);
}
/// <summary>
/// Initializes a new instance of the
/// <see cref="T:HestonModel.Classes.InterfaceClasses.HestonCalibrationResult"/> class.
/// </summary>
/// <param name="pricingError">Pricing error.</param>
/// <param name="status">Calibration Status.</param>
/// <param name="parameters">Result Parameters.</param>
public HestonCalibrationResult(double pricingError,
CalibrationOutcome status, HestonModelParameters parameters)
{
_PricingError = pricingError;
_MinimizerStatus = status;
_Parameters = parameters;
}
/// <summary>
/// Method for calibrating the heston model.
/// </summary>
/// <param name="guessModelParameters">Object implementing IHestonModelParameters interface containing the risk-free rate, initial stock price
/// and initial guess parameters to be used in the calibration.</param>
/// <param name="referenceData">A collection of objects implementing IOptionMarketData<IEuropeanOption> interface. These should contain the reference data used for calibration.</param>
/// <param name="calibrationSettings">An object implementing ICalibrationSettings interface.</param>
/// <returns>Object implementing IHestonCalibrationResult interface which contains calibrated model parameters and additional diagnostic information</returns>
public static IHestonCalibrationResult CalibrateHestonParameters(IHestonModelParameters guessModelParameters, IEnumerable <IOptionMarketData <IEuropeanOption> > referenceData, ICalibrationSettings calibrationSettings)
{
try
{
// Copy Linked List
LinkedList <OptionMarketData <EuropeanOption> > data =
new LinkedList <OptionMarketData <EuropeanOption> >();
foreach (OptionMarketData <IEuropeanOption> marketData in referenceData)
{
OptionMarketData <EuropeanOption> newMarketData =
new OptionMarketData <EuropeanOption>((EuropeanOption)marketData.Option, marketData.Price);
data.AddLast(newMarketData);
}
// Heston Calibrator
HestonCalibrator calibrator =
new HestonCalibrator((HestonModelParameters)guessModelParameters,
data,
(CalibrationSettings)calibrationSettings);
// Calibration procedure
calibrator.Calibrate();
// Retrieve outcome
double error = 0;
CalibrationOutcome outcome = CalibrationOutcome.NotStarted;
calibrator.GetCalibrationStatus(ref outcome, ref error);
HestonModelParameters parameters = calibrator.GetCalibratedModel();
// Form calibration result object
HestonCalibrationResult result = new HestonCalibrationResult(error, outcome, parameters);
return(result);
}
catch (Exception ex)
{
throw ex;
}
}
public void GetCalibrationStatus(ref CalibrationOutcome calibOutcome, ref double pricingError)
{
calibOutcome = outcome;
VasicekModel m = new VasicekModel(r0, calibratedParams);
pricingError = CalcMeanSquareErrorBetweenModelAndMarket(m);
}
/// <summary>
/// Method for calibrating the heston model.
/// </summary>
/// <param name="guessModelParameters">Object implementing IHestonModelParameters interface containing the risk-free rate, initial stock price
/// and initial guess parameters to be used in the calibration.</param>
/// <param name="referenceData">A collection of objects implementing IOptionMarketData<IEuropeanOption> interface. These should contain the reference data used for calibration.</param>
/// <param name="calibrationSettings">An object implementing ICalibrationSettings interface.</param>
/// <returns>Object implementing IHestonCalibrationResult interface which contains calibrated model parameters and additional diagnostic information</returns>
public static IHestonCalibrationResult CalibrateHestonParameters(IHestonModelParameters guessModelParameters,
IEnumerable <IOptionMarketData <IEuropeanOption> > referenceData,
ICalibrationSettings calibrationSettings)
{
HestonCalibrator calibrator = new HestonCalibrator(guessModelParameters.RiskFreeRate,
guessModelParameters.InitialStockPrice,
calibrationSettings.Accuracy,
calibrationSettings.MaximumNumberOfIterations);
calibrator.SetGuessParameters(guessModelParameters.VarianceParameters.V0,
guessModelParameters.VarianceParameters.Kappa,
guessModelParameters.VarianceParameters.Theta,
guessModelParameters.VarianceParameters.Rho,
guessModelParameters.VarianceParameters.Sigma);
foreach (IOptionMarketData <IEuropeanOption> M in referenceData)
{
calibrator.AddObservedOption(M.Option.StrikePrice, M.Option.Maturity, M.Price);
}
calibrator.Calibrate();
double error = 0;
CalibrationOutcome outcome = CalibrationOutcome.NotStarted;
calibrator.GetCalibrationStatus(ref outcome, ref error);
var calibratedModel = calibrator.GetCalibratedModel();
Console.WriteLine("Calibration outcome: {0} and error: {1}", outcome, error);
return(new HestonCalibrationResult(outcome, error, new HestonParametersGrading(guessModelParameters.InitialStockPrice, guessModelParameters.RiskFreeRate,
calibratedModel.GetK(), calibratedModel.GetTheta(), calibratedModel.GetSigma(), calibratedModel.GetRho(), calibratedModel.GetNv())));
/*foreach (CalibrationOutcome MinimizerStatus in sss)*/
/*object[,] ansTable =*/
}
public void GetCalibrationStatus(ref CalibrationOutcome calibOutcome, ref double pricingError)
{
calibOutcome = outcome;
Ssvi m = new Ssvi(calibratedParams);
pricingError = CalcMeanSquareErrorBetweenOmegaAndMarketNonATM(m);
}
public void GetCalibrationStatus(ref CalibrationOutcome calibOutcome, ref double pricingError)
{
calibOutcome = outcome;
Hestonformula m = new Hestonformula(calibratedParams);
pricingError = CalcMeanSquareErrorBetweenModelAndMarket(m);
}
/// <summary>
/// Gets the calibration status.
/// </summary>
/// <param name="calibOutcome">Calibration outcome.</param>
/// <param name="pricingError">Pricing error.</param>
public void GetCalibrationStatus(ref CalibrationOutcome calibOutcome, ref double pricingError)
{
calibOutcome = outcome;
VarianceProcessParameters varianceParams = new VarianceProcessParameters
(calibratedParams[0], calibratedParams[1], calibratedParams[2], calibratedParams[3], calibratedParams[4]);
HestonModelParameters m = new HestonModelParameters(_InitialStockPrice, _RiskFreeRate, varianceParams);
pricingError = CalcMeanSquareErrorBetweenModelAndMarket(m);
}
public void Calibrate()
{
outcome = CalibrationOutcome.NotStarted;
double[] initialParams = new double[VasicekModel.numModelParams];
calibratedParams.CopyTo(initialParams, 0); // a reasonable starting guees
double epsg = accuracy;
double epsf = accuracy; //1e-4;
double epsx = accuracy;
double diffstep = 1.0e-6;
int maxits = maxIterations;
double stpmax = 0.05;
alglib.minlbfgsstate state;
alglib.minlbfgsreport rep;
alglib.minlbfgscreatef(1, initialParams, diffstep, out state);
alglib.minlbfgssetcond(state, epsg, epsf, epsx, maxits);
alglib.minlbfgssetstpmax(state, stpmax);
// this will do the work
alglib.minlbfgsoptimize(state, CalibrationObjectiveFunction, null, null);
double[] resultParams = new double[VasicekModel.numModelParams];
alglib.minlbfgsresults(state, out resultParams, out rep);
System.Console.WriteLine("Termination type: {0}", rep.terminationtype);
System.Console.WriteLine("Num iterations {0}", rep.iterationscount);
System.Console.WriteLine("{0}", alglib.ap.format(resultParams, 5));
if (rep.terminationtype == 1 || // relative function improvement is no more than EpsF.
rep.terminationtype == 2 || // relative step is no more than EpsX.
rep.terminationtype == 4)
{ // gradient norm is no more than EpsG
outcome = CalibrationOutcome.FinishedOK;
// we update the ''inital parameters''
calibratedParams = resultParams;
}
else if (rep.terminationtype == 5)
{ // MaxIts steps was taken
outcome = CalibrationOutcome.FailedMaxItReached;
// we update the ''inital parameters'' even in this case
calibratedParams = resultParams;
}
else
{
outcome = CalibrationOutcome.FailedOtherReason;
throw new CalibrationFailedException("Vasicek model calibration failed badly.");
}
}
public void CalibrateEtaGammaRhoNonATM()
{
outcome = CalibrationOutcome.NotStarted;
double[] initialParams = new double[Ssvi.numModelParams];
calibratedParams.CopyTo(initialParams, 0);
double epsg = accuracy;
double epsf = accuracy;
double epsx = accuracy;
double diffstep = 1.0e-6;
int maxits = maxIterations;
double stpmax = 0.05;
alglib.minlbfgsstate state;
alglib.minlbfgsreport rep;
alglib.minlbfgscreatef(1, initialParams, diffstep, out state);
alglib.minlbfgssetcond(state, epsg, epsf, epsx, maxits);
alglib.minlbfgssetstpmax(state, stpmax);
alglib.minlbfgsoptimize(state, CalibrationObjectiveFunctionNonATM, null, null);
double[] resultParams = new double[Ssvi.numModelParams];
alglib.minlbfgsresults(state, out resultParams, out rep);
if (rep.terminationtype == 1 || // relative function improvement is no more than EpsF.
rep.terminationtype == 2 || // relative step is no more than EpsX.
rep.terminationtype == 4) // gradient norm is no more than EpsG
{
outcome = CalibrationOutcome.FinishedOK;
calibratedParams = resultParams;
}
else if (rep.terminationtype == 5)
{ // MaxIts steps was taken
outcome = CalibrationOutcome.FailedMaxItReached;
calibratedParams = resultParams;
}
else
{
outcome = CalibrationOutcome.FailedOtherReason;
throw new CalibrationFailedException("Ssvi model calibration failed badly.");
}
}
public static void TestVasicekCalibration()
{
double r0 = 0.01;
double k = 0.5;
double theta = 0.01;
double sigma = 0.2;
VasicekModel model = new VasicekModel(r0, k, theta, sigma);
double[] bondMaturities = new double[] { 1, 2, 10 };
double[] optionExerciseTimes = new double[] { 0.5, 1, 2 };
double[] optionStrikes = new double[] { 0.9, 0.9, 0.9 };
double[] prices = new double[bondMaturities.Length];
//Console.WriteLine("European call options on ZCBs, prices");
for (int i = 0; i < bondMaturities.Length; ++i)
{
double T = bondMaturities[i], S = optionExerciseTimes[i], K = optionStrikes[i];
prices[i] = model.PriceZCBCall(S, K, T);
}
VasicekCalibrator calibrator = new VasicekCalibrator(r0, 1e-20, 2000);
for (int i = 0; i < bondMaturities.Length; ++i)
{
// Here you should add the market data to the vasicekCalibrator...
// .. for that you will need to modify the calibrator appropriately
// e.g. add an AddObservedOption method to the VasicekCalibrator as follows
//calibrator.AddObservedOption(bondMaturities[i], optionExerciseTimes[i], optionStrikes[i], prices[i]);
throw new NotImplementedException("Method not implemented... that's part of the exercise.");
}
calibrator.Calibrate();
double error = 0;
CalibrationOutcome outcome = CalibrationOutcome.NotStarted;
calibrator.GetCalibrationStatus(ref outcome, ref error);
Console.WriteLine("Calibration outcome: {0} and error: {1}", outcome, error);
}
static void Main(string[] args)
{
double r = 0.10;
double theta = 0.06;
double k = 2.00;
double sigma = 0.40;
double rho = 0.5;
double nv = 0.04;
/*double r = 0.025;
* double theta = 0.0398;
* double k = 1.5768;
* double sigma = 0.5751;
* double rho = -0.5711;
* double nv = 0.0175;*/
double S = 100;
double T1 = 1.0;
double T2 = 2.0;
double T3 = 3.0;
double T4 = 4.0;
double T5 = 15.0;
double K = 100.0;
double C1, C2, C3, C4, C5, C6, C7, C8, C9, C10;
double[] parameters = new double[5];
parameters[0] = nv;
parameters[1] = k;
parameters[2] = theta;
parameters[3] = rho;
parameters[4] = sigma;
/*Hestonformula r1 = new Hestonformula(parameters);
* Console.WriteLine("These are from Heston formula call option:");
* C1 = r1.CalculateCallOptionPrice(S, K, r, T1);
* Console.WriteLine(C1);
* C2 = r1.CalculateCallOptionPrice(S, K, r, T2);
* Console.WriteLine(C2);
* C3 = r1.CalculateCallOptionPrice(S, K, r, T3);
* Console.WriteLine(C3);
* C4 = r1.CalculateCallOptionPrice(S, K, r, T4);
* Console.WriteLine(C4);
* C5 = r1.CalculateCallOptionPrice(S, K, r, T5);
* Console.WriteLine(C5);
* Console.WriteLine("These are from Heston formula put option:");
* C6 = r1.CalculatePutOptionPrice(S, K, r, T1);
* Console.WriteLine(C6);
* C7 = r1.CalculatePutOptionPrice(S, K, r, T2);
* Console.WriteLine(C7);
* C8 = r1.CalculatePutOptionPrice(S, K, r, T3);
* Console.WriteLine(C8);
* C9 = r1.CalculatePutOptionPrice(S, K, r, T4);
* Console.WriteLine(C9);
* C10 = r1.CalculatePutOptionPrice(S, K, r, T5);
* Console.WriteLine(C10);*/
int n = 100000;
int N = 365;
double tau1 = T1 / N;
double tau2 = T2 / N;
double tau3 = T3 / N;
double tau4 = T4 / N;
double tau5 = T5 / N;
double A1, A2, A3, A4, A5, A6, A7, A8, A9, A10;
/*HestonMC p1 = new HestonMC();
* Console.WriteLine("These are from Heston European call option MC:");
* A1 = p1.CalculateEuropeanCallOptionPrice(S, K, r, T1, nv, k, theta, rho, sigma, N, n);
* Console.WriteLine(A1);
* A2 = p1.CalculateEuropeanCallOptionPrice(S, K, r, T2, nv, k, theta, rho, sigma, N, n);
* Console.WriteLine(A2);
* A3 = p1.CalculateEuropeanCallOptionPrice(S, K, r, T3, nv, k, theta, rho, sigma, N, n);
* Console.WriteLine(A3);
* A4 = p1.CalculateEuropeanCallOptionPrice(S, K, r, T4, nv, k, theta, rho, sigma, N, n);
* Console.WriteLine(A4);
* A5 = p1.CalculateEuropeanCallOptionPrice(S, K, r, T5, nv, k, theta, rho, sigma, N, n);
* Console.WriteLine(A5);
* Console.WriteLine("These are from Heston European put option MC:");
* A6 = p1.CalculatePutOptionPrice(S, K, r, T1, nv, k, theta, rho, sigma, N, n);
* Console.WriteLine(A6);
* A7 = p1.CalculatePutOptionPrice(S, K, r, T2, nv, k, theta, rho, sigma, N, n);
* Console.WriteLine(A7);
* A8 = p1.CalculatePutOptionPrice(S, K, r, T3, nv, k, theta, rho, sigma, N, n);
* Console.WriteLine(A8);
* A9 = p1.CalculatePutOptionPrice(S, K, r, T4, nv, k, theta, rho, sigma, N, n);
* Console.WriteLine(A9);
* A10 = p1.CalculatePutOptionPrice(S, K, r, T5, nv, k, theta, rho, sigma, N, n);
* Console.WriteLine(A10);*/
double t1 = 1.0;
double t2 = 3.0;
double t3 = 5.0;
double t4 = 7.0;
double t5 = 9.0;
double K1, K2, K3, K4, K5;
/*HestonLookbackoption w1 = new HestonLookbackoption();
* Console.WriteLine("These are from Look back option MC:");
* K1 = w1.CalculateLookbackCallOptionPrice(S, r, t1, nv, k, theta, rho, sigma, N, n);
* Console.WriteLine(K1);
* K2 = w1.CalculateLookbackCallOptionPrice(S, r, t2, nv, k, theta, rho, sigma, N, n);
* Console.WriteLine(K2);
* K3 = w1.CalculateLookbackCallOptionPrice(S, r, t3, nv, k, theta, rho, sigma, N, n);
* Console.WriteLine(K3);
* K4 = w1.CalculateLookbackCallOptionPrice(S, r, t4, nv, k, theta, rho, sigma, N, n);
* Console.WriteLine(K4);
* K5 = w1.CalculateLookbackCallOptionPrice(S, r, t5, nv, k, theta, rho, sigma, N, n);
* Console.WriteLine(K5);*/
/*double[] T11 = { 0.75, 1.00 };
* double[] T22 = { 0.25, 0.50, 0.75, 1.00, 1.25, 1.50, 1.75 };
* double[] T33 = { 1.00, 2.00, 3.00 };*/
/*IEnumerable<double> T11 = new double[] { 0.75, 1.00 };
* IEnumerable<double> T22 = new double[] { 0.25, 0.50, 0.75, 1.00, 1.25, 1.50, 1.75 };
* IEnumerable<double> T33 = new double[] { 1.00, 2.00, 3.00 };
* double O1, O2, O3, O4, O5, O6;
* HestonAsianoption v1 = new HestonAsianoption();
* Console.WriteLine("These are from Asian call option MC:");
* O1 = v1.CalculateAsianCallOptionPrice(S, K, r, T11, T1, nv, k, theta, rho, sigma, N, n);
* Console.WriteLine(O1);
* O2 = v1.CalculateAsianCallOptionPrice(S, K, r, T22, T2, nv, k, theta, rho, sigma, N, n);
* Console.WriteLine(O2);
* O3 = v1.CalculateAsianCallOptionPrice(S, K, r, T33, T3, nv, k, theta, rho, sigma, N, n);
* Console.WriteLine(O3);*/
/*Console.WriteLine("These are from Asian put option MC:");
* O4 = v1.CalculateAsianPutOptionPrice(S, K, r, T11, T1, nv, k, theta, rho, sigma, N, n);
* Console.WriteLine(O4);
* O5 = v1.CalculateAsianPutOptionPrice(S, K, r, T22, T2, nv, k, theta, rho, sigma, N, n);
* Console.WriteLine(O5);
* O6 = v1.CalculateAsianPutOptionPrice(S, K, r, T33, T3, nv, k, theta, rho, sigma, N, n);
* Console.WriteLine(O6);*/
double r0 = 0.025;
double S0 = 100;
double theta1 = 0.0398;
double k1 = 1.5768;
double sigma1 = 0.5751;
double rho1 = -0.5711;
double nv1 = 0.0175;
Hestonformula model = new Hestonformula(nv1, k1, theta1, rho1, sigma1);
double[] optionExerciseTimes = new double[] { 1, 1, 2, 2, 1.5 };
double[] optionStrikes = new double[] { 80, 90, 80, 100, 100 };
double[] prices = new double[] { 25.72, 18.93, 30.49, 19.36, 16.58 };
HestonCalibrator calibrator = new HestonCalibrator(r0, S0, 1e-3, 1000);
calibrator.SetGuessParameters(nv1, k1, theta1, rho1, sigma1);
for (int i = 0; i < optionExerciseTimes.Length; ++i)
{
calibrator.AddObservedOption(optionExerciseTimes[i], optionStrikes[i], prices[i]);
}
calibrator.Calibrate();
double error = 0;
CalibrationOutcome outcome = CalibrationOutcome.NotStarted;
calibrator.GetCalibrationStatus(ref outcome, ref error);
Console.WriteLine("Calibration outcome: {0} and error: {1}", outcome, error);
/*double U1, U2, U3, U4, U5;
* HestonRainbowoptionprice e1 = new HestonRainbowoptionprice();
* Console.WriteLine("These are from Rainbow option MC:");
* U1 = e1.CalculateRainbowOptionPrice(S, K, r, T1, nv, k, theta, rho, sigma, N, n);
* Console.WriteLine(U1);
* U2 = e1.CalculateRainbowOptionPrice(S, K, r, T2, nv, k, theta, rho, sigma, N, n);
* Console.WriteLine(U2);
* U3 = e1.CalculateRainbowOptionPrice(S, K, r, T3, nv, k, theta, rho, sigma, N, n);
* Console.WriteLine(U3);
* U4 = e1.CalculateRainbowOptionPrice(S, K, r, T4, nv, k, theta, rho, sigma, N, n);
* Console.WriteLine(U4);
* U5 = e1.CalculateRainbowOptionPrice(S, K, r, T5, nv, k, theta, rho, sigma, N, n);
* Console.WriteLine(U5);*/
Console.ReadKey();
}
// This should be able to report how that calibration went and what the mean square error is
public void GetCalibrationStatus(ref CalibrationOutcome calibOutcome, ref double pricingError)
{
throw new NotImplementedException("Method not implemented... that's part of the exercise.");
}
public static object[,] CalibrateVasicekParameters(
double kGuess,
double thetaGuess,
double sigmaGuess,
double r0,
double[] strikesArray,
double[] bondMaturitiesArray,
double[] optionExerciseTimesArray,
double[] observedPricesArray,
double accuracy,
int maxIterations)
{
if (strikesArray.Length != bondMaturitiesArray.Length ||
bondMaturitiesArray.Length != optionExerciseTimesArray.Length ||
optionExerciseTimesArray.Length != observedPricesArray.Length)
{
throw new ArgumentException("CalibrateVasicekParameters: strikes, optionExerciseTimes, bondMaturities and observedPrices must be of same length.");
}
VasicekCalibrator vasicekCalibrator = new VasicekCalibrator(r0, accuracy, maxIterations);
vasicekCalibrator.SetGuessParameters(kGuess, thetaGuess, sigmaGuess);
int numObservedOptions = strikesArray.Length;
for (int optionIdx = 0; optionIdx < numObservedOptions; ++optionIdx)
{
vasicekCalibrator.AddObservedOption(bondMaturitiesArray[optionIdx],
optionExerciseTimesArray[optionIdx],
strikesArray[optionIdx],
observedPricesArray[optionIdx]);
}
vasicekCalibrator.Calibrate();
CalibrationOutcome outcome = CalibrationOutcome.NotStarted;
double calibrationError = 0;
vasicekCalibrator.GetCalibrationStatus(ref outcome, ref calibrationError);
VasicekModel calibratedModel = vasicekCalibrator.GetCalibratedModel();
// for output
const int numCols = 2;
const int numRows = 5;
object[,] output = new object[numRows, numCols];
output[0, 0] = "k"; output[0, 1] = calibratedModel.GetK();
output[1, 0] = "theta"; output[1, 1] = calibratedModel.GetTheta();
output[2, 0] = "sigma"; output[2, 1] = calibratedModel.GetSigma();
output[3, 0] = "Minimizer Status";
if (outcome == CalibrationOutcome.FinishedOK)
{
output[3, 1] = "OK";
}
else if (outcome == CalibrationOutcome.FailedMaxItReached)
{
output[3, 1] = "Reached max. num. iterations.";
}
else if (outcome == CalibrationOutcome.FailedOtherReason)
{
output[3, 1] = "Failed.";
}
else
{
output[3, 1] = "Unknown outcome.";
}
{
output[4, 0] = "Pricing error"; output[4, 1] = Math.Sqrt(calibrationError);
}
return(output);
}
public HestonCalibrationResult(CalibrationOutcome minimizerStatus, double error, IHestonModelParameters parameters)
{
this.minimizerStatus = minimizerStatus;
this.error = error;
this.parameters = parameters;
}
public void Task_2_5()
{
// Variance Process Values
double Kappa = 1.5768;
double Theta = 0.398;
double Sigma = 0.5751;
double V0 = 0.0175;
double Rho = -0.5711;
// Heston Model Params
double InitialStockPrice = 100;
double RiskFreeRate = 0.025;
// Callibration Settings
double accuracy = 0.001;
int maxIter = 1000;
VarianceProcessParameters varParams =
new VarianceProcessParameters(Kappa, Theta, Sigma, V0, Rho);
HestonModelParameters hestonModel =
new HestonModelParameters(InitialStockPrice, RiskFreeRate, varParams);
CalibrationSettings calibrationSettings = new CalibrationSettings(accuracy, maxIter);
// Market Data
LinkedList <OptionMarketData <EuropeanOption> > observedOptions =
new LinkedList <OptionMarketData <EuropeanOption> >();
EuropeanOption eu1 = new EuropeanOption(80, PayoffType.Call, 1);
OptionMarketData <EuropeanOption> marketData1 =
new OptionMarketData <EuropeanOption>(eu1, 25.72);
observedOptions.AddLast(marketData1);
EuropeanOption eu2 = new EuropeanOption(90, PayoffType.Call, 1);
OptionMarketData <EuropeanOption> marketData2 =
new OptionMarketData <EuropeanOption>(eu2, 18.93);
observedOptions.AddLast(marketData2);
EuropeanOption eu3 = new EuropeanOption(80, PayoffType.Call, 2);
OptionMarketData <EuropeanOption> marketData3 =
new OptionMarketData <EuropeanOption>(eu3, 30.49);
observedOptions.AddLast(marketData3);
EuropeanOption eu4 = new EuropeanOption(100, PayoffType.Call, 2);
OptionMarketData <EuropeanOption> marketData4 =
new OptionMarketData <EuropeanOption>(eu4, 19.36);
observedOptions.AddLast(marketData4);
EuropeanOption eu5 = new EuropeanOption(100, PayoffType.Call, 1.5);
OptionMarketData <EuropeanOption> marketData5 =
new OptionMarketData <EuropeanOption>(eu5, 16.58);
observedOptions.AddLast(marketData5);
// Heston Calibrator
HestonCalibrator calibrator = new HestonCalibrator(hestonModel, observedOptions, calibrationSettings);
calibrator.Calibrate();
double error = 0;
CalibrationOutcome outcome = CalibrationOutcome.NotStarted;
calibrator.GetCalibrationStatus(ref outcome, ref error);
Console.WriteLine("Calibration outcome: {0} and error: {1}", outcome, error);
}
public static object[,] CalibrateDupireSsviParametersNonATM(
[ExcelArgument(Description = "A 3x2 XL Range with guess values for gamma, eta, rho")] object guessModelParameters,
[ExcelArgument(Description = "constant continuously compounded rate of return")] double riskFreeRate,
[ExcelArgument(Description = "the current risky asset price")] double underlyingPrice,
[ExcelArgument(Description = "the SSVI alpha from ATM calibration")] double alpha,
[ExcelArgument(Description = "the SSVI beta from ATM calibration")] double beta,
[ExcelArgument(Description = "An Nx1 XL Range of option strikes")] object strikes,
[ExcelArgument(Description = "An Nx1 XL Range of option maturities")] object maturities,
[ExcelArgument(Description = "An Nx1 XL Range of option either C or P for Calls and Puts")] object type,
[ExcelArgument(Description = "An Nx1 XL Range of option prices")] object observedPrices,
[ExcelArgument(Description = "Accuracy parameter for calibration")] double accuracy,
[ExcelArgument(Description = "Number of iterations parameter for calibration")] int maxIterations)
{
try
{
if (ExcelDnaUtil.IsInFunctionWizard())
{
return(null);
}
double[] strikesArray = XLInterfaceBase.ConvertToVector <double>(strikes);
double[] maturitesArray = XLInterfaceBase.ConvertToVector <double>(maturities);
string[] typeArray = XLInterfaceBase.ConvertToVector <string>(type);
double[] observedPricesArray = XLInterfaceBase.ConvertToVector <double>(observedPrices);
if (strikesArray.Length != maturitesArray.Length ||
maturitesArray.Length != typeArray.Length ||
typeArray.Length != observedPricesArray.Length)
{
XLInterfaceBase.AddErrorMessage("CalibrateSsviParameters: strikes, maturites, types and observedPrices must be of same length.");
return(null);
}
KeyValuePair <string, double>[] paramPairs = XLInterfaceBase.ConvertToKeyValuePairs(guessModelParameters);
if (paramPairs.Length != 3)
{
XLInterfaceBase.AddErrorMessage("CalibrateSsviParameters: guessModelParameters must be three key - value pairs.");
return(null);
}
double eta = 0; double gamma = 0; double rho = 0;
for (int paramIdx = 0; paramIdx < paramPairs.Length; ++paramIdx)
{
KeyValuePair <string, double> pair = paramPairs[paramIdx];
string key = pair.Key;
double value = pair.Value;
if (key.Equals("eta", StringComparison.CurrentCultureIgnoreCase))
{
eta = value;
}
else if (key.Equals("gamma", StringComparison.CurrentCultureIgnoreCase))
{
gamma = value;
}
else if (key.Equals("rho", StringComparison.CurrentCultureIgnoreCase))
{
rho = value;
}
else
{
XLInterfaceBase.AddErrorMessage("CalibrateSsviParameters: guessModelParameters: unknown key: " + key);
return(null);
}
}
SsviCalibrator ssviCalibrator = new SsviCalibrator(riskFreeRate, underlyingPrice, accuracy, maxIterations);
ssviCalibrator.SetGuessParameters(alpha, beta, gamma, eta, rho);
int numObservedOptions = strikesArray.Length;
for (int optionIdx = 0; optionIdx < numObservedOptions; ++optionIdx)
{
ssviCalibrator.AddObservedOption(maturitesArray[optionIdx], strikesArray[optionIdx], observedPricesArray[optionIdx], typeArray[optionIdx]);
}
ssviCalibrator.CalibrateEtaGammaRhoNonATM();
CalibrationOutcome outcome = CalibrationOutcome.NotStarted;
double calibrationError = 0;
ssviCalibrator.GetCalibrationStatus(ref outcome, ref calibrationError);
Ssvi calibratedModel = ssviCalibrator.GetCalibratedModel();
// for output
const int numCols = 2;
const int numRows = 5;
object[,] output = new object[numRows, numCols];
output[0, 0] = "Gamma"; output[0, 1] = calibratedModel.GetGamma();
output[1, 0] = "Eta"; output[1, 1] = calibratedModel.GetEta();
output[2, 0] = "Rho"; output[2, 1] = calibratedModel.GetRho();
output[3, 0] = "Minimizer Status";
if (outcome == CalibrationOutcome.FinishedOK)
{
output[3, 1] = "OK";
}
else if (outcome == CalibrationOutcome.FailedMaxItReached)
{
output[3, 1] = "Reached max. num. iterations.";
}
else if (outcome == CalibrationOutcome.FailedOtherReason)
{
output[3, 1] = "Failed.";
}
else
{
output[3, 1] = "Unknown outcome.";
}
output[4, 0] = "Pricing error"; output[4, 1] = Math.Sqrt(calibrationError);
return(output);
}
catch (Exception e)
{
XLInterfaceBase.AddErrorMessage("CalibrateParameters: unknown error: " + e.Message);
}
return(null);
}
