public void DiscountFactorToZeroRateTest()
{
var result = new double[Rates.Length];
for (var i = 0; i < Rates.Length; i++)
{
result[i] = Rates[i] * Times[i];
}
var vectorRatesTimes = new DoubleVector(result);
vectorRatesTimes.Multiply(-1.0d);
vectorRatesTimes.Apply(Math.Exp);
var index = 0;
foreach (var pointvalue in vectorRatesTimes)
{
var yearFraction = (decimal)Times[index];
foreach (var comp in _compounding)
{
var result2 = RateAnalytics.DiscountFactorToZeroRate(1.0m, (decimal)pointvalue, yearFraction, comp);
Debug.WriteLine($"Rate : {result2} Time: {yearFraction}");
}
index++;
}
}
public void TestSelfConsistency()
{
var result = new double[Rates.Length];
for (var i = 0; i < Rates.Length; i++)
{
result[i] = Rates[i] * Times[i];
}
var vectorRatesTimes = new DoubleVector(result);
vectorRatesTimes.Multiply(-1.0d);
vectorRatesTimes.Apply(Math.Exp);
var index = 0;
foreach (var pointvalue in vectorRatesTimes)
{
var yearFraction = (decimal)Times[index];
foreach (var comp in _compounding)
{
var result2 = RateAnalytics.DiscountFactorToZeroRate(1.0m, (decimal)pointvalue, yearFraction, comp);
var result1 = RateAnalytics.ZeroRateToDiscountFactor(result2, yearFraction, comp);
Debug.WriteLine($"DFIn : {pointvalue} DFOut: {(double) result1}");
Assert.AreEqual((double)result1, pointvalue, .000000001);
}
index++;
}
}
///<summary>
///</summary>
///<param name="discount"></param>
///<param name="shift"></param>
public void Populate(QuarterlyDiscounts discount, QuarterlyShifts shift)
{
var forward = new double[_maxTenor + 1];
var accumForward = new double[_maxTenor + 1];
var accumForwardTimesRate = new double[_maxTenor + 1];
var accumForwardTimesShiftedRate = new double[_maxTenor + 1];
accumForward[0] = 0;
accumForwardTimesRate[0] = 0;
accumForwardTimesShiftedRate[0] = 0;
var w = new double[_maxTenor];
var h = new double[_maxTenor];
for (int i = 0; i < _maxExpiry; i++)
{
for (int j = 0; j < _maxTenor - i; j++)
{
//See "Engineering BGM" page 34 for explicit formula. Function definitions can be found in chapter 4.
forward[j + 1] = RateAnalytics.ForwardContract(i + 1, i + j + 2, discount);
accumForward[j + 1] = accumForward[j] + forward[j + 1];
accumForwardTimesRate[j + 1]
= accumForwardTimesRate[j] + forward[j + 1] * RateAnalytics.CashForwardRate(i + j + 1, discount);
accumForwardTimesShiftedRate[j + 1]
= accumForwardTimesShiftedRate[j] + forward[j + 1] * RateAnalytics.ShiftedCashForwardRate(i + j + 1, discount, shift);
h[j] = 0.25 * RateAnalytics.ShiftedCashForwardRate(i + j + 1, discount, shift) / (1 + 0.25 * RateAnalytics.CashForwardRate(i + j + 1, discount));
for (int k = 0; k < j + 1; k++)
{
w[k] = forward[k + 1] * RateAnalytics.ShiftedCashForwardRate(i + k + 1, discount, shift) / accumForwardTimesShiftedRate[j + 1];
_weights[i][j][k] = w[k] - h[k] * ((accumForwardTimesRate[j + 1] - accumForwardTimesRate[k]) / accumForwardTimesShiftedRate[j + 1]
- (1 - accumForward[k] / accumForward[j + 1]) * accumForwardTimesRate[j + 1] / accumForwardTimesShiftedRate[j + 1]);
}
}
}
}
/// <summary>
/// Gets the forward lin365.
/// </summary>
/// <param name="yearFraction">The year fraction.</param>
/// <param name="divdays">The div days.</param>
/// <param name="divamts">The div amounts.</param>
/// <param name="ratedays">The rate days.</param>
/// <param name="rateamts">The rate amounts.</param>
/// <returns></returns>
public static double GetForwardCCLin365(double spot, double yearFraction, int[] divdays, double[] divamts, int[] ratedays, double[] rateamts)
{
double pvdivs = GetPVDivsCCLin365(0, yearFraction, divdays, divamts, ratedays, rateamts);
double r0 = GetRateCCLin365(0, yearFraction, ratedays, rateamts);
double df = RateAnalytics.ZeroRateToDiscountFactor(r0, yearFraction, CompoundingFrequencyEnum.Continuous);
return((spot - pvdivs) / df);
}
public void TerminalWealthFromZeroRateTest()
{
const decimal rate = 0.05m;
const decimal yearFraction = 1.5m;
decimal actual = RateAnalytics.TerminalWealthFromZeroRate(rate, yearFraction, "Quarterly");
Assert.AreEqual(0.98153875, (double)actual, 0.00000001);
}
private static double AdjustCapletImpliedVol(int expiry, double volatility, QuarterlyDiscounts discount, QuarterlyShifts shift)
{
double strike = RateAnalytics.CashForwardRate(expiry, discount);
double capletPrice = BlackModel.GetValue(expiry / 4.0, strike, strike, volatility, PayStyle.Call);
double result = BlackModel.GetImpliedVolatility(expiry / 4.0, strike + shift.Get(expiry), strike + shift.Get(expiry), capletPrice, volatility, PayStyle.Call);
return(result);
}
public void ZeroRateToDiscountFactor2Test()
{
double result = RateAnalytics.ZeroRateToDiscountFactor(0.02, 0.5, "SemiAnnual");
Assert.AreEqual(0.99009900, result, 0.00000001);
result = RateAnalytics.ZeroRateToDiscountFactor(0.02, 0.5, "Continuous");
Assert.AreEqual(0.99004983, result, 0.00000001);
}
private static double AdjustSwaptionImpliedVol(int expiry, int tenor, double volatility, QuarterlyDiscounts discount, QuarterlyShifts shift)
{
double strike = RateAnalytics.SwapRate(expiry, tenor, discount);
double swapShift = RateAnalytics.SwapShift(expiry, tenor, discount, shift);
double swaptionPrice = BlackModel.GetValue(expiry / 4.0, strike, strike, volatility, PayStyle.Call);
double result = BlackModel.GetImpliedVolatility(expiry / 4.0, strike + swapShift, strike + swapShift, swaptionPrice, volatility, PayStyle.Call);
return(result);
}
public void DiscountFactorToZeroRate3Test()
{
double result = RateAnalytics.DiscountFactorToZeroRate(0.9, 0.5, "Quarterly");
Assert.AreEqual(0.21637021, result, 0.00000001);
result = RateAnalytics.DiscountFactorToZeroRate(0.9, 0.5, "SemiAnnual");
Assert.AreEqual(0.22222222, result, 0.00000001);
}
/// <summary>
/// Gets the dividend discount factor.
/// </summary>
public static decimal GetDiscountFactor(decimal years, decimal rate, CompoundingFrequencyEnum cf)
{
double years0 = Convert.ToDouble(years);
double rate0 = Convert.ToDouble(rate);
double df = RateAnalytics.ZeroRateToDiscountFactor(rate0, years0, cf);
decimal df0 = Convert.ToDecimal(df);
return(df0);
}
public void DiscountFactorToZeroRate5Test()
{
double result = (double)RateAnalytics.DiscountFactorToZeroRate(0.9m, 0.8m, 0.5m, 0.25m);
Assert.AreEqual(0.24264068, result, 0.00000001);
result = (double)RateAnalytics.DiscountFactorToZeroRate(0.9m, 0.8m, 0.5m, 0);
Assert.AreEqual(0.23556607, result, 0.00000001);
}
/// <summary>
/// Gets the df.
/// </summary>
/// <param name="days">The days.</param>
/// <returns></returns>
public decimal GetDf(int days)
{
var rateCurve = new InterpolatedCurve(new DiscreteCurve(GetYearsArray(),
RateArray), InterpolationFactory.Create(InterpolationType), false);
double maturityYrs = days / 365.0;
IPoint point = new Point1D(maturityYrs);
double rate = rateCurve.Value(point);
double df = RateAnalytics.ZeroRateToDiscountFactor(rate, maturityYrs, RateType);
decimal df0 = Convert.ToDecimal(df);
return(df0);
}
public void ZeroRateToDiscountFactor1Test()
{
decimal result = RateAnalytics.ZeroRateToDiscountFactor(0.02m, 0.5m, 0.5m);
Assert.AreEqual(0.99009900, (double)result, 0.00000001);
result = RateAnalytics.ZeroRateToDiscountFactor(0.02m, 0.5m, 0);
Assert.AreEqual(0.99004983, (double)result, 0.00000001);
result = RateAnalytics.ZeroRateToDiscountFactor(0.02m, 0m, 0.5m);
Assert.AreEqual(1, result);
}
internal static double GetAdjustedDiscountFactor(DateTime baseDate, DateTime baseCurveDate,
IDayCounter dayCounter, double zeroRateSpread, IRateCurve baseCurve)
{
const double compoundingPeriod = 0.25;
// Convert to Zero Rate
double yearFraction = dayCounter.YearFraction(baseDate, baseCurveDate);
double df0 = baseCurve.GetDiscountFactor(baseCurveDate);
double z0 = RateAnalytics.DiscountFactorToZeroRate(df0, yearFraction, compoundingPeriod);
// Add the spread
double z = z0 + zeroRateSpread;
// Change back
double discountFactor = RateAnalytics.ZeroRateToDiscountFactor(z, yearFraction, compoundingPeriod);
return(discountFactor);
}
public void ZeroRateToDiscountFactor0Test()
{
var index = 0;
foreach (var pointvalue in Rates)
{
var yearFraction = (decimal)Times[index];
foreach (var comp in _compounding)
{
var result2 = RateAnalytics.ZeroRateToDiscountFactor((decimal)pointvalue, yearFraction, comp);
Debug.WriteLine($"rate : {result2} Time: {yearFraction}");
}
index++;
}
}
public void DiscountFactorToZeroRate2Test()
{
double result = RateAnalytics.DiscountFactorToZeroRate(0.9, 0.5, "Quarterly");
Assert.AreEqual(0.21637021, result, 0.00000001);
result = RateAnalytics.DiscountFactorToZeroRate(0.9, 0.5, "Continuous");
Assert.AreEqual(0.21072103, result, 0.00000001);
result = RateAnalytics.DiscountFactorToZeroRate(0.9, 0.5, "Weekly");
Assert.AreEqual(0.21114856, result, 0.00000001);
result = RateAnalytics.DiscountFactorToZeroRate(0.9, 0.5, "Daily");
Assert.AreEqual(0.21078186, result, 0.00000001);
result = RateAnalytics.DiscountFactorToZeroRate(0.9, 0.5, "Annual");
Assert.AreEqual(0.23456790, result, 0.00000001);
}
public double ShortEndTargetFunction(double guess)
{
DateTime baseDate = _baseCurve.GetBaseDate();
DateTime date0 = _assetDates.First();
DateTime date1 = _assetDates.Last();
double d0 = _baseCurve.GetDiscountFactor(date0);
double d1 = _baseCurve.GetDiscountFactor(date1);
double y = _dayCounter.YearFraction(date0, date1);
double y0 = _dayCounter.YearFraction(baseDate, date0);
double y1 = _dayCounter.YearFraction(baseDate, date1);
double z0 = RateAnalytics.DiscountFactorToZeroRate(d0, y0, _compoundingPeriod);
double z1 = RateAnalytics.DiscountFactorToZeroRate(d1, y1, _compoundingPeriod);
double projectedRate = 1 / y * (d0 / d1 - 1);
double basisSpread = (double)_asset.MarketQuote.value;
double term1 = Math.Pow(1 + 0.25 * (z0 + guess), -4 * y0);
double term2 = Math.Pow(1 + 0.25 * (z1 + guess), -4 * y1);
double term3 = y * term2 * (projectedRate + basisSpread);
double result = -term1 + term2 + term3;
return(result);
}
///<summary>
/// Converts a discount factor to a compounding zero rate.
///</summary>
///<param name="yearFraction">The year Fraction.</param>
///<param name="discountFactor">The discount factor.</param>
///<param name="frequency">The compounding frequency. Can take: Continuous, Daily, Quarterly,
/// Semi-Annual,SemiAnnual,Semi and Annual</param>
///<returns>The compounded zero rate requested.</returns>
public double DiscountFactorToZeroRate3(double yearFraction, double discountFactor, String frequency)
{
return(RateAnalytics.DiscountFactorToZeroRate(discountFactor, yearFraction, frequency));
}
/// <summary>
/// Gets the derivative of the discount factor wrt the zero rate..
/// </summary>
/// <param name="discountFactor">The relevant df.</param>
/// <param name="yearFraction">The year fraction.</param>
/// <param name="rate">the rate.</param>
/// <returns></returns>
public Decimal GetDeltaZeroRate(decimal discountFactor, decimal yearFraction, decimal rate)
{
return(RateAnalytics.GetDeltaZeroRate(discountFactor, yearFraction, rate));
}
/// <summary>
/// Evaluates the implied quote.
/// </summary>
/// <returns></returns>
protected virtual Decimal EvaluateImpliedQuote()//TODO this won't work.
{
return(RateAnalytics.DiscountFactorToZeroRate(AnalyticParameters.StartDiscountFactor, AnalyticParameters.EndDiscountFactor, AnalyticParameters.YearFraction, AnalyticParameters.PeriodAsTimesPerYear));
}
/// <summary>
/// Gets the discount factor at maturity.
/// </summary>
/// <param name="startDiscountFactor">The start df.</param>
/// <param name="yearFraction">The year fraction.</param>
/// <param name="rate">the rate.</param>
/// <returns></returns>
public Decimal GetDFAtMaturity(decimal startDiscountFactor, decimal yearFraction, decimal rate)
{
return(RateAnalytics.GetDiscountFactorAtMaturity(startDiscountFactor, yearFraction, rate));
}
/// <summary>
/// Evaluates the delta wrt the fixed rate R.
/// </summary>
/// <returns></returns>
public static decimal GetDelta1(decimal npv, decimal curveYearFraction, decimal rate, decimal yearFraction)
{
return(RateAnalytics.GetDelta1(npv, curveYearFraction, rate, yearFraction));
}
/// <summary>
///
/// </summary>
/// <param name="startDF"></param>
/// <param name="endDF"></param>
/// <param name="yearFraction"></param>
/// <returns></returns>
protected static Decimal GetRate(decimal startDF, decimal endDF, decimal yearFraction)
{
return(RateAnalytics.GetRate(startDF, endDF, yearFraction));
}
/// <summary>
/// Evaluates the delta wrt the continuously compounding rate R.
/// </summary>
/// <returns></returns>
public Decimal GetDeltaCCR(Decimal npv, Decimal curveYearFraction, Decimal rate, Decimal yearFraction)
{
return(RateAnalytics.GetDeltaCcr(npv, curveYearFraction, rate, yearFraction));
}
///<summary>
/// Converts a discount factor to a compounding zero rate.
///</summary>
///<param name="targetDate">The target date.</param>
///<param name="discountFactor">The discount factor.</param>
///<param name="frequency">The compounding frequency. Can take: Continuous, Daily, Quarterly,
/// Semi-Annual,SemiAnnual,Semi and Annual.</param>
///<param name="baseDate">The base date.</param>
///<returns>The compounded zero rate requested.</returns>
public double DiscountFactorToZeroRate1(DateTime baseDate, DateTime targetDate, double discountFactor, String frequency)
{
double yearFraction = Actual365.Instance.YearFraction(baseDate, targetDate);
return(RateAnalytics.DiscountFactorToZeroRate(discountFactor, yearFraction, frequency));
}
/// <summary>
/// Converts from the zero rate to a terminal wealth.
/// </summary>
/// <param name="rate"></param>
/// <param name="yearFraction"></param>
/// <param name="compoundingPeriod"></param>
/// <returns></returns>
public decimal ZeroRateToDiscountFactor(decimal rate, decimal yearFraction,//TODO yearFraction <> 0.
decimal compoundingPeriod)
{
return(RateAnalytics.ZeroRateToDiscountFactor(rate, yearFraction,
compoundingPeriod));
}
/// <summary>
/// Gets the rate.
/// </summary>
/// <param name="startDiscountFactor">The start discount factor.</param>
/// <param name="endDiscountFactor">The end discount factor.</param>
/// <param name="yearFraction">The year fraction.</param>
/// <returns></returns>
public Decimal GetRate(Decimal startDiscountFactor, Decimal endDiscountFactor, Decimal yearFraction)
{
return(RateAnalytics.GetRate(startDiscountFactor, endDiscountFactor, yearFraction));
}
/// <summary>
/// Converts from the zero rate to a terminal wealth.
/// </summary>
/// <param name="startDiscountFactor"></param>
/// <param name="endDiscountFactor"></param>
/// <param name="yearFraction"></param>
/// <param name="compoundingPeriod"></param>
/// <returns></returns>
public decimal DiscountFactorToZeroRate2(decimal startDiscountFactor, decimal endDiscountFactor,
decimal yearFraction, decimal compoundingPeriod)
{
return(RateAnalytics.DiscountFactorToZeroRate(startDiscountFactor, endDiscountFactor,
yearFraction, compoundingPeriod));
}
/// <summary>
/// Evaluates the discount factor at maturity.
/// </summary>
/// <returns></returns>
protected virtual Decimal EvaluateDiscountFactorAtMaturity()
{
return(AnalyticParameters.StartDiscountFactor * RateAnalytics.ZeroRateToDiscountFactor(AnalyticParameters.Rate, AnalyticParameters.YearFraction, AnalyticParameters.PeriodAsTimesPerYear));
}
