Options
All
  • Public
  • Public/Protected
  • All
Menu

Helper class to extend an OptionletStripper1 object stripping

additional optionlet (i.e. caplet/floorlet) volatilities (a.k.a. forward-forward volatilities) from the (cap/floor) At-The-Money term volatilities of a CapFloorTermVolCurve.

Hierarchy

Implements

Index

Constructors

constructor

Properties

Private _accuracy

_accuracy: Real

_alwaysForward

_alwaysForward: boolean = false

Private _atmCapFloorPrices

_atmCapFloorPrices: Real[]

Private _atmCapFloorStrikes

_atmCapFloorStrikes: Rate[]

Private _atmCapFloorTermVolCurve

_atmCapFloorTermVolCurve: Handle<CapFloorTermVolCurve>

Protected _atmOptionletRate

_atmOptionletRate: Rate[]

_calculated

_calculated: boolean = false

Protected _capFloorLengths

_capFloorLengths: Period[]

Private _caps

_caps: CapFloor[]

Private _dc

Protected _discount

Protected _displacement

_displacement: Real

_frozen

_frozen: boolean = false

Protected _iborIndex

_iborIndex: IborIndex

_isDisposed

_isDisposed: boolean = false

Private _maxEvaluations

_maxEvaluations: Size

Private _nOptionExpiries

_nOptionExpiries: Size

Protected _nOptionletTenors

_nOptionletTenors: Size

Protected _nStrikes

_nStrikes: Size

_observables

_observables: Set<Observable> = new Set()

_observers

_observers: Set<Observer> = new Set()

Protected _optionletAccrualPeriods

_optionletAccrualPeriods: Time[]

Protected _optionletDates

_optionletDates: Date[]

Protected _optionletPaymentDates

_optionletPaymentDates: Date[]

Protected _optionletStrikes

_optionletStrikes: Rate[][]

Protected _optionletTenors

_optionletTenors: Period[]

Protected _optionletTimes

_optionletTimes: Time[]

Protected _optionletVolatilities

_optionletVolatilities: Volatility[][]

Private _spreadsVolImplied

_spreadsVolImplied: Volatility[]

Private _stripper1

_stripper1: OptionletStripper1

Protected _termVolSurface

_termVolSurface: CapFloorTermVolSurface

Protected _volatilityType

_volatilityType: VolatilityType

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

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

atmCapFloorPrices

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

atmCapFloorStrikes

  • atmCapFloorStrikes(): Rate[]
  • Returns Rate[]

atmOptionletRates

  • atmOptionletRates(): Rate[]

businessDayConvention

calculate

  • calculate(): void
  • This method performs all needed calculations by calling the performCalculations method.

    warning Objects cache the results of the previous calculation. Such results will be returned upon later invocations of calculate. When the results depend on arguments which could change between invocations, the lazy object must register itself as observer of such objects for the calculations to be performed again when they change.

    warning Should this method be redefined in derived classes, LazyObject.calculate() should be called in the overriding method.

    Returns void

calendar

dayCounter

deepUpdate

  • deepUpdate(): void

displacement

  • displacement(): Real

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

iborIndex

optionletAccrualPeriods

  • optionletAccrualPeriods(): Time[]

optionletFixingDates

  • optionletFixingDates(): Date[]

optionletFixingTenors

  • optionletFixingTenors(): Period[]

optionletFixingTimes

  • optionletFixingTimes(): Time[]

optionletMaturities

  • optionletMaturities(): Size

optionletPaymentDates

  • optionletPaymentDates(): Date[]

optionletStrikes

optionletVolatilities

performCalculations

  • performCalculations(): void

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

settlementDays

spreadsVol

  • Returns Volatility[]

spreadsVolImplied

  • Returns Volatility[]

termVolSurface

unfreeze

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

    Returns void

update

  • update(): void

volatilityType