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); }