FixedRateBond::FixedRateBond(Natural settlementDays,
Real faceAmount,
const Schedule& schedule,
const std::vector<Rate>& coupons,
const DayCounter& accrualDayCounter,
BusinessDayConvention paymentConvention,
Real redemption,
const Date& issueDate,
const Calendar& paymentCalendar)
: Bond(settlementDays,
paymentCalendar==Calendar() ? schedule.calendar() : paymentCalendar,
issueDate),
frequency_(schedule.tenor().frequency()),
dayCounter_(accrualDayCounter) {
maturityDate_ = schedule.endDate();
cashflows_ = FixedRateLeg(schedule)
.withNotionals(faceAmount)
.withCouponRates(coupons, accrualDayCounter)
.withPaymentCalendar(calendar_)
.withPaymentAdjustment(paymentConvention);
addRedemptionsToCashflows(std::vector<Real>(1, redemption));
QL_ENSURE(!cashflows().empty(), "bond with no cashflows!");
QL_ENSURE(redemptions_.size() == 1, "multiple redemptions created");
}
AmortizingFixedRateBond::AmortizingFixedRateBond(
Natural settlementDays,
const Calendar& calendar,
Real initialFaceAmount,
const Date& startDate,
const Period& bondTenor,
const Frequency& sinkingFrequency,
const Rate coupon,
const DayCounter& accrualDayCounter,
BusinessDayConvention paymentConvention,
const Date& issueDate)
: Bond(settlementDays, calendar, issueDate),
frequency_(sinkingFrequency),
dayCounter_(accrualDayCounter) {
maturityDate_ = startDate + bondTenor;
cashflows_ =
FixedRateLeg(sinkingSchedule(startDate, bondTenor,
sinkingFrequency, calendar))
.withNotionals(sinkingNotionals(bondTenor,
sinkingFrequency, coupon,
initialFaceAmount))
.withCouponRates(coupon, accrualDayCounter)
.withPaymentAdjustment(paymentConvention);
addRedemptionsToCashflows();
}
FixedRateBond::FixedRateBond(Natural settlementDays,
const Calendar& calendar,
Real faceAmount,
const Date& startDate,
const Date& maturityDate,
const Period& tenor,
const std::vector<Rate>& coupons,
const DayCounter& accrualDayCounter,
BusinessDayConvention accrualConvention,
BusinessDayConvention paymentConvention,
Real redemption,
const Date& issueDate,
const Date& stubDate,
DateGeneration::Rule rule,
bool endOfMonth,
const Calendar& paymentCalendar)
: Bond(settlementDays,
paymentCalendar==Calendar() ? calendar : paymentCalendar,
issueDate),
frequency_(tenor.frequency()), dayCounter_(accrualDayCounter) {
maturityDate_ = maturityDate;
Date firstDate, nextToLastDate;
switch (rule) {
case DateGeneration::Backward:
firstDate = Date();
nextToLastDate = stubDate;
break;
case DateGeneration::Forward:
firstDate = stubDate;
nextToLastDate = Date();
break;
case DateGeneration::Zero:
case DateGeneration::ThirdWednesday:
case DateGeneration::Twentieth:
case DateGeneration::TwentiethIMM:
QL_FAIL("stub date (" << stubDate << ") not allowed with " <<
rule << " DateGeneration::Rule");
default:
QL_FAIL("unknown DateGeneration::Rule (" << Integer(rule) << ")");
}
Schedule schedule(startDate, maturityDate_, tenor,
calendar, accrualConvention, accrualConvention,
rule, endOfMonth,
firstDate, nextToLastDate);
cashflows_ = FixedRateLeg(schedule)
.withNotionals(faceAmount)
.withCouponRates(coupons, accrualDayCounter)
.withPaymentCalendar(calendar_)
.withPaymentAdjustment(paymentConvention);
addRedemptionsToCashflows(std::vector<Real>(1, redemption));
QL_ENSURE(!cashflows().empty(), "bond with no cashflows!");
QL_ENSURE(redemptions_.size() == 1, "multiple redemptions created");
}
CallableFixedRateBond::CallableFixedRateBond(
Natural settlementDays,
Real faceAmount,
const Schedule& schedule,
const std::vector<Rate>& coupons,
const DayCounter& accrualDayCounter,
BusinessDayConvention paymentConvention,
Real redemption,
const Date& issueDate,
const CallabilitySchedule& putCallSchedule)
: CallableBond(settlementDays, schedule, accrualDayCounter,
issueDate, putCallSchedule) {
frequency_ = schedule.tenor().frequency();
bool isZeroCouponBond = (coupons.size() == 1 && close(coupons[0], 0.0));
if (!isZeroCouponBond) {
cashflows_ =
FixedRateLeg(schedule)
.withNotionals(faceAmount)
.withCouponRates(coupons, accrualDayCounter)
.withPaymentAdjustment(paymentConvention);
addRedemptionsToCashflows(std::vector<Real>(1, redemption));
} else {
Date redemptionDate = calendar_.adjust(maturityDate_,
paymentConvention);
setSingleRedemption(faceAmount, redemption, redemptionDate);
}
// used for impliedVolatility() calculation
boost::shared_ptr<SimpleQuote> dummyVolQuote(new SimpleQuote(0.));
blackVolQuote_.linkTo(dummyVolQuote);
blackEngine_ = boost::shared_ptr<PricingEngine>(
new BlackCallableFixedRateBondEngine(blackVolQuote_,
blackDiscountCurve_));
}
FloatingCatBond::FloatingCatBond(
Natural settlementDays,
Real faceAmount,
const Schedule& schedule,
const boost::shared_ptr<IborIndex>& iborIndex,
const DayCounter& paymentDayCounter,
boost::shared_ptr<NotionalRisk> notionalRisk,
BusinessDayConvention paymentConvention,
Natural fixingDays,
const std::vector<Real>& gearings,
const std::vector<Spread>& spreads,
const std::vector<Rate>& caps,
const std::vector<Rate>& floors,
bool inArrears,
Real redemption,
const Date& issueDate)
: CatBond(settlementDays, schedule.calendar(), issueDate, notionalRisk) {
maturityDate_ = schedule.endDate();
cashflows_ = IborLeg(schedule, iborIndex)
.withNotionals(faceAmount)
.withPaymentDayCounter(paymentDayCounter)
.withPaymentAdjustment(paymentConvention)
.withFixingDays(fixingDays)
.withGearings(gearings)
.withSpreads(spreads)
.withCaps(caps)
.withFloors(floors)
.inArrears(inArrears);
addRedemptionsToCashflows(std::vector<Real>(1, redemption));
QL_ENSURE(!cashflows().empty(), "bond with no cashflows!");
QL_ENSURE(redemptions_.size() == 1, "multiple redemptions created");
registerWith(iborIndex);
}
AmortizingFixedRateBond::AmortizingFixedRateBond(
Natural settlementDays,
const std::vector<Real>& notionals,
const Schedule& schedule,
const std::vector<Rate>& coupons,
const DayCounter& accrualDayCounter,
BusinessDayConvention paymentConvention,
const Date& issueDate)
: Bond(settlementDays, schedule.calendar(), issueDate),
frequency_(schedule.tenor().frequency()),
dayCounter_(accrualDayCounter) {
maturityDate_ = schedule.endDate();
cashflows_ = FixedRateLeg(schedule)
.withNotionals(notionals)
.withCouponRates(coupons, accrualDayCounter)
.withPaymentAdjustment(paymentConvention);
addRedemptionsToCashflows();
QL_ENSURE(!cashflows().empty(), "bond with no cashflows!");
}
FloatingRateBond::FloatingRateBond(
Natural settlementDays,
Real faceAmount,
const Date& startDate,
const Date& maturityDate,
Frequency couponFrequency,
const Calendar& calendar,
const ext::shared_ptr<IborIndex>& iborIndex,
const DayCounter& accrualDayCounter,
BusinessDayConvention accrualConvention,
BusinessDayConvention paymentConvention,
Natural fixingDays,
const std::vector<Real>& gearings,
const std::vector<Spread>& spreads,
const std::vector<Rate>& caps,
const std::vector<Rate>& floors,
bool inArrears,
Real redemption,
const Date& issueDate,
const Date& stubDate,
DateGeneration::Rule rule,
bool endOfMonth)
: Bond(settlementDays, calendar, issueDate) {
maturityDate_ = maturityDate;
Date firstDate, nextToLastDate;
switch (rule) {
case DateGeneration::Backward:
firstDate = Date();
nextToLastDate = stubDate;
break;
case DateGeneration::Forward:
firstDate = stubDate;
nextToLastDate = Date();
break;
case DateGeneration::Zero:
case DateGeneration::ThirdWednesday:
case DateGeneration::Twentieth:
case DateGeneration::TwentiethIMM:
QL_FAIL("stub date (" << stubDate << ") not allowed with " <<
rule << " DateGeneration::Rule");
default:
QL_FAIL("unknown DateGeneration::Rule (" << Integer(rule) << ")");
}
Schedule schedule(startDate, maturityDate_, Period(couponFrequency),
calendar_, accrualConvention, accrualConvention,
rule, endOfMonth,
firstDate, nextToLastDate);
cashflows_ = IborLeg(schedule, iborIndex)
.withNotionals(faceAmount)
.withPaymentDayCounter(accrualDayCounter)
.withPaymentAdjustment(paymentConvention)
.withFixingDays(fixingDays)
.withGearings(gearings)
.withSpreads(spreads)
.withCaps(caps)
.withFloors(floors)
.inArrears(inArrears);
addRedemptionsToCashflows(std::vector<Real>(1, redemption));
QL_ENSURE(!cashflows().empty(), "bond with no cashflows!");
QL_ENSURE(redemptions_.size() == 1, "multiple redemptions created");
registerWith(iborIndex);
}
