#include <qle/models/poollossmodel.hpp>

Inheritance diagram for PoolLossModel< CopulaPolicy >:

Collaboration diagram for PoolLossModel< CopulaPolicy >:

Public Member Functions
	PoolLossModel (bool homogeneous, const QuantLib::ext::shared_ptr< ExtendedConstantLossLatentModel< CopulaPolicy > > &copula, QuantLib::Size nBuckets, QuantLib::Real max=5.0, QuantLib::Real min=-5.0, QuantLib::Size nSteps=50, bool useQuadrature=false, bool useStochasticRecovery=false)

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

QuantLib::Real	percentile (const QuantLib::Date &d, QuantLib::Real percentile) const override

QuantLib::Real	expectedShortfall (const QuantLib::Date &d, QuantLib::Probability percentile) const override

QuantLib::Real	correlation () const override

std::vector< std::vector< Real > >	marginalProbabilitiesVV (Date d, Real recoveryRate=Null< Real >()) const

Private Member Functions
QuantLib::Distribution	lossDistrib (const QuantLib::Date &d, Real recoveryRate=Null< Real >()) const

void	updateLGDs (Real recoveryRate=Null< Real >()) const

void	updateThresholds (QuantLib::Date d, Real recoveryRate=Null< Real >()) const

std::vector< Real >	updateCPRs (std::vector< QuantLib::Real > factor, Real recoveryRate=Null< Real >()) const

void	resetModel () override
	Concrete models do now any updates/inits they need on basket reset. More...

QuantLib::Real	expectedTrancheLoss1 (const QuantLib::Date &d, Distribution &dist) const

QuantLib::Real	expectedTrancheLoss2 (const QuantLib::Date &d, const Array &p, const Array &A) const

Private Attributes
bool	homogeneous_

QuantLib::ext::shared_ptr< ExtendedConstantLossLatentModel< CopulaPolicy > >	copula_

QuantLib::Size	nBuckets_

QuantLib::Real	max_

QuantLib::Real	min_

QuantLib::Size	nSteps_

bool	useQuadrature_

bool	useStochasticRecovery_

QuantLib::Real	delta_

QuantLib::Real	attach_

QuantLib::Real	detach_

QuantLib::Real	notional_

QuantLib::Real	attachAmount_

QuantLib::Real	detachAmount_

std::vector< QuantLib::Real >	notionals_

std::vector< QuantLib::Real >	lgd_

std::vector< std::vector< QuantLib::Real > >	q_

std::vector< std::vector< QuantLib::Real > >	c_

std::vector< std::vector< QuantLib::Real > >	lgdVV_

std::vector< std::vector< QuantLib::Real > >	cprVV_

Additional Inherited Members
Protected Member Functions inherited from DefaultLossModel
	DefaultLossModel ()

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

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

virtual Real	percentile (const Date &d, Real percentile) const
	Value at Risk given a default loss percentile. More...

virtual Real	expectedShortfall (const Date &d, Real percentile) const
	Expected shortfall given a default loss percentile. More...

virtual std::vector< Real >	splitVaRLevel (const Date &d, Real loss) const
	Associated VaR fraction to each counterparty. More...

virtual std::vector< Real >	splitESFLevel (const Date &d, Real loss) const
	Associated ESF fraction to each counterparty. More...

virtual std::map< Real, Probability >	lossDistribution (const Date &) const
	Full loss distribution. More...

virtual Real	densityTrancheLoss (const Date &d, Real lossFraction) const
	Probability density of a given loss fraction of the basket notional. More...

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

virtual Real	defaultCorrelation (const Date &d, Size iName, Size jName) const
	Pearsons' default probability correlation. More...

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

virtual Real	expectedRecovery (const Date &, Size iName, const DefaultProbKey &) const

Protected Attributes inherited from DefaultLossModel
RelinkableHandle< QuantExt::Basket >	basket_

Detailed Description

template<class CopulaPolicy>
class QuantExt::PoolLossModel< CopulaPolicy >

Default loss distribution convolution for finite homogeneous or non-homogeneous pool

Definition at line 38 of file poollossmodel.hpp.

Constructor & Destructor Documentation

◆ PoolLossModel()

PoolLossModel	(	bool	homogeneous,
		const QuantLib::ext::shared_ptr< ExtendedConstantLossLatentModel< CopulaPolicy > > &	copula,
		QuantLib::Size	nBuckets,
		QuantLib::Real	max = `5.0`,
		QuantLib::Real	min = `-5.0`,
		QuantLib::Size	nSteps = `50`,
		bool	useQuadrature = `false`,
		bool	useStochasticRecovery = `false`
	)

Definition at line 139 of file poollossmodel.hpp.

    : homogeneous_(homogeneous),
      copula_(copula),
      nBuckets_(nBuckets),
      max_(max),
      min_(min),
      nSteps_(nSteps),
      useQuadrature_(useQuadrature),
      useStochasticRecovery_(useStochasticRecovery),
      delta_((max - min) / nSteps),
      attach_(0.0),
      detach_(0.0),
      notional_(0.0),
      attachAmount_(0.0),
      detachAmount_(0.0) {
 
    QL_REQUIRE(copula->numFactors() == 1, "Multifactor PoolLossModel not yet implemented.");
}

Here is the call graph for this function:

Member Function Documentation

◆ expectedTrancheLoss()

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

override

Definition at line 167 of file poollossmodel.hpp.

                                                                                                            {
 
    QuantLib::Distribution dist = lossDistrib(d, recoveryRate);
 
    // RL: dist.trancheExpectedValue() using x = dist.average(i)
    // FIXME: some remaining inaccuracy in dist.cumulativeDensity(detachAmount_)
    QuantLib::Real expectedLoss = 0;
    dist.normalize();
    for (QuantLib::Size i = 0; i < dist.size(); i++) {
        // Real x = dist.x(i) + dist.dx(i)/2; // in QL distribution.cpp
        QuantLib::Real x = dist.average(i);
        if (x < attachAmount_)
            continue;
        if (x > detachAmount_)
            break;
        expectedLoss += (x - attachAmount_) * dist.dx(i) * dist.density(i);
    }
    expectedLoss += (detachAmount_ - attachAmount_) * (1.0 - dist.cumulativeDensity(detachAmount_));
 
    return expectedLoss;
}

◆ percentile()

QuantLib::Real percentile	(	const QuantLib::Date &	d,
		QuantLib::Real	percentile
	)		const

override

Definition at line 229 of file poollossmodel.hpp.

                                                                                                         {
    QuantLib::Real portfLoss = lossDistrib(d).confidenceLevel(percentile);
    return std::min(std::max(portfLoss - attachAmount_, 0.), detachAmount_ - attachAmount_);
}

◆ expectedShortfall()

QuantLib::Real expectedShortfall	(	const QuantLib::Date &	d,
		QuantLib::Probability	percentile
	)		const

override

Definition at line 235 of file poollossmodel.hpp.

                                                                 {
 
    QuantLib::Distribution dist = lossDistrib(d);
    dist.tranche(attachAmount_, detachAmount_);
    return dist.expectedShortfall(percentile);
}

◆ correlation()

QuantLib::Real correlation

overridevirtual

Return single correlation number for one factor models. If not implemented or not applicable, returns a Null<Real>().

Reimplemented from DefaultLossModel.

Definition at line 244 of file poollossmodel.hpp.

                                                            {
 
    const std::vector<std::vector<QuantLib::Real> >& weights = copula_->factorWeights();
 
    if (weights.empty() || weights[0].size() != 1) {
        return QuantLib::Null<QuantLib::Real>();
    }
 
    QuantLib::Real res = weights[0][0];
    for (QuantLib::Size i = 1; i < weights.size(); ++i) {
        if (weights[i].size() != 1 || !close(res, weights[i][0])) {
            return QuantLib::Null<QuantLib::Real>();
        }
    }
 
    return res * res;
}

◆ marginalProbabilitiesVV()

std::vector< std::vector< Real > > marginalProbabilitiesVV	(	Date	d,
		Real	recoveryRate = `Null<Real>()`
	)		const

Definition at line 334 of file poollossmodel.hpp.

                                                                                                               {
 
    std::vector<QuantLib::Real> prob = basket_->remainingProbabilities(d);
    std::vector<std::vector<QuantLib::Real>> probVV(notionals_.size(), std::vector<Real>());
    if (!useStochasticRecovery_ || recoveryRate == Null<Real>()) {
        for (Size i = 0; i < notionals_.size(); ++i)
            probVV[i].resize(1, prob[i]);
        return probVV;
    } else {
        QL_REQUIRE(copula_->recoveryProbabilities().size() == notionals_.size(),
                   "number of rec rate probability vectors does not match number of notionals"); 
        for (Size i = 0; i < notionals_.size(); ++i) {
            Real pd = prob[i];
            std::vector<Real> rrProbs = copula_->recoveryProbabilities()[i];
            probVV[i].resize(rrProbs.size(), 0.0);
            for (Size j = 0; j < rrProbs.size(); ++j)
                probVV[i][j] = pd * rrProbs[j];
        }
        return probVV;
    }
}

◆ lossDistrib()

QuantLib::Distribution lossDistrib	(	const QuantLib::Date &	d,
		Real	recoveryRate = `Null<Real>()`
	)		const

private

Definition at line 404 of file poollossmodel.hpp.

                                                                                                            {
 
    bool check = false;
    
    Real maximum = detachAmount_; 
    Real minimum = 0.0;
    
    // Update the LGD vector, could be moved to resetModel() if we can disregard the zeroRecovery flag
    updateLGDs(recoveryRate);
 
    // Update probabilities qij and thresholds cij, needs to stay here because date dependent
    updateThresholds(d, recoveryRate);
 
    // Init bucketing class
    HullWhiteBucketing hwb(minimum, maximum, nBuckets_);
 
    // Container for the final (unconditional) loss distribution up to date d.
    Array p(hwb.buckets()-1, 0.0), A(hwb.buckets()-1, 0.0);
    QuantLib::Distribution dist(nBuckets_, minimum, maximum);
    
    // Use the relevant loss bucketing algorithm
    QuantLib::ext::shared_ptr<QuantLib::LossDist> bucketing;
    if (homogeneous_)
        bucketing = QuantLib::ext::make_shared<QuantLib::LossDistHomogeneous>(nBuckets_, maximum);
    else
        bucketing = QuantLib::ext::make_shared<QuantLib::LossDistBucketing>(nBuckets_, maximum);
 
    // Is the ql bucketing used?
    bool useQlBucketing = false;
 
    // Switch between quadrature integration and basic segment type scheme.
    if (useQuadrature_ && !useStochasticRecovery_) {
 
        // FIXME: Ensure quadrature works with stochastic recovery
 
        QuantLib::GaussHermiteIntegration Integrator(nSteps_);
        // Marginal probabilities for each remaining entity in basket, P(\tau_i < t).
        std::vector<QuantLib::Real> prob = basket_->remainingProbabilities(d);
        LossModelConditionalDist<CopulaPolicy> lmcd(copula_, bucketing, prob, lgd_);
 
        for (QuantLib::Size j = 0; j < nBuckets_; j++) {
            std::function<QuantLib::Real(QuantLib::Real)> densityFunc = std::bind(
                &LossModelConditionalDist<CopulaPolicy>::conditionalDensity, &lmcd, std::placeholders::_1, j);
            std::function<QuantLib::Real(QuantLib::Real)> averageFunc = std::bind(
                &LossModelConditionalDist<CopulaPolicy>::conditionalAverage, &lmcd, std::placeholders::_1, j);
            dist.addDensity(j, Integrator(densityFunc));
            dist.addAverage(j, Integrator(averageFunc));
        }
 
        useQlBucketing = true;
 
    } else {
 
        std::vector<QuantLib::Real> factor{ min_ + delta_ / 2.0 };      
 
        for (QuantLib::Size k = 0; k < nSteps_; k++) {
            
            std::vector<Real> cpr = updateCPRs(factor, recoveryRate);
 
            // Loss distribution up to date d conditional on common factor M = m.
            Distribution conditionalDist;
            if (useStochasticRecovery_) {
                // HW bucketing with multi-state extension for stochastic recovery
                // With stochastic recovery the portfolios is in general not homogeneous any more, so that
                // bucketing is the only choice. We could use this call in all cases (including deterministic
                // recovery, homogeneous pool), but this can cause small regression errors (using bucketing
                // instead of homogeneoius pool algorithm) and calculation time increase (QuantLib::LossDist's
                // bucketing is faster).
                hwb.computeMultiState(cprVV_.begin(), cprVV_.end(), lgdVV_.begin());                
            }
            else if (homogeneous_) {
                // Original QuantLib::LossDist (homogeneous), works with deterministic recovery only.
                // If possible we use the homogeneous algorithm in QuantLib::LossDist. This also avoids small
                // regression errors from switching to any of the bucketing algorithms in the homogeneous case. 
                conditionalDist = (*bucketing)(lgd_, cpr);
                useQlBucketing = true;
            }
            else {
                // We could use hwb.computeMultiState here as well, yields the same result,
                // but compute is slightly faster than computeMultiState.
                hwb.compute(cpr.begin(), cpr.end(), lgd_.begin());                
            }
 
            // Update final distribution with contribution from common factor M = m.
            Real densitydm = delta_ * copula_->density(factor);
 
            if (useQlBucketing) {
                for (Size j = 0; j < nBuckets_; j++) {
                    dist.addDensity(j, conditionalDist.density(j) * densitydm);
                    dist.addAverage(j, conditionalDist.average(j) * densitydm);
                }
            }
            else {
                // Bucket 0 contains losses up to lowerBound, and bucket 1 from [lowerBound, lowerBound + dx),
                // together both buckets contains (-inf, lowerBound + dx)
                // Since we dont have any negative losses in a CDO its [0, dx)
                double p0 = (hwb.probability()[0] + hwb.probability()[1]);
                double A0 = 0;
                if (!QuantLib::close_enough(p0, 0.0)) {
                    A0 = (hwb.averageLoss()[0] * hwb.probability()[0] + hwb.averageLoss()[1] * hwb.probability()[1]) / p0; 
                }
                p[0] += p0 * densitydm;
                A[0] += A0 * densitydm;
                 
                for (Size j = 2; j < hwb.buckets(); j++) {
                    p[j-1] += hwb.probability()[j] * densitydm;
                    A[j-1] += hwb.averageLoss()[j] * densitydm;
                }
            }
            
            // Move to next value of common factor in [min,max] region.
            factor[0] += delta_;
        }
 
        if (!useQlBucketing) {
            // Copy results to distribution, skip the right-most bucket (maximum, infty)
            for (Size j = 0; j < nBuckets_; j++) {
                dist.addDensity(j, p[j] / dist.dx(j));
                dist.addAverage(j, A[j]);
            }
        }
    }
 
    if (check && !useQlBucketing) {
        // This checks the consistency between the Distribution object and the "raw" p and A vectors
        // by way of expectedTrancheLoss calculations.
        // Can be deactivated because of its performance impact.
        Real etl1 = expectedTrancheLoss1(d, dist);
        Real etl2 = expectedTrancheLoss2(d, p, A);
        Real tiny = 1e-3;
        QL_REQUIRE(fabs((etl1 - etl2)/etl2) < tiny, "expected tranche loss failed, " << etl1 << " vs " << etl2);
    }
 
    return dist;
}

Here is the call graph for this function:

◆ updateLGDs()

void updateLGDs ( Real recoveryRate = Null<Real>() ) const

private

Definition at line 263 of file poollossmodel.hpp.

                                                                    {
 
    // one LGD per entity, notional modified with deterministic recovery rate
    lgd_ = notionals_;
    const std::vector<Real>& recoveries = copula_->recoveries();
    for (QuantLib::Size i = 0; i < notionals_.size(); ++i) {
        if (recoveryRate != Null<Real>())
            lgd_[i] *= (1 - recoveryRate);
        else
            lgd_[i] *= (1 - recoveries[i]);
    }
    
    // Initialize the LGD matrix for stochastic recovery
    lgdVV_.clear();    
    lgdVV_.resize(notionals_.size(), std::vector<Real>());
    for (Size i = 0; i < notionals_.size(); ++i) {
        if (recoveryRate != Null<Real>())
            lgdVV_[i].push_back(notionals_[i] * (1.0 - recoveryRate));
        else if (!useStochasticRecovery_)
            lgdVV_[i].push_back(notionals_[i] * (1.0 - recoveries[i]));
        else {
            const std::vector<Real>& rrGrid = copula_->recoveryRateGrids()[i];
            for (Size j = 0; j < rrGrid.size(); ++j) {                
                QL_REQUIRE(j == 0 || rrGrid[j] <= rrGrid[j-1], "recovery rates need to be sorted in decreasing order");
                // j == 0 corresponds to the lowest recovery or largest loss
                lgdVV_[i].push_back(notionals_[i] * (1.0 - rrGrid[j]));
            }
            // std::cout << std::endl;
        }
    }
}

◆ updateThresholds()

void updateThresholds	(	QuantLib::Date	d,
		Real	recoveryRate = `Null<Real>()`
	)		const

private

Definition at line 296 of file poollossmodel.hpp.

                                                                                          {
    // Initialize probability of default function Q and thresholds C according to spec
 
    // Marginal probabilities of default for each remaining entity in basket
    std::vector<QuantLib::Real> prob = basket_->remainingProbabilities(d);
 
    q_.resize(notionals_.size());
    c_.resize(notionals_.size());
 
    if (useStochasticRecovery_ && recoveryRate == Null<Real>()) {
        Real tiny = 1.0e-10;
        for (Size i = 0; i < notionals_.size(); ++i) {
            QL_REQUIRE(copula_->recoveryProbabilities().size() == notionals_.size(),
                       "number of rec rate probability vectors does not match number of notionals"); 
            std::vector<Real> rrProbs = copula_->recoveryProbabilities()[i];
            q_[i] = std::vector<Real>(rrProbs.size() + 1, prob[i]);
            c_[i] = std::vector<Real>(rrProbs.size() + 1, copula_->inverseCumulativeY(q_[i][0], i));
            Real sum = 0.0;
            for (Size j = 0; j < rrProbs.size(); ++j) {
                sum += rrProbs[j];
                q_[i][j+1] = q_[i][0] * (1.0 - sum);
                if (QuantLib::close_enough(q_[i][j+1], 0.0))
                    c_[i][j+1] = QL_MIN_REAL;
                else
                    c_[i][j+1] = copula_->inverseCumulativeY(q_[i][j+1], i); 
            }
            QL_REQUIRE(fabs(q_[i].back()) < tiny, "expected zero qij, but found " << q_[i].back() << " for i=" << i); 
        }
    }
    else {
        for (QuantLib::Size i = 0; i < prob.size(); i++) {
            q_[i] = std::vector<Real>(1, prob[i]);
            c_[i] = std::vector<Real>(1, copula_->inverseCumulativeY(prob[i], i));
        }
    }
}

Here is the call graph for this function:

◆ updateCPRs()

std::vector< Real > updateCPRs	(	std::vector< QuantLib::Real >	factor,
		Real	recoveryRate = `Null<Real>()`
	)		const

private

Definition at line 357 of file poollossmodel.hpp.

                                                                                                               {
    cprVV_.clear();
 
    Real tiny = 1.0e-10;
    if (useStochasticRecovery_ && recoveryRate == Null<Real>()) {
        cprVV_.resize(notionals_.size(), std::vector<Real>());
        for (Size i = 0; i < c_.size(); ++i) {
            cprVV_[i].resize(c_[i].size() - 1, 0.0);
            Real pd = copula_->conditionalDefaultProbabilityInvP(c_[i][0], i, factor);
            Real sum = 0.0;
            for (Size j = 1; j < c_[i].size(); ++j) {
                // probability of recovery j conditional on default of i
                cprVV_[i][j-1] = copula_->conditionalDefaultProbabilityInvP(c_[i][j-1], i, factor)
                    - copula_->conditionalDefaultProbabilityInvP(c_[i][j], i, factor);
                sum += cprVV_[i][j-1];
            }
            QL_REQUIRE(fabs(sum - pd) < tiny, "probability check failed for factor0 " << factor[0]);
        }
    }
    else {
        cprVV_.resize(notionals_.size(), std::vector<Real>(1, 0));
        for (Size i = 0; i < c_.size(); ++i) {
            cprVV_[i][0] = copula_->conditionalDefaultProbabilityInvP(c_[i][0], i, factor);
        }
    }
    
    // Vector of default probabilities conditional on the common market factor M: P(\tau_i < t | M = m).
    std::vector<Real> probs;
    for (Size i = 0; i < c_.size(); i++)
        probs.push_back(copula_->conditionalDefaultProbabilityInvP(c_[i][0], i, factor));
 
    return probs;
}

Here is the call graph for this function:

◆ resetModel()

void resetModel ( )

overrideprivatevirtual

Concrete models do now any updates/inits they need on basket reset.

Implements DefaultLossModel.

Definition at line 392 of file poollossmodel.hpp.

                                             {
    // need to be capped now since the limit amounts might be over the remaining notional (think amortizing)
    attach_ = std::min(basket_->remainingAttachmentAmount() / basket_->remainingNotional(), 1.);
    detach_ = std::min(basket_->remainingDetachmentAmount() / basket_->remainingNotional(), 1.);
    notional_ = basket_->remainingNotional();
    notionals_ = basket_->remainingNotionals();
    attachAmount_ = basket_->remainingAttachmentAmount();
    detachAmount_ = basket_->remainingDetachmentAmount();
    copula_->resetBasket(basket_.currentLink());
}

◆ expectedTrancheLoss1()

QuantLib::Real expectedTrancheLoss1	(	const QuantLib::Date &	d,
		Distribution &	dist
	)		const

private

Definition at line 190 of file poollossmodel.hpp.

                                                                                                              {
 
    // RL: dist.trancheExpectedValue() using x = dist.average(i)
    // FIXME: some remaining inaccuracy in dist.cumulativeDensity(detachAmount_)
    QuantLib::Real expectedLoss = 0;
    for (QuantLib::Size i = 0; i < dist.size(); i++) {
        // Real x = dist.x(i) + dist.dx(i)/2; // in QL distribution.cpp
        QuantLib::Real x = dist.average(i);
        if (x < attachAmount_)
            continue;
        if (x > detachAmount_)
            break;
        expectedLoss += (x - attachAmount_) * dist.dx(i) * dist.density(i);
    }
    expectedLoss += (detachAmount_ - attachAmount_) * (1.0 - dist.cumulativeDensity(detachAmount_));
 
    return expectedLoss;
}

◆ expectedTrancheLoss2()

QuantLib::Real expectedTrancheLoss2	(	const QuantLib::Date &	d,
		const Array &	p,
		const Array &	A
	)		const

private

Definition at line 210 of file poollossmodel.hpp.

                                                                                                                          {
    // QL_REQUIRE(A.back() > detachAmount_, "A grid (max " << A.back() << ") does not cover the tranche with D " << detachAmount_);
    QuantLib::Real expectedLoss = 0;
    QuantLib::Real cumulative = 0.0;
    for (QuantLib::Size i = 0; i < p.size(); i++) {
        QuantLib::Real x = A[i];
        if (x < attachAmount_)
            continue;
        if (x > detachAmount_)
            break;
        expectedLoss += (x - attachAmount_) * p[i];
        cumulative += p[i];
    }
    expectedLoss += (detachAmount_ - attachAmount_) * (1.0 - cumulative);
 
    return expectedLoss;
}

Member Data Documentation

◆ homogeneous_

bool homogeneous_

private

Definition at line 62 of file poollossmodel.hpp.

◆ copula_

QuantLib::ext::shared_ptr<ExtendedConstantLossLatentModel<CopulaPolicy> > copula_

private

Definition at line 63 of file poollossmodel.hpp.

◆ nBuckets_

QuantLib::Size nBuckets_

private

Definition at line 64 of file poollossmodel.hpp.

◆ max_

QuantLib::Real max_

private

Definition at line 65 of file poollossmodel.hpp.

◆ min_

QuantLib::Real min_

private

Definition at line 66 of file poollossmodel.hpp.

◆ nSteps_

QuantLib::Size nSteps_

private

Definition at line 67 of file poollossmodel.hpp.

◆ useQuadrature_

bool useQuadrature_

private

Definition at line 68 of file poollossmodel.hpp.

◆ useStochasticRecovery_

bool useStochasticRecovery_

private

Definition at line 69 of file poollossmodel.hpp.

◆ delta_

QuantLib::Real delta_

private

Definition at line 71 of file poollossmodel.hpp.

◆ attach_

QuantLib::Real attach_

mutableprivate

Definition at line 72 of file poollossmodel.hpp.

◆ detach_

QuantLib::Real detach_

mutableprivate

Definition at line 73 of file poollossmodel.hpp.

◆ notional_

QuantLib::Real notional_

mutableprivate

Definition at line 74 of file poollossmodel.hpp.

◆ attachAmount_

QuantLib::Real attachAmount_

mutableprivate

Definition at line 75 of file poollossmodel.hpp.

◆ detachAmount_

QuantLib::Real detachAmount_

mutableprivate

Definition at line 76 of file poollossmodel.hpp.

◆ notionals_

std::vector<QuantLib::Real> notionals_

mutableprivate

Definition at line 77 of file poollossmodel.hpp.

◆ lgd_

std::vector<QuantLib::Real> lgd_

mutableprivate

Definition at line 80 of file poollossmodel.hpp.

◆ q_

std::vector<std::vector<QuantLib::Real> > q_

mutableprivate

Definition at line 82 of file poollossmodel.hpp.

◆ c_

std::vector<std::vector<QuantLib::Real> > c_

mutableprivate

Definition at line 84 of file poollossmodel.hpp.

◆ lgdVV_

std::vector<std::vector<QuantLib::Real> > lgdVV_

mutableprivate

Definition at line 86 of file poollossmodel.hpp.

◆ cprVV_

std::vector<std::vector<QuantLib::Real> > cprVV_

mutableprivate

Definition at line 88 of file poollossmodel.hpp.

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ PoolLossModel()

Member Function Documentation

◆ expectedTrancheLoss()

◆ percentile()

◆ expectedShortfall()

◆ correlation()

◆ marginalProbabilitiesVV()

◆ lossDistrib()

◆ updateLGDs()

◆ updateThresholds()

◆ updateCPRs()

◆ resetModel()

◆ expectedTrancheLoss1()

◆ expectedTrancheLoss2()

Member Data Documentation

◆ homogeneous_

◆ copula_

◆ nBuckets_

◆ max_

◆ min_

◆ nSteps_

◆ useQuadrature_

◆ useStochasticRecovery_

◆ delta_

◆ attach_

◆ detach_

◆ notional_

◆ attachAmount_

◆ detachAmount_

◆ notionals_

◆ lgd_

◆ q_

◆ c_

◆ lgdVV_

◆ cprVV_