public static impliedRate ( double compound, Date d1, Date d2, DayCounter resultDC, Compounding comp ) : |
||
compound | double | |
d1 | Date | |
d2 | Date | |
resultDC | DayCounter | |
comp | Compounding | |
return |
/*! Simple yield calculation based on underlying spot and * forward values, taking into account underlying income. * When \f$ t>0 \f$, call with: * underlyingSpotValue=spotValue(t), * forwardValue=strikePrice, to get current yield. For a * repo, if \f$ t=0 \f$, impliedYield should reproduce the * spot repo rate. For FRA's, this should reproduce the * relevant zero rate at the FRA's maturityDate_; */ public InterestRate impliedYield(double underlyingSpotValue, double forwardValue, Date settlementDate, Compounding compoundingConvention, DayCounter dayCounter) { double tenor = dayCounter.yearFraction(settlementDate, maturityDate_); double compoundingFactor = forwardValue / (underlyingSpotValue - spotIncome(incomeDiscountCurve_)); return(InterestRate.impliedRate(compoundingFactor, dayCounter, compoundingConvention, Frequency.Annual, tenor)); }
/*! The resulting interest rate has the same day-counting rule * used by the term structure. The same rule should be used * for calculating the passed time t. */ public InterestRate zeroRate(double t, Compounding comp, Frequency freq = Frequency.Annual, bool extrapolate = false) { if (t.IsEqual(0.0)) { t = dt; } double compound = 1.0 / discount(t, extrapolate); return(InterestRate.impliedRate(compound, dayCounter(), comp, freq, t)); }
public InterestRate zeroRate(double t, Compounding comp, Frequency freq, bool extrapolate) { if (t == 0) { t = 0.0001; } double compound = 1 / discount(t, extrapolate); return(InterestRate.impliedRate(compound, t, dayCounter(), comp, freq)); }
// These methods return the implied zero-yield rate for a // given date or time. In the former case, the time is // calculated as a fraction of year from the reference date. /*! The resulting interest rate has the required daycounting * rule. */ public InterestRate zeroRate(Date d, DayCounter dayCounter, Compounding comp, Frequency freq = Frequency.Annual, bool extrapolate = false) { if (d == referenceDate()) { double compound = 1.0 / discount(dt, extrapolate); // t has been calculated with a possibly different daycounter // but the difference should not matter for very small times return(InterestRate.impliedRate(compound, dayCounter, comp, freq, dt)); } double compound1 = 1.0 / discount(d, extrapolate); return(InterestRate.impliedRate(compound1, dayCounter, comp, freq, referenceDate(), d)); }
public InterestRate zeroRate(Date d, DayCounter dayCounter, Compounding comp, Frequency freq, bool extrapolate) { if (d == referenceDate()) { double t = 0.0001; double compound = 1 / discount(t, extrapolate); return(InterestRate.impliedRate(compound, t, dayCounter, comp, freq)); } else { double compound = 1 / discount(d, extrapolate); return(InterestRate.impliedRate(compound, referenceDate(), d, dayCounter, comp, freq)); } }
public InterestRate forwardRate(double t1, double t2, Compounding comp, Frequency freq, bool extrapolate) { if (t2 == t1) { t2 = t1 + 0.0001; } if (!(t2 > t1)) { throw new ArgumentException("t2 (" + t2 + ") < t1 (" + t2 + ")"); } double compound = discount(t1, extrapolate) / discount(t2, extrapolate); return(InterestRate.impliedRate(compound, t2 - t1, dayCounter(), comp, freq)); }
// These methods returns the forward interest rate between two dates // or times. In the former case, times are calculated as fractions // of year from the reference date. // // If both dates (times) are equal the instantaneous forward rate is // returned. /*! The resulting interest rate has the required day-counting * rule. */ public InterestRate forwardRate(Date d1, Date d2, DayCounter dayCounter, Compounding comp, Frequency freq = Frequency.Annual, bool extrapolate = false) { if (d1 == d2) { checkRange(d1, extrapolate); double t1 = Math.Max(timeFromReference(d1) - dt / 2.0, 0.0); double t2 = t1 + dt; double compound = discount(t1, true) / discount(t2, true); // times have been calculated with a possibly different daycounter // but the difference should not matter for very small times return(InterestRate.impliedRate(compound, dayCounter, comp, freq, dt)); } Utils.QL_REQUIRE(d1 < d2, () => d1 + " later than " + d2); double compound1 = discount(d1, extrapolate) / discount(d2, extrapolate); return(InterestRate.impliedRate(compound1, dayCounter, comp, freq, d1, d2)); }
/*! The resulting interest rate has the same day-counting rule * used by the term structure. The same rule should be used * for calculating the passed times t1 and t2. */ public InterestRate forwardRate(double t1, double t2, Compounding comp, Frequency freq = Frequency.Annual, bool extrapolate = false) { double compound; if (t2.IsEqual(t1)) { checkRange(t1, extrapolate); t1 = Math.Max(t1 - dt / 2.0, 0.0); t2 = t1 + dt; compound = discount(t1, true) / discount(t2, true); } else { Utils.QL_REQUIRE(t2 > t1, () => "t2 (" + t2 + ") < t1 (" + t2 + ")"); compound = discount(t1, extrapolate) / discount(t2, extrapolate); } return(InterestRate.impliedRate(compound, dayCounter(), comp, freq, t2 - t1)); }
public InterestRate forwardRate(Date d1, Date d2, DayCounter resultDayCounter, Compounding comp, Frequency freq, bool extrapolate) { if (d1 == d2) { double t1 = timeFromReference(d1); double t2 = t1 + 0.0001; double compound = discount(t1, extrapolate) / discount(t2, extrapolate); return(InterestRate.impliedRate(compound, t2 - t1, resultDayCounter, comp, freq)); } else { if (!(d1 < d2)) { throw new ArgumentException(d1 + " later than " + d2); } double compound = discount(d1, extrapolate) / discount(d2, extrapolate); return(InterestRate.impliedRate(compound, d1, d2, resultDayCounter, comp, freq)); } }