public bool SimpleImpliedVolatilityTest() { OptionType type = OptionType.Call; double strike = 31.21; double spot = 31.525; double volatility = 0.25116165; double riskFreeRate = 0.085209; double ttm = (double)35 / 365; EquityOptionStaticData staticData = new EquityOptionStaticData(type, strike, spot, volatility, riskFreeRate, ttm); IPriceable priceable = staticData.BuildPriceable(); double price = priceable.Price(); BlackScholes bs = new BlackScholes(); double volGuess = 0.25; double relTolerance = 0.00001; int maxAttempts = 10; price = 1.28; double impliedVol = bs.GetImpliedVolatility(type, price, spot, strike, riskFreeRate, ttm, volGuess, relTolerance, maxAttempts); double relDiff = Math.Abs(impliedVol - volatility) / volatility; if (relDiff <= relTolerance) { return(true); } else { return(false); } }
public static ModelConfig BlackScholes1() { var stepsX = 1000; var stepsT = 750; var xMin = .001; var xMax = +6.0; var tMax = 4.0; var grid = new Grid(stepsX, stepsT, xMin, xMax, tMax); var sigma = .35; var mu = .2; var blackScholes = new BlackScholes(mu, sigma); var x0 = .9; var p_0 = Helpers.GetDiracDelta(x0, grid, .99); var integral0 = .0; var dx = (xMax - xMin) / (double)stepsX; for (int iStepX = 0; iStepX < stepsX; iStepX++) { integral0 += p_0(xMin + iStepX * dx) * dx; } return(new ModelConfig(blackScholes, grid, p_0)); }
private decimal CalcPosDelta() { decimal delta = 0M; delta += _futuresPosition; delta += DeltaBuffer; _optionsPositions.ForEach(pair => { decimal?futPrice = null; if (pair.Value > 0) { futPrice = Security.BestBid?.Price; } if (pair.Value < 0) { futPrice = Security.BestAsk?.Price; } var bs = new BlackScholes(pair.Key, Security, Connector); delta += bs.Delta(DateTimeOffset.Now, null, futPrice).CheckIfValueNullThenZero() * pair.Value; }); return(delta); }
private decimal[] GetSecurityGreeks(Security sec, decimal pos) { decimal delta = 0M; decimal gamma = 0M; decimal vega = 0M; decimal theta = 0M; if (sec.Type == SecurityTypes.Future) { delta += pos; } if (sec.Type == SecurityTypes.Option) { var bs = new BlackScholes(sec, _dataManager.UnderlyingAsset, _connector); var lastPrice = pos > 0 ? _dataManager.UnderlyingAsset.BestBid.Price : _dataManager.UnderlyingAsset.BestAsk.Price; delta = MessageManager.MsgGreeksRounding(bs.Delta(DateTimeOffset.Now, null, lastPrice) ?? 0); gamma = MessageManager.MsgGreeksRounding(bs.Gamma(DateTimeOffset.Now, null, lastPrice) ?? 0, 1); vega = MessageManager.MsgGreeksRounding(bs.Vega(DateTimeOffset.Now, null, lastPrice) ?? 0); theta = MessageManager.MsgGreeksRounding(bs.Theta(DateTimeOffset.Now, null, lastPrice) ?? 0, -2); } return(new decimal[] { delta, gamma, vega, theta }); }
private decimal[] GetSummaryGreeks(Dictionary <Security, decimal> securityPositionMapping) { decimal delta = 0M; decimal gamma = 0M; decimal vega = 0M; decimal theta = 0M; securityPositionMapping.OrderBy(kvp => kvp.Key.Code).ForEach(kvp => { if (kvp.Value == 0) { return; } if (kvp.Key.Type == SecurityTypes.Future) { delta += kvp.Value; } if (kvp.Key.Type == SecurityTypes.Option) { var bs = new BlackScholes(kvp.Key, _dataManager.UnderlyingAsset, _connector); var lastPrice = kvp.Value > 0 ? _dataManager.UnderlyingAsset.BestBid.Price : _dataManager.UnderlyingAsset.BestAsk.Price; delta += MessageManager.MsgGreeksRounding((bs.Delta(DateTimeOffset.Now, null, lastPrice) ?? 0)) * kvp.Value; gamma += MessageManager.MsgGreeksRounding((bs.Gamma(DateTimeOffset.Now, null, lastPrice) ?? 0), 1) * kvp.Value; vega += MessageManager.MsgGreeksRounding((bs.Vega(DateTimeOffset.Now, null, lastPrice) ?? 0)) * kvp.Value; theta += MessageManager.MsgGreeksRounding((bs.Theta(DateTimeOffset.Now, null, lastPrice) ?? 0), -2) * kvp.Value; } }); return(new decimal[] { delta, gamma, vega, theta }); }
/// <summary> /// We can roughly proxy the alpha-th percentile of the simulation /// by calculating the upper alpha percentile confidence point for a given time slice /// of the ln-OU process and pricing the collar with this asset value for a given profile point /// This should roughly compare to the calculated (1-alpha)-worst PCE point. /// </summary> /// <param name="spot"></param> /// <param name="kappa"></param> /// <param name="theta"></param> /// <param name="histvol"></param> /// <param name="time0"></param> /// <param name="maturity"></param> /// <param name="callstrike"></param> /// <param name="putstrike"></param> /// <param name="zerodays"></param> /// <param name="zerorates"></param> /// <param name="divdays"></param> /// <param name="divamts"></param> /// <param name="volSurface"></param> /// <returns></returns> public static double PCEProxyCalc(double spot, double kappa, double theta, double histvol, double time0, double maturity, double callstrike, double putstrike, int[] zerodays, double[] zerorates, int[] divdays, double[] divamts, List <OrcWingParameters> volSurface) { double tau = maturity - time0; double upperBound = EquityPCEAnalytics.LNOUUpperBound(spot, 0.95, kappa, theta, histvol, time0); double fStar = EquityAnalytics.GetForwardCCLin365(upperBound, time0, maturity, divdays, divamts, zerodays, zerorates); double callvol = EquityAnalytics.GetWingValue(volSurface, new LinearInterpolation(), tau, callstrike); double putvol = EquityAnalytics.GetWingValue(volSurface, new LinearInterpolation(), tau, putstrike); double r0 = EquityAnalytics.GetRateCCLin365(time0, maturity, zerodays, zerorates); BlackScholes bs = new BlackScholes(); double lhs = Math.Max(bs.BSprice(fStar, tau, callstrike, r0, callvol, true) - bs.BSprice(fStar, tau, putstrike, r0, putvol, false), 0); return(lhs); }
private static void SingleConvergeTest() { int numberOfSteps = 2000; var tree = new CapmBinTree(numberOfSteps); tree.InitialStockPrice = 100; tree.Volatility = 0.2; tree.StrikePrice = 105; tree.TotalTimeYears = 0.5; tree.RiskFree = 0.03; tree.MarketRiskPremium = 0.06; tree.StockBeta = 1; // B&S = call: 4.17 (con strike =105) double callPriceBS = BlackScholes.CallPrice((double)tree.InitialStockPrice, (double)tree.StrikePrice, (double)tree.TotalTimeYears, (double)tree.RiskFree, (double)tree.Volatility); Console.WriteLine("call B&S: " + callPriceBS.ToString("##0.######")); tree.CalculateStockPrices(); tree.CalculateOptionPrices(); Console.WriteLine(); //OutputTree(tree, delegate(BinTree.Node node) { return node.StockPrice.ToString("##0.##"); }); Console.WriteLine("call: " + tree.GetRootNode().OptionPrice.ToString("##0.######")); }
public static void SmallTreeBetaGraph() { int numberOfSteps = 10; var tree = new CapmBinTree(numberOfSteps); tree.InitialStockPrice = 100; tree.Volatility = 0.2; tree.StrikePrice = 105; tree.TotalTimeYears = 0.5; tree.RiskFree = 0.03; tree.MarketRiskPremium = 0.06; tree.StockBeta = 1; // B&S = call: 4.17 (con strike =105) double callPriceBS = BlackScholes.CallPrice((double)tree.InitialStockPrice, (double)tree.StrikePrice, (double)tree.TotalTimeYears, (double)tree.RiskFree, (double)tree.Volatility); Console.WriteLine("call B&S: " + callPriceBS.ToString("##0.######")); tree.CalculateStockPrices(); tree.CalculateOptionPrices(); Console.WriteLine(); OutputTree(tree, delegate(BinTree.Node node) { return((-node.ReplPortBond / (node.StockPrice * node.ReplPortDelta + node.ReplPortBond)).ToString("##0.##")); }); }
private double CalcDeltaOne(BlackScholes blackScholes) { double stockDividedByStrike = Math.Log(blackScholes.StockPrice / blackScholes.StrikePrice); double riskPerVolatility = blackScholes.RiskFreeRate + blackScholes.Volatility * blackScholes.Volatility / 2.0; double stockPerRisksAndDays = stockDividedByStrike + riskPerVolatility * blackScholes.PeriodInDays; return(stockPerRisksAndDays / (blackScholes.Volatility * Math.Sqrt(blackScholes.PeriodInDays))); }
private double CalculateForCallOption(BlackScholes blackScholes, double deltaOne, double deltaTwo) { double riskPerPeriod = Math.Exp(-blackScholes.RiskFreeRate * blackScholes.PeriodInDays); double stockVersusDelta = blackScholes.StockPrice * deltaOne.CumulativeNormalDistribution(); double strikeVersusRisk = blackScholes.StrikePrice * riskPerPeriod * deltaTwo.CumulativeNormalDistribution(); return(stockVersusDelta - strikeVersusRisk); }
public void CalculateTest() { var algorithm = new BlackScholes(); var data = algorithm.CalculateBlackScholes(Domain.Enums.CallPutFlag.C, 30, 20, 1, 5, 40); Assert.AreEqual(30, data); }
public static object BSDelta(double Spot, double DivYield, double Vol, double T, double DF, double Strike, int PutCall) { CallPut cp = (CallPut)PutCall; CommonTypes.Maths.BlackScholes bb = new BlackScholes(cp, T, DF, Vol, DivYield, Spot, Strike); double delta = bb.Delta(); return(delta); }
public static object BSPremium(double Spot, double DivYield, double Vol, double T, double DF, double Strike, int PutCall) { CallPut cp = (CallPut)PutCall; CommonTypes.Maths.BlackScholes bb = new BlackScholes(cp, T, DF, Vol, DivYield, Spot, Strike); double premium = bb.Premium(); return(premium); }
private static void asset_path_test() //****************************************************************************80 // // Purpose: // // ASSET_PATH_TEST tests ASSET_PATH. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 08 June 2016 // // Author: // // John Burkardt // { const int n = 100; Console.WriteLine(""); Console.WriteLine("ASSET_PATH_TEST:"); Console.WriteLine(" Demonstrate the simulated of an asset price path."); const double s0 = 2.0; const double mu = 0.1; const double sigma = 0.3; const double t1 = 1.0; int seed = 123456789; typeMethods.r8vecNormalData data = new(); Console.WriteLine(""); Console.WriteLine(" The asset price at time 0 S0 = " + s0 + ""); Console.WriteLine(" The asset expected growth rate MU = " + mu + ""); Console.WriteLine(" The asset volatility SIGMA = " + sigma + ""); Console.WriteLine(" The expiry date T1 = " + t1 + ""); Console.WriteLine(" The number of time steps N = " + n + ""); Console.WriteLine(" The random number seed was SEED = " + seed + ""); double[] s = BlackScholes.asset_path(s0, mu, sigma, t1, n, ref data, ref seed); typeMethods.r8vec_print_part(n + 1, s, 10, " Partial results:"); string output_filename = "asset_path.txt"; typeMethods.r8vec_write(output_filename, n + 1, s); Console.WriteLine(""); Console.WriteLine(" Full results written to \"" + output_filename + "\"."); }
private static void IterateByAmountOfSteps() { double InitialStockPrice = 100; double Volatility = 0.2; double StrikePrice = 105; double TotalTimeYears = 0.5; double RiskFree = 0.03; double MarketRiskPremium = 0.06; double StockBeta = 1; double callPriceBS = BlackScholes.CallPrice((double)InitialStockPrice, (double)StrikePrice, (double)TotalTimeYears, (double)RiskFree, (double)Volatility); int minNumberOfSteps = 7000; int maxNumberOfSteps = 9000; bool createHeaders = !File.Exists("output.csv"); using (var writer = new StreamWriter("output.csv", true)) { if (createHeaders) { writer.WriteLine("Steps,CallValueBS,CallValueCAPM"); } var tree = new CapmBinTree(maxNumberOfSteps); tree.InitialStockPrice = InitialStockPrice; tree.Volatility = Volatility; tree.StrikePrice = StrikePrice; tree.TotalTimeYears = TotalTimeYears; tree.RiskFree = RiskFree; tree.MarketRiskPremium = MarketRiskPremium; tree.StockBeta = StockBeta; for (int steps = minNumberOfSteps; steps < maxNumberOfSteps; steps += (int)Math.Pow(Math.Log10(steps), 3)) { tree.NumberOfSteps = steps; tree.ResetTreeParameterCalcs(); tree.CalculateStockPrices(); tree.CalculateOptionPrices(); writer.WriteLine(steps + "," + callPriceBS.ToString("##0.#############################") + ", " + tree.GetRootNode().OptionPrice.ToString("##0.#############################")); writer.Flush(); Console.WriteLine("Step Number: " + steps); } } }
public void CalculateImpliedVolatility(string ammOptionsFile, string underlyingsMarketDataFile, string optionsMarketDataFile, double daysToMaturity, double riskFreeRate, ref VolSurface volSurface) { double workingDaysInTheYear = 252; double timeToMaturity = daysToMaturity / workingDaysInTheYear; Dictionary <string, OptionInfo> allAvailableOptions = this.ListAllAvailableOptions(ammOptionsFile); Dictionary <string, OrderBook> underlyingsMarketData = this.GetMarketData(underlyingsMarketDataFile); Dictionary <string, OrderBook> optionsMarketData = this.GetMarketData(optionsMarketDataFile); foreach (var pair in optionsMarketData) { OrderBook optionOrderBook = pair.Value; OptionInfo option = null; if (allAvailableOptions.TryGetValue(optionOrderBook.Name, out option)) { OrderBook underlyingOrderBook = null; if (underlyingsMarketData.TryGetValue(option.Underlying, out underlyingOrderBook)) { double spot = underlyingOrderBook.GetPriceMid(); double bid = (optionOrderBook.Bid != null) ? optionOrderBook.Bid.Value : 0.00; double bidSize = (optionOrderBook.BidSize != null) ? optionOrderBook.BidSize.Value : 0.00;; double ask = (optionOrderBook.Ask != null) ? optionOrderBook.Ask.Value : 0.00;; double askSize = (optionOrderBook.AskSize != null) ? optionOrderBook.AskSize.Value : 0.00;; BlackScholes bs = new BlackScholes(); double bidImpliedVolatility = 0.00; double askImpliedVolatility = 0.00; if (bid > 0.00 && bidSize > 0.00) { bidImpliedVolatility = bs.GetImpliedVolatility(option.Type, bid, spot, option.Strike, riskFreeRate, timeToMaturity); } if (ask > 0.00 && askSize > 0.00) { askImpliedVolatility = bs.GetImpliedVolatility(option.Type, ask, spot, option.Strike, riskFreeRate, timeToMaturity); } if (!(bidImpliedVolatility > 0.0000)) { bidImpliedVolatility = 0.00; } if (!(askImpliedVolatility > 0.0000)) { askImpliedVolatility = 0.00; } VolQuote volQuote = new VolQuote(bidSize, askSize, bidImpliedVolatility, askImpliedVolatility); volSurface.Update(option.ExpiryDate, option.Strike, option.Type, volQuote); } } } }
public static object BSRho(double Spot, double DivYield, double Vol, double T, double DF, double Strike, int PutCall, object DaysOpt) { double days = Utils.GetOptionalParameter(DaysOpt, 1); CallPut cp = (CallPut)PutCall; CommonTypes.Maths.BlackScholes bb = new BlackScholes(cp, T, DF, Vol, DivYield, Spot, Strike); double rho = bb.Rho(days); return(rho); }
public static object TestBS(double Spot, double DivYield, double Vol, double T, double DF, double Strike) { CommonTypes.Maths.BlackScholes bb = new BlackScholes(CallPut.Call, T, DF, Vol, DivYield, Spot, Strike); object[,] ret = new object[2, 2]; double premium = bb.Premium(); double delta = bb.Delta(); ret[0, 0] = "Premium"; ret[0, 1] = premium; ret[1, 0] = "Delta"; ret[1, 1] = delta; return(ret); }
private static void mc_test() //****************************************************************************80 // // Purpose: // // MC_TEST tests MC. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 08 June 2016 // // Author: // // John Burkardt // { Console.WriteLine(""); Console.WriteLine("MC_TEST:"); Console.WriteLine(" A demonstration of the Monte Carlo method"); Console.WriteLine(" for option valuation."); const double s0 = 2.0; const double e = 1.0; const double r = 0.05; const double sigma = 0.25; const double t1 = 3.0; const int m = 1000000; int seed = 123456789; typeMethods.r8vecNormalData data = new(); Console.WriteLine(""); Console.WriteLine(" The asset price at time 0, S0 = " + s0 + ""); Console.WriteLine(" The exercise price E = " + e + ""); Console.WriteLine(" The interest rate R = " + r + ""); Console.WriteLine(" The asset volatility SIGMA = " + sigma + ""); Console.WriteLine(" The expiry date T1 = " + t1 + ""); Console.WriteLine(" The number of simulations M = " + m + ""); Console.WriteLine(" The random number seed was SEED = " + seed + ""); double[] conf = BlackScholes.mc(s0, e, r, sigma, t1, m, ref data, ref seed); Console.WriteLine(""); Console.WriteLine(" The confidence interval is [" + conf[0] + ", " + conf[1] + "]."); }
public static object BSVega(double Spot, double DivYield, double Vol, double T, double DF, double Strike, int PutCall) { CallPut cp = (CallPut)PutCall; CommonTypes.Maths.BlackScholes bb = new BlackScholes(cp, T, DF, Vol, DivYield, Spot, Strike); if (PutCall == 0) { return(0); } double vega = bb.Vega(); return(vega); }
public static double IterativeBS(double price, double underlying, double strike, double expiry, double rate, string cp) { //Newton-Ralpson iterative method BlackScholes option = new BlackScholes(price, underlying, strike, expiry, rate, cp); do { option.CalculateRiskProbabilities(); option.vol = option.vol - (option.CalculateOptionValue() - price) / option.CalculateVega(); } while ((option.CalculateOptionValue() - price) > 0.01); return option.vol; }
//public void GenerateOptionsSample() //{ // OptionType type = OptionType.Call; // double spot = 100; // double riskFreeRate = 0.10; // // Time to maturity = 1 month // List<OptionInfo> optionInfos1M = new List<OptionInfo>(); // double ttm = 1 / 12; // StrikeVol[] strikeVol1M = // { // new StrikeVol(50, 60), // new StrikeVol(60, 45), // new StrikeVol(70, 35), // new StrikeVol(80, 25), // new StrikeVol(90, 20), // new StrikeVol(100, 15), // new StrikeVol(110, 12), // new StrikeVol(120, 15), // new StrikeVol(130, 20), // new StrikeVol(140, 30), // new StrikeVol(150, 40) // }; // for (int i = 0; i < strikeVol1M.Length; i++) // { // OptionInfo info = this.PopulateOptionInfo(type, strikeVol1M[i].Strike, spot, strikeVol1M[i].Volatility, riskFreeRate, ttm); // optionInfos1M.Add(info); // } // // Time to maturity = 2 months // List<OptionInfo> optionInfos2M = new List<OptionInfo>(); // ttm = 2 / 12; // StrikeVol[] strikeVol2M = // { // new StrikeVol(50, 60), // new StrikeVol(60, 58), // new StrikeVol(70, 56), // new StrikeVol(80, 54), // new StrikeVol(90, 52), // new StrikeVol(100, 50), // new StrikeVol(110, 50), // new StrikeVol(120, 52), // new StrikeVol(130, 54), // new StrikeVol(140, 56), // new StrikeVol(150, 58) // }; // for (int i = 0; i < strikeVol2M.Length; i++) // { // OptionInfo info = this.PopulateOptionInfo(type, strikeVol2M[i].Strike, spot, strikeVol2M[i].Volatility, riskFreeRate, ttm); // optionInfos2M.Add(info); // } // // Time to maturity = 3 months // List<OptionInfo> optionInfos3M = new List<OptionInfo>(); // ttm = 3 / 12; // StrikeVol[] strikeVol3M = // { // new StrikeVol(100, 45), // new StrikeVol(110, 44), // new StrikeVol(120, 43), // new StrikeVol(130, 42), // new StrikeVol(140, 41), // new StrikeVol(150, 40), // new StrikeVol(160, 39), // new StrikeVol(170, 38), // new StrikeVol(180, 37), // new StrikeVol(190, 36), // new StrikeVol(200, 35) // }; // for (int i = 0; i < strikeVol3M.Length; i++) // { // OptionInfo info = this.PopulateOptionInfo(type, strikeVol3M[i].Strike, spot, strikeVol3M[i].Volatility, riskFreeRate, ttm); // optionInfos3M.Add(info); // } //} public void CalculateImpliedVolatilityToFile(string ammOptionsFile, string underlyingsMarketDataFile, string optionsMarketDataFile, string outputFile, double daysToMaturity, double riskFreeRate, double volGuess) { double workingDaysInTheYear = 252; double relTolerance = 0.0001; int maxAttempts = 10; double timeToMaturity = daysToMaturity / workingDaysInTheYear; Dictionary <string, OptionInfo> allAvailableOptions = this.ListAllAvailableOptions(ammOptionsFile); Dictionary <string, OrderBook> underlyingsMarketData = this.GetMarketData(underlyingsMarketDataFile); Dictionary <string, OrderBook> optionsMarketData = this.GetMarketData(optionsMarketDataFile); StreamWriter streamWriter = new StreamWriter(outputFile); foreach (var pair in optionsMarketData) { OrderBook optionOrderBook = pair.Value; OptionInfo option = null; if (allAvailableOptions.TryGetValue(optionOrderBook.Name, out option)) { OrderBook underlyingOrderBook = null; if (underlyingsMarketData.TryGetValue(option.Underlying, out underlyingOrderBook)) { double spot = underlyingOrderBook.GetPriceMid(); double optionObservedPrice = optionOrderBook.GetPriceAverage(); BlackScholes bs = new BlackScholes(); double impliedVol = bs.GetImpliedVolatility(option.Type, optionObservedPrice, spot, option.Strike, riskFreeRate, timeToMaturity, volGuess, relTolerance, maxAttempts); if (impliedVol > 0.00000 && impliedVol < 1000) { StringBuilder sb = new StringBuilder(); sb.Append(option.Name); sb.Append(";"); string optionType = (option.Type == OptionType.Call) ? "Call" : "Put"; sb.Append(optionType); sb.Append(";"); sb.Append(option.Strike); sb.Append(";"); sb.Append(impliedVol.ToString()); streamWriter.WriteLine(sb.ToString()); } } } } streamWriter.Close(); }
private double CalculateFor(BlackScholes blackScholes) { double deltaOne = CalcDeltaOne(blackScholes); double deltaTwo = CalcDeltaTwo(blackScholes, deltaOne); if (blackScholes.CallOption == CallOption.Call) { return(CalculateForCallOption(blackScholes, deltaOne, deltaTwo)); } else if (blackScholes.CallOption == CallOption.Put) { return(CalculateForPutOption(blackScholes, deltaOne, deltaTwo)); } throw new InvalidCallOptionException(); }
private VolSurface GetVolSurface(SortedDictionary <DateTime, RiskFreeRate> riskFreeRates, OrderBook underlyingOrderBook, List <OptionMarketData> optionsMarketData) { double businessDaysInTheYear = 252; VolSurface volSurface = new VolSurface(); double spot = underlyingOrderBook.GetPriceMid(); foreach (OptionMarketData option in optionsMarketData) { RiskFreeRate riskFreeRate = null; riskFreeRates.TryGetValue(option.OptionInfo.ExpiryDate, out riskFreeRate); double timeToMaturity = riskFreeRate.BusinessDays / businessDaysInTheYear; double bid = (option.OrderBook.Bid != null) ? option.OrderBook.Bid.Value : 0.00; double bidSize = (option.OrderBook.BidSize != null) ? option.OrderBook.BidSize.Value : 0.00;; double ask = (option.OrderBook.Ask != null) ? option.OrderBook.Ask.Value : 0.00;; double askSize = (option.OrderBook.AskSize != null) ? option.OrderBook.AskSize.Value : 0.00;; BlackScholes bs = new BlackScholes(); double bidImpliedVolatility = 0.00; double askImpliedVolatility = 0.00; if (bid > 0.00 && bidSize > 0.00) { bidImpliedVolatility = bs.GetImpliedVolatility(option.OptionInfo.Type, bid, spot, option.OptionInfo.Strike, riskFreeRate.Rate, timeToMaturity); } if (ask > 0.00 && askSize > 0.00) { askImpliedVolatility = bs.GetImpliedVolatility(option.OptionInfo.Type, ask, spot, option.OptionInfo.Strike, riskFreeRate.Rate, timeToMaturity); } if (!(bidImpliedVolatility > 0.0000)) { bidImpliedVolatility = 0.00; } if (!(askImpliedVolatility > 0.0000)) { askImpliedVolatility = 0.00; } VolQuote volQuote = new VolQuote(bidSize, askSize, bidImpliedVolatility, askImpliedVolatility); volSurface.Update(option.OptionInfo.ExpiryDate, option.OptionInfo.Strike, option.OptionInfo.Type, volQuote); } return(volSurface); }
private static void binomial_test() //****************************************************************************80 // // Purpose: // // BINOMIAL_TEST tests BINOMIAL. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 18 February 2012 // // Author: // // John Burkardt // { Console.WriteLine(""); Console.WriteLine("BINOMIAL_TEST:"); Console.WriteLine(" A demonstration of the binomial method"); Console.WriteLine(" for option valuation."); const double s0 = 2.0; const double e = 1.0; const double r = 0.05; const double sigma = 0.25; const double t1 = 3.0; const int m = 256; Console.WriteLine(""); Console.WriteLine(" The asset price at time 0 S0 = " + s0 + ""); Console.WriteLine(" The exercise price E = " + e + ""); Console.WriteLine(" The interest rate R = " + r + ""); Console.WriteLine(" The asset volatility SIGMA = " + sigma + ""); Console.WriteLine(" The expiry date T1 = " + t1 + ""); Console.WriteLine(" The number of intervals M = " + m + ""); double c = BlackScholes.binomial(s0, e, r, sigma, t1, m); Console.WriteLine(""); Console.WriteLine(" The option value is " + c + ""); }
private static void bsf_test() //****************************************************************************80 // // Purpose: // // BSF_TEST tests BSF. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 18 February 2012 // // Author: // // John Burkardt // { Console.WriteLine(""); Console.WriteLine("BSF_TEST:"); Console.WriteLine(" A demonstration of the Black-Scholes formula"); Console.WriteLine(" for option valuation."); const double s0 = 2.0; const double t0 = 0.0; const double e = 1.0; const double r = 0.05; const double sigma = 0.25; const double t1 = 3.0; Console.WriteLine(""); Console.WriteLine(" The asset price at time T0 S0 = " + s0 + ""); Console.WriteLine(" The time T0 = " + t0 + ""); Console.WriteLine(" The exercise price E = " + e + ""); Console.WriteLine(" The interest rate R = " + r + ""); Console.WriteLine(" The asset volatility SIGMA = " + sigma + ""); Console.WriteLine(" The expiry date T1 = " + t1 + ""); double c = BlackScholes.bsf(s0, t0, e, r, sigma, t1); Console.WriteLine(""); Console.WriteLine(" The option value C = " + c + ""); }
public static object BSTheta(double Spot, double DivYield, double Vol, double T, double DF, double Strike, int PutCall, object DaysOpt) { double days = Utils.GetOptionalParameter(DaysOpt, 1); CallPut cp = (CallPut)PutCall; CommonTypes.Maths.BlackScholes bb = new BlackScholes(cp, T, DF, Vol, DivYield, Spot, Strike); if (PutCall == 0) { return(0); } double theta = bb.Theta(days); return(theta); }
public void Calculate() { var Calculator = new BlackScholes(); var Values = new CalculatorValues { UnderlinePrice = Convert.ToDouble(TextBoxStockPrice.Text), RiskFreeRate = Convert.ToDouble(TextBoxRiskRate.Text) / 100, Volatility = Convert.ToDouble(TextBoxVolatility.Text) / 100, Strike = Convert.ToDouble(TextBoxStrikeOption.Text), QtdDaysExpire = Convert.ToDouble(TextBoxTimeToExpire.Text), Dividend = 0 }; TextBoxBSCallPrice.Content = Calculator.CallPremium(Values).ToString("0.000"); TextBoxBSPutPrice.Content = Calculator.PutPremium(Values).ToString("0.000"); }
private void Calculate_Click(object sender, RoutedEventArgs e) { var option = SelectedOption; var volatility = Volatility.Text.To <decimal>() / 100; var bs = new BlackScholes(option); Delta.Text = bs.Delta(volatility).ToString("0.000"); Gamma.Text = bs.Gamma(volatility).ToString("0.000000"); Vega.Text = bs.Vega(volatility).ToString("0.00"); Theta.Text = bs.Theta(volatility).ToString("0.00"); Rho.Text = bs.Rho(volatility).ToString("0.00"); if (option.LastTrade != null) { IV.Text = bs.IV(option.LastTrade.Price).ToString("0.00"); } }
public double GetImpliedVolatilitMay() { OptionType type = OptionType.Call; double strike = 26.72; double spot = 27.00; double price = 2.17; //double volatility = 0.50; double riskFreeRate = 0.132343187; // discrete = 0.1415, continuos = ln(1+r) = 0.132343187 double ttm = (double)30 / 252; BlackScholes bs = new BlackScholes(); double volGuess = 0.30; double relTolerance = 0.01; int maxAttempts = 10; double impliedVol = bs.GetImpliedVolatility(type, price, spot, strike, riskFreeRate, ttm, volGuess, relTolerance, maxAttempts); return(impliedVol); }
public void TestCrankNicolson() { double spot = 385.5; double epsilon = 0.0001; double strike = 400; double[] rt = { 0.0425, 0.0452, 0.0457, 0.0462 }; int[] tt = { 1, 32, 63, 93 }; int[] divdays = { 0, 48 }; double[] divs = { 20, 10 }; double vol = 0.2046; int steps = 80; double tStepSize = 0.01; DateTime today = new DateTime(2010, 05, 07); DateTime expiry = new DateTime(2010, 06, 24); //string style = "European"; double t = expiry.Subtract(today).Days / 365.0 + epsilon; // For CN backwards propagation div time needs to be strictly less than expiry time double fwd = EquityAnalytics.GetForwardCCLin365(spot, t, divdays, divs, tt, rt); double df = EquityAnalytics.GetDFCCLin365(0, t, tt, rt); BlackScholes bs = new BlackScholes(spot, strike, false, t, vol, tt, rt, divdays, divs); CrankNicolson lhs = new CrankNicolson(false, false, spot, strike, t, vol, steps, tStepSize, 8.0, divdays, divs, tt, rt); double[,] res0 = OptionAnalytics.BlackScholesWithGreeks(false, fwd, strike, vol, t); double[] res_cn = lhs.GetPriceAndGreeks(); double pr_bs = bs.GetPrice(); double delta_bs = bs.GetDelta(); double gamma_bs = bs.GetGamma(); double theta_bs = bs.GetTheta(); double pr_cn = res_cn[0]; double delta_cn = res_cn[1]; double gamma_cn = res_cn[2]; double theta_cn = res_cn[3]; Assert.AreEqual(pr_cn, pr_bs, 0.50); Assert.AreEqual(delta_cn, delta_bs, 0.03); Assert.AreEqual(gamma_cn, 0.012931145370580023, 0.005); Assert.AreEqual(bs.GetTheta(), theta_cn, 0.01); }
private VolSurface GetVolSurface(SortedDictionary<DateTime, RiskFreeRate> riskFreeRates, OrderBook underlyingOrderBook, List<OptionMarketData> optionsMarketData) { double businessDaysInTheYear = 252; VolSurface volSurface = new VolSurface(); double spot = underlyingOrderBook.GetPriceMid(); foreach (OptionMarketData option in optionsMarketData) { RiskFreeRate riskFreeRate = null; riskFreeRates.TryGetValue(option.OptionInfo.ExpiryDate, out riskFreeRate); double timeToMaturity = riskFreeRate.BusinessDays / businessDaysInTheYear; double bid = (option.OrderBook.Bid != null) ? option.OrderBook.Bid.Value : 0.00; double bidSize = (option.OrderBook.BidSize != null) ? option.OrderBook.BidSize.Value : 0.00; ; double ask = (option.OrderBook.Ask != null) ? option.OrderBook.Ask.Value : 0.00; ; double askSize = (option.OrderBook.AskSize != null) ? option.OrderBook.AskSize.Value : 0.00; ; BlackScholes bs = new BlackScholes(); double bidImpliedVolatility = 0.00; double askImpliedVolatility = 0.00; if (bid > 0.00 && bidSize > 0.00) bidImpliedVolatility = bs.GetImpliedVolatility(option.OptionInfo.Type, bid, spot, option.OptionInfo.Strike, riskFreeRate.Rate, timeToMaturity); if (ask > 0.00 && askSize > 0.00) askImpliedVolatility = bs.GetImpliedVolatility(option.OptionInfo.Type, ask, spot, option.OptionInfo.Strike, riskFreeRate.Rate, timeToMaturity); if (!(bidImpliedVolatility > 0.0000)) bidImpliedVolatility = 0.00; if (!(askImpliedVolatility > 0.0000)) askImpliedVolatility = 0.00; VolQuote volQuote = new VolQuote(bidSize, askSize, bidImpliedVolatility, askImpliedVolatility); volSurface.Update(option.OptionInfo.ExpiryDate, option.OptionInfo.Strike, option.OptionInfo.Type, volQuote); } return volSurface; }