protected virtual Decimal CalculateOptionValue2()
{
var result = OptionAnalytics.Opt(AnalyticParameters.IsCall, (double)AnalyticParameters.Rate + (double)AnalyticParameters.Spread - 0.0001, (double)GetStrike(),
(double)GetVolatility(), (double)AnalyticParameters.ExpiryYearFraction);
return((decimal)result);
}
protected virtual Decimal CalculateOptionDelta()
{
var result = OptionAnalytics.OptWithGreeks(GetIsCall(), (double)FloatingIndex, (double)GetStrike(),
(double)GetVolatility(), (double)GetExpiry())[1];
return((decimal)result);
}
protected Decimal CalculateOptionValue()
{
var result = OptionAnalytics.Opt(AnalyticParameters.IsCall, (double)AnalyticParameters.SwapBreakEvenRate, (double)AnalyticParameters.Strike,
(double)Volatility, (double)AnalyticParameters.TimeToExpiry);
return((decimal)result);
}
protected Decimal CalculateStrikeDelta()
{
var result = OptionAnalytics.OptWithGreeks(AnalyticParameters.IsCall, (double)AnalyticParameters.SwapBreakEvenRate, (double)AnalyticParameters.Strike,
(double)Volatility, (double)AnalyticParameters.TimeToExpiry)[6];
return((decimal)result);
}
/// <summary>
/// Values a digital option with greeks.
/// </summary>
/// <param name="callFlag"></param>
/// <param name="fwdPrice"></param>.
/// <param name="strike"></param>
/// <param name="vol"></param>
/// <param name="t"></param>
/// <returns>value, d_dfwdPrice, d2_dfwdPrice2, d_dvol, d_dstrike, d2_dstrike2, d_dt</returns>
public object[,] DigitalWithGreeks(bool callFlag, double fwdPrice, double strike, double vol, double t)
{
var unqVals = OptionAnalytics.DigitalWithGreeks(callFlag, fwdPrice, strike, vol, t);
var result = RangeHelper.ConvertArrayToRange(unqVals);
return(result);
}
/// <summary>
/// Valuation of a regular chooser option:
/// The pricing model values this as the sum of a call option of expiry tL
/// and strike strike, plus a put option of expiry tS and strike strike * df(tS,tL)
/// where df(tS,tL) is the discount function between dates tS and tL.
/// </summary>
/// <param name="fwdPrice">Outright: to pay now for assured delivery of asset at tL</param>
/// <param name="vol">Volatility</param>
/// <param name="tS">Time to date where choice has to be made (years)</param>
/// <param name="tL">Time to expiry of underlying option (years; must be greater than tS)</param>
/// <param name="strike">strike of option</param>
/// <param name="rL">exp(-rL.tL) is DF from now to time tL</param>
/// <returns>An array of calculated doubles: Premium, delta, gamma, vega, rhoL, thetal, thetaS.</returns>
public object[,] ChooserOpt(double fwdPrice, double vol, double tS, double tL, double strike, double rL)
{
var unqVals = OptionAnalytics.ChooserOpt(fwdPrice, vol, tS, tL, strike, rL);
var result = RangeHelper.ConvertArrayToRange(unqVals);
return(result);
}
///<summary>
/// A dual strike dual notional call option.
///</summary>
///<param name="nSteps"></param>
///<param name="notl1"></param>
///<param name="fwdPrice1">price fixable now for purchase of asset 1 at time t</param>
///<param name="strike1"></param>
///<param name="notl2"></param>
///<param name="fwdPrice2">price fixable now for purchase of asset 2 at time t</param>
///<param name="strike2"></param>
///<param name="vol1"></param>
///<param name="vol2"></param>
///<param name="corr">correlation coefficient</param>
///<param name="r">riskless CC interest rate to option expiry</param>
///<param name="t">time to option expiry (years) </param>
///<returns></returns>
public double DualStrikeDualNotionalCall(
long nSteps,
double notl1,
double fwdPrice1,
double strike1,
double notl2,
double fwdPrice2,
double strike2,
double vol1,
double vol2,
double corr,
double r,
double t)
{
return(OptionAnalytics.DualStrikeDualNotionalCall(nSteps,
notl1,
fwdPrice1,
strike1,
notl2,
fwdPrice2,
strike2,
vol1,
vol2,
corr,
r,
t));
}
protected virtual Decimal CalculateCollarOptionValue2()
{
var result = OptionAnalytics.Opt(!AnalyticParameters.IsCall, (double)AnalyticParameters.Rate + (double)AnalyticParameters.Spread - 0.0001, (double)CollarFloorStrike,
(double)CollarFloorVolatility, (double)AnalyticParameters.ExpiryYearFraction);
return((decimal)result);
}
protected virtual Decimal CalculateOptionTheta()
{
var result = OptionAnalytics.OptWithGreeks(!AnalyticParameters.IsPut, (double)AnalyticParameters.Rate, (double)AnalyticParameters.Strike,
(double)AnalyticParameters.Volatility, (double)AnalyticParameters.TimeToExpiry)[4];
return((decimal)result);
}
protected virtual Decimal CalculateOptionDelta()
{
var result = OptionAnalytics.OptWithGreeks(AnalyticParameters.IsCall, (double)AnalyticParameters.Rate + (double)AnalyticParameters.Spread, (double)GetStrike(),
(double)GetVolatility(), (double)AnalyticParameters.ExpiryYearFraction)[1];
return((decimal)result);
}
public static Decimal CalculateStrikeDelta(bool isCall, decimal swapBreakEvenRate, decimal strike, double timeToExpiry, double timeToIndex, IVolatilitySurface indexVolSurface)
{
var volatility = (decimal)indexVolSurface.GetValue(timeToIndex, (double)strike);
var result = OptionAnalytics.OptWithGreeks(isCall, (double)swapBreakEvenRate, (double)strike, (double)volatility, timeToExpiry)[6];
return((decimal)result);
}
protected virtual Decimal CalculateOptionValue(decimal forwardRate)
{
var result = OptionAnalytics.Opt(GetIsCall(), (double)forwardRate, (double)GetStrike(),
(double)GetVolatility(), (double)GetExpiry());
return((decimal)result);
}
protected virtual Decimal CalculateOptionValue2()
{
var result = OptionAnalytics.Opt(GetIsCall(), (double)FloatingIndex - 0.0001, (double)GetStrike(),
(double)GetVolatility(), (double)GetExpiry());
return((decimal)result);
}
protected virtual Decimal CalculateVolatility()
{
var result = OptionAnalytics.OptSolveVol(!AnalyticParameters.IsPut, (double)AnalyticParameters.Rate, (double)AnalyticParameters.Strike,
(double)AnalyticParameters.Premium, 0.0, (double)AnalyticParameters.TimeToExpiry);
return((decimal)result);
}
protected virtual Decimal CalculateCollarOptionDelta()
{
var result = OptionAnalytics.OptWithGreeks(!AnalyticParameters.IsCall, (double)AnalyticParameters.Rate + (double)AnalyticParameters.Spread, (double)CollarFloorStrike,
(double)CollarFloorVolatility, (double)AnalyticParameters.ExpiryYearFraction)[1];
return((decimal)result);
}
protected virtual Decimal CalculateVolatility()
{
var result = OptionAnalytics.OptSolveVol(AnalyticParameters.IsPut, (double)AnalyticParameters.Rate, (double)AnalyticParameters.Strike,
(double)AnalyticParameters.Premium / (double)AnalyticParameters.PremiumPaymentDiscountFactor, 0.0, (double)AnalyticParameters.TimeToExpiry);
//result = BlackModel.GetPutOptionValue(AnalyticParameters.ForwardRate, AnalyticParameters.Strike, AnalyticParameters.Volatility, AnalyticParameters.CurveYearFraction);
return((decimal)result);
}
protected virtual Decimal CalculateOptionDelta()
{
var result = OptionAnalytics.OptWithGreeks(AnalyticParameters.IsPut, (double)AnalyticParameters.Rate, (double)AnalyticParameters.Strike,
(double)AnalyticParameters.Volatility, (double)AnalyticParameters.TimeToExpiry)[1];
//result = BlackModel.GetPutOptionValue(AnalyticParameters.ForwardRate, AnalyticParameters.Strike, AnalyticParameters.Volatility, AnalyticParameters.CurveYearFraction);
return((decimal)result);
}
/// <summary>
/// Valuation of an option on an option:
/// </summary>
/// <param name="callOnOptionFlag">Boolean for option on option being call/put</param>
/// <param name="strikeS">strike of option on option</param>
/// <param name="rS">exp(-rS.tS) is DF from now to time tS</param>
/// <param name="tS">Time to expiry of option on option (years)</param>
/// <param name="callFlag">Boolean for underlying option being call/put</param>
/// <param name="strikeL">strike of underlying option</param>
/// <param name="rL">exp(-rL.tL) is DF from now to time tL</param>
/// <param name="tL">Time to expiry of underlying option (years; must be greater than tS)</param>
/// <param name="fwdPrice">Outright: to pay now for assured delivery of asset at tL</param>
/// <param name="vol">The volatility.</param>
/// <returns>The order of the return types is: Premium, Delta, Gamma, Vega, ThetaS, ThetaL, RhoS, RhoL</returns>
public double[] CompoundOpt(bool callOnOptionFlag, double strikeS, double rS, double tS,
bool callFlag, double strikeL, double rL, double tL, double fwdPrice, double vol)
{
var result = OptionAnalytics.CompoundOpt(callOnOptionFlag, strikeS, rS, tS,
callFlag, strikeL, rL, tL, fwdPrice, vol);
return(result);
}
/// <summary>
/// European option obtained by approximating log normal integral with a sum ...
/// </summary>
/// <param name="callFlag"></param>
/// <param name="fwdPrice"></param>
/// <param name="nSteps"></param>
/// <param name="strike"></param>
/// <param name="vol"></param>
/// <param name="df"></param>
/// <param name="t"></param>
/// <returns>The value</returns>
public double CoxEuroOption4(bool callFlag, double fwdPrice, short nSteps,
double strike, double vol, double df, double t)
{
var result = OptionAnalytics.CoxEuroOption4(callFlag, fwdPrice, nSteps,
strike, vol, df, t);
return(result);
}
///<summary>
///</summary>
///<param name="f"></param>
///<param name="k"></param>
///<param name="expiry"></param>
///<param name="xlParams"></param>
///<param name="interpMethod"></param>
///<returns></returns>
public double InterpBlackVolSABR(double f, double k, double expiry, Excel.Range xlParams, string interpMethod)
{
object[,] values = xlParams.Value[System.Reflection.Missing.Value] as object[, ];
interpMethod = interpMethod.ToUpper();
interpMethod = interpMethod.Trim();
interpMethod = interpMethod.Substring(0, 1);
return(OptionAnalytics.InterpBlackVolSABR(f, k, expiry, ArrayHelper.RangeToMatrix(values), interpMethod));
}
/// <summary>
/// To value and work out sensitivities for an option where the forward value of the asset
/// is fwdPrice.exp(corr.vol1.vol2.t)
/// </summary>
/// <param name="callFlag"></param>
/// <param name="fwdPrice"></param>
/// <param name="strike"></param>
/// <param name="vol1"></param>
/// <param name="vol2"></param>
/// <param name="corr"></param>
/// <param name="t"></param>
/// <returns>value, d_dfwdPrice, d2_dfwdPrice2, d_dvol1, d_dvol2, d_dcorr, d_dt, </returns>
public object[,] QOptWithGreeks(Boolean callFlag, double fwdPrice,
double strike, double vol1, double vol2, double corr, double t)
{
var unqVals = OptionAnalytics.QOptWithGreeks(callFlag, fwdPrice,
strike, vol1, vol2, corr, t);
var result = RangeHelper.ConvertArrayToRange(unqVals);
return(result);
}
///<summary>
///</summary>
///<param name="f"></param>
///<param name="k"></param>
///<param name="sigma"></param>
///<param name="T"></param>
///<param name="lambda"></param>
///<returns></returns>
public object[] BlackFwdPrice(double f, double k, double sigma, double T, int lambda)
{
if (f == 0 | k == 0 | sigma == 0 | T == 0 | lambda == 0)
{
return(null);
}
object[] output = OptionAnalytics.BlackFwdPrice(f, k, sigma, T, lambda);
return(output);
}
///<summary>
///</summary>
///<param name="f"></param>
///<param name="k"></param>
///<param name="price"></param>
///<param name="T"></param>
///<param name="lambda"></param>
///<returns></returns>
public double BlackImpliedVol(double f, double k, double price, double T, int lambda)
{
if (f == 0 | k == 0 | price < 0 | T == 0 | lambda == 0)
{
return(0);
}
double output = OptionAnalytics.BlackImpliedVol(f, k, price, T, lambda);
return(output);
}
protected Decimal CalculateOptionStrike()
{
//if (AnalyticParameters.OtherNPV != null)
//{
var premium = Math.Abs(AnalyticParameters.OtherNPV) / Math.Abs(AnalyticParameters.SwapAccrualFactor) / 10000;
var result = (decimal)OptionAnalytics.OptSolveStrike(AnalyticParameters.IsCall, (double)AnalyticParameters.SwapBreakEvenRate, (double)Volatility,
0.0, (double)AnalyticParameters.TimeToExpiry, (double)premium);
//}
return(result);
}
protected Decimal CalculateOptionStrike()
{
var result = 0.0m;
if (AnalyticParameters.Premium != null)
{
var premium = (decimal)AnalyticParameters.Premium;
result = (decimal)OptionAnalytics.OptSolveStrike(GetIsCall(), (double)FloatingIndex, (double)GetVolatility(),
0.0, (double)AnalyticParameters.ExpiryYearFraction, (double)premium);
}
return(result);
}
protected Decimal CalculateOptionStrike()
{
var result = 0.0m;
if (AnalyticParameters.SwapAccrualFactor != 0.0m && AnalyticParameters.Premium != 0.0m)
{
var premium = AnalyticParameters.Premium / Math.Abs(AnalyticParameters.SwapAccrualFactor);
result = (decimal)OptionAnalytics.OptSolveStrike(AnalyticParameters.IsCall, (double)EvaluateBreakEvenRate(), (double)Volatility,
0.0, (double)AnalyticParameters.ExpiryYearFraction, (double)premium);
}
return(result);
}
/// <summary>
/// Evaluates the npv.
/// </summary>
/// <returns></returns>
protected List <double> EvaluateRawValues()
{
var rawValues = new List <double>();
var rates = EvaluateRates();
if (rates.Count == AnalyticParameters.Strikes.Count && rates.Count == AnalyticParameters.Volatilities.Count && rates.Count == AnalyticParameters.TimesToExpiry.Count)
{
var index = 0;
foreach (var rate in rates)
{
var value = OptionAnalytics.Opt(!AnalyticParameters.IsPut, rate, AnalyticParameters.Strikes[index],
AnalyticParameters.Volatilities[index], AnalyticParameters.TimesToExpiry[index]);
rawValues.Add(value);
index++;
}
}
return(rawValues);
}
/// <summary>
/// Evaluates the greeks.
/// </summary>
/// <returns>The option greeks.</returns>
protected List <double[]> EvaluateGreeks()
{
var greekValues = new List <double[]>();
var rates = EvaluateRates();
if (ValidateOptionInputs(rates))
{
var index = 0;
foreach (var rate in rates)
{
var value = OptionAnalytics.OptWithGreeks(!AnalyticParameters.IsPut, rate, AnalyticParameters.Strikes[index],
AnalyticParameters.Volatilities[index], AnalyticParameters.TimesToExpiry[index]);
greekValues.Add(value);
index++;
}
}
return(greekValues);
}
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);
}
/// <summary>
/// SpreadOptWithGreeks
/// </summary>
/// <param name="nSteps"></param>
/// <param name="fwdPrice1">price fixable now for purchase of asset 1 at time t</param>
/// <param name="fwdPrice2">price fixable now for purchase of asset 2 at time t</param>
/// <param name="strike">strike</param>
/// <param name="vol1">volatility of asset 1</param>
/// <param name="vol2">volatility of asset 2</param>
/// <param name="corr">correlation coefficient</param>
/// <param name="t">time to option expiry in years</param>
/// <returns>delta1, delta2, gamma11, gamma22,
/// gamma12, vega1, vega2, corrSens, theta and the nsteps</returns>
public object[,] SpreadOptWithGreeks(long nSteps,
double fwdPrice1, // price fixable now for purchase of asset 1 at time t
double fwdPrice2, // price fixable now for purchase of asset 2 at time t
double strike, // strike
double vol1, // volatility of asset 1
double vol2, // volatility of asset 2
double corr, // correlation coefficient
double t) // time to option expiry in years
{
var unqVals = OptionAnalytics.SpreadOptWithGreeks(nSteps,
fwdPrice1, // price fixable now for purchase of asset 1 at time t
fwdPrice2, // price fixable now for purchase of asset 2 at time t
strike, // strike
vol1, // volatility of asset 1
vol2, // volatility of asset 2
corr, // correlation coefficient
t);
var result = RangeHelper.ConvertArrayToRange(unqVals);
return(result);
}
