Options
All
  • Public
  • Public/Protected
  • All
Menu

Stochastic-volatility GJR-GARCH(1,1) process

parameters supplied should be daily constants they are annualized by setting the parameter daysPerYear This class describes the stochastic volatility process governed by $$ \begin{array}{rcl} dS(t, S) &=& \mu S dt + \sqrt{v} S dW_1 \ dv(t, S) &=& (\omega + (\beta + \alpha * q_{2}

  • \gamma * q_{3} - 1) v) dt + (\alpha \sigma_{12}
  • \gamma \sigma_{13}) v dW_1
  • \sqrt{\alpha^{2} (\sigma^{2}{2} - \sigma^{2}{12})
  • \gamma^{2} (\sigma^{2}{3} - \sigma^{2}{13})
  • 2 \alpha \gamma (\sigma_{23} - \sigma_{12} \sigma_{13})} v dW_2 \
    N = normalCDF(\lambda) \ n &=& \exp{-\lambda^{2}/2} / \sqrt{2 \pi} \ q_{2} &=& 1 + \lambda^{2} \ q_{3} &=& \lambda n + N + \lambda^2 N \ \sigma^{2}{2} = 2 + 4 \lambda^{4} \ \sigma^{2}{3} = \lambda^{3} n + 5 \lambda n + 3N
  • \lambda^{4} N + 6 \lambda^{2} N -\lambda^{2} n^{2} - N^{2}
  • \lambda^{4} N^{2} - 2 \lambda n N - 2 \lambda^{3} nN
  • 2 \lambda^{2} N^{2} \
    \sigma_{12} = -2 \lambda \ \sigma_{13} = -2 n - 2 \lambda N \ \sigma_{23} = 2N + \sigma_{12} \sigma_{13} \ \end{array} $$

Hierarchy

Implements

Index

Constructors

constructor

Properties

Private _alpha

_alpha: Real

Private _beta

_beta: Real

Private _daysPerYear

_daysPerYear: Real

_discretization

_discretization: discretization

_discretization1

_discretization1: Discretization

Private _dividendYield

_dividendYield: Handle<YieldTermStructure>

Private _gamma

_gamma: Real

_isDisposed

_isDisposed: boolean = false

Private _lambda

_lambda: Real

_observables

_observables: Set<Observable> = new Set()

_observers

_observers: Set<Observer> = new Set()

Private _omega

_omega: Real

Private _riskFreeRate

_riskFreeRate: Handle<YieldTermStructure>

Private _s0

Private _v0

_v0: Real

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

alpha

  • Returns Real

apply1

beta

  • Returns Real

covariance

  • returns the covariance $$ V(\mathrm{x}{t_0 + \Delta t} | \mathrm{x}{t_0} = \mathrm{x}_0) $$ of the process after a time interval $ \Delta t $ according to the given discretization. This method can be overridden in derived classes which want to hard-code a particular discretization.

    Parameters

    Returns Matrix

daysPerYear

  • daysPerYear(): Real
  • Returns Real

deepUpdate

  • deepUpdate(): void

diffusion1

dividendYield

drift1

evolve1

expectation1

  • returns the expectation $$ E(\mathrm{x}{t_0 + \Delta t} | \mathrm{x}{t_0} = \mathrm{x}_0) $$ of the process after a time interval $ \Delta t $ according to the given discretization. This method can be overridden in derived classes which want to hard-code a particular discretization.

    Parameters

    Returns Real[]

factors

  • returns the number of independent factors of the process

    Returns Size

gamma

  • Returns Real

init

initialValues

  • initialValues(): Real[]

lambda

  • Returns Real

omega

  • Returns Real

riskFreeRate

s0

  • Returns Handle<Quote>

size

stdDeviation1

  • returns the standard deviation $$ S(\mathrm{x}{t_0 + \Delta t} | \mathrm{x}{t_0} = \mathrm{x}_0) $$ of the process after a time interval $ \Delta t $ according to the given discretization. This method can be overridden in derived classes which want to hard-code a particular discretization.

    Parameters

    Returns Matrix

time

  • time(d: Date): Time

update

  • update(): void

v0

  • Returns Real