public async Task TestForEndTimeOfFebInNonLeapYear() { IDateGeneration dateGeneration = new DateGeneration(); string EndTime = await dateGeneration.GenerateLastTime(2, 2005); Assert.Equal("2005-2-28 23:59:59", EndTime); }
public async Task TestForEndTimeOfAugust() { IDateGeneration dateGeneration = new DateGeneration(); string EndTime = await dateGeneration.GenerateLastTime(8, 2004); Assert.Equal("2004-8-31 23:59:59", EndTime); }
public async Task TestForStartTime() { IDateGeneration dateGeneration = new DateGeneration(); string StartTime = await dateGeneration.GenerateStartTime(2, 2000); Assert.Equal("2000-2-01 00:00:00", StartTime); }
public async Task TestForEndTimeOfNovember() { IDateGeneration dateGeneration = new DateGeneration(); string EndTime = await dateGeneration.GenerateLastTime(11, 2004); Assert.Equal("2004-11-30 23:59:59", EndTime); }
public async Task TestForStartTimeOfDecember() { IDateGeneration dateGeneration = new DateGeneration(); string StartTime = await dateGeneration.GenerateStartTime(12, 2004); Assert.Equal("2004-12-01 00:00:00", StartTime); }
//public FloatingRateBond(int settlementDays, double faceAmount, Date startDate, Date maturityDate, Frequency couponFrequency, // Calendar calendar, IborIndex index, DayCounter accrualDayCounter, // BusinessDayConvention accrualConvention = Following, // BusinessDayConvention paymentConvention = Following, // int fixingDays = Null<Natural>(), // List<double> gearings = std::vector<Real>(1, 1.0), // List<double> spreads = std::vector<Spread>(1, 0.0), // List<double> caps = std::vector<Rate>(), // List<double> floors = std::vector<Rate>(), // bool inArrears = false, // double redemption = 100.0, // Date issueDate = Date(), // Date stubDate = Date(), // DateGeneration.Rule rule = DateGeneration::Backward, // bool endOfMonth = false) public FloatingRateBond(int settlementDays, double faceAmount, Date startDate, Date maturityDate, Frequency couponFrequency, Calendar calendar, IborIndex index, DayCounter accrualDayCounter, BusinessDayConvention accrualConvention, BusinessDayConvention paymentConvention, int fixingDays, List<double> gearings, List<double> spreads, List<double> caps, List<double> floors, bool inArrears, double redemption, Date issueDate, Date stubDate, DateGeneration.Rule rule, bool endOfMonth) : base(settlementDays, calendar, issueDate) { maturityDate_ = maturityDate; Date firstDate, nextToLastDate; switch (rule) { case DateGeneration.Rule.Backward: firstDate = null; nextToLastDate = stubDate; break; case DateGeneration.Rule.Forward: firstDate = stubDate; nextToLastDate = null; break; case DateGeneration.Rule.Zero: case DateGeneration.Rule.ThirdWednesday: case DateGeneration.Rule.Twentieth: case DateGeneration.Rule.TwentiethIMM: throw new ApplicationException("stub date (" + stubDate + ") not allowed with " + rule + " DateGeneration::Rule"); default: throw new ApplicationException("unknown DateGeneration::Rule (" + rule + ")"); } Schedule schedule = new Schedule(startDate, maturityDate_, new Period(couponFrequency), calendar_, accrualConvention, accrualConvention, rule, endOfMonth, firstDate, nextToLastDate); cashflows_ = new IborLeg(schedule, index) .withPaymentDayCounter(accrualDayCounter) .withFixingDays(fixingDays) .withGearings(gearings) .withSpreads(spreads) .withCaps(caps) .withFloors(floors) .inArrears(inArrears) .withNotionals(faceAmount) .withPaymentAdjustment(paymentConvention); addRedemptionsToCashflows(new List<double>() { redemption }); if (cashflows().Count == 0) throw new ApplicationException("bond with no cashflows!"); if (redemptions_.Count != 1) throw new ApplicationException("multiple redemptions created"); index.registerWith(update); }
public Schedule(List<Date> dates, Calendar calendar = null, BusinessDayConvention convention = BusinessDayConvention.Unadjusted, BusinessDayConvention? terminationDateConvention = null, Period tenor = null, DateGeneration.Rule? rule = null, bool? endOfMonth = null, IList<bool> isRegular = null) { if (calendar == null) calendar_ = new NullCalendar(); else calendar_ = calendar; tenor_ = tenor; convention_ = convention; terminationDateConvention_ = terminationDateConvention; rule_ = rule; endOfMonth_ = (tenor != null && tenor < new Period(1, TimeUnit.Months)) ? false : endOfMonth; dates_ = dates; if (isRegular == null) isRegular_ = new List<bool>(); else isRegular_ = isRegular; Utils.QL_REQUIRE( isRegular_.Count == 0 || isRegular_.Count() == dates.Count() - 1, () => string.Format("isRegular size ({0}) must be zero or equal to the number of dates minus 1 ({1})", isRegular_.Count, dates.Count - 1)); }
public MakeBasisSwap withFloating2LegRule(DateGeneration.Rule r) { float2Rule_ = r; return this; }
public MakeBasisSwap withRule(DateGeneration.Rule r) { float1Rule_ = r; float2Rule_ = r; return this; }
public Schedule(Date effectiveDate__, Date terminationDate__, Period tenor__, Calendar calendar__, BusinessDayConvention convention__, BusinessDayConvention terminationDateConvention__, DateGeneration.Rule rule__, bool endOfMonth__, Date firstDate__, Date nextToLastDate__) { // first save the properties fullInterface_ = true; tenor_ = tenor__; calendar_ = calendar__; convention_ = convention__; terminationDateConvention_ = terminationDateConvention__; rule_ = rule__; endOfMonth_ = endOfMonth__; firstDate_ = firstDate__; nextToLastDate_ = nextToLastDate__; // sanity checks if (effectiveDate__ == null) throw new ArgumentException("Null effective date"); if (terminationDate__ == null) throw new ArgumentException("Null termination date"); if (effectiveDate__ >= terminationDate__) throw new ArgumentException("Effective date (" + effectiveDate__ + ") is later than or equal to termination date (" + terminationDate__ + ")"); if (tenor_.length() == 0) rule_ = DateGeneration.Rule.Zero; else if (tenor_.length() < 0) throw new ArgumentException("Non positive tenor (" + tenor_ + ") is not allowed"); if (firstDate_ != null) { switch (rule_) { case DateGeneration.Rule.Backward: case DateGeneration.Rule.Forward: if (!(firstDate_ > effectiveDate__ && firstDate_ < terminationDate__)) throw new ArgumentException("First date (" + firstDate_ + ") is out of range [effective date (" + effectiveDate__ + "), termination date (" + terminationDate__ + ")]"); // we should ensure that the above condition is still verified after adjustment break; case DateGeneration.Rule.ThirdWednesday: if (!IMM.isIMMdate(firstDate_, false)) throw new ArgumentException("first date (" + firstDate_ + ") is not an IMM date"); break; case DateGeneration.Rule.Zero: case DateGeneration.Rule.Twentieth: case DateGeneration.Rule.TwentiethIMM: case DateGeneration.Rule.OldCDS: case DateGeneration.Rule.CDS: throw new ArgumentException("First date is incompatible with " + rule_ + " date generation rule"); default: throw new ArgumentException("Unknown DateGeneration rule: " + rule_); } } if (nextToLastDate_ != null) { switch (rule_) { case DateGeneration.Rule.Backward: case DateGeneration.Rule.Forward: if (!(nextToLastDate_ > effectiveDate__ && nextToLastDate_ < terminationDate__)) throw new ArgumentException("Next to last date (" + nextToLastDate_ + ") out of range [effective date (" + effectiveDate__ + "), termination date (" + terminationDate__ + ")]"); // we should ensure that the above condition is still verified after adjustment break; case DateGeneration.Rule.ThirdWednesday: if (!IMM.isIMMdate(firstDate_, false)) throw new ArgumentException("first date (" + firstDate_ + ") is not an IMM date"); break; case DateGeneration.Rule.Zero: case DateGeneration.Rule.Twentieth: case DateGeneration.Rule.TwentiethIMM: case DateGeneration.Rule.OldCDS: case DateGeneration.Rule.CDS: throw new ArgumentException("next to last is incompatible with " + rule_ + " date generation rule"); default: throw new ArgumentException("Unknown DateGeneration rule: " + rule_); } } // calendar needed for endOfMonth adjustment Calendar nullCalendar = new NullCalendar(); int periods = 1; Date seed = new Date(), exitDate; switch (rule_) { case DateGeneration.Rule.Zero: tenor_ = new Period(0, TimeUnit.Years); originalDates_.Add(effectiveDate__); originalDates_.Add(terminationDate__); isRegular_.Add(true); break; case DateGeneration.Rule.Backward: originalDates_.Add(terminationDate__); seed = terminationDate__; if (nextToLastDate_ != null) { originalDates_.Insert(0, nextToLastDate_); Date temp = nullCalendar.advance(seed, -periods * tenor_, convention_, endOfMonth_); isRegular_.Insert(0, temp == nextToLastDate_); seed = nextToLastDate_; } exitDate = effectiveDate__; if (firstDate_ != null) exitDate = firstDate_; while (true) { Date temp = nullCalendar.advance(seed, -periods * tenor_, convention_, endOfMonth_); if (temp < exitDate) { if (firstDate_ != null && (calendar_.adjust(originalDates_.First(), convention_) != calendar_.adjust(firstDate_, convention_))) { originalDates_.Insert(0, firstDate_); isRegular_.Insert(0, false); } break; } else { originalDates_.Insert(0, temp); isRegular_.Insert(0, true); ++periods; } } if (endOfMonth_ && calendar_.isEndOfMonth(seed)) convention_ = BusinessDayConvention.Preceding; if (calendar_.adjust(originalDates_[0], convention_) != calendar_.adjust(effectiveDate__, convention_)) { originalDates_.Insert(0, effectiveDate__); isRegular_.Insert(0, false); } break; case DateGeneration.Rule.Twentieth: case DateGeneration.Rule.TwentiethIMM: case DateGeneration.Rule.ThirdWednesday: case DateGeneration.Rule.OldCDS: case DateGeneration.Rule.CDS: if (endOfMonth_) throw new ArgumentException("endOfMonth convention is incompatible with " + rule_ + " date generation rule"); goto case DateGeneration.Rule.Forward; // fall through case DateGeneration.Rule.Forward: if (rule_ == DateGeneration.Rule.CDS) { originalDates_.Add(previousTwentieth(effectiveDate__,DateGeneration.Rule.CDS)); } else { originalDates_.Add(effectiveDate__); } seed = effectiveDate__; if (firstDate_ != null) { originalDates_.Add(firstDate_); Date temp = nullCalendar.advance(seed, periods * tenor_, convention_, endOfMonth_); isRegular_.Add(temp == firstDate_); seed = firstDate_; } else if (rule_ == DateGeneration.Rule.Twentieth || rule_ == DateGeneration.Rule.TwentiethIMM || rule_ == DateGeneration.Rule.OldCDS || rule_ == DateGeneration.Rule.CDS) { Date next20th = nextTwentieth(effectiveDate__, rule_); if (rule_ == DateGeneration.Rule.OldCDS) { // distance rule inforced in natural days long stubDays = 30; if (next20th - effectiveDate__ < stubDays) { // +1 will skip this one and get the next next20th = nextTwentieth(next20th + 1, rule_); } } if (next20th != effectiveDate__) { originalDates_.Add(next20th); isRegular_.Add(false); seed = next20th; } } exitDate = terminationDate__; if (nextToLastDate_ != null) exitDate = nextToLastDate_; while (true) { Date temp = nullCalendar.advance(seed, periods * tenor_, convention_, endOfMonth_); if (temp > exitDate) { if (nextToLastDate_ != null && (calendar_.adjust(originalDates_.Last(), convention_) != calendar_.adjust(nextToLastDate_, convention_))) { originalDates_.Add(nextToLastDate_); isRegular_.Add(false); } break; } else { originalDates_.Add(temp); isRegular_.Add(true); ++periods; } } if (endOfMonth_ && calendar_.isEndOfMonth(seed)) convention_ = BusinessDayConvention.Preceding; if (calendar_.adjust(originalDates_.Last(), terminationDateConvention_) != calendar_.adjust(terminationDate__, terminationDateConvention_)) { if (rule_ == DateGeneration.Rule.Twentieth || rule_ == DateGeneration.Rule.TwentiethIMM || rule_ == DateGeneration.Rule.OldCDS || rule_ == DateGeneration.Rule.CDS ) { originalDates_.Add(nextTwentieth(terminationDate__, rule_)); isRegular_.Add(true); } else { originalDates_.Add(terminationDate__); isRegular_.Add(false); } } break; default: throw new ArgumentException("Unknown DateGeneration rule: " + rule_); } // adjustments to holidays, etc. if (rule_ == DateGeneration.Rule.ThirdWednesday) for (int i = 1; i < originalDates_.Count; ++i) originalDates_[i] = Date.nthWeekday(3, DayOfWeek.Wednesday, originalDates_[i].Month, originalDates_[i].Year); if (endOfMonth && calendar_.isEndOfMonth(seed)) { // adjust to end of month if (convention_ == BusinessDayConvention.Unadjusted) { for (int i = 0; i < originalDates_.Count; ++i) originalDates_[i] = Date.endOfMonth(originalDates_[i]); } else { for (int i = 0; i < originalDates_.Count; ++i) originalDates_[i] = calendar_.endOfMonth(originalDates_[i]); } if (terminationDateConvention_ == BusinessDayConvention.Unadjusted) originalDates_[originalDates_.Count - 1] = Date.endOfMonth(originalDates_.Last()); else originalDates_[originalDates_.Count - 1] = calendar_.endOfMonth(originalDates_.Last()); } else { // first date not adjusted for CDS schedules if (rule_ != DateGeneration.Rule.OldCDS) originalDates_[0] = calendar_.adjust(originalDates_[0], convention_); for (int i = 1; i < originalDates_.Count; ++i) originalDates_[i] = calendar_.adjust(originalDates_[i], convention_); foreach (Date d in originalDates_) adjustedDates_.Add(d); // termination date is NOT adjusted as per ISDA specifications, unless otherwise specified in the // confirmation of the deal or unless we're creating a CDS schedule if (terminationDateConvention_ != BusinessDayConvention.Unadjusted || rule_ == DateGeneration.Rule.Twentieth || rule_ == DateGeneration.Rule.TwentiethIMM || rule_ == DateGeneration.Rule.OldCDS || rule_ == DateGeneration.Rule.CDS) adjustedDates_[adjustedDates_.Count - 1] = calendar_.adjust(originalDates_.Last(), terminationDateConvention_); } }
public MakeOIS withRule(DateGeneration.Rule r) { rule_ = r; if (r==DateGeneration.Rule.Zero) paymentFrequency_ = Frequency.Once; return this; }
public MakeCash withRule(DateGeneration.Rule r) { rule_ = r; return this; }
public MakeFloatingLoan withRule(DateGeneration.Rule r) { rule_ = r; return this; }
Date previousTwentieth(Date d, DateGeneration.Rule rule) { Date result = new Date(20, d.month(), d.year()); if (result > d) result -= new Period(1, TimeUnit.Months); if (rule == DateGeneration.Rule.TwentiethIMM || rule == DateGeneration.Rule.OldCDS || rule == DateGeneration.Rule.CDS) { int m = result.month(); if (m % 3 != 0) { // not a main IMM nmonth int skip = m % 3; result -= new Period(skip, TimeUnit.Months); } } return result; }
public MakeSchedule withRule(DateGeneration.Rule r) { rule_ = r; return this; }
public Schedule(Date effectiveDate, Date terminationDate, Period tenor, Calendar calendar, BusinessDayConvention convention, BusinessDayConvention terminationDateConvention, DateGeneration.Rule rule, bool endOfMonth) : this(NQuantLibcPINVOKE.new_Schedule__SWIG_3(Date.getCPtr(effectiveDate), Date.getCPtr(terminationDate), Period.getCPtr(tenor), Calendar.getCPtr(calendar), (int)convention, (int)terminationDateConvention, (int)rule, endOfMonth), true) { if (NQuantLibcPINVOKE.SWIGPendingException.Pending) throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve(); }
public Schedule( Date effectiveDate, Date terminationDate, Period tenor, Calendar calendar, BusinessDayConvention convention, BusinessDayConvention terminationDateConvention, DateGeneration.Rule rule, bool endOfMonth ) : this(effectiveDate, terminationDate, tenor, calendar, convention, terminationDateConvention, rule, endOfMonth, null, null) { }
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(DateGeneration obj) { return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; }
public Schedule( Date effectiveDate, Date terminationDate, Period tenor, Calendar calendar, BusinessDayConvention convention, BusinessDayConvention terminationDateConvention, DateGeneration.Rule rule, bool endOfMonth, Date firstDate = null, Date nextToLastDate = null) { // first save the properties fullInterface_ = true; tenor_ = tenor; if ( calendar == null ) calendar_ = new NullCalendar(); else calendar_ = calendar; convention_ = convention; terminationDateConvention_ = terminationDateConvention; rule_ = rule; endOfMonth_ = endOfMonth; if ( firstDate == effectiveDate ) firstDate_ = null; else firstDate_ = firstDate; if ( nextToLastDate == terminationDate ) nextToLastDate_ = null; else nextToLastDate_ = nextToLastDate; // sanity checks Utils.QL_REQUIRE( terminationDate != null, () => "null termination date" ); // in many cases (e.g. non-expired bonds) the effective date is not // really necessary. In these cases a decent placeholder is enough if ( effectiveDate == null && firstDate == null && rule== DateGeneration.Rule.Backward) { Date evalDate = Settings.evaluationDate(); Utils.QL_REQUIRE( evalDate < terminationDate, () => "null effective date" ); int y; if (nextToLastDate != null) { y = (nextToLastDate - evalDate)/366 + 1; effectiveDate = nextToLastDate - new Period(y,TimeUnit.Years); } else { y = (terminationDate - evalDate)/366 + 1; effectiveDate = terminationDate - new Period(y,TimeUnit.Years); } } else Utils.QL_REQUIRE( effectiveDate != null, () => "null effective date" ); if (tenor_.length() == 0) rule_ = DateGeneration.Rule.Zero; else Utils.QL_REQUIRE( tenor.length() > 0, () => "non positive tenor (" + tenor + ") not allowed" ); if (firstDate_ != null) { switch (rule_) { case DateGeneration.Rule.Backward: case DateGeneration.Rule.Forward: Utils.QL_REQUIRE(firstDate_ > effectiveDate && firstDate_ < terminationDate, () => "first date (" + firstDate_ + ") out of effective-termination date range [" + effectiveDate + ", " + terminationDate + ")"); // we should ensure that the above condition is still verified after adjustment break; case DateGeneration.Rule.ThirdWednesday: Utils.QL_REQUIRE( IMM.isIMMdate( firstDate_, false ), () => "first date (" + firstDate_ + ") is not an IMM date" ); break; case DateGeneration.Rule.Zero: case DateGeneration.Rule.Twentieth: case DateGeneration.Rule.TwentiethIMM: case DateGeneration.Rule.OldCDS: case DateGeneration.Rule.CDS: Utils.QL_FAIL("first date incompatible with " + rule_ + " date generation rule"); break; default: Utils.QL_FAIL("unknown rule (" + rule_ + ")"); break; } } if (nextToLastDate_ != null) { switch (rule_) { case DateGeneration.Rule.Backward: case DateGeneration.Rule.Forward: Utils.QL_REQUIRE( nextToLastDate_ > effectiveDate && nextToLastDate_ < terminationDate, () => "next to last date (" + nextToLastDate_ + ") out of effective-termination date range (" + effectiveDate + ", " + terminationDate + "]"); // we should ensure that the above condition is still verified after adjustment break; case DateGeneration.Rule.ThirdWednesday: Utils.QL_REQUIRE( IMM.isIMMdate( nextToLastDate_, false ), () => "next-to-last date (" + nextToLastDate_ + ") is not an IMM date"); break; case DateGeneration.Rule.Zero: case DateGeneration.Rule.Twentieth: case DateGeneration.Rule.TwentiethIMM: case DateGeneration.Rule.OldCDS: case DateGeneration.Rule.CDS: Utils.QL_FAIL("next to last date incompatible with " + rule_ + " date generation rule"); break; default: Utils.QL_FAIL("unknown rule (" + rule_ + ")"); break; } } // calendar needed for endOfMonth adjustment Calendar nullCalendar = new NullCalendar(); int periods = 1; Date seed = new Date() , exitDate; switch (rule_) { case DateGeneration.Rule.Zero: tenor_ = new Period(0, TimeUnit.Years); dates_.Add(effectiveDate); dates_.Add(terminationDate); isRegular_.Add(true); break; case DateGeneration.Rule.Backward: dates_.Add(terminationDate); seed = terminationDate; if (nextToLastDate_ != null) { dates_.Insert(0, nextToLastDate_); Date temp = nullCalendar.advance(seed, -periods * tenor_, convention_, endOfMonth_); if (temp != nextToLastDate_) isRegular_.Insert(0, false); else isRegular_.Insert(0, true); seed = nextToLastDate_; } exitDate = effectiveDate; if (firstDate_ != null) exitDate = firstDate_; while (true) { Date temp = nullCalendar.advance(seed, -periods * tenor_, convention_, endOfMonth_); if (temp < exitDate) { if (firstDate_ != null && (calendar_.adjust(dates_.First(), convention_) != calendar_.adjust(firstDate_, convention_))) { dates_.Insert(0, firstDate_); isRegular_.Insert(0, false); } break; } else { // skip dates that would result in duplicates // after adjustment if (calendar_.adjust(dates_.First(), convention_) != calendar_.adjust(temp, convention_)) { dates_.Insert(0, temp); isRegular_.Insert(0, true); } ++periods; } } if (calendar_.adjust(dates_.First(), convention) != calendar_.adjust(effectiveDate, convention)) { dates_.Insert(0, effectiveDate); isRegular_.Insert(0, false); } break; case DateGeneration.Rule.Twentieth: case DateGeneration.Rule.TwentiethIMM: case DateGeneration.Rule.ThirdWednesday: case DateGeneration.Rule.OldCDS: case DateGeneration.Rule.CDS: Utils.QL_REQUIRE( !endOfMonth, () => "endOfMonth convention incompatible with " + rule_ + " date generation rule" ); goto case DateGeneration.Rule.Forward; // fall through case DateGeneration.Rule.Forward: if (rule_ == DateGeneration.Rule.CDS) { dates_.Add(previousTwentieth(effectiveDate, DateGeneration.Rule.CDS)); } else { dates_.Add(effectiveDate); } seed = dates_.Last(); if (firstDate_ != null) { dates_.Add(firstDate_); Date temp = nullCalendar.advance(seed, periods * tenor_, convention_, endOfMonth_); if (temp != firstDate_) isRegular_.Add(false); else isRegular_.Add(true); seed = firstDate_; } else if (rule_ == DateGeneration.Rule.Twentieth || rule_ == DateGeneration.Rule.TwentiethIMM || rule_ == DateGeneration.Rule.OldCDS || rule_ == DateGeneration.Rule.CDS) { Date next20th = nextTwentieth(effectiveDate, rule_); if (rule_ == DateGeneration.Rule.OldCDS) { // distance rule inforced in natural days long stubDays = 30; if (next20th - effectiveDate < stubDays) { // +1 will skip this one and get the next next20th = nextTwentieth(next20th + 1, rule_); } } if (next20th != effectiveDate) { dates_.Add(next20th); isRegular_.Add(false); seed = next20th; } } exitDate = terminationDate; if (nextToLastDate_ != null) exitDate = nextToLastDate_; while (true) { Date temp = nullCalendar.advance(seed, periods * tenor_, convention_, endOfMonth_); if (temp > exitDate) { if (nextToLastDate_ != null && (calendar_.adjust(dates_.Last(), convention_) != calendar_.adjust(nextToLastDate_, convention_))) { dates_.Add(nextToLastDate_); isRegular_.Add(false); } break; } else { // skip dates that would result in duplicates // after adjustment if (calendar_.adjust(dates_.Last(), convention_) != calendar_.adjust(temp, convention_)) { dates_.Add(temp); isRegular_.Add(true); } ++periods; } } if (calendar_.adjust(dates_.Last(), terminationDateConvention_) != calendar_.adjust(terminationDate, terminationDateConvention_)) { if (rule_ == DateGeneration.Rule.Twentieth || rule_ == DateGeneration.Rule.TwentiethIMM || rule_ == DateGeneration.Rule.OldCDS || rule_ == DateGeneration.Rule.CDS) { dates_.Add(nextTwentieth(terminationDate, rule_)); isRegular_.Add(true); } else { dates_.Add(terminationDate); isRegular_.Add(false); } } break; default: Utils.QL_FAIL("unknown rule (" + rule_ + ")"); break; } // adjustments if (rule_ == DateGeneration.Rule.ThirdWednesday) for (int i = 1; i < dates_.Count-1; ++i) dates_[i] = Date.nthWeekday(3, DayOfWeek.Wednesday, dates_[i].Month, dates_[i].Year); if (endOfMonth && calendar_.isEndOfMonth(seed)) { // adjust to end of month if (convention_ == BusinessDayConvention.Unadjusted) { for (int i = 0; i < dates_.Count-1; ++i) dates_[i] = Date.endOfMonth(dates_[i]); } else { for (int i = 0; i < dates_.Count-1; ++i) dates_[i] = calendar_.endOfMonth(dates_[i]); } if (terminationDateConvention_ != BusinessDayConvention.Unadjusted) dates_[dates_.Count - 1] = calendar_.endOfMonth(dates_.Last()); } else { // first date not adjusted for CDS schedules if (rule_ != DateGeneration.Rule.OldCDS) dates_[0] = calendar_.adjust(dates_[0], convention_); for (int i = 1; i < dates_.Count-1; ++i) dates_[i] = calendar_.adjust(dates_[i], convention_); // termination date is NOT adjusted as per ISDA specifications, unless otherwise specified in the // confirmation of the deal or unless we're creating a CDS schedule if (terminationDateConvention_ != BusinessDayConvention.Unadjusted || rule_ == DateGeneration.Rule.Twentieth || rule_ == DateGeneration.Rule.TwentiethIMM || rule_ == DateGeneration.Rule.OldCDS || rule_ == DateGeneration.Rule.CDS) dates_[dates_.Count - 1] = calendar_.adjust(dates_.Last(), terminationDateConvention_); } // final safety check to remove duplicated last dates, if any // it can happen if EOM is applied to two near dates if (dates_.Count >= 2 && dates_[dates_.Count - 2] >= dates_.Last()) { isRegular_[dates_.Count() - 2] = (dates_[dates_.Count() - 2] == dates_.Last()); dates_[dates_.Count() - 2] = dates_.Last(); dates_.RemoveAt(dates_.Count - 1); isRegular_.RemoveAt(isRegular_.Count - 1); } }
public SpreadCdsHelper(double spread, Period tenor, int settlementDays, Calendar calendar, Frequency frequency, BusinessDayConvention convention, DateGeneration.Rule rule, DayCounter dayCounter, double recoveryRate, YieldTermStructureHandle discountCurve) : this(NQuantLibcPINVOKE.new_SpreadCdsHelper__SWIG_5(spread, Period.getCPtr(tenor), settlementDays, Calendar.getCPtr(calendar), (int)frequency, (int)convention, (int)rule, DayCounter.getCPtr(dayCounter), recoveryRate, YieldTermStructureHandle.getCPtr(discountCurve)), true) { if (NQuantLibcPINVOKE.SWIGPendingException.Pending) throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve(); }
public MakeVanillaSwap withFloatingLegRule(DateGeneration.Rule r) { floatRule_ = r; return this; }
public MakeVanillaSwap withRule(DateGeneration.Rule r) { fixedRule_ = r; floatRule_ = r; return this; }
public MakeCommercialPaper withRule(DateGeneration.Rule r) { rule_ = r; return this; }
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(DateGeneration obj) { return((obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr); }
/*! simple annual compounding coupon rates with internal schedule calculation */ public FixedRateBond(int settlementDays, Calendar calendar, double faceAmount, Date startDate, Date maturityDate, Period tenor, List<double> coupons, DayCounter accrualDayCounter, BusinessDayConvention accrualConvention = BusinessDayConvention.Following, BusinessDayConvention paymentConvention = BusinessDayConvention.Following, double redemption = 100, Date issueDate = null, Date stubDate = null, DateGeneration.Rule rule = DateGeneration.Rule.Backward, bool endOfMonth = false, Calendar paymentCalendar = null, Period exCouponPeriod = null, Calendar exCouponCalendar = null, BusinessDayConvention exCouponConvention = BusinessDayConvention.Unadjusted, bool exCouponEndOfMonth = false) : base(settlementDays, paymentCalendar == null ? calendar : paymentCalendar, issueDate) { frequency_ = tenor.frequency(); dayCounter_ = accrualDayCounter; maturityDate_ = maturityDate; Date firstDate, nextToLastDate; switch (rule) { case DateGeneration.Rule.Backward: firstDate = null; nextToLastDate = stubDate; break; case DateGeneration.Rule.Forward: firstDate = stubDate; nextToLastDate = null; break; case DateGeneration.Rule.Zero: case DateGeneration.Rule.ThirdWednesday: case DateGeneration.Rule.Twentieth: case DateGeneration.Rule.TwentiethIMM: throw new ApplicationException("stub date (" + stubDate + ") not allowed with " + rule + " DateGeneration::Rule"); default: throw new ApplicationException("unknown DateGeneration::Rule (" + rule + ")"); } Schedule schedule = new Schedule(startDate, maturityDate_, tenor, calendar, accrualConvention, accrualConvention, rule, endOfMonth, firstDate, nextToLastDate); cashflows_ = new FixedRateLeg(schedule) .withCouponRates(coupons, accrualDayCounter) .withExCouponPeriod(exCouponPeriod, exCouponCalendar, exCouponConvention, exCouponEndOfMonth) .withPaymentCalendar(calendar_) .withNotionals(faceAmount) .withPaymentAdjustment(paymentConvention); addRedemptionsToCashflows(new List<double>() { redemption }); if (cashflows().Count == 0) throw new ApplicationException("bond with no cashflows!"); if (redemptions_.Count != 1) throw new ApplicationException("multiple redemptions created"); }
public Schedule(Date effectiveDate__, Date terminationDate__, Period tenor__, Calendar calendar__, BusinessDayConvention convention__, BusinessDayConvention terminationDateConvention__, DateGeneration.Rule rule__, bool endOfMonth__) : this(effectiveDate__, terminationDate__, tenor__, calendar__, convention__, terminationDateConvention__, rule__, endOfMonth__, null, null) { }