/// <summary> /// Get the Calibration status for the calibration engine using /// the expiry/tenor pair /// </summary> /// <param name="engine">The calibration engine handle</param> /// <param name="expiry">The exercise time of the option</param> /// <param name="tenor">The asset Code of the swap (tenor)</param> /// <returns></returns> public bool IsSABRModelCalibrated(string engine, string expiry, string tenor) { if (_sabrEngines.ContainsKey(engine)) { //SABREngineCollection SABREngines = _SABREngines[engine]; SortedDictionary <SABRKey, SABRCalibrationEngine> sabrEngines = _sabrEngines[engine]; var key = new SABRKey(SABRHelper.GenerateTenorLabel(expiry), SABRHelper.GenerateTenorLabel(tenor)); if (sabrEngines.ContainsKey(key)) { SABRCalibrationEngine calibrationEngine = sabrEngines[key]; return(calibrationEngine.IsSABRModelCalibrated); } } return(false); }
/// <summary> /// Get the Calibration Engine Calibration Error the expiry/tenor pair /// </summary> /// <param name="engine">The calibration engine handle</param> /// <param name="expiry">The exercise time of the option</param> /// <param name="tenor">The asset Code of the swap (tenor)</param> /// <returns></returns> public decimal SABRCalibrationError(string engine, string expiry, string tenor) { if (_sabrEngines.ContainsKey(engine)) { //SABREngineCollection SABREngines = _SABREngines[engine]; SortedDictionary <SABRKey, SABRCalibrationEngine> sabrEngines = _sabrEngines[engine]; var key = new SABRKey(SABRHelper.GenerateTenorLabel(expiry), SABRHelper.GenerateTenorLabel(tenor)); if (sabrEngines.ContainsKey(key)) { SABRCalibrationEngine calibrationEngine = sabrEngines[key]; return(calibrationEngine.CalibrationError); } throw new ArgumentException("The Calibration Engine with Key(" + expiry + "," + tenor + ") not found."); } throw new ArgumentException("Calibration Engine " + engine + " not found."); }
/// <summary> /// Calculate the SABR implied volatility for the strike value. /// This method uses the calibration engine indexed by the exerciseTime/assetCode pair /// When an ATM engine is used then the assetCode is ignored. /// </summary> /// <param name="engineHandle">The CalibrationEngine to use</param> /// <param name="exerciseTime">Option Expiry index</param> /// <param name="assetCode">Swap Tenor index</param> /// <param name="strike">The strike to calculate Volatility for</param> /// <returns></returns> public decimal SABRInterpolateVolatility(string engineHandle, string exerciseTime, string assetCode, decimal strike) { decimal result = 0; string errmsg = ""; // Only process if the engine object holder holds the engine for this exercise/asset key if (_sabrEngines.ContainsKey(engineHandle)) { // Extract the information we need from this engine holder var engine = _sabrEngines[engineHandle]; var key = new SABRKey(SABRHelper.GenerateTenorLabel(exerciseTime), SABRHelper.GenerateTenorLabel(assetCode)); // Check that the engine for this exercise/asset key exists if (engine.ContainsKey(key)) { SABRCalibrationEngine calibrationEngine = engine[key]; if (!calibrationEngine.IsSABRModelCalibrated) { throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, "SABR Engine with key: {0}:{1} is not calibrated", new object[] { key.Expiry, key.Tenor })); } // Create SABRImpliedVolatility parameters decimal assetPrice = _engineRatesGrid.ContainsKey(engineHandle) ? _engineRatesGrid[engineHandle].GetAssetPrice(exerciseTime, assetCode) : calibrationEngine.AssetPrice; decimal strikeValue = strike; var expiry = (decimal)SABRHelper.GenerateDayValue(exerciseTime, 365.0d); //decimal strikeValue = strike / 100.0m; // build an ImpliedVolatility object SABRParameters parameters = calibrationEngine.GetSABRParameters; var vol = new SABRImpliedVolatility(parameters, true); // value the strike (interpolate as necessary) if (!vol.SABRInterpolatedVolatility(assetPrice, expiry, strikeValue, ref errmsg, ref result, true)) { throw new ArgumentException(errmsg); } } else { throw new ArgumentException("The Calibration Engine with Key(" + exerciseTime + "," + assetCode + ") not found."); } } else { throw new ArgumentException("Calibration Engine " + engineHandle + " not found."); } return(result); }
/// <summary> /// Get the SABR Calibration engine parameter for the provided options /// The exercise/tenor pair form the key to the correct calibration engine /// from an underlying store. /// </summary> /// <param name="param">The parameter type to return</param> /// <param name="engine">The engine to use</param> /// <param name="pExercise">The exercise (option expiry) part of the key</param> /// <param name="pTenor">The tenor (asset code) part of the key</param> /// <returns></returns> public decimal GetSABRParameter(CalibrationParameter param, string engine, string pExercise, string pTenor) { string exercise = SABRHelper.GenerateTenorLabel(pExercise); string tenor = SABRHelper.GenerateTenorLabel(pTenor); if (!_sabrEngines.ContainsKey(engine)) { throw new ArgumentException("Calibration Engine " + engine + " not found."); } SortedDictionary <SABRKey, SABRCalibrationEngine> sabrEngines = _sabrEngines[engine]; var key = new SABRKey(exercise, tenor); if (!sabrEngines.ContainsKey(key)) { throw new ArgumentException("The Calibration Engine with Key(" + exercise + "," + tenor + ") not found."); } SABRCalibrationEngine calibrationEngine = sabrEngines[key]; SABRParameters parameters = calibrationEngine.GetSABRParameters; switch (param) { case CalibrationParameter.Alpha: return(parameters.Alpha); case CalibrationParameter.Beta: return(parameters.Beta); case CalibrationParameter.Nu: return(parameters.Nu); case CalibrationParameter.Rho: return(parameters.Rho); default: throw new ArgumentException("Unknown Calibration Parameter request"); } }
/// <summary> /// Generate a new set of full calibration engines for the supplied data. /// Add or overwrite the engine store for the new engine. /// Each engineId will point to a set of engines indexed by swap tenor and option expiry /// Calibration assumes that the format of the grid data is as follows: /// /// + XXXX | lbl0 | lbl1 | ... | lbln + /// | lbl0 | d[0,0] | d[0,1] | ... | d[0,n] | /// | lbl1 | d[1,0] | d[1,1] | ... | d[1,n] | /// | ... | ... | ... | ... | ... | /// + lbln | d[n,0] | d[n,1] | ... | d[n,n] + /// /// </summary> /// <param name="engineHandle">Calibration Engine handle</param> /// <param name="settingsHandle">Calibartion settings handle</param> /// <param name="strikes">An array of strikes.</param> /// <param name="rawVols">A grid of volatilities (with row/column labels)</param> /// <param name="rawAssets">A grid of asset values</param> /// <param name="assetExpiry">An array of asset expiries.</param> /// <param name="optionEx">The ption expiry to index against</param> /// <param name="tenors">An array of expiry tenors.</param> /// <param name="assetTenors">An array of asset tenors.</param> /// <returns></returns> public string SABRCalibrateModel(string engineHandle, string settingsHandle, String[] tenors, decimal[] strikes, Decimal[,] rawVols, Decimal[,] rawAssets, String[] assetTenors, String[] assetExpiry, string optionEx) { // Create the asset and volatility data grids SwaptionDataMatrix volatilityGrid = ParseVolatilityInput(tenors, strikes, rawVols, optionEx); ForwardRatesMatrix assetGrid = ParseAssetInputWithInterpolation(assetTenors, assetExpiry, rawAssets); // Retrieve the calibration settings to use with this calibration engine SABRCalibrationSettings settings = _sabrSettings[settingsHandle]; // Generate the CalibrationEngine Id string calibrationEngineId = engineHandle; string optionExpiry = SABRHelper.GenerateTenorLabel(optionEx); // Create a new engine holder object SortedDictionary <SABRKey, SABRCalibrationEngine> sabrEngine = BuildEngineCollection(volatilityGrid, assetGrid, settings, calibrationEngineId, optionExpiry); // We have an asset grid (forward rates) with this engine type so we should keep it // for future reference (that is during the lifetime of this session) if (_engineRatesGrid.ContainsKey(engineHandle)) { _engineRatesGrid[engineHandle] = assetGrid; } else { _engineRatesGrid.Add(engineHandle, assetGrid); } // Add the SABREngine to the persistent store if (_sabrEngines.ContainsKey(calibrationEngineId)) { _sabrEngines[calibrationEngineId] = sabrEngine; } else { _sabrEngines.Add(calibrationEngineId, sabrEngine); } return(engineHandle); }
/// <summary> /// Generate an ATM (At-The-Money) Swaption Calibration engine using the supplied parameters /// This form of engine creates a single cell engine that does not support asset/volatility grid data. /// </summary> /// <param name="engineHandle">The engine identifier</param> /// <param name="settingsHandle">The settings identifier</param> /// <param name="nu">Nu value</param> /// <param name="rho">Rho value</param> /// <param name="atmVolatility">The ATM volatility</param> /// <param name="assetPrice">Asset Price to use</param> /// <param name="exerciseTime">Exercise time for the option</param> /// <param name="assetCode">The asset code.</param> /// <returns></returns> public string SABRCalibrateATMModel(string engineHandle, string settingsHandle, decimal nu, decimal rho, decimal atmVolatility, decimal assetPrice, string exerciseTime, string assetCode) { // Create the parameters used in this engine SABRCalibrationSettings settings = _sabrSettings[settingsHandle]; // Create the engine SortedDictionary <SABRKey, SABRCalibrationEngine> sabrEngine = BuildEngineCollection(settings, engineHandle, nu, rho, atmVolatility, assetPrice, SABRHelper.GenerateTenorLabel(exerciseTime), SABRHelper.GenerateTenorLabel(assetCode)); // Add the SABREngine to the persistent store if (_sabrEngines.ContainsKey(engineHandle)) { _sabrEngines[engineHandle] = sabrEngine; } else { _sabrEngines.Add(engineHandle, sabrEngine); } return(engineHandle); }