HullWhiteBucketing Class Reference

#include <qle/models/hullwhitebucketing.hpp>

Inheritance diagram for HullWhiteBucketing:

Collaboration diagram for HullWhiteBucketing:

Public Member Functions
template<class I >
	HullWhiteBucketing (I bucketsBegin, I bucketsEnd)
	HullWhiteBucketing (const Real lowerBound, const Real upperBound, const Size n)
template<class I1 , class I2 >
void	compute (I1 pdBegin, I1 pdEnd, I2 lossesBegin)
template<class I1 , class I2 >
void	computeMultiState (I1 pBegin, I1 pEnd, I2 lossesBegin)
const Array &	probability () const
const Array &	averageLoss () const
Public Member Functions inherited from Bucketing
template<class I >
	Bucketing (I bucketsBegin, I bucketsEnd)
	Bucketing (const Real lowerBound, const Real upperBound, const Size n)
const std::vector< Real > &	upperBucketBound () const
Size	index (const Real x) const
Size	buckets () const

Private Member Functions
void	init_p_A ()
void	finalize_p_A ()

Private Attributes
Array	p_
Array	A_

Additional Inherited Members
Protected Member Functions inherited from Bucketing
void	initBuckets ()
Protected Attributes inherited from Bucketing
std::vector< Real >	buckets_
bool	uniformBuckets_ = false
Real	lowerBound_
Real	upperBound_
Real	h_

Detailed Description

Definition at line 51 of file hullwhitebucketing.hpp.

Constructor & Destructor Documentation

HullWhiteBucketing() [1/2]

HullWhiteBucketing	(	I	bucketsBegin,
		I	bucketsEnd
	)

Definition at line 53 of file hullwhitebucketing.hpp.

: Bucketing(bucketsBegin, bucketsEnd) {}

HullWhiteBucketing() [2/2]

HullWhiteBucketing	(	const Real	lowerBound,
		const Real	upperBound,
		const Size	n
	)

Definition at line 54 of file hullwhitebucketing.hpp.

        : Bucketing(lowerBound, upperBound, n) {}

Member Function Documentation

compute()

void compute	(	I1	pdBegin,
		I1	pdEnd,
		I2	lossesBegin
	)

Definition at line 81 of file hullwhitebucketing.hpp.

                                                                                                   {
    init_p_A();
    Array A2(A_.size()), p2(p_.size());
 
    auto it2 = lossesBegin;
    for (auto it = pdBegin; it != pdEnd; ++it, ++it2) {
        if (QuantLib::close_enough(*it, 0.0) || QuantLib::close_enough(*it2, 0.0))
            continue;
        std::fill(A2.begin(), A2.end(), 0.0);
        std::fill(p2.begin(), p2.end(), 0.0);
        for (Size k = 0; k < buckets_.size(); ++k) {
            if (QuantLib::close_enough(p_[k], 0.0))
                continue;
            Size t = index(A_[k] / p_[k] + *it2);
            p2[k] += p_[k] * (1.0 - (*it));
            A2[k] += A_[k] * (1.0 - (*it));
            p2[t] += p_[k] * (*it);
            A2[t] += (*it) * (A_[k] + p_[k] * (*it2));
        }
        std::copy(A2.begin(), A2.end(), A_.begin());
        std::copy(p2.begin(), p2.end(), p_.begin());
    }
 
    finalize_p_A();
 
} // compute

Here is the call graph for this function:

Here is the caller graph for this function:

computeMultiState()

void computeMultiState	(	I1	pBegin,
		I1	pEnd,
		I2	lossesBegin
	)

Definition at line 108 of file hullwhitebucketing.hpp.

                                                                                                           {
    init_p_A();
    Array A2(A_.size()), p2(p_.size());
 
    auto it2 = lossesBegin;
    for (auto it = pBegin; it != pEnd; ++it, ++it2) {
        std::fill(A2.begin(), A2.end(), 0.0);
        std::fill(p2.begin(), p2.end(), 0.0);
        for (Size k = 0; k < buckets_.size(); ++k) {
            if (QuantLib::close_enough(p_[k], 0.0))
                continue;
            Real q = 0.0;
            auto it2_i = (*it2).begin();
            for (auto it_i = (*it).begin(), itend = (*it).end(); it_i != itend; ++it_i, ++it2_i) {
                if (QuantLib::close_enough(*it_i, 0.0) || QuantLib::close_enough(*it2_i, 0.0))
                    continue;
                Size t = index(A_[k] / p_[k] + *it2_i);
                p2[t] += p_[k] * (*it_i);
                A2[t] += (*it_i) * (A_[k] + p_[k] * (*it2_i));
                q += *it_i;
            }
            p2[k] += p_[k] * (1.0 - q);
            A2[k] += A_[k] * (1.0 - q);
        }
        std::copy(A2.begin(), A2.end(), A_.begin());
        std::copy(p2.begin(), p2.end(), p_.begin());
    } // for it
 
    finalize_p_A();
 
} // computeMultiState

Here is the call graph for this function:

Here is the caller graph for this function:

probability()

const Array & probability

(

)

const

Definition at line 66 of file hullwhitebucketing.hpp.

{ return p_; }

Here is the caller graph for this function:

averageLoss()

const Array & averageLoss

(

)

const

Definition at line 67 of file hullwhitebucketing.hpp.

{ return A_; }

Here is the caller graph for this function:

init_p_A()

void init_p_A ( )

private

Definition at line 57 of file hullwhitebucketing.cpp.

                                  {
    Size N = buckets_.size();
    p_ = Array(N, 0);
    A_ = Array(N, 0);
    Size zeroIdx = index(0.0);
    p_[zeroIdx] = 1.0;
    A_[zeroIdx] = 0.0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

finalize_p_A()

void finalize_p_A ( )

private

Definition at line 66 of file hullwhitebucketing.cpp.

                                      {
    Size N = buckets_.size();
    for (Size i = 0; i < N; ++i) {
        if (QuantLib::close_enough(p_[i], 0.0)) {
            // the probability for a bucket is zero => fill average with midpoint (endpoints)
            if (i == 0) {
                A_[i] = buckets_.front();
            } else if (i == N - 1) {
                A_[i] = buckets_[N - 2];
            } else {
                A_[i] = 0.5 * (buckets_[i - 1] + buckets_[i]);
            }
        } else {
            // otherwise normalize the bucket to represent the conditional aveage for this bucket
            A_[i] /= p_[i];
        }
    }
}

Here is the caller graph for this function:

Member Data Documentation

p_

Array p_

private

Definition at line 72 of file hullwhitebucketing.hpp.

A_

Array A_

private

Definition at line 72 of file hullwhitebucketing.hpp.