SyntheticCDO − Synthetic Collateralized Debt Obligation.

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

Inherits **Instrument**.

**Classes**

class **engine
CDO** base engine.

**Public Member Functions**

**SyntheticCDO** (const boost::shared_ptr< **Basket** > &basket, Protection::Side side, const **Schedule** &schedule, **Rate** upfrontRate, **Rate** runningRate, const **DayCounter** &dayCounter, **BusinessDayConvention** paymentConvention, boost::optional< **Real** > notional=boost::none)

const boost::shared_ptr< **Basket** > & **basket** () const

bool **isExpired** () const

returns whether the instrument might have value greater than zero. **
Rate fairPremium** () const

Rate fairUpfrontPremium

Rate premiumValue

Rate protectionValue

Real premiumLegNPV

Real protectionLegNPV

Real remainingNotional

Real leverageFactor

const

Last protection date.

Real implicitCorrelation

Disposable

Size error

void

void

**Additional Inherited Members**

Synthetic 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. ].PP 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) |
||

• |

ight] $ of the

Determine the expected value $ E_i = E_{t_i}t[Pay(LGD) protection payoff $ Pay(LGD) $ at each time $ t_i$ where Pay(L) = min g i n { a r r a y } { l (D_1, LGD) - min (D_2, LGD) = t c 0 &;& LGD < D_1 \ isplaystyle LGD - l } i s p l a y s t y l D_1 &;& D_1 LGD D_2 \ isplaystyle D_2 - D_1 &;& LGD > D_2ight. ] \nd{array} |
|||

• |
The protection value is then calculated as V_1 = _{i=1}^N (E_i - E_{i-1}) |

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

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.

**SyntheticCDO (const boost::shared_ptr< Basket > & basket, Protection::Side side, const Schedule & schedule, Rate upfrontRate, Rate runningRate, const DayCounter & dayCounter, BusinessDayConvention paymentConvention, boost::optional< Real > notional =** `boost::none`**)**

If the notional exceeds the basket inception tranche notional, the cdo is leveraged by that factor.

**Real remainingNotional () const**

Total outstanding tranche notional, not wiped out

**Real leverageFactor () const**

The number of times the contract contains the portfolio tranched notional.

**Real implicitCorrelation (const std::vector< Real > & recoveries, const Handle< YieldTermStructure > & discountCurve, Real targetNPV =** `0.`**, Real accuracy =** `1.0e−3`**) const**

The Gaussian Copula LHP implied correlation that makes the contract zero value. This is for a flat correlation along time and portfolio loss level.

**Disposable<std::vector<Real> > expectedTrancheLoss () const**

Expected tranche loss for all payment dates

**void setupArguments (PricingEngine::arguments *) const** `[virtual]`

When a derived argument structure is defined for an instrument, this method should be overridden to fill it. This is mandatory in case a pricing engine is used.

Reimplemented from **Instrument**.

**void fetchResults (const PricingEngine::results * r) const** `[virtual]`

When a derived result structure is defined for an instrument, this method should be overridden to read from it. This is mandatory in case a pricing engine is used.

Reimplemented from **Instrument**.

Generated automatically by Doxygen for QuantLib from the source code.