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