CDO Class Reference

collateralized debt obligation More...

`#include <ql/experimental/credit/cdo.hpp>`

Inheritance diagram for CDO:
[legend]

## Public Member Functions

CDO (Real attachment, Real detachment, const std::vector< Real > &nominals, const std::vector< Handle< DefaultProbabilityTermStructure > > &basket, const Handle< OneFactorCopula > &copula, bool protectionSeller, const Schedule &premiumSchedule, Rate premiumRate, const DayCounter &dayCounter, Rate recoveryRate, Rate upfrontPremiumRate, const Handle< YieldTermStructure > &yieldTS, Size nBuckets, const Period &integrationStep=Period(10, Years))

Real | nominal ()
Real | lgd ()
Real | attachment ()
Real | detachment ()
std::vector< Real > | nominals ()
Size | size ()
bool | isExpired () const
| returns whether the instrument might have value greater than zero.
Rate | fairPremium () const
Rate | premiumValue () const
Rate | protectionValue () const
Size | error () const
Public Member Functions inherited from Instrument
virtual void | setupArguments (PricingEngine::arguments *) const
virtual void | fetchResults (const PricingEngine::results *) const
Real | NPV () const
| returns the net present value of the instrument.
Real | errorEstimate () const
| returns the error estimate on the NPV when available.
const Date & | valuationDate () const
| returns the date the net present value refers to.
template<typename T >
T | result (const std::string &tag) const
| returns any additional result returned by the pricing engine.
const std::map< std::string, boost::any > & | additionalResults () const
| returns all additional result returned by the pricing engine.
void | setPricingEngine (const boost::shared_ptr< PricingEngine > &)
| set the pricing engine to be used. More...
Public Member Functions inherited from LazyObject
void | update ()
void | recalculate ()
void | freeze ()
void | unfreeze ()
void | alwaysForwardNotifications ()
Public Member Functions inherited from Observable
| Observable (const Observable &)
Observable & | operator= (const Observable &)
void | notifyObservers ()
Public Member Functions inherited from Observer
| Observer (const Observer &)
Observer & | operator= (const Observer &)
std::pair< iterator, bool > | registerWith (const boost::shared_ptr< Observable > &)
void | registerWithObservables (const boost::shared_ptr< Observer > &)
Size | unregisterWith (const boost::shared_ptr< Observable > &)
void | unregisterWithAll ()
virtual void | deepUpdate ()

## Additional Inherited Members

Public Types inherited from Observer
typedef std::set< boost::shared_ptr< Observable > > | set_type
typedef set_type::iterator | iterator
Protected Member Functions inherited from Instrument
void | calculate () const
Protected Member Functions inherited from LazyObject
Protected Attributes inherited from Instrument
boost::shared_ptr< PricingEngine > | engine_
Real | NPV_
Real | errorEstimate_
Date | valuationDate_
std::map< std::string, boost::any > | additionalResults_
Protected Attributes inherited from LazyObject
bool | calculated_
bool | frozen_
bool | alwaysForward_

## Detailed Description

collateralized debt obligation

The instrument prices a mezzanine CDO tranche with loss given default between attachment point \( D_1\) and detachment point \( D_2 > D_1 \).

For purchased protection, the instrument value is given by the difference of the protection value \( V_1 \) and premium value \( V_2 \),

\[ V = V_1 - V_2. \]

The protection leg is priced as follows:

- Build the probability distribution for volume of defaults \( L \) (before recovery) or Loss Given Default \( LGD = (1-r)\,L \) at times/dates \( t_i, i=1, ..., N\) (premium schedule times with intermediate steps)
- Determine the expected value \( E_i = E_{t_i}\,\left[Pay(LGD)\right] \) of the protection payoff \( Pay(LGD) \) at each time \( t_i\) where

  \[ Pay(L) = min (D_1, LGD) - min (D_2, LGD) = \left\{ \begin{array}{lcl} \displaystyle 0 &;& LGD < D_1 \\ \displaystyle LGD - D_1 &;& D_1 \leq LGD \leq D_2 \\ \displaystyle D_2 - D_1 &;& LGD > D_2 \end{array} \right. \]

- The protection value is then calculated as

  \[ V_1 \:=\: \sum_{i=1}^N (E_i - E_{i-1}) \cdot d_i \]

  where \( d_i\) is the discount factor at time/date \( t_i \)

The premium is paid on the protected notional amount, initially \( D_2 - D_1. \) This notional amount is reduced by the expected protection payments \( E_i \) at times \( t_i, \) so that the premium value is calculated as

\[ V_2 = m \, \cdot \sum_{i=1}^N \,(D_2 - D_1 - E_i) \cdot \Delta_{i-1,i}\,d_i \]

where \( m \) is the premium rate, \( \Delta_{i-1, i}\) is the day count fraction between date/time \( t_{i-1}\) and \( t_i.\)

The construction of the portfolio loss distribution \( E_i \) is based on the probability bucketing algorithm described in

John Hull and Alan White, "Valuation of a CDO and nth to default CDS without Monte Carlo simulation", Journal of Derivatives 12, 2, 2004

The pricing algorithm allows for varying notional amounts and default termstructures of the underlyings.

## Constructor & Destructor Documentation

## CDO()

CDO | ( | Real | attachment,
|  | Real | detachment,
|  | const std::vector< Real > & | nominals,
|  | const std::vector< Handle< DefaultProbabilityTermStructure > > & | basket,
|  | const Handle< OneFactorCopula > & | copula,
|  | bool | protectionSeller,
|  | const Schedule & | premiumSchedule,
|  | Rate | premiumRate,
|  | const DayCounter & | dayCounter,
|  | Rate | recoveryRate,
|  | Rate | upfrontPremiumRate,
|  | const Handle< YieldTermStructure > & | yieldTS,
|  | Size | nBuckets,
|  | const Period & | integrationStep = `Period(10, Years)`
| ) |  |

Parameters

  attachment | fraction of the LGD where protection starts
  detachment | fraction of the LGD where protection ends
  nominals | vector of basket nominal amounts
  basket | default basket represented by a vector of default term structures that allow computing single name default probabilities depending on time
  copula | one-factor copula
  protectionSeller | sold protection if set to true, purchased otherwise
  premiumSchedule | schedule for premium payments
  premiumRate | annual premium rate, e.g. 0.05 for 5% p.a.
  dayCounter | day count convention for the premium rate
  recoveryRate | recovery rate as a fraction
  upfrontPremiumRate | premium as a tranche notional fraction
  yieldTS | yield term structure handle
  nBuckets | number of distribution buckets
  integrationStep | time step for integrating over one premium period; if larger than premium period length, a single step is taken