#include <qle/instruments/bondbasket.hpp>

Collaboration diagram for BondBasket:

Public Member Functions
	BondBasket (const std::map< std::string, QuantLib::ext::shared_ptr< QuantLib::Bond > > &qlBonds, const std::map< std::string, double > &recoveries, const std::map< std::string, double > &multipliers, const std::map< std::string, QuantLib::Handle< QuantLib::YieldTermStructure > > &yieldTermStructures, const std::map< std::string, Currency > &currencies, const QuantLib::ext::shared_ptr< QuantLib::Pool > pool, Currency baseCcy, const std::map< std::string, QuantLib::ext::shared_ptr< QuantExt::FxIndex > > &fxIndexMap, const QuantLib::Date &reinvestmentEndDate, const std::map< std::string, std::vector< double > > &reinvestmentScalar, const std::map< std::string, std::vector< std::string > > &flowType)

const std::map< std::string, QuantLib::ext::shared_ptr< QuantLib::Bond > > &	bonds () const
	Inspectors. More...

const QuantLib::ext::shared_ptr< QuantLib::Pool > &	pool () const

const std::map< std::string, QuantLib::ext::shared_ptr< QuantExt::FxIndex > > &	fxIndexMap () const

const std::set< QuantLib::Currency >	unique_currencies () const

const double	recoveryRate (const std::string &name) const

const double	multiplier (const std::string &name) const

Real	convert (Real amount, Currency ccy, Date date=Date())

void	setGrid (std::vector< Date > dates)

std::map< Currency, std::vector< Cash > >	scenarioCashflow (std::vector< Date > dates)

std::map< Currency, std::vector< Cash > >	scenarioInterestflow (std::vector< Date > dates)

std::map< Currency, std::vector< Cash > >	scenarioPrincipalflow (std::vector< Date > dates)

std::map< Currency, std::vector< Real > >	scenarioRemainingNotional (std::vector< Date > dates)

std::map< Currency, std::vector< Cash > >	scenarioLossflow (std::vector< Date > dates)

std::map< Currency, std::vector< Cash > >	scenarioFeeflow (const std::vector< QuantLib::Date > &dates)

void	fillFlowMaps ()

Private Member Functions
const double	getScalar (const std::string &name, const QuantLib::Date &currentDate) const

const QuantLib::Handle< QuantLib::YieldTermStructure >	yts (const std::string &name) const

const Currency	currency (const std::string &name) const

const std::vector< double >	reinvestmentScalar (const std::string &name) const

const std::string	flowType (const std::string &name, int idx) const

const QuantLib::ext::shared_ptr< QuantExt::FxIndex >	fxIndex (const std::string &name) const

Private Attributes
const std::map< std::string, QuantLib::ext::shared_ptr< QuantLib::Bond > >	qlBonds_

const std::map< std::string, double >	recoveries_

const std::map< std::string, double >	multipliers_

const std::map< std::string, QuantLib::Handle< QuantLib::YieldTermStructure > >	yieldTermStructures_

const std::map< std::string, QuantLib::Currency >	currencies_

const QuantLib::ext::shared_ptr< QuantLib::Pool >	pool_

const Currency	baseCcy_

const std::map< std::string, QuantLib::ext::shared_ptr< QuantExt::FxIndex > >	fxIndexMap_

const Date	reinvestmentEndDate_

const std::map< std::string, std::vector< double > >	reinvestmentScalar_

const std::map< std::string, std::vector< std::string > >	flowType_

std::set< QuantLib::Currency >	unique_currencies_

std::vector< Date >	grid_

std::map< std::string, std::vector< int > >	cashflow2grid_

std::map< std::string, std::vector< int > >	interestflow2grid_

std::map< std::string, std::vector< int > >	notionalflow2grid_

std::map< std::string, std::vector< int > >	feeflow2grid_

std::map< std::string, std::vector< ext::shared_ptr< QuantLib::CashFlow > > >	cashflows_

std::map< std::string, std::vector< ext::shared_ptr< QuantLib::CashFlow > > >	interestFlows_

std::map< std::string, std::vector< ext::shared_ptr< QuantLib::CashFlow > > >	notionalFlows_

std::map< std::string, std::vector< ext::shared_ptr< QuantLib::CashFlow > > >	feeFlows_

Detailed Description

Bond Basket.

This class holds a basket of defaultable bonds along with the pool of relevant names. There may be more bonds than names involved, e.g. several different bonds with same issuer.

The class provides tools for evaluating basket cash flows of different kinds (interest, principal) for scenarios of default times stored for all names involved in the Pool structure.

For further information refer to the detailed QuantExt documentation.

Definition at line 71 of file bondbasket.hpp.

Constructor & Destructor Documentation

◆ BondBasket()

BondBasket	(	const std::map< std::string, QuantLib::ext::shared_ptr< QuantLib::Bond > > &	qlBonds,
		const std::map< std::string, double > &	recoveries,
		const std::map< std::string, double > &	multipliers,
		const std::map< std::string, QuantLib::Handle< QuantLib::YieldTermStructure > > &	yieldTermStructures,
		const std::map< std::string, Currency > &	currencies,
		const QuantLib::ext::shared_ptr< QuantLib::Pool >	pool,
		Currency	baseCcy,
		const std::map< std::string, QuantLib::ext::shared_ptr< QuantExt::FxIndex > > &	fxIndexMap,
		const QuantLib::Date &	reinvestmentEndDate,
		const std::map< std::string, std::vector< double > > &	reinvestmentScalar,
		const std::map< std::string, std::vector< std::string > > &	flowType
	)

Parameters

qlBonds	map of QuantLib bonds
recoveries	recoveries per bonds
multipliers	multipliers per bonds
yieldTermStructures	discount curves per bonds
currencies	currencies per bonds
pool	Pool storing default time for all names involved in the basekt above
baseCcy	Base currency
fxIndexMap	Forex structure to compute spot and forward FX rates
reinvestmentEndDate	end of reinvestment period
reinvestmentScalar	scalar for reinvestment period per bonds
flowType	flow types of cashflows per bonds

Definition at line 130 of file bondbasket.cpp.

        :   qlBonds_(qlBonds),
            recoveries_(recoveries),
            multipliers_(multipliers),
            yieldTermStructures_(yieldTermStructures),
            currencies_(currencies),
            pool_(pool),
            baseCcy_(baseCcy),
            fxIndexMap_(fxIndexMap),
            reinvestmentEndDate_(reinvestmentEndDate),
            reinvestmentScalar_(reinvestmentScalar),
            flowType_(flowType)
            {
 
                QL_REQUIRE(!qlBonds_.empty(), "no bonds given");
                QL_REQUIRE(qlBonds_.size() == recoveries_.size(), "mismatch number bonds vs recoveries");
                QL_REQUIRE(qlBonds_.size() == multipliers_.size(), "mismatch number bonds vs multipliers");
                QL_REQUIRE(qlBonds_.size() == yieldTermStructures_.size(), "mismatch number bonds vs yieldTermStructures");
                QL_REQUIRE(qlBonds_.size() == currencies_.size(), "mismatch number bonds vs currencies");
 
                for (const auto& ccy : currencies_)
                    unique_currencies_.insert(ccy.second);
 
                grid_ = vector<Date>();
 
    }

Member Function Documentation

◆ bonds()

const std::map< std::string, QuantLib::ext::shared_ptr< QuantLib::Bond > > & bonds ( ) const

Inspectors.

Vector of risky bonds

Definition at line 100 of file bondbasket.hpp.

100{ return qlBonds_; }

◆ pool()

const QuantLib::ext::shared_ptr< Pool > & pool ( ) const

Pool of names with associated default times

Definition at line 167 of file bondbasket.cpp.

                                                              {
        return pool_;
    }

◆ fxIndexMap()

const std::map< std::string, QuantLib::ext::shared_ptr< QuantExt::FxIndex > > & fxIndexMap ( ) const

Forex structure

Definition at line 104 of file bondbasket.hpp.

104{ return fxIndexMap_;}

◆ unique_currencies()

const std::set< QuantLib::Currency > unique_currencies ( ) const

Unique currencies involved

Definition at line 106 of file bondbasket.hpp.

106{ return unique_currencies_; }

◆ recoveryRate()

const double recoveryRate ( const std::string & name ) const

Recovery rate for given name

Definition at line 171 of file bondbasket.cpp.

                                                                      {
        auto it = recoveries_.find(name);
        if(it != recoveries_.end())
            return it->second;
        QL_FAIL("no recovery value for bond " << name);
    };

Here is the caller graph for this function:

◆ multiplier()

const double multiplier ( const std::string & name ) const

Multiplier for given name

Definition at line 178 of file bondbasket.cpp.

                                                                    {
        auto it = multipliers_.find(name);
        if(it != multipliers_.end())
            return it->second;
        QL_FAIL("no multiplier for bond " << name);
    };

Here is the caller graph for this function:

◆ convert()

Real convert	(	Real	amount,
		Currency	ccy,
		Date	date = `Date()`
	)

FX conversion

Definition at line 115 of file bondbasket.cpp.

                                                                 {
 
        if(date == Date())
            date = Settings::instance().evaluationDate();
 
        if (ccy == baseCcy_)
            return amount;
        else {
            std::string code = ccy.code();
            double fxRate = fxIndex(code)->fixing(date, false);
            double inBase = fxRate * amount;
            return inBase;
        }
    }

Here is the call graph for this function:

◆ setGrid()

void setGrid ( std::vector< Date > dates )

Set the date grid for mapping cash flows. Store for each bond cash flow date the associated date grid bucket.

Definition at line 220 of file bondbasket.cpp.

                                               {
        grid_ = dates;
        for (auto bond : qlBonds_) {
            string name = bond.first;
            cashflow2grid_[name].resize(cashflows_[name].size(), -1);
            for (Size j = 0; j < cashflows_[name].size(); j++) {
                Date d = cashflows_[name][j]->date();
                for (Size k = 1; k < dates.size(); k++) {
                    if (d > dates[k-1] && d <= dates[k]) {
                        cashflow2grid_[name][j] = k;
                        continue;
                    }
                }
            }
            interestflow2grid_[name].resize(interestFlows_[name].size(),-1);
            for (Size j = 0; j < interestFlows_[name].size(); j++) {
                Date d = interestFlows_[name][j]->date();
                for (Size k = 1; k < dates.size(); k++) {
                    if (d > dates[k-1] && d <= dates[k]) {
                        interestflow2grid_[name][j] = k;
                        continue;
                    }
                }
            }
            notionalflow2grid_[name].resize(notionalFlows_[name].size(), -1);
            for (Size j = 0; j < notionalFlows_[name].size(); j++) {
                Date d = notionalFlows_[name][j]->date();
                for (Size k = 1; k < dates.size(); k++) {
                    if (d > dates[k-1] && d <= dates[k]) {
                        notionalflow2grid_[name][j] = k;
                        continue;
                    }
                }
            }
            feeflow2grid_[name].resize(feeFlows_[name].size(), -1);
            for (Size j = 0; j < feeFlows_[name].size(); j++) {
                Date d = feeFlows_[name][j]->date();
                for (Size k = 1; k < dates.size(); k++) {
                    if (d > dates[k-1] && d <= dates[k]) {
                        feeflow2grid_[name][j] = k;
                        continue;
                    }
                }
            }
        }
    }

◆ scenarioCashflow()

std::map< Currency, vector< Cash > > scenarioCashflow ( std::vector< Date > dates )

Definition at line 268 of file bondbasket.cpp.

                                                   {
        QL_REQUIRE(grid_.size() > 0, "grid not set");
        Date today = Settings::instance().evaluationDate();
        map<Currency,vector<Cash> > cf;
        for (const auto & ccy : unique_currencies_)
            cf[ccy].resize(dates.size(), Cash());
        for (const auto & bond : qlBonds_) {
            string name = bond.first;
            DayCounter dc = yts(name)->dayCounter();
            Currency ccy = currency(name);
            Real defaultTime = pool_->getTime(name);
            Real maturityTime = dc.yearFraction(today, bond.second->maturityDate());
            for (Size j = 0; j < cashflows_[name].size(); j++) {
                Date d = cashflows_[name][j]->date();
                Real t = dc.yearFraction(today, d);
 
                if (t < defaultTime) {
                    Size k = cashflow2grid_[name][j];
                    //QL_REQUIRE(k >= 0 && k < grid_.size(), "k out of range");
                    if (k < grid_.size()) {
                        cf[ccy][k].flow_ += cashflows_[name][j]->amount();
                        cf[ccy][k].discountedFlow_
                            += cashflows_[name][j]->amount()
                            * yts(name)->discount(t);
                    }
                }
                else break;
            }
            if (defaultTime < maturityTime) {
                for (Size k = 1; k < dates.size(); k++) {
                    Real t1 = dc.yearFraction(today, dates[k-1]);
                    Real t2 = dc.yearFraction(today, dates[k]);
                    if (defaultTime >= t1 && defaultTime < t2) {
                        cf[ccy][k].flow_
                            += recoveryRate(name) * bond.second->notional(dates[k-1]) * multiplier(name);
                        cf[ccy][k].discountedFlow_
                            += recoveryRate(name) * bond.second->notional(dates[k-1]) * multiplier(name)
                            * yts(name)->discount(defaultTime);
                    }
                }
            }
        }
        return cf;
    }

Here is the call graph for this function:

◆ scenarioInterestflow()

std::map< Currency, vector< Cash > > scenarioInterestflow ( std::vector< Date > dates )

Definition at line 314 of file bondbasket.cpp.

                                                       {
        QL_REQUIRE(grid_.size() > 0, "grid not set");
        Date today = Settings::instance().evaluationDate();
        map<Currency,vector<Cash> > cf;
        for (const auto & ccy : unique_currencies_)
            cf[ccy].resize(dates.size(), Cash());
        for (const auto & bond : qlBonds_) {
            string name = bond.first;
            DayCounter dc = yts(name)->dayCounter();
            Currency ccy = currency(name);
            Real defaultTime = pool_->getTime(name);
            for (Size j = 0; j < interestFlows_[name].size(); j++) {
                Date d = interestFlows_[name][j]->date();
                Real t = dc.yearFraction(today, d);
                if (t < defaultTime) {
                    Size k = interestflow2grid_[name][j];
                    //QL_REQUIRE(k >= 0 && k < grid_.size(), "k out of range");
                    if (k < grid_.size()) {
                        cf[ccy][k].flow_ += interestFlows_[name][j]->amount();
                        cf[ccy][k].discountedFlow_
                            += interestFlows_[name][j]->amount()
                            * yts(name)->discount(t);
                    }
                }
                else break;
            }
        }
        return cf;
    }

Here is the call graph for this function:

◆ scenarioPrincipalflow()

std::map< Currency, vector< Cash > > scenarioPrincipalflow ( std::vector< Date > dates )

Definition at line 345 of file bondbasket.cpp.

                                                        {
        QL_REQUIRE(grid_.size() > 0, "grid not set");
        Date today = Settings::instance().evaluationDate();
        map<Currency,vector<Cash> > cf;
        for (const auto & ccy : unique_currencies_)
            cf[ccy].resize(dates.size(), Cash());
        for (const auto & bond : qlBonds_) {
            string name = bond.first;
            DayCounter dc = yts(name)->dayCounter();
            Currency ccy = currency(name);
            Real defaultTime = pool_->getTime(name);
            Real maturityTime = dc.yearFraction(today, bond.second->maturityDate());
            for (Size j = 0; j < notionalFlows_[name].size(); j++) {
                Date d = notionalFlows_[name][j]->date();
                Real t = dc.yearFraction(today, d);
                if (t < defaultTime) {
                    Size k = notionalflow2grid_[name][j];
                    //QL_REQUIRE(k >= 0 && k < grid_.size(), "k out of range");
                    if (k < grid_.size()) {
                        cf[ccy][k].flow_ += notionalFlows_[name][j]->amount();
                        cf[ccy][k].discountedFlow_
                            += notionalFlows_[name][j]->amount()
                            * yts(name)->discount(t);
                    }
                }
                else break;
            }
            if (defaultTime < maturityTime) {
                for (Size k = 1; k < dates.size(); k++) {
                    Real t1 = dc.yearFraction(today, dates[k-1]);
                    Real t2 = dc.yearFraction(today, dates[k]);
                    if (defaultTime >= t1 &&
                        defaultTime < t2) {
                        cf[ccy][k].flow_
                            += recoveryRate(name) * bond.second->notional(dates[k-1]) * multiplier(name);
                        cf[ccy][k].discountedFlow_
                            += recoveryRate(name) * bond.second->notional(dates[k-1]) * multiplier(name)
                            * yts(name)->discount(defaultTime);
                    }
                }
            }
        }
        return cf;
    }

Here is the call graph for this function:

◆ scenarioRemainingNotional()

std::map< Currency, vector< Real > > scenarioRemainingNotional ( std::vector< Date > dates )

Definition at line 451 of file bondbasket.cpp.

                                                            {
        QL_REQUIRE(grid_.size() > 0, "grid not set");
        Date today = Settings::instance().evaluationDate();
        map<Currency,vector<Real> > cf;
        for (const auto & ccy : unique_currencies_)
            cf[ccy].resize(dates.size(), 0.0);
        for (const auto & bond : qlBonds_) {
            string name = bond.first;
            DayCounter dc = yts(name)->dayCounter();
            Currency ccy = currency(name);
            Real defaultTime = pool_->getTime(name);
            for (Size k = 1; k < dates.size(); k++) {
                Real t1 = dc.yearFraction(today, dates[k]);
                if (defaultTime >= t1) {
                    cf[ccy][k] +=  bond.second->notional(dates[k]) * multiplier(name) * getScalar(name, dates[k]);
                }
            }
        }
        return cf;
    }

Here is the call graph for this function:

◆ scenarioLossflow()

std::map< Currency, vector< Cash > > scenarioLossflow ( std::vector< Date > dates )

Definition at line 420 of file bondbasket.cpp.

                                                   {
        QL_REQUIRE(grid_.size() > 0, "grid not set");
        Date today = Settings::instance().evaluationDate();
        map<Currency,vector<Cash> > cf;
        for (const auto & ccy : unique_currencies_)
            cf[ccy].resize(dates.size(), Cash());
        for (const auto & bond : qlBonds_) {
            string name = bond.first;
            DayCounter dc = yts(name)->dayCounter();
            Currency ccy = currency(name);
            Real defaultTime = pool_->getTime(name);
            Real maturityTime = dc.yearFraction(today, bond.second->maturityDate());
            if (defaultTime < maturityTime) {
                for (Size k = 1; k < dates.size(); k++) {
                    Real t1 = dc.yearFraction(today, dates[k-1]);
                    Real t2 = dc.yearFraction(today, dates[k]);
                    if (defaultTime >= t1 &&
                        defaultTime < t2) {
                        cf[ccy][k].flow_
                        += (1.0 - recoveryRate(name)) * bond.second->notional(dates[k-1]) * multiplier(name);
                        cf[ccy][k].discountedFlow_
                        += (1.0 - recoveryRate(name)) * bond.second->notional(dates[k-1]) * multiplier(name)
                        * yts(name)->discount(defaultTime);
                    }
                }
            }
        }
        return cf;
    }

Here is the call graph for this function:

◆ scenarioFeeflow()

std::map< Currency, vector< Cash > > scenarioFeeflow ( const std::vector< QuantLib::Date > & dates )

Definition at line 390 of file bondbasket.cpp.

                                                                                                   {
        QL_REQUIRE(grid_.size() > 0, "grid not set");
        Date today = Settings::instance().evaluationDate();
        map<Currency,vector<Cash> > cf;
        for (const auto & ccy : unique_currencies_)
            cf[ccy].resize(dates.size(), Cash());
        for (const auto & bond : qlBonds_) {
            string name = bond.first;
            DayCounter dc = yts(name)->dayCounter();
            Currency ccy = currency(name);
            Real defaultTime = pool_->getTime(name);
            for (Size j = 0; j < feeFlows_[name].size(); j++) {
                Date d = feeFlows_[name][j]->date();
                Real t = dc.yearFraction(today, d);
                if (t < defaultTime) {
                    Size k = feeflow2grid_[name][j];
                    if (k < dates.size()) {
                        cf[ccy][k].flow_ += feeFlows_[name][j]->amount();
                        cf[ccy][k].discountedFlow_
                        += feeFlows_[name][j]->amount() * yts(name)->discount(t);
 
                    }
                }
                else break;
            }
        }
        return cf;
    }

Here is the call graph for this function:

◆ fillFlowMaps()

void fillFlowMaps ( )

Definition at line 43 of file bondbasket.cpp.

                                 {
 
        cashflows_.clear();
        interestFlows_.clear();
        notionalFlows_.clear();
        feeFlows_.clear();
 
        for(auto bond : qlBonds_){
 
            std::string name = bond.first;
            double multi = multiplier(name);
            vector<double> scalar = reinvestmentScalar(name);
            Leg leg = bond.second->cashflows();
 
            std::vector<ext::shared_ptr<QuantLib::CashFlow> > cashflows;
            std::vector<ext::shared_ptr<QuantLib::CashFlow> > interestFlows;
            std::vector<ext::shared_ptr<QuantLib::CashFlow> > notionalFlows;
            std::vector<ext::shared_ptr<QuantLib::CashFlow> > feeFlows;
 
            for (size_t j = 0; j < leg.size(); j++) {
 
                QuantLib::ext::shared_ptr<QuantLib::CashFlow> ptrFlow = leg[j];
 
                if(flowType(name,j) == "int"){
 
                    QuantLib::ext::shared_ptr<QuantLib::Coupon> ptrCoupon =
                            QuantLib::ext::dynamic_pointer_cast<QuantLib::Coupon>(ptrFlow);
                    QL_REQUIRE(ptrCoupon, "expected couopn type");
 
                    QuantLib::ext::shared_ptr<QuantExt::ScaledCoupon> newPtr( new QuantExt::ScaledCoupon(multi * scalar[j], ptrCoupon ));
                    interestFlows.push_back(newPtr);
                    cashflows.push_back(newPtr);
 
                } else if(flowType(name,j) == "xnl"){
 
                    double amort = 1.0;
                    if(reinvestmentEndDate_ > ptrFlow->date())
                        amort = 0.0;
 
                    ext::shared_ptr<CashFlow>
                        flow(new SimpleCashFlow(ptrFlow->amount() * multi * scalar[j] * amort, ptrFlow->date()));
                    notionalFlows.push_back(flow);
                    cashflows.push_back(flow);
 
                }  else if (flowType(name,j) == "fee"){
 
                    ext::shared_ptr<CashFlow>
                        flow(new SimpleCashFlow(ptrFlow->amount() * multi * scalar[j], ptrFlow->date()));
                    feeFlows.push_back(flow);
                    cashflows.push_back(flow);
 
                } else {
                    //ALOG("bond " << name << " leg " << j << " paymentDate " << leg[j]->date() << " could not be assigned");
                }
 
            }//leg - j
            cashflows_[name] = cashflows;
            notionalFlows_[name] = notionalFlows;
            feeFlows_[name] = feeFlows;
            interestFlows_[name] = interestFlows;
        }//bonds - b
    }//void BondBasket::fillFlowMaps()

Here is the call graph for this function:

◆ getScalar()

const double getScalar	(	const std::string &	name,
		const QuantLib::Date &	currentDate
	)		const

private

Definition at line 28 of file bondbasket.cpp.

                                                                                                   {
        double result = -1.0;
        for(auto& bond : qlBonds_){
            if(bond.first == name){
                const QuantLib::Leg& leg = bond.second->cashflows();
                vector<Real> scalar = reinvestmentScalar(name);
                for(size_t d = 1; d < leg.size(); d++){
                    if(leg[d-1]->date() < currentDate && leg[d]->date() >= currentDate)
                        result = scalar[d];
                }
            }
        }
        return result;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ yts()

const QuantLib::Handle< QuantLib::YieldTermStructure > yts ( const std::string & name ) const

private

Definition at line 185 of file bondbasket.cpp.

                                                                                               {
        auto it = yieldTermStructures_.find(name);
        if(it != yieldTermStructures_.end())
            return it->second;
        QL_FAIL("no yieldTermStructure for bond " << name);
    }

Here is the caller graph for this function:

◆ currency()

const Currency currency ( const std::string & name ) const

private

Definition at line 192 of file bondbasket.cpp.

                                                                  {
        auto it = currencies_.find(name);
        if(it != currencies_.end())
            return it->second;
        QL_FAIL("no currency for bond " << name);
    }

Here is the caller graph for this function:

◆ reinvestmentScalar()

const vector< double > reinvestmentScalar ( const std::string & name ) const

private

Definition at line 199 of file bondbasket.cpp.

                                                                                  {
        auto it = reinvestmentScalar_.find(name);
        if(it != reinvestmentScalar_.end())
            return it->second;
        QL_FAIL("no reinvestmentScalar for bond " << name);
    }

Here is the caller graph for this function:

◆ flowType()

const string flowType	(	const std::string &	name,
		int	idx
	)		const

private

Definition at line 206 of file bondbasket.cpp.

                                                                         {
        auto it = flowType_.find(name);
        if(it != flowType_.end())
            return it->second[idx];
        QL_FAIL("no flowType for bond " << name);
    }

Here is the caller graph for this function:

◆ fxIndex()

const QuantLib::ext::shared_ptr< QuantExt::FxIndex > fxIndex ( const std::string & name ) const

private

Definition at line 213 of file bondbasket.cpp.

                                                                                               {
        auto it = fxIndexMap_.find(name);
        if(it != fxIndexMap_.end())
            return it->second;
        QL_FAIL("no fxIndex for bond " << name);
    }

Here is the caller graph for this function:

Member Data Documentation

◆ qlBonds_

const std::map<std::string, QuantLib::ext::shared_ptr<QuantLib::Bond> > qlBonds_

private

Definition at line 139 of file bondbasket.hpp.

◆ recoveries_

const std::map<std::string, double> recoveries_

private

Definition at line 140 of file bondbasket.hpp.

◆ multipliers_

const std::map<std::string, double> multipliers_

private

Definition at line 141 of file bondbasket.hpp.

◆ yieldTermStructures_

const std::map<std::string, QuantLib::Handle<QuantLib::YieldTermStructure> > yieldTermStructures_

private

Definition at line 142 of file bondbasket.hpp.

◆ currencies_

const std::map<std::string, QuantLib::Currency> currencies_

private

Definition at line 143 of file bondbasket.hpp.

◆ pool_

const QuantLib::ext::shared_ptr<QuantLib::Pool> pool_

private

Definition at line 144 of file bondbasket.hpp.

◆ baseCcy_

const Currency baseCcy_

private

Definition at line 145 of file bondbasket.hpp.

◆ fxIndexMap_

const std::map<std::string, QuantLib::ext::shared_ptr<QuantExt::FxIndex> > fxIndexMap_

private

Definition at line 146 of file bondbasket.hpp.

◆ reinvestmentEndDate_

const Date reinvestmentEndDate_

private

Definition at line 147 of file bondbasket.hpp.

◆ reinvestmentScalar_

const std::map<std::string, std::vector<double> > reinvestmentScalar_

private

Definition at line 148 of file bondbasket.hpp.

◆ flowType_

const std::map<std::string, std::vector<std::string> > flowType_

private

Definition at line 149 of file bondbasket.hpp.

◆ unique_currencies_

std::set<QuantLib::Currency> unique_currencies_

private

Definition at line 151 of file bondbasket.hpp.

◆ grid_

std::vector<Date> grid_

private

Definition at line 152 of file bondbasket.hpp.

◆ cashflow2grid_

std::map<std::string, std::vector<int> > cashflow2grid_

private

Definition at line 154 of file bondbasket.hpp.

◆ interestflow2grid_

std::map<std::string, std::vector<int> > interestflow2grid_

private

Definition at line 155 of file bondbasket.hpp.

◆ notionalflow2grid_

std::map<std::string, std::vector<int> > notionalflow2grid_

private

Definition at line 156 of file bondbasket.hpp.

◆ feeflow2grid_

std::map<std::string, std::vector<int> > feeflow2grid_

private

Definition at line 157 of file bondbasket.hpp.

◆ cashflows_

std::map<std::string, std::vector<ext::shared_ptr<QuantLib::CashFlow> > > cashflows_

private

Definition at line 159 of file bondbasket.hpp.

◆ interestFlows_

std::map<std::string, std::vector<ext::shared_ptr<QuantLib::CashFlow> > > interestFlows_

private

Definition at line 160 of file bondbasket.hpp.

◆ notionalFlows_

std::map<std::string, std::vector<ext::shared_ptr<QuantLib::CashFlow> > > notionalFlows_

private

Definition at line 161 of file bondbasket.hpp.

◆ feeFlows_

std::map<std::string, std::vector<ext::shared_ptr<QuantLib::CashFlow> > > feeFlows_

private

Definition at line 162 of file bondbasket.hpp.

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ BondBasket()

Member Function Documentation

◆ bonds()

◆ pool()

◆ fxIndexMap()

◆ unique_currencies()

◆ recoveryRate()

◆ multiplier()

◆ convert()

◆ setGrid()

◆ scenarioCashflow()

◆ scenarioInterestflow()

◆ scenarioPrincipalflow()

◆ scenarioRemainingNotional()

◆ scenarioLossflow()

◆ scenarioFeeflow()

◆ fillFlowMaps()

◆ getScalar()

◆ yts()

◆ currency()

◆ reinvestmentScalar()

◆ flowType()

◆ fxIndex()

Member Data Documentation

◆ qlBonds_

◆ recoveries_

◆ multipliers_

◆ yieldTermStructures_

◆ currencies_

◆ pool_

◆ baseCcy_

◆ fxIndexMap_

◆ reinvestmentEndDate_

◆ reinvestmentScalar_

◆ flowType_

◆ unique_currencies_

◆ grid_

◆ cashflow2grid_

◆ interestflow2grid_

◆ notionalflow2grid_

◆ feeflow2grid_

◆ cashflows_

◆ interestFlows_

◆ notionalFlows_

◆ feeFlows_