public OISRateHelper(int settlementDays, Period tenor, // swap maturity Handle<Quote> fixedRate, OvernightIndex overnightIndex) : base(fixedRate) { settlementDays_ = settlementDays; tenor_ = tenor; overnightIndex_ = overnightIndex; overnightIndex_.registerWith(update); initializeDates(); }
public OvernightIndexedCoupon( Date paymentDate, double nominal, Date startDate, Date endDate, OvernightIndex overnightIndex, double gearing = 1.0, double spread = 0.0, Date refPeriodStart = null, Date refPeriodEnd = null, DayCounter dayCounter = null) : base(nominal, paymentDate,startDate, endDate, overnightIndex.fixingDays(), overnightIndex, gearing, spread, refPeriodStart, refPeriodEnd, dayCounter, false) { // value dates Schedule sch = new MakeSchedule() .from(startDate) .to(endDate) .withTenor(new Period(1,TimeUnit.Days)) .withCalendar(overnightIndex.fixingCalendar()) .withConvention(overnightIndex.businessDayConvention()) .backwards() .value(); valueDates_ = sch.dates(); if (valueDates_.Count < 2) throw new ArgumentException("degenerate schedule"); // fixing dates n_ = valueDates_.Count()-1; if (overnightIndex.fixingDays()==0) { fixingDates_ = new List<Date>(valueDates_); } else { fixingDates_ = new List<Date>(n_); for (int i=0; i<n_; ++i) fixingDates_[i] = overnightIndex.fixingDate(valueDates_[i]); } // accrual (compounding) periods dt_ = new List<double>(n_); DayCounter dc = overnightIndex.dayCounter(); for (int i=0; i<n_; ++i) dt_.Add(dc.yearFraction(valueDates_[i], valueDates_[i+1])); setPricer(new OvernightIndexedCouponPricer()); }
public OvernightIndexedSwapIndex( string familyName, Period tenor, int settlementDays, Currency currency, OvernightIndex overnightIndex) : base(familyName, tenor, settlementDays, currency, overnightIndex.fixingCalendar(), new Period(1,TimeUnit.Years),BusinessDayConvention.ModifiedFollowing, overnightIndex.dayCounter(),overnightIndex) { overnightIndex_ = overnightIndex; }
public OvernightIndexedSwap(Type type, double nominal, Schedule schedule, double fixedRate, DayCounter fixedDC, OvernightIndex overnightIndex, double spread) : base(2) { type_= type; nominal_ = nominal; paymentFrequency_ = schedule.tenor().frequency(); fixedRate_ = fixedRate; fixedDC_ = fixedDC; overnightIndex_ = overnightIndex; spread_ = spread; if (fixedDC_== null) fixedDC_ = overnightIndex_.dayCounter(); legs_[0] = new FixedRateLeg(schedule) .withCouponRates(fixedRate_, fixedDC_) .withNotionals(nominal_); legs_[1] = new OvernightLeg(schedule, overnightIndex_) .withNotionals(nominal_) .withSpreads(spread_); for (int j = 0; j < 2; ++j) { for (int i = 0; i < legs_[j].Count; i++) legs_[j][i].registerWith(update); } switch (type_) { case Type.Payer: payer_[0] = -1.0; payer_[1] = +1.0; break; case Type.Receiver: payer_[0] = +1.0; payer_[1] = -1.0; break; default: throw new ApplicationException("Unknown overnight-swap type"); } }
public MakeOIS(Period swapTenor, OvernightIndex overnightIndex, double? fixedRate, Period fwdStart) { swapTenor_=swapTenor; overnightIndex_ = overnightIndex; fixedRate_= fixedRate; forwardStart_= fwdStart; fixingDays_ = 2; paymentFrequency_ = Frequency.Annual; rule_ = DateGeneration.Rule.Backward; endOfMonth_ = (new Period(1,TimeUnit.Months)<=swapTenor && swapTenor<=new Period(2,TimeUnit.Years) ? true : false); type_ = OvernightIndexedSwap.Type.Payer; nominal_ = 1.0; overnightSpread_ = 0.0; fixedDayCount_ = overnightIndex.dayCounter(); engine_ = new DiscountingSwapEngine(overnightIndex_.forwardingTermStructure()); }
public static List <CashFlow> OvernightLeg(List <double> nominals, Schedule schedule, BusinessDayConvention paymentAdjustment, OvernightIndex overnightIndex, List <double> gearings, List <double> spreads, DayCounter paymentDayCounter) { Utils.QL_REQUIRE(!nominals.empty(), () => "no nominal given"); List <CashFlow> leg = new List <CashFlow>(); // the following is not always correct Calendar calendar = schedule.calendar(); Date refStart, start, refEnd, end; Date paymentDate; int n = schedule.Count; for (int i = 0; i < n - 1; ++i) { refStart = start = schedule.date(i); refEnd = end = schedule.date(i + 1); paymentDate = calendar.adjust(end, paymentAdjustment); if (i == 0 && !schedule.isRegular(i + 1)) { refStart = calendar.adjust(end - schedule.tenor(), paymentAdjustment); } if (i == n - 1 && !schedule.isRegular(i + 1)) { refEnd = calendar.adjust(start + schedule.tenor(), paymentAdjustment); } leg.Add(new OvernightIndexedCoupon(paymentDate, Utils.Get(nominals, i), start, end, overnightIndex, Utils.Get(gearings, i, 1.0), Utils.Get(spreads, i, 0.0), refStart, refEnd, paymentDayCounter)); } return(leg); }
public MakeOIS(Period swapTenor, OvernightIndex overnightIndex, double?fixedRate = null, Period fwdStart = null) { swapTenor_ = swapTenor; overnightIndex_ = overnightIndex; fixedRate_ = fixedRate; forwardStart_ = fwdStart ?? new Period(0, TimeUnit.Days); settlementDays_ = 2; calendar_ = overnightIndex.fixingCalendar(); paymentFrequency_ = Frequency.Annual; rule_ = DateGeneration.Rule.Backward; // any value here for endOfMonth_ would not be actually used isDefaultEOM_ = true; //endOfMonth_ = (new Period(1,TimeUnit.Months)<=swapTenor && swapTenor<=new Period(2,TimeUnit.Years) ? true : false); type_ = OvernightIndexedSwap.Type.Payer; nominal_ = 1.0; overnightSpread_ = 0.0; fixedDayCount_ = overnightIndex.dayCounter(); //engine_ = new DiscountingSwapEngine(overnightIndex_.forwardingTermStructure()); }
public DatedOISRateHelper(Date startDate, Date endDate, Handle<Quote> fixedRate, OvernightIndex overnightIndex) : base(fixedRate) { overnightIndex.registerWith(update); // dummy OvernightIndex with curve/swap arguments // review here IborIndex clonedIborIndex = overnightIndex.clone(termStructureHandle_); OvernightIndex clonedOvernightIndex = clonedIborIndex as OvernightIndex; swap_ = new MakeOIS(new Period(), clonedOvernightIndex, 0.0) .withEffectiveDate(startDate) .withTerminationDate(endDate) .withDiscountingTermStructure(termStructureHandle_); earliestDate_ = swap_.startDate(); latestDate_ = swap_.maturityDate(); }
public DatedOISRateHelper(Date startDate, Date endDate, Handle <Quote> fixedRate, OvernightIndex overnightIndex) : base(fixedRate) { overnightIndex.registerWith(update); // dummy OvernightIndex with curve/swap arguments // review here IborIndex clonedIborIndex = overnightIndex.clone(termStructureHandle_); OvernightIndex clonedOvernightIndex = clonedIborIndex as OvernightIndex; swap_ = new MakeOIS(new Period(), clonedOvernightIndex, 0.0) .withEffectiveDate(startDate) .withTerminationDate(endDate) .withDiscountingTermStructure(termStructureHandle_); earliestDate_ = swap_.startDate(); latestDate_ = swap_.maturityDate(); }
public override double swapletRate() { OvernightIndex index = coupon_.index() as OvernightIndex; List <Date> fixingDates = coupon_.fixingDates(); List <double> dt = coupon_.dt(); int n = dt.Count(); int i = 0; double compoundFactor = 1.0; // already fixed part Date today = Settings.evaluationDate(); while (fixingDates[i] < today && i < n) { // rate must have been fixed double pastFixing = IndexManager.instance().getHistory( index.name()).value()[fixingDates[i]]; if (pastFixing == default(double)) { throw new ApplicationException("Missing " + index.name() + " fixing for " + fixingDates[i].ToString()); } compoundFactor *= (1.0 + pastFixing * dt[i]); ++i; } // today is a border case if (fixingDates[i] == today && i < n) { // might have been fixed try { double pastFixing = IndexManager.instance().getHistory( index.name()).value()[fixingDates[i]]; if (pastFixing != default(double)) { compoundFactor *= (1.0 + pastFixing * dt[i]); ++i; } else { ; // fall through and forecast } } catch (Exception e) { ; // fall through and forecast } } // forward part using telescopic property in order // to avoid the evaluation of multiple forward fixings if (i < n) { Handle <YieldTermStructure> curve = index.forwardingTermStructure(); if (curve.empty()) { throw new ArgumentException("null term structure set to this instance of" + index.name()); } List <Date> dates = coupon_.valueDates(); double startDiscount = curve.link.discount(dates[i]); double endDiscount = curve.link.discount(dates[n]); compoundFactor *= startDiscount / endDiscount; } double rate = (compoundFactor - 1.0) / coupon_.accrualPeriod(); return(coupon_.gearing() * rate + coupon_.spread()); }
public OvernightLeg(Schedule schedule, OvernightIndex overnightIndex) { schedule_ = schedule; overnightIndex_ = overnightIndex; paymentAdjustment_ = BusinessDayConvention.Following; }
public MakeOIS(Period swapTenor, OvernightIndex overnightIndex) : this(swapTenor, overnightIndex, null, new Period(0, TimeUnit.Days)) { }
public MakeOIS(Period swapTenor, OvernightIndex overnightIndex, double?fixedRate) : this(swapTenor, overnightIndex, fixedRate, new Period(0, TimeUnit.Days)) { }
public OvernightLeg(Schedule schedule,OvernightIndex overnightIndex) { schedule_ = schedule; overnightIndex_ = overnightIndex; paymentAdjustment_ = BusinessDayConvention.Following; }
public MakeOIS(Period swapTenor, OvernightIndex overnightIndex) : this(swapTenor, overnightIndex, null, new Period(0, TimeUnit.Days)) {}
public MakeOIS(Period swapTenor, OvernightIndex overnightIndex, double? fixedRate) : this(swapTenor,overnightIndex,fixedRate,new Period (0,TimeUnit.Days)) {}