Simulated Paths

The concept of a path adds a layer of abstraction. On the one-hand side we have models and simulations. These objects are specified by the mathematical details of stochastic processes. On the other hand-side we have payoffs and products. These objects are specified by the business context.

A path is used to link business context and payoff evaluation to models and simulations.

Path Creation

DiffFusion.AbstractPath — Type

abstract type AbstractPath end

An AbstractPath specifies the interface for path implementations.

This aims at providing the flexibility to add other types of paths in the future.

DiffFusion.Path — Type

struct Path <: AbstractPath
    sim::Simulation
    ts_dict::Dict{String,<:Termstructure}
    state_alias_dict::Dict{String,Int}
    context::Context
    interpolation::PathInterpolation
end

A Path combines a model, simulated model states and term structures. The interface to market references is established by a valuation context.

Paths are used by payoffs to calculate simulated zero bonds, asset prices and further building blocks of financial instrument payoffs.

DiffFusion.path — Function

path(
    sim::Simulation,
    ts_dict::Dict{String,<:Termstructure},
    cxt::Context,
    ip::PathInterpolation = NoPathInterpolation
    )

Create a Path object.

path(
    sim::Simulation,
    ts::Vector{Termstructure},
    cxt::Context,
    ip::PathInterpolation = NoPathInterpolation
    )

Create a Path object from a list of term structures.

DiffFusion.PathInterpolation — Type

@enum(
    PathInterpolation,
    NoPathInterpolation,
    LinearPathInterpolation,
)

PathInterpolation encodes how simulated states can be interpolates.

Path Functions

DiffFusion.numeraire — Function

numeraire(p::AbstractPath, t::ModelTime, curve_key::String)

Calculate the numeraire in the domestic currency.

We allow for curve-specific numeraire calculation e.g. to allow for trade-specific discounting in AMC valuation.

numeraire(p::Path, t::ModelTime, curve_key::String)

Calculate the numeraire in the domestic currency.

We allow for curve-specific numeraire calculation e.g. to allow for trade-specific discounting in AMC valuation.

DiffFusion.bank_account — Function

bank_account(p::AbstractPath, t::ModelTime, key::String)

Calculate a continuous compounded bank account value.

bank_account(p::Path, t::ModelTime, key::String)

Calculate a continuous compounded bank account value.

DiffFusion.zero_bond — Function

zero_bond(p::AbstractPath, t::ModelTime, T::ModelTime, key::String)

Calculate a zero coupon bond price.

zero_bond(p::Path, t::ModelTime, T::ModelTime, key::String)

Calculate a zero coupon bond price.

DiffFusion.zero_bonds — Function

zero_bonds(
    yts::YieldTermstructure,
    m::GaussianHjmModel,
    t::ModelTime,
    T::AbstractVector,
    SX::ModelState,
    )

Zero bond price reconstruction.

Returns a vector of length p where p is the number of paths in SX.

zero_bond(p::AbstractPath, t::ModelTime, T::ModelTime, key::String)

Calculate a zero coupon bond prices.

zero_bonds(p::Path, t::ModelTime, T::AbstractVector, key::String)

Calculate zero coupon bond prices.

DiffFusion.compounding_factor — Function

compounding_factor(p::AbstractPath, t::ModelTime, T1::ModelTime, T2::ModelTime, key::String)

Calculate a compounding factor P(t,T1) / P(t,T2).

compounding_factor(p::Path, t::ModelTime, T1::ModelTime, T2::ModelTime, key::String)

Calculate a compounding factor P(t,T1) / P(t,T2).

DiffFusion.asset — Function

asset(p::AbstractPath, t::ModelTime, key::String)

Calculate asset price.

asset(p::Path, t::ModelTime, key::String)

Calculate asset price.

DiffFusion.forward_asset — Function

forward_asset(p::AbstractPath, t::ModelTime, T::ModelTime, key::String)

Calculate forward asset price as expectation in T-forward measure.

forward_asset(p::Path, t::ModelTime, T::ModelTime, key::String)

Calculate forward asset price as expectation in T-forward measure, conditional on time-t.

DiffFusion.forward_asset_and_zero_bonds — Function

forward_asset_and_zero_bonds(p::AbstractPath, t::ModelTime, T::ModelTime, key::String)

Calculate asset and zero bond components for forward asset price calculation.

forward_asset_and_zero_bonds(p::Path, t::ModelTime, T::ModelTime, key::String)

Calculate asset (plus deterministic jumps) as well as domestic and foreign zero bond price associated with an Asset key.

This function implements methodology redundant to forward_asset(...). But it returns asset and zero bonds separately.

This function is used for barrier option pricing.

DiffFusion.fixing — Function

fixing(p::AbstractPath, t::ModelTime, key::String)

Return a fixing from a term structure.

This is used to handle fixings for indices etc.

fixing(p::Path, t::ModelTime, key::String)

Return a fixing from a term structure.

DiffFusion.asset_convexity_adjustment — Function

asset_convexity_adjustment(
    p::AbstractPath,
    t::ModelTime,
    T0::ModelTime,
    T1::ModelTime,
    T2::ModelTime,
    key::String
    )

Return the convexity adjustment for a YoY asset payoff.

asset_convexity_adjustment(
    p::Path,
    t::ModelTime,
    T0::ModelTime,
    T1::ModelTime,
    T2::ModelTime,
    key::String
    )

Return the convexity adjustment for a YoY asset payoff.

DiffFusion.forward_index — Function

forward_index(p::AbstractPath, t::ModelTime, T::ModelTime, key::String)

Expectation Et^T[ST] of a tradeable asset.

forward_index(p::Path, t::ModelTime, T::ModelTime, key::String)

Expectation Et^T[ST] of a tradeable asset.

DiffFusion.index_convexity_adjustment — Function

index_convexity_adjustment(
    p::AbstractPath,
    t::ModelTime,
    T0::ModelTime,
    T1::ModelTime,
    T2::ModelTime,
    key::String
    )

Return the convexity adjustment for a YoY index payoff.

index_convexity_adjustment(
    p::Path,
    t::ModelTime,
    T0::ModelTime,
    T1::ModelTime,
    T2::ModelTime,
    key::String
    )

Return the convexity adjustment for a YoY index payoff.

DiffFusion.future_index — Function

future_index(p::AbstractPath, t::ModelTime, T::ModelTime, key::String)

Expectation E_t^Q[F(T,T)] of a Future index/price.

future_index(p::Path, t::ModelTime, T::ModelTime, key::String)

Expectation E_t^Q[F(T,T)] of a Future index/price.

Auxiliary methods

Base.length — Function

length(p::AbstractPath)

Return the number of realisations represented by the AbstractPath object.

We assume that model functions applied to an AbstractPath return a vector of length(p) where p is the number realisations.

length(p::Path)

Derive the number of realisations from the linked simulation.

DiffFusion.state_variable — Function

state_variable(
    m::QuasiGaussianModel,
    X::ModelState,
    )

Extract the quasi-Gaussian state variable x from ModelState.

state_variable(sim::Simulation, t::ModelTime, ip::PathInterpolation)

Derive a state variable for a given observation time.

DiffFusion.discount — Function

discount(
    t::ModelTime,
    ts_dict::Dict{String,Termstructure},
    first_alias::String,
    second_alias::Union{String,Nothing} = nothing,
    operation::Union{String,Nothing} = nothing,
    )

Derive the discount factor for one or two of curve alias and a curve operation.