test_hullwhitebucketing Namespace Reference

Functions
void	computeDiscreteDistribution (std::vector< std::vector< double > >::iterator beginPDs, std::vector< std::vector< double > >::iterator endPDs, std::vector< std::vector< double > >::iterator beginLGDs, double runningDensity, double runningLoss, std::map< double, double > &dist)
std::map< double, double >	lossDistribution (const std::vector< double > &pds, const std::vector< double > &lgds)
std::map< double, double >	lossDistribution (const std::vector< vector< double > > &pds, const std::vector< vector< double > > &lgds)
std::ostream &	operator<< (std::ostream &os, const BucketedDistribution &dist)
double	expectedTrancheLoss (const std::map< double, double > &dist, double detachmentPoint)
double	expectedTrancheLoss (QuantLib::Distribution dist, double attachmentAmount, double detachmentAmount)
double	expectedTrancheLoss (const vector< double > &prob, const vector< double > &loss, double detachment)

Function Documentation

computeDiscreteDistribution()

void computeDiscreteDistribution	(	std::vector< std::vector< double > >::iterator	beginPDs,
		std::vector< std::vector< double > >::iterator	endPDs,
		std::vector< std::vector< double > >::iterator	beginLGDs,
		double	runningDensity,
		double	runningLoss,
		std::map< double, double > &	dist
	)

Definition at line 46 of file hullwhitebucketing.cpp.

                                                  {
    if (beginPDs == endPDs) {
        dist[runningLoss] = dist[runningLoss]  + runningDensity;
    } else {
        for (size_t eventId = 0; eventId < beginPDs->size(); eventId++) {
            double loss = runningLoss + beginLGDs->at(eventId);
            double density = runningDensity * beginPDs->at(eventId);
            computeDiscreteDistribution(beginPDs + 1, endPDs, beginLGDs + 1, density, loss, dist);
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

lossDistribution() [1/2]

std::map< double, double > lossDistribution	(	const std::vector< double > &	pds,
		const std::vector< double > &	lgds
	)

Definition at line 61 of file hullwhitebucketing.cpp.

                                                                                                     {
 
    QL_REQUIRE(pds.size() == lgds.size(), "Mismatch number of pds and lgds");
 
    vector<vector<double>> statePDs;
    vector<vector<double>> stateLGDs;
    for (const auto& pd : pds) {
        statePDs.push_back({pd, 1 - pd});
    }
    for (const auto& lgd : lgds) {
        stateLGDs.push_back({lgd, 0});
    }
    std::map<double, double> dist;
    computeDiscreteDistribution(statePDs.begin(), statePDs.end(), stateLGDs.begin(), 1.0, 0.0, dist);
    return dist;
}

Here is the call graph for this function:

lossDistribution() [2/2]

std::map< double, double > lossDistribution	(	const std::vector< vector< double > > &	pds,
		const std::vector< vector< double > > &	lgds
	)

Definition at line 78 of file hullwhitebucketing.cpp.

                                                                             {
 
    QL_REQUIRE(pds.size() == lgds.size(), "Mismatch number of pds and lgds");
 
    vector<vector<double>> statePDs;
    vector<vector<double>> stateLGDs;
    for (const auto& pd : pds) {
        statePDs.push_back(pd);
        statePDs.back().push_back(1.0-std::accumulate(pd.begin(), pd.end(), 0.0));
    }
    for (const auto& lgd : lgds) {
        stateLGDs.push_back(lgd);
        stateLGDs.back().push_back(0);
    }
 
    std::map<double, double> dist;
    computeDiscreteDistribution(statePDs.begin(), statePDs.end(), stateLGDs.begin(), 1.0, 0.0, dist);
    return dist;
}

Here is the call graph for this function:

operator<<()

std::ostream & operator<<	(	std::ostream &	os,
		const BucketedDistribution &	dist
	)

Definition at line 138 of file hullwhitebucketing.cpp.

                                                                         {
    os << "#\tLB\tUB\tPD\tAvg" << std::endl;
    for (Size i = 0; i < dist.A.size(); ++i) {
 
        os << i << "\t" << dist.lowerBound[i] << "\t" << dist.upperBound[i] << "\t" << dist.p[i] << "\t"
           << dist.A[i] << std::endl;
    }
    return os;
}

expectedTrancheLoss() [1/3]

double expectedTrancheLoss	(	const std::map< double, double > &	dist,
		double	detachmentPoint
	)

Definition at line 148 of file hullwhitebucketing.cpp.

                                                                                       {
    double expectedLoss = 0.0;
    for (const auto& [L, pd] : dist) {
        if (L <= detachmentPoint) {
            expectedLoss += L * pd;
        } else {
            expectedLoss += detachmentPoint * pd;
        }
    }
    return expectedLoss;
}

Here is the caller graph for this function:

expectedTrancheLoss() [2/3]

double expectedTrancheLoss	(	QuantLib::Distribution	dist,
		double	attachmentAmount,
		double	detachmentAmount
	)

Definition at line 160 of file hullwhitebucketing.cpp.

                                                                                                        {
    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 < attachmentAmount)
            continue;
        if (x > detachmentAmount)
            break;
        expectedLoss += (x - attachmentAmount) * dist.dx(i) * dist.density(i);
    }
    expectedLoss += (detachmentAmount - attachmentAmount) * (1.0 - dist.cumulativeDensity(detachmentAmount));
    return expectedLoss;
}

expectedTrancheLoss() [3/3]

double expectedTrancheLoss	(	const vector< double > &	prob,
		const vector< double > &	loss,
		double	detachment
	)

Definition at line 177 of file hullwhitebucketing.cpp.

                                                                                                      {
    QuantLib::Real expectedLoss = 0;
    for (size_t i = 0; i < prob.size(); ++i) {
        expectedLoss += std::min(loss[i], detachment) * prob[i];
    }
    return expectedLoss;
}