#include <qle/models/basket.hpp>

Inheritance diagram for Basket:

Collaboration diagram for Basket:

Public Member Functions
	Basket ()

	Basket (const Date &refDate, const std::vector< std::string > &names, const std::vector< Real > &notionals, const QuantLib::ext::shared_ptr< Pool > pool, Real attachmentRatio=0.0, Real detachmentRatio=1.0, const QuantLib::ext::shared_ptr< Claim > &claim=QuantLib::ext::shared_ptr< Claim >(new FaceValueClaim()))

void	computeBasket () const

Size	size () const
	Basket inception number of counterparties. More...

const std::vector< std::string > &	names () const
	Basket counterparties names at inception. More...

const std::vector< Real > &	notionals () const
	Basket counterparties notionals at inception. More...

Real	exposure (const std::string &name, const Date &=Date()) const
	Returns the total expected exposures for that name. More...

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

std::vector< DefaultProbKey >	defaultKeys () const
	The keys each counterparty enters the basket with (sensitive to) More...

const Date &	refDate () const
	Basket inception date. More...

Real	attachmentRatio () const

Real	detachmentRatio () const
	Detachment point expressed as a fraction of the total pool notional. More...

Real	basketNotional () const
	Original basket notional ignoring any losses. More...

Real	trancheNotional () const
	Original tranche notional ignoring any realized losses. More...

Real	attachmentAmount () const
	Attachment amount = attachmentRatio() * basketNotional() More...

Real	detachmentAmount () const
	Detachment amount = detachmentRatio() * basketNotional() More...

QuantLib::ext::shared_ptr< Claim >	claim () const
	default claim, same for all positions and counterparties More...

std::vector< Probability >	probabilities (const Date &d) const

Real	settledLoss () const

Real	settledLoss (const Date &) const

Real	cumulatedLoss () const

Real	cumulatedLoss (const Date &) const

Real	remainingNotional () const

Real	remainingNotional (const Date &) const

const std::vector< Real > &	remainingNotionals () const

std::vector< Real >	remainingNotionals (const Date &) const

const std::vector< std::string > &	remainingNames () const

std::vector< std::string >	remainingNames (const Date &) const

const std::vector< DefaultProbKey > &	remainingDefaultKeys () const

std::vector< DefaultProbKey >	remainingDefaultKeys (const Date &) const

Size	remainingSize () const
	Number of counterparties alive on the requested date. More...

Size	remainingSize (const Date &) const

std::vector< Probability >	remainingProbabilities (const Date &d) const

Real	remainingAttachmentAmount () const

Real	remainingAttachmentAmount (const Date &endDate) const

Real	remainingDetachmentAmount () const

Real	remainingDetachmentAmount (const Date &endDate) const

Real	remainingTrancheNotional () const
	Remaining basket tranched notional on calculation date. More...

Real	remainingTrancheNotional (const Date &endDate) const

const std::vector< Size > &	liveList () const
	Indexes of remaining names. Notice these are names and not positions. More...

std::vector< Size >	liveList (const Date &) const

void	setLossModel (const QuantLib::ext::shared_ptr< QuantExt::DefaultLossModel > &lossModel)
	Assigns the default loss model to this basket. Resets calculations. More...

Basket Loss Statistics
Methods providing statistical metrics on the loss or value distribution of the basket. Most calculations rely on the pressence of a model assigned to the basket.
std::vector< Real >	notionals_

QuantLib::ext::shared_ptr< Pool >	pool_

const QuantLib::ext::shared_ptr< Claim >	claim_
	The claim is the same for all names. More...

Real	attachmentRatio_

Real	detachmentRatio_

Real	basketNotional_

Real	attachmentAmount_
	basket tranched inception attachment amount: More...

Real	detachmentAmount_
	basket tranched inception detachment amount: More...

Real	trancheNotional_
	basket tranched notional amount: More...

Real	evalDateSettledLoss_

Real	evalDateRemainingNot_

Real	evalDateAttachAmount_

Real	evalDateDetachAmmount_

std::vector< Size >	evalDateLiveList_

std::vector< Real >	evalDateLiveNotionals_

std::vector< std::string >	evalDateLiveNames_

std::vector< DefaultProbKey >	evalDateLiveKeys_

const Date	refDate_
	Basket inception date. More...

QuantLib::ext::shared_ptr< QuantExt::DefaultLossModel >	lossModel_

Real	expectedTrancheLoss (const Date &d, Real recoveryRate=Null< Real >()) const

Probability	probOverLoss (const Date &d, Real lossFraction) const

Real	percentile (const Date &d, Probability prob) const

Real	expectedShortfall (const Date &d, Probability prob) const

std::vector< Real >	splitVaRLevel (const Date &date, Real loss) const

std::map< Real, Probability >	lossDistribution (const Date &) const

Real	densityTrancheLoss (const Date &d, Real lossFraction) const

Real	defaultCorrelation (const Date &d, Size iName, Size jName) const

std::vector< Probability >	probsBeingNthEvent (Size n, const Date &d) const

Probability	probAtLeastNEvents (Size n, const Date &d) const

Real	recoveryRate (const Date &d, Size iName) const

QuantLib::Real	correlation () const

void	performCalculations () const override

Detailed Description

Credit Basket.

: A basket is a collection of credit names, represented by a unique identifier (a text string), associated notional amounts, a pool and tranche information. The pool is a map of "names" to issuers. The Basket structure is motivated by CDO squared instruments containing various underlying inner CDOs which can be represented by respective baskets including their tranche structure. The role of the Pool is providing a unique list of relevant issuers while names may appear multiple times across different baskets (overlap).

Definition at line 52 of file basket.hpp.

Constructor & Destructor Documentation

◆ Basket() [1/2]

Basket ( )

Definition at line 54 of file basket.hpp.

54{}

◆ Basket() [2/2]

Basket	(	const Date &	refDate,
		const std::vector< std::string > &	names,
		const std::vector< Real > &	notionals,
		const QuantLib::ext::shared_ptr< Pool >	pool,
		Real	attachmentRatio = `0.0`,
		Real	detachmentRatio = `1.0`,
		const QuantLib::ext::shared_ptr< Claim > &	claim = `QuantLib::ext::shared_ptr<Claim>(new FaceValueClaim())`
	)

Constructs a basket of simple collection of constant notional positions subject to default risk only.

The refDate parameter is the basket inception date, that is, the date at which defaultable events are relevant. (There are no constraints on forward baskets but models assigned should be consistent.)

Definition at line 31 of file basket.cpp.

    : notionals_(notionals), pool_(pool), claim_(claim), attachmentRatio_(attachment), detachmentRatio_(detachment),
      basketNotional_(0.0), attachmentAmount_(0.0), detachmentAmount_(0.0), trancheNotional_(0.0), refDate_(refDate) {
    QL_REQUIRE(!notionals_.empty(), "notionals empty");
    QL_REQUIRE(attachmentRatio_ >= 0 && attachmentRatio_ <= detachmentRatio_ && detachmentRatio_ <= 1,
               "invalid attachment/detachment ratio");
    QL_REQUIRE(pool_, "Empty pool pointer.");
    QL_REQUIRE(notionals_.size() == pool_->size(), "unmatched data entry sizes in basket, "
                                                       << notionals_.size() << " notionals, " << pool_->size()
                                                       << " pool size");
 
    // registrations relevant to the loss status, not to the expected
    // loss values; those are through models.
    registerWith(Settings::instance().evaluationDate());
    registerWith(claim_);
}

Member Function Documentation

◆ computeBasket()

void computeBasket ( ) const

Definition at line 66 of file basket.hpp.

                               {
        Date today = Settings::instance().evaluationDate();
        /* update cache values at the calculation date (work as arguments
          to the Loss Models)
        \to do: IMPORTANT: notice that defaults added to Issuers dont get
        notify as the codes stnds today. Issuers need to be observables.
        */
        // this one must remain on top since there are dependencies
        evalDateLiveKeys_ = remainingDefaultKeys(today);
        evalDateSettledLoss_ = settledLoss(today);
        evalDateRemainingNot_ = remainingNotional(today);
        evalDateLiveNotionals_ = remainingNotionals(today);
        evalDateLiveNames_ = remainingNames(today);
        evalDateAttachAmount_ = remainingAttachmentAmount(today);
        evalDateDetachAmmount_ = remainingDetachmentAmount(today);
        evalDateLiveList_ = liveList(today);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ size()

Size size ( ) const

Basket inception number of counterparties.

Definition at line 319 of file basket.hpp.

319{ return pool_->size(); }

Here is the caller graph for this function:

◆ names()

const std::vector< std::string > & names ( ) const

Basket counterparties names at inception.

Definition at line 86 of file basket.hpp.

86{ return pool_->names(); }

◆ notionals()

const std::vector< Real > & notionals ( ) const

Basket counterparties notionals at inception.

Definition at line 321 of file basket.hpp.

321{ return notionals_; }

◆ exposure()

Real exposure	(	const std::string &	name,
		const Date &	d = `Date()`
	)		const

Returns the total expected exposures for that name.

Definition at line 196 of file basket.cpp.

                                                                {
    calculate();
    //'this->names_' contains duplicates, contrary to 'pool->names'
    std::vector<std::string>::const_iterator match = std::find(pool_->names().begin(), pool_->names().end(), name);
    QL_REQUIRE(match != pool_->names().end(), "Name not in basket.");
    Real totalNotional = 0.;
    do {
        totalNotional +=
            // NOT IMPLEMENTED YET:
            // positions_[std::distance(names_.begin(), match)]->expectedExposure(d);
            notionals_[std::distance(pool_->names().begin(), match)];
        ++match;
        match = std::find(match, pool_->names().end(), name);
    } while (match != pool_->names().end());
 
    return totalNotional;
    // Size position = std::distance(poolNames.begin(),
    //    std::find(poolNames.begin(), poolNames.end(), name));
    // QL_REQUIRE(position < pool_->size(), "Name not in pool list");
 
    // return positions_[position]->expectedExposure(d);
}

Here is the caller graph for this function:

◆ pool()

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

Underlying pool.

Definition at line 325 of file basket.hpp.

325{ return pool_; }

◆ defaultKeys()

std::vector< DefaultProbKey > defaultKeys ( ) const

The keys each counterparty enters the basket with (sensitive to)

Definition at line 323 of file basket.hpp.

323{ return pool_->defaultKeys(); }

Here is the caller graph for this function:

◆ refDate()

const Date & refDate ( ) const

Basket inception date.

Loss Given Default for all issuers/notionals based on expected recovery rates for the respective issuers.

Definition at line 99 of file basket.hpp.

99{ return refDate_; }

◆ attachmentRatio()

Real attachmentRatio ( ) const

Attachment point expressed as a fraction of the total inception notional.

Definition at line 103 of file basket.hpp.

103{ return attachmentRatio_; }

◆ detachmentRatio()

Real detachmentRatio ( ) const

Detachment point expressed as a fraction of the total pool notional.

Definition at line 105 of file basket.hpp.

105{ return detachmentRatio_; }

◆ basketNotional()

Real basketNotional ( ) const

Original basket notional ignoring any losses.

Definition at line 107 of file basket.hpp.

                                {
        calculate();
        return basketNotional_;
    }

◆ trancheNotional()

Real trancheNotional ( ) const

Original tranche notional ignoring any realized losses.

Definition at line 112 of file basket.hpp.

                                 {
        calculate();
        return trancheNotional_;
    }

◆ attachmentAmount()

Real attachmentAmount ( ) const

Attachment amount = attachmentRatio() * basketNotional()

Definition at line 117 of file basket.hpp.

                                  {
        calculate();
        return attachmentAmount_;
    }

◆ detachmentAmount()

Real detachmentAmount ( ) const

Detachment amount = detachmentRatio() * basketNotional()

Definition at line 122 of file basket.hpp.

                                  {
        calculate();
        return detachmentAmount_;
    }

◆ claim()

QuantLib::ext::shared_ptr< Claim > claim ( ) const

default claim, same for all positions and counterparties

Definition at line 127 of file basket.hpp.

127{ return claim_; }

◆ probabilities()

vector< Real > probabilities ( const Date & d ) const

Vector of cumulative default probability to date d for all issuers in the basket.

Definition at line 91 of file basket.cpp.

                                                      {
    calculate();
    vector<Real> prob(size());
    vector<DefaultProbKey> defKeys = defaultKeys();
    for (Size j = 0; j < size(); j++)
        prob[j] = pool_->get(pool_->names()[j]).defaultProbability(defKeys[j])->defaultProbability(d);
    return prob;
}

Here is the call graph for this function:

◆ settledLoss() [1/2]

Real settledLoss ( ) const

Realized basket losses between the reference date and the calculation date, taking the actual recovery rates of loss events into account. Only default events that have settled (have a realized RR) are accounted for. For contingent losses after a default you need to compute the losses through a DefaultLossModel

Optionally one can pass a date in the future and that will collect events stored in the issuers list. This shows the effect of 'programmed' (after today's) events on top of past ones. The intention is to be used in risk analysis (jump to default, etc).

Definition at line 357 of file basket.hpp.

                                      {
    calculate();
    return evalDateSettledLoss_;
}

Here is the caller graph for this function:

◆ settledLoss() [2/2]

Real settledLoss ( const Date & endDate ) const

Definition at line 122 of file basket.cpp.

                                                  {
    calculate();
    QL_REQUIRE(endDate >= refDate_, "Target date lies before basket inception");
 
    Real loss = 0.0;
    for (Size i = 0; i < size(); i++) {
        QuantLib::ext::shared_ptr<DefaultEvent> credEvent =
            pool_->get(pool_->names()[i]).defaultedBetween(refDate_, endDate, pool_->defaultKeys()[i]);
        if (credEvent) {
            if (credEvent->hasSettled()) {
                loss += claim_->amount(credEvent->date(),
                                       // notionals_[i],
                                       exposure(pool_->names()[i], credEvent->date()),
                                       // NOtice I am requesting an exposure in the past...
                                       /* also the seniority does not belong to the
                                       counterparty anymore but to the position.....*/
                                       credEvent->settlement().recoveryRate(pool_->defaultKeys()[i].seniority()));
            }
        }
    }
    return loss;
}

Here is the call graph for this function:

◆ cumulatedLoss() [1/2]

Real cumulatedLoss ( ) const

Actual basket losses between the reference date and the calculation date, taking the actual recovery rates of loss events into account. If the event has not settled yet a model driven recovery is used.

Returns the realized losses in this portfolio since the portfolio default reference date. This method relies on an implementation of the loss given default since the events have not necessarily settled.

Definition at line 352 of file basket.hpp.

                                        {
    calculate();
    return this->evalDateSettledLoss_;
}

Here is the caller graph for this function:

◆ cumulatedLoss() [2/2]

Real cumulatedLoss ( const Date & endDate ) const

Definition at line 100 of file basket.cpp.

                                                    {
    calculate();
    QL_REQUIRE(endDate >= refDate_, "Target date lies before basket inception");
    Real loss = 0.0;
    for (Size i = 0; i < size(); i++) {
        QuantLib::ext::shared_ptr<DefaultEvent> credEvent =
            pool_->get(pool_->names()[i]).defaultedBetween(refDate_, endDate, pool_->defaultKeys()[i]);
        if (credEvent) {
            /* \todo If the event has not settled one would need to
            introduce some model recovery rate (independently of a loss
            model) This remains to be done.
            */
            if (credEvent->hasSettled())
                loss += claim_->amount(credEvent->date(),
                                       // notionals_[i],
                                       exposure(pool_->names()[i], credEvent->date()),
                                       credEvent->settlement().recoveryRate(pool_->defaultKeys()[i].seniority()));
        }
    }
    return loss;
}

Here is the call graph for this function:

◆ remainingNotional() [1/2]

Real remainingNotional ( ) const

Remaining full basket (untranched) notional after settled losses between the reference date and the given date. The full notional for defaulted names is subracted, recovery ignored.

Definition at line 145 of file basket.cpp.

                                     {
    calculate();
    return evalDateRemainingNot_;
}

Here is the caller graph for this function:

◆ remainingNotional() [2/2]

Real remainingNotional ( const Date & endDate ) const

Definition at line 160 of file basket.cpp.

                                                        {
    calculate();
    Real notional = 0;
    vector<DefaultProbKey> defKeys = defaultKeys();
    for (Size i = 0; i < size(); i++) {
        if (!pool_->get(pool_->names()[i]).defaultedBetween(refDate_, endDate, defKeys[i]))
            notional += notionals_[i];
    }
    return notional;
}

Here is the call graph for this function:

◆ remainingNotionals() [1/2]

const std::vector< Real > & remainingNotionals ( ) const

Vector of surviving notionals after settled losses between the reference date and the given date, recovery ignored.

Definition at line 347 of file basket.hpp.

                                                               {
    calculate();
    return evalDateLiveNotionals_;
}

Here is the caller graph for this function:

◆ remainingNotionals() [2/2]

vector< Real > remainingNotionals ( const Date & endDate ) const

Definition at line 171 of file basket.cpp.

                                                                 {
    calculate();
    QL_REQUIRE(endDate >= refDate_, "Target date lies before basket inception");
 
    std::vector<Real> calcBufferNotionals;
    const std::vector<Size>& alive = liveList(endDate);
    for (Size i = 0; i < alive.size(); i++)
        calcBufferNotionals.push_back(exposure(pool_->names()[i], endDate)); // some better way to trim it?
    return calcBufferNotionals;
}

Here is the call graph for this function:

◆ remainingNames() [1/2]

const std::vector< std::string > & remainingNames ( ) const

Vector of surviving issuers after defaults between the reference basket date and the given (or evaluation) date.

Definition at line 342 of file basket.hpp.

                                                                {
    calculate();
    return evalDateLiveNames_;
}

Here is the caller graph for this function:

◆ remainingNames() [2/2]

std::vector< std::string > remainingNames ( const Date & endDate ) const

Definition at line 219 of file basket.cpp.

                                                                     {
    calculate();
    // maybe return zero directly instead?:
    QL_REQUIRE(endDate >= refDate_, "Target date lies before basket inception");
 
    const std::vector<Size>& alive = liveList(endDate);
    std::vector<std::string> calcBufferNames;
    for (Size i = 0; i < alive.size(); i++)
        calcBufferNames.push_back(pool_->names()[alive[i]]);
    return calcBufferNames;
}

Here is the call graph for this function:

◆ remainingDefaultKeys() [1/2]

const std::vector< DefaultProbKey > & remainingDefaultKeys ( ) const

Default keys of non defaulted counterparties

Definition at line 362 of file basket.hpp.

                                                                           {
    calculate();
    return evalDateLiveKeys_;
}

Here is the caller graph for this function:

◆ remainingDefaultKeys() [2/2]

vector< DefaultProbKey > remainingDefaultKeys ( const Date & endDate ) const

Definition at line 231 of file basket.cpp.

                                                                             {
    calculate();
    QL_REQUIRE(endDate >= refDate_, "Target date lies before basket inception");
 
    const std::vector<Size>& alive = liveList(endDate);
    vector<DefaultProbKey> defKeys;
    for (Size i = 0; i < alive.size(); i++)
        defKeys.push_back(pool_->defaultKeys()[alive[i]]);
    return defKeys;
}

Here is the call graph for this function:

◆ remainingSize() [1/2]

Size remainingSize ( ) const

Number of counterparties alive on the requested date.

Definition at line 242 of file basket.cpp.

                                 {
    calculate();
    return evalDateLiveList_.size();
}

◆ remainingSize() [2/2]

Size remainingSize ( const Date & ) const

◆ remainingProbabilities()

std::vector< Probability > remainingProbabilities ( const Date & d ) const

Vector of cumulative default probability to date d for all issuers still (at the evaluation date) alive in the basket.

Definition at line 182 of file basket.cpp.

                                                                         {
    calculate();
    QL_REQUIRE(d >= refDate_, "Target date lies before basket inception");
    vector<Real> prob;
    const std::vector<Size>& alive = liveList();
 
    for (Size i = 0; i < alive.size(); i++)
        prob.push_back(
            pool_->get(pool_->names()[i]).defaultProbability(pool_->defaultKeys()[i])->defaultProbability(d, true));
    return prob;
}

Here is the call graph for this function:

◆ remainingAttachmentAmount() [1/2]

Real remainingAttachmentAmount ( ) const

Attachment amount of the equivalent (after defaults) remaining basket The remaining attachment amount is RAA = max (0, attachmentAmount - cumulatedLoss())

The remaining attachment ratio is then RAR = RAA / remainingNotional()

Definition at line 337 of file basket.hpp.

                                                    {
    calculate();
    return evalDateAttachAmount_;
}

Here is the caller graph for this function:

◆ remainingAttachmentAmount() [2/2]

Real remainingAttachmentAmount ( const Date & endDate ) const

Definition at line 255 of file basket.cpp.

                                                                {
    calculate();
    // maybe return zero directly instead?:
    QL_REQUIRE(endDate >= refDate_, "Target date lies before basket inception");
    Real loss = settledLoss(endDate);
    return std::min(detachmentAmount_, attachmentAmount_ + std::max(0.0, loss - attachmentAmount_));
}

Here is the call graph for this function:

◆ remainingDetachmentAmount() [1/2]

Real remainingDetachmentAmount ( ) const

Detachment amount of the equivalent remaining basket. The remaining detachment amount is RDA = max (0, detachmentAmount - cumulatedLoss())

The remaining detachment ratio is then RDR = RDA / remainingNotional()

Definition at line 332 of file basket.hpp.

                                                    {
    calculate();
    return evalDateDetachAmmount_;
}

Here is the caller graph for this function:

◆ remainingDetachmentAmount() [2/2]

Real remainingDetachmentAmount ( const Date & endDate ) const

Definition at line 250 of file basket.cpp.

                                                                {
    calculate();
    return detachmentAmount_;
}

◆ remainingTrancheNotional() [1/2]

Real remainingTrancheNotional ( ) const

Remaining basket tranched notional on calculation date.

Definition at line 207 of file basket.hpp.

                                          {
        calculate();
        return evalDateDetachAmmount_ - evalDateAttachAmount_;
    }

◆ remainingTrancheNotional() [2/2]

Real remainingTrancheNotional ( const Date & endDate ) const

Expected basket tranched notional on the requested date according to the basket model. Model should have been assigned.

Definition at line 214 of file basket.hpp.

                                                             {
        calculate();
        return remainingDetachmentAmount(endDate) - remainingAttachmentAmount(endDate);
    }

Here is the call graph for this function:

◆ liveList() [1/2]

const std::vector< Size > & liveList ( ) const

Indexes of remaining names. Notice these are names and not positions.

Definition at line 327 of file basket.hpp.

                                                     {
    calculate();
    return evalDateLiveList_;
}

Here is the caller graph for this function:

◆ liveList() [2/2]

std::vector< Size > liveList ( const Date & endDate ) const

Definition at line 150 of file basket.cpp.

                                                          {
    calculate();
    std::vector<Size> calcBufferLiveList;
    for (Size i = 0; i < size(); i++)
        if (!pool_->get(pool_->names()[i]).defaultedBetween(refDate_, endDate, pool_->defaultKeys()[i]))
            calcBufferLiveList.push_back(i);
 
    return calcBufferLiveList;
}

Here is the call graph for this function:

◆ setLossModel()

void setLossModel ( const QuantLib::ext::shared_ptr< QuantExt::DefaultLossModel > & lossModel )

Assigns the default loss model to this basket. Resets calculations.

Definition at line 53 of file basket.cpp.

                                                                                  {
 
    if (lossModel_)
        unregisterWith(lossModel_);
    lossModel_ = lossModel;
    if (lossModel_) {
        // recovery quotes, defaults(once Issuer is observable)etc might
        //  trigger us:
        registerWith(lossModel_);
    }
    LazyObject::update(); //<- just set calc=false
}

◆ expectedTrancheLoss()

Real expectedTrancheLoss	(	const Date &	d,
		Real	recoveryRate = `Null<Real>()`
	)		const

Definition at line 293 of file basket.cpp.

                                                                       {
    calculate();
    return cumulatedLoss() + lossModel_->expectedTrancheLoss(d, recoveryRate);
}

Here is the call graph for this function:

◆ probOverLoss()

Probability probOverLoss	(	const Date &	d,
		Real	lossFraction
	)		const

The lossFraction is the fraction of losses expressed in inception (no losses) tranche units (e.g. 'attach level'=0%, 'detach level'=100%)

Definition at line 263 of file basket.cpp.

                                                                       {
    // convert initial basket fraction to remaining basket fraction
    calculate();
    // if eaten up all the tranche the prob of losing any amount is 1
    //  (we have already lost it)
    if (evalDateRemainingNot_ == 0.)
        return 1.;
 
    // Turn to live (remaining) tranche units to feed into the model request
    Real xPtfl = attachmentAmount_ + (detachmentAmount_ - attachmentAmount_) * lossFraction;
    Real xPrim = (xPtfl - evalDateAttachAmount_) / (detachmentAmount_ - evalDateAttachAmount_);
    // in live tranche fractional units
    // if the level falls within realized losses the prob is 1.
    if (xPtfl < 0.)
        return 1.;
 
    return lossModel_->probOverLoss(d, xPrim);
}

◆ percentile()

Real percentile	(	const Date &	d,
		Probability	prob
	)		const

Definition at line 282 of file basket.cpp.

                                                             {
    calculate();
    return lossModel_->percentile(d, prob);
 
    // Real percLiveFract = lossModel_->percentile(d, prob);
    // return (percLiveFract * (detachmentAmount_ - evalDateAttachAmount_) + attachmentAmount_ - evalDateAttachAmount_)
    // /
    //       (detachmentAmount_ - attachmentAmount_);
}

◆ expectedShortfall()

Real expectedShortfall	(	const Date &	d,
		Probability	prob
	)		const

ESF

Definition at line 303 of file basket.cpp.

                                                                    {
    calculate();
    return lossModel_->expectedShortfall(d, prob);
}

◆ splitVaRLevel()

std::vector< Real > splitVaRLevel	(	const Date &	date,
		Real	loss
	)		const

Definition at line 298 of file basket.cpp.

                                                                       {
    calculate();
    return lossModel_->splitVaRLevel(date, loss);
}

◆ lossDistribution()

std::map< Real, Probability > lossDistribution ( const Date & d ) const

Full loss distribution

Definition at line 308 of file basket.cpp.

                                                                      {
    calculate();
    return lossModel_->lossDistribution(d);
}

◆ densityTrancheLoss()

Real densityTrancheLoss	(	const Date &	d,
		Real	lossFraction
	)		const

◆ defaultCorrelation()

Real defaultCorrelation	(	const Date &	d,
		Size	iName,
		Size	jName
	)		const

Definition at line 322 of file basket.cpp.

                                                                           {
    calculate();
    return lossModel_->defaultCorrelation(d, iName, jName);
}

◆ probsBeingNthEvent()

std::vector< Probability > probsBeingNthEvent	(	Size	n,
		const Date &	d
	)		const

Probability vector that each of the remaining live names (at eval date) is the n-th default by date d.

The n parameter is the internal index to the name; it should be alive at the evaluation date.

------—TO DO: Implement with a string passed-------------------— ------—TO DO: Perform check the name is alive------------------—

Definition at line 313 of file basket.cpp.

                                                                             {
    Size alreadyDefaulted = pool_->size() - remainingNames().size();
    if (alreadyDefaulted >= n)
        return std::vector<Probability>(remainingNames().size(), 0.);
 
    calculate();
    return lossModel_->probsBeingNthEvent(n - alreadyDefaulted, d);
}

Here is the call graph for this function:

◆ probAtLeastNEvents()

Probability probAtLeastNEvents	(	Size	n,
		const Date &	d
	)		const

Returns the probaility of having a given or larger number of defaults in the basket portfolio at a given time.

Definition at line 330 of file basket.cpp.

                                                                  {
    calculate();
    return lossModel_->probAtLeastNEvents(n, d);
}

◆ recoveryRate()

Real recoveryRate	(	const Date &	d,
		Size	iName
	)		const

Expected recovery rate of the underlying position as a fraction of its exposure value at date d given it has defaulted on that date. NOTICE THE ARG IS THE CTPTY....SHOULDNT IT BE THE POSITION/INSTRUMENT?????<<<<<<<<<<<<<<<<<<<<<<<

Definition at line 335 of file basket.cpp.

                                                         {
    calculate();
    return lossModel_->expectedRecovery(d, iName, pool_->defaultKeys()[iName]);
}

Here is the caller graph for this function:

◆ correlation()

Real correlation ( ) const

Return single correlation number from the underlying loss model if it is a one factor model. If the underlying loss model is null, this returns a Null<Real>().

Definition at line 340 of file basket.cpp.

                               {
    calculate();
    if (lossModel_)
        return lossModel_->correlation();
    else
        return Null<Real>();
}

◆ performCalculations()

void performCalculations ( ) const

overrideprivate

Definition at line 66 of file basket.cpp.

                                       {
    basketNotional_ = attachmentAmount_ = detachmentAmount_ = 0.0;
    for (Size i = 0; i < notionals_.size(); i++) {
        basketNotional_ += notionals_[i];
        attachmentAmount_ += notionals_[i] * attachmentRatio_;
        detachmentAmount_ += notionals_[i] * detachmentRatio_;
    }
    trancheNotional_ = detachmentAmount_ - attachmentAmount_;
    // Calculations for status
    computeBasket(); // or we might be called from an statistic member
                     // without being intialized yet (first called)
    QL_REQUIRE(lossModel_, "Basket has no default loss model assigned.");
 
    /* The model must notify us if the another basket calls it for
    reasignment. The basket works as an argument to the deafult loss models
    so, even if the models dont cache anything, they will be using the wrong
    defautl TS. \todo: This has a possible optimization: the basket
    incorporates trancheability and many models do their compuations
    independently of that (some do but do it inefficiently when asked for
    two tranches on the same basket; e,g, recursive model) so it might be
    more efficient sending the pool only; however the modtionals and other
    basket info are still used.*/
    lossModel_->setBasket(const_cast<Basket*>(this));
}

Here is the call graph for this function:

The claim is the same for all names.

Definition at line 282 of file basket.hpp.

◆ attachmentRatio_

Real attachmentRatio_

private

Definition at line 284 of file basket.hpp.

◆ detachmentRatio_

Real detachmentRatio_

private

Definition at line 285 of file basket.hpp.

◆ lossModel_

QuantLib::ext::shared_ptr<QuantExt::DefaultLossModel> lossModel_

private

Definition at line 314 of file basket.hpp.

Public Member Functions

Basket Loss Statistics

Detailed Description

Constructor & Destructor Documentation

◆ Basket() [1/2]

◆ Basket() [2/2]

Member Function Documentation

◆ computeBasket()

◆ size()

◆ names()

◆ notionals()

◆ exposure()

◆ pool()

◆ defaultKeys()

◆ refDate()

◆ attachmentRatio()

◆ detachmentRatio()

◆ basketNotional()

◆ trancheNotional()

◆ attachmentAmount()

◆ detachmentAmount()

◆ claim()

◆ probabilities()

◆ settledLoss() [1/2]

◆ settledLoss() [2/2]

◆ cumulatedLoss() [1/2]

◆ cumulatedLoss() [2/2]

◆ remainingNotional() [1/2]

◆ remainingNotional() [2/2]

◆ remainingNotionals() [1/2]

◆ remainingNotionals() [2/2]

◆ remainingNames() [1/2]

◆ remainingNames() [2/2]

◆ remainingDefaultKeys() [1/2]

◆ remainingDefaultKeys() [2/2]

◆ remainingSize() [1/2]

◆ remainingSize() [2/2]

◆ remainingProbabilities()

◆ remainingAttachmentAmount() [1/2]

◆ remainingAttachmentAmount() [2/2]

◆ remainingDetachmentAmount() [1/2]

◆ remainingDetachmentAmount() [2/2]

◆ remainingTrancheNotional() [1/2]

◆ remainingTrancheNotional() [2/2]

◆ liveList() [1/2]

◆ liveList() [2/2]

◆ setLossModel()

◆ expectedTrancheLoss()

◆ probOverLoss()

◆ percentile()

◆ expectedShortfall()

◆ splitVaRLevel()

◆ lossDistribution()

◆ densityTrancheLoss()

◆ defaultCorrelation()

◆ probsBeingNthEvent()

◆ probAtLeastNEvents()

◆ recoveryRate()

◆ correlation()

◆ performCalculations()

Member Data Documentation

◆ notionals_

◆ pool_

◆ claim_

◆ attachmentRatio_

◆ detachmentRatio_

◆ basketNotional_

◆ attachmentAmount_

◆ detachmentAmount_

◆ trancheNotional_

◆ evalDateSettledLoss_

◆ evalDateRemainingNot_

◆ evalDateAttachAmount_

◆ evalDateDetachAmmount_

◆ evalDateLiveList_

◆ evalDateLiveNotionals_

◆ evalDateLiveNames_

◆ evalDateLiveKeys_

◆ refDate_

◆ lossModel_