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