Options
All
  • Public
  • Public/Protected
  • All
Menu

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.

todo

Investigate and fix cases $ E_{i+1} < E_i. $

Hierarchy

Implements

Index

Constructors

constructor

  • Parameters

    • attachment: Real

      fraction of the LGD where protection starts

    • detachment: Real

      fraction of the LGD where protection ends

    • nominals: Real[]

      vector of basket nominal amounts

    • basket: Array<Handle<DefaultProbabilityTermStructure>>

      default basket represented by a vector of default term structures that allow computing single name default probabilities depending on time

    • copula: Handle<OneFactorCopula>

      one-factor copula

    • protectionSeller: boolean

      sold protection if set to true, purchased otherwise

    • premiumSchedule: Schedule

      schedule for premium payments

    • premiumRate: Rate

      annual premium rate, e.g. 0.05 for 5% p.a.

    • dayCounter: DayCounter

      day count convention for the premium rate

    • recoveryRate: Rate

      recovery rate as a fraction

    • upfrontPremiumRate: Rate

      premium as a tranche notional fraction

    • yieldTS: Handle<YieldTermStructure>

      yield term structure handle

    • nBuckets: Size

      number of distribution buckets

    • Default value integrationStep: Period = new Period().init1(10, TimeUnit.Years)

      time step for integrating over one premium period; if larger than premium period length, a single step is taken

    Returns CDO

Properties

Protected _NPV

_NPV: Real

Protected _additionalResults

_additionalResults: Map<string, any> = new Map<string, any>()

_alwaysForward

_alwaysForward: boolean = false

Private _attachment

_attachment: Real

Private _basket

_calculated

_calculated: boolean = false

Private _copula

Private _dayCounter

_dayCounter: DayCounter

Private _detachment

_detachment: Real

_engine

_engine: PricingEngine

Private _error

_error: Size

Protected _errorEstimate

_errorEstimate: Real

_frozen

_frozen: boolean = false

Private _integrationStep

_integrationStep: Period

_isDisposed

_isDisposed: boolean = false

Private _lgd

_lgd: Real

Private _lgds

_lgds: Real[]

Private _nBuckets

_nBuckets: Size

Private _nominal

_nominal: Real

Private _nominals

_nominals: Real[]

_observables

_observables: Set<Observable> = new Set()

_observers

_observers: Set<Observer> = new Set()

Private _premiumRate

_premiumRate: Rate

Private _premiumSchedule

_premiumSchedule: Schedule

Private _premiumValue

_premiumValue: Real

Private _protectionSeller

_protectionSeller: boolean

Private _protectionValue

_protectionValue: Real

Private _recoveryRate

_recoveryRate: Rate

Private _upfrontPremiumRate

_upfrontPremiumRate: Rate

Private _upfrontPremiumValue

_upfrontPremiumValue: Real

Protected _valuationDate

_valuationDate: Date

Private _xMax

_xMax: Real

Private _xMin

_xMin: Real

Private _yieldTS

dispose

dispose: () => void

Type declaration

    • (): void
    • Returns void

isDisposed

isDisposed: boolean

notifyObservers

notifyObservers: () => void

Type declaration

    • (): void
    • Returns void

registerObserver

registerObserver: (o: Observer) => void

Type declaration

registerWith

registerWith: (h: Observable) => void

Type declaration

registerWithObservables

registerWithObservables: (o: Observer) => void

Type declaration

unregisterObserver

unregisterObserver: (o: Observer) => void

Type declaration

unregisterWith

unregisterWith: (h: Observable) => Size

Type declaration

unregisterWithAll

unregisterWithAll: () => void

Type declaration

    • (): void
    • Returns void

Methods

NPV

  • returns the net present value of the instrument.

    Returns Real

additionalResults

  • additionalResults(): Map<string, any>
  • returns all additional result returned by the pricing engine.

    Returns Map<string, any>

alwaysForwardNotifications

  • alwaysForwardNotifications(): void
  • This method causes the object to forward all notifications, even when not calculated. The default behavior is to forward the first notification received, and discard the others until recalculated; the rationale is that observers were already notified, and don't need further notification until they recalculate, at which point this object would be recalculated too. After recalculation, this object would again forward the first notification received.

    warning Forwarding all notifications will cause a performance hit, and should be used only when discarding notifications cause an incorrect behavior.

    Returns void

attachment

  • attachment(): Real
  • Returns Real

calculate

  • calculate(): void

deepUpdate

  • deepUpdate(): void

detachment

  • detachment(): Real
  • Returns Real

error

  • Returns Size

errorEstimate

  • errorEstimate(): Real
  • returns the error estimate on the NPV when available.

    Returns Real

expectedTrancheLoss

  • expectedTrancheLoss(d: Date): Real
  • Parameters

    • d: Date

    Returns Real

fairPremium

  • fairPremium(): Rate
  • Returns Rate

fetchResults

  • 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.

    Parameters

    Returns void

freeze

  • freeze(): void
  • This method constrains the object to return the presently cached results on successive invocations, even if arguments upon which they depend should change.

    Returns void

init

isExpired

  • isExpired(): boolean

lgd

  • Returns Real

nominal

  • Returns Real

nominals

  • nominals(): Real[]
  • Returns Real[]

performCalculations

  • performCalculations(): void

premiumValue

  • premiumValue(): Rate
  • Returns Rate

protectionValue

  • protectionValue(): Rate
  • Returns Rate

recalculate

  • recalculate(): void
  • This method force the recalculation of any results which would otherwise be cached. It is not declared as const since it needs to call the non-const notifyObservers method.

    note Explicit invocation of this method is not necessary if the object registered itself as observer with the structures on which such results depend. It is strongly advised to follow this policy when possible.

    Returns void

result

  • result(tag: string): any
  • returns any additional result returned by the pricing engine.

    Parameters

    • tag: string

    Returns any

setPricingEngine

  • set the pricing engine to be used.

    warning calling this method will have no effects in case the performCalculation method was overridden in a derived class.

    Parameters

    Returns void

setupArguments

  • 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.

    Parameters

    Returns void

setupExpired

  • setupExpired(): void

size

  • Returns Size

unfreeze

  • unfreeze(): void
  • This method reverts the effect of the freeze method, thus re-enabling recalculations.

    Returns void

update

  • update(): void

valuationDate

  • valuationDate(): Date
  • returns the date the net present value refers to.

    Returns Date