Options
All
  • Public
  • Public/Protected
  • All
Menu

N-th to default swap

A NTD instrument exchanges protection against the nth default in a basket of underlying credits for premium payments based on the protected notional amount.

The pricing is analogous to the pricing of a CDS instrument which represents protection against default of a single underlying credit. The only difference is the calculation of the probability of default. In the CDS case, it is the probabilty of single name default; in the NTD case the probability of at least N defaults in the portfolio of underlying credits.

This probability is computed using the algorithm 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 algorithm allows for varying probability of default across the basket. Otherwise, for identical probabilities of default, the probability of n defaults is given by the binomial distribution.

Default correlation is modeled using a one-factor Gaussian copula approach.

The class is tested against data in Hull-White (see reference above.)

Hierarchy

Implements

Index

Constructors

constructor

Properties

Protected _NPV

_NPV: Real

Protected _additionalResults

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

_alwaysForward

_alwaysForward: boolean = false

Private _basket

_basket: Basket

_calculated

_calculated: boolean = false

Private _dayCounter

_dayCounter: DayCounter

_engine

_engine: PricingEngine

Protected _errorEstimate

_errorEstimate: Real

Private _fairPremium

_fairPremium: Real

_frozen

_frozen: boolean = false

_isDisposed

_isDisposed: boolean = false

Private _n

_n: Size

Private _nominal

_nominal: Real

_observables

_observables: Set<Observable> = new Set()

_observers

_observers: Set<Observer> = new Set()

Private _premiumLeg

_premiumLeg: Leg

Private _premiumRate

_premiumRate: Rate

Private _premiumSchedule

_premiumSchedule: Schedule

Private _premiumValue

_premiumValue: Rate

Private _protectionValue

_protectionValue: Real

Private _settlePremiumAccrual

_settlePremiumAccrual: boolean

Private _side

_side: Side

Private _upfrontPremiumValue

_upfrontPremiumValue: Real

Private _upfrontRate

_upfrontRate: Rate

Protected _valuationDate

_valuationDate: Date

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

basket

  • Returns Basket

basketSize

  • basketSize(): Size
  • Returns Size

calculate

  • calculate(): void

dayCounter

  • Returns DayCounter

deepUpdate

  • deepUpdate(): void

errorEstimate

  • errorEstimate(): Real

fairPremium

  • fairPremium(): Rate
  • Returns Rate

fetchResults

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
  • Returns boolean

maturity

  • maturity(): Date
  • Returns Date

nominal

  • Returns Real

performCalculations

  • performCalculations(): void

premium

  • Returns Rate

premiumLegNPV

  • premiumLegNPV(): Real
  • Returns Real

protectionLegNPV

  • protectionLegNPV(): Real
  • Returns Real

rank

  • Returns Size

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

setupExpired

  • setupExpired(): void

side

  • Returns Side

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